bedrock/
vk2.rs

1#![allow(clippy::inconsistent_digit_grouping)]
2#![allow(non_upper_case_globals, non_camel_case_types, non_snake_case, dead_code)]
3
4//! Vulkan API Definitions 1.4.305 with some extensions
5
6/*
7** Copyright 2025 S.Percentage.
8** Original C Header: Copyright 2015-2025 The Khronos Group Inc.
9**
10** SPDX-License-Identifier: Apache-2.0
11*/
12
13#[inline]
14pub const fn VK_MAKE_VERSION(variant: u8, major: u16, minor: u16, patch: u16) -> u32 {
15    ((variant as u32) << 29) | ((major as u32) << 22) | ((minor as u32) << 12) | patch as u32
16}
17
18pub const fn VK_VARIANT_VERSION(v: u32) -> u8 {
19    (v >> 29) as _
20}
21
22#[inline]
23pub const fn VK_MAJOR_VERSION(v: u32) -> u16 {
24    ((v >> 22) & 0x7f) as _
25}
26
27#[inline]
28pub const fn VK_MINOR_VERSION(v: u32) -> u16 {
29    ((v >> 12) & 0x3ff) as _
30}
31
32#[inline]
33pub const fn VK_PATCH_VERSION(v: u32) -> u16 {
34    (v & 0xfff) as _
35}
36
37/// (major, minor, patch)
38#[inline]
39pub const fn vk_deserialize_version(v: u32) -> (u16, u16, u16) {
40    (VK_MAJOR_VERSION(v), VK_MINOR_VERSION(v), VK_PATCH_VERSION(v))
41}
42
43/// Vulkan 1.0 version number
44pub const VK_API_VERSION_1_0: u32 = VK_MAKE_VERSION(0, 1, 0, 0);
45
46/// Version of this file
47pub const VK_HEADER_VERSION: u16 = 305;
48pub const VK_HEADER_VERSION_COMPLETE: u32 = VK_MAKE_VERSION(0, 1, 4, VK_HEADER_VERSION);
49
50#[rustfmt::skip]
51pub type VkSampleMask = u32;
52#[rustfmt::skip]
53pub type VkBool32 = u32;
54#[rustfmt::skip]
55pub type VkFlags = u32;
56#[rustfmt::skip]
57pub type VkFlags64 = u64;
58#[rustfmt::skip]
59pub type VkDeviceSize = u64;
60#[rustfmt::skip]
61pub type VkDeviceAddress = u64;
62
63#[rustfmt::skip]
64pub type VkAccessFlags = VkFlags;
65#[rustfmt::skip]
66pub type VkAccessFlagBits = VkFlags;
67#[rustfmt::skip]
68pub const VK_ACCESS_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits = 0x00000001;
69#[rustfmt::skip]
70pub const VK_ACCESS_INDEX_READ_BIT: VkAccessFlagBits = 0x00000002;
71#[rustfmt::skip]
72pub const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits = 0x00000004;
73#[rustfmt::skip]
74pub const VK_ACCESS_UNIFORM_READ_BIT: VkAccessFlagBits = 0x00000008;
75#[rustfmt::skip]
76pub const VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits = 0x00000010;
77#[rustfmt::skip]
78pub const VK_ACCESS_SHADER_READ_BIT: VkAccessFlagBits = 0x00000020;
79#[rustfmt::skip]
80pub const VK_ACCESS_SHADER_WRITE_BIT: VkAccessFlagBits = 0x00000040;
81#[rustfmt::skip]
82pub const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits = 0x00000080;
83#[rustfmt::skip]
84pub const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 0x00000100;
85#[rustfmt::skip]
86pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits = 0x00000200;
87#[rustfmt::skip]
88pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 0x00000400;
89#[rustfmt::skip]
90pub const VK_ACCESS_TRANSFER_READ_BIT: VkAccessFlagBits = 0x00000800;
91#[rustfmt::skip]
92pub const VK_ACCESS_TRANSFER_WRITE_BIT: VkAccessFlagBits = 0x00001000;
93#[rustfmt::skip]
94pub const VK_ACCESS_HOST_READ_BIT: VkAccessFlagBits = 0x00002000;
95#[rustfmt::skip]
96pub const VK_ACCESS_HOST_WRITE_BIT: VkAccessFlagBits = 0x00004000;
97#[rustfmt::skip]
98pub const VK_ACCESS_MEMORY_READ_BIT: VkAccessFlagBits = 0x00008000;
99#[rustfmt::skip]
100pub const VK_ACCESS_MEMORY_WRITE_BIT: VkAccessFlagBits = 0x00010000;
101#[cfg(feature = "VK_EXT_blend_operation_advanced")]
102#[rustfmt::skip]
103pub const VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlagBits = 0x00080000;
104
105#[cfg(feature = "VK_KHR_synchronization2")]
106#[rustfmt::skip]
107pub type VkAccessFlags2KHR = VkFlags64;
108#[cfg(feature = "Allow1_3APIs")]
109#[rustfmt::skip]
110pub type VkAccessFlags2 = VkAccessFlags2KHR;
111#[cfg(feature = "VK_KHR_synchronization2")]
112#[rustfmt::skip]
113pub type VkAccessFlagBits2KHR = VkFlags64;
114#[cfg(feature = "Allow1_3APIs")]
115#[rustfmt::skip]
116pub type VkAccessFlagBits2 = VkAccessFlagBits2KHR;
117#[cfg(feature = "VK_KHR_synchronization2")]
118#[rustfmt::skip]
119pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000001;
120#[cfg(feature = "Allow1_3APIs")]
121#[rustfmt::skip]
122pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000001;
123#[cfg(feature = "VK_KHR_synchronization2")]
124#[rustfmt::skip]
125pub const VK_ACCESS_2_INDEX_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000002;
126#[cfg(feature = "Allow1_3APIs")]
127#[rustfmt::skip]
128pub const VK_ACCESS_2_INDEX_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000002;
129#[cfg(feature = "VK_KHR_synchronization2")]
130#[rustfmt::skip]
131pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000004;
132#[cfg(feature = "Allow1_3APIs")]
133#[rustfmt::skip]
134pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000004;
135#[cfg(feature = "VK_KHR_synchronization2")]
136#[rustfmt::skip]
137pub const VK_ACCESS_2_UNIFORM_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000008;
138#[cfg(feature = "Allow1_3APIs")]
139#[rustfmt::skip]
140pub const VK_ACCESS_2_UNIFORM_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000008;
141#[cfg(feature = "VK_KHR_synchronization2")]
142#[rustfmt::skip]
143pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000010;
144#[cfg(feature = "Allow1_3APIs")]
145#[rustfmt::skip]
146pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000010;
147#[cfg(feature = "VK_KHR_synchronization2")]
148#[rustfmt::skip]
149pub const VK_ACCESS_2_SHADER_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000020;
150#[cfg(feature = "Allow1_3APIs")]
151#[rustfmt::skip]
152pub const VK_ACCESS_2_SHADER_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000020;
153#[cfg(feature = "VK_KHR_synchronization2")]
154#[rustfmt::skip]
155pub const VK_ACCESS_2_SHADER_WRITE_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000040;
156#[cfg(feature = "Allow1_3APIs")]
157#[rustfmt::skip]
158pub const VK_ACCESS_2_SHADER_WRITE_BIT: VkAccessFlagBits2KHR = 0x0000000000000040;
159#[cfg(feature = "VK_KHR_synchronization2")]
160#[rustfmt::skip]
161pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000080;
162#[cfg(feature = "Allow1_3APIs")]
163#[rustfmt::skip]
164pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000080;
165#[cfg(feature = "VK_KHR_synchronization2")]
166#[rustfmt::skip]
167pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000100;
168#[cfg(feature = "Allow1_3APIs")]
169#[rustfmt::skip]
170pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2KHR = 0x0000000000000100;
171#[cfg(feature = "VK_KHR_synchronization2")]
172#[rustfmt::skip]
173pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000200;
174#[cfg(feature = "Allow1_3APIs")]
175#[rustfmt::skip]
176pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000200;
177#[cfg(feature = "VK_KHR_synchronization2")]
178#[rustfmt::skip]
179pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000400;
180#[cfg(feature = "Allow1_3APIs")]
181#[rustfmt::skip]
182pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2KHR = 0x0000000000000400;
183#[cfg(feature = "VK_KHR_synchronization2")]
184#[rustfmt::skip]
185pub const VK_ACCESS_2_TRANSFER_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000000800;
186#[cfg(feature = "Allow1_3APIs")]
187#[rustfmt::skip]
188pub const VK_ACCESS_2_TRANSFER_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000000800;
189#[cfg(feature = "VK_KHR_synchronization2")]
190#[rustfmt::skip]
191pub const VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000001000;
192#[cfg(feature = "Allow1_3APIs")]
193#[rustfmt::skip]
194pub const VK_ACCESS_2_TRANSFER_WRITE_BIT: VkAccessFlagBits2KHR = 0x0000000000001000;
195#[cfg(feature = "VK_KHR_synchronization2")]
196#[rustfmt::skip]
197pub const VK_ACCESS_2_HOST_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000002000;
198#[cfg(feature = "Allow1_3APIs")]
199#[rustfmt::skip]
200pub const VK_ACCESS_2_HOST_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000002000;
201#[cfg(feature = "VK_KHR_synchronization2")]
202#[rustfmt::skip]
203pub const VK_ACCESS_2_HOST_WRITE_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000004000;
204#[cfg(feature = "Allow1_3APIs")]
205#[rustfmt::skip]
206pub const VK_ACCESS_2_HOST_WRITE_BIT: VkAccessFlagBits2KHR = 0x0000000000004000;
207#[cfg(feature = "VK_KHR_synchronization2")]
208#[rustfmt::skip]
209pub const VK_ACCESS_2_MEMORY_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000008000;
210#[cfg(feature = "Allow1_3APIs")]
211#[rustfmt::skip]
212pub const VK_ACCESS_2_MEMORY_READ_BIT: VkAccessFlagBits2KHR = 0x0000000000008000;
213#[cfg(feature = "VK_KHR_synchronization2")]
214#[rustfmt::skip]
215pub const VK_ACCESS_2_MEMORY_WRITE_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000000010000;
216#[cfg(feature = "Allow1_3APIs")]
217#[rustfmt::skip]
218pub const VK_ACCESS_2_MEMORY_WRITE_BIT: VkAccessFlagBits2KHR = 0x0000000000010000;
219#[cfg(feature = "VK_KHR_synchronization2")]
220#[rustfmt::skip]
221pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000100000000;
222#[cfg(feature = "Allow1_3APIs")]
223#[rustfmt::skip]
224pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT: VkAccessFlagBits2KHR = 0x0000000100000000;
225#[cfg(feature = "VK_KHR_synchronization2")]
226#[rustfmt::skip]
227pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000200000000;
228#[cfg(feature = "Allow1_3APIs")]
229#[rustfmt::skip]
230pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT: VkAccessFlagBits2KHR = 0x0000000200000000;
231#[cfg(feature = "VK_KHR_synchronization2")]
232#[rustfmt::skip]
233pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR: VkAccessFlagBits2KHR = 0x0000000400000000;
234#[cfg(feature = "Allow1_3APIs")]
235#[rustfmt::skip]
236pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT: VkAccessFlagBits2KHR = 0x0000000400000000;
237
238#[cfg(feature = "VK_KHR_android_surface")]
239#[rustfmt::skip]
240pub type VkAndroidSurfaceCreateFlagsKHR = VkFlags;
241#[cfg(feature = "VK_KHR_android_surface")]
242#[rustfmt::skip]
243pub type VkAndroidSurfaceCreateFlagBitsKHR = VkFlags;
244
245#[rustfmt::skip]
246pub type VkAttachmentDescriptionFlags = VkFlags;
247#[rustfmt::skip]
248pub type VkAttachmentDescriptionFlagBits = VkFlags;
249#[rustfmt::skip]
250pub const VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: VkAttachmentDescriptionFlagBits = 0x00000001;
251
252#[rustfmt::skip]
253pub type VkBufferCreateFlags = VkFlags;
254#[rustfmt::skip]
255pub type VkBufferCreateFlagBits = VkFlags;
256#[rustfmt::skip]
257pub const VK_BUFFER_CREATE_SPARSE_BINDING_BIT: VkBufferCreateFlagBits = 0x00000001;
258#[rustfmt::skip]
259pub const VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT: VkBufferCreateFlagBits = 0x00000002;
260#[rustfmt::skip]
261pub const VK_BUFFER_CREATE_SPARSE_ALIASED_BIT: VkBufferCreateFlagBits = 0x00000004;
262#[cfg(feature = "Allow1_1APIs")]
263#[rustfmt::skip]
264pub const VK_BUFFER_CREATE_PROTECTED_BIT: VkBufferCreateFlagBits = 0x00000008;
265
266#[rustfmt::skip]
267pub type VkBufferUsageFlags = VkFlags;
268#[rustfmt::skip]
269pub type VkBufferUsageFlagBits = VkFlags;
270#[rustfmt::skip]
271pub const VK_BUFFER_USAGE_TRANSFER_SRC_BIT: VkBufferUsageFlagBits = 0x00000001;
272#[rustfmt::skip]
273pub const VK_BUFFER_USAGE_TRANSFER_DST_BIT: VkBufferUsageFlagBits = 0x00000002;
274#[rustfmt::skip]
275pub const VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 0x00000004;
276#[rustfmt::skip]
277pub const VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 0x00000008;
278#[rustfmt::skip]
279pub const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT: VkBufferUsageFlagBits = 0x00000010;
280#[rustfmt::skip]
281pub const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT: VkBufferUsageFlagBits = 0x00000020;
282#[rustfmt::skip]
283pub const VK_BUFFER_USAGE_INDEX_BUFFER_BIT: VkBufferUsageFlagBits = 0x00000040;
284#[rustfmt::skip]
285pub const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT: VkBufferUsageFlagBits = 0x00000080;
286#[rustfmt::skip]
287pub const VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT: VkBufferUsageFlagBits = 0x00000100;
288
289#[rustfmt::skip]
290pub type VkBufferViewCreateFlags = VkFlags;
291#[rustfmt::skip]
292pub type VkBufferViewCreateFlagBits = VkFlags;
293
294#[rustfmt::skip]
295pub type VkColorComponentFlags = VkFlags;
296#[rustfmt::skip]
297pub type VkColorComponentFlagBits = VkFlags;
298#[rustfmt::skip]
299pub const VK_COLOR_COMPONENT_R_BIT: VkColorComponentFlagBits = 0x00000001;
300#[rustfmt::skip]
301pub const VK_COLOR_COMPONENT_G_BIT: VkColorComponentFlagBits = 0x00000002;
302#[rustfmt::skip]
303pub const VK_COLOR_COMPONENT_B_BIT: VkColorComponentFlagBits = 0x00000004;
304#[rustfmt::skip]
305pub const VK_COLOR_COMPONENT_A_BIT: VkColorComponentFlagBits = 0x00000008;
306
307#[rustfmt::skip]
308pub type VkCommandBufferResetFlags = VkFlags;
309#[rustfmt::skip]
310pub type VkCommandBufferResetFlagBits = VkFlags;
311#[rustfmt::skip]
312pub const VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: VkCommandBufferResetFlagBits = 0x00000001;
313
314#[rustfmt::skip]
315pub type VkCommandBufferUsageFlags = VkFlags;
316#[rustfmt::skip]
317pub type VkCommandBufferUsageFlagBits = VkFlags;
318#[rustfmt::skip]
319pub const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: VkCommandBufferUsageFlagBits = 0x00000001;
320#[rustfmt::skip]
321pub const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: VkCommandBufferUsageFlagBits = 0x00000002;
322#[rustfmt::skip]
323pub const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: VkCommandBufferUsageFlagBits = 0x00000004;
324
325#[rustfmt::skip]
326pub type VkCommandPoolCreateFlags = VkFlags;
327#[rustfmt::skip]
328pub type VkCommandPoolCreateFlagBits = VkFlags;
329#[rustfmt::skip]
330pub const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT: VkCommandPoolCreateFlagBits = 0x00000001;
331#[rustfmt::skip]
332pub const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: VkCommandPoolCreateFlagBits = 0x00000002;
333#[cfg(feature = "Allow1_1APIs")]
334#[rustfmt::skip]
335pub const VK_COMMAND_POOL_CREATE_PROTECTED_BIT: VkCommandPoolCreateFlagBits = 0x00000004;
336
337#[rustfmt::skip]
338pub type VkCommandPoolResetFlags = VkFlags;
339#[rustfmt::skip]
340pub type VkCommandPoolResetFlagBits = VkFlags;
341#[rustfmt::skip]
342pub const VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: VkCommandPoolResetFlagBits = 0x00000001;
343
344#[cfg(feature = "VK_KHR_maintenance1")]
345#[rustfmt::skip]
346pub type VkCommandPoolTrimFlagsKHR = VkFlags;
347#[cfg(feature = "Allow1_1APIs")]
348#[rustfmt::skip]
349pub type VkCommandPoolTrimFlags = VkCommandPoolTrimFlagsKHR;
350#[cfg(feature = "VK_KHR_maintenance1")]
351#[rustfmt::skip]
352pub type VkCommandPoolTrimFlagBitsKHR = VkFlags;
353#[cfg(feature = "Allow1_1APIs")]
354#[rustfmt::skip]
355pub type VkCommandPoolTrimFlagBits = VkCommandPoolTrimFlagBitsKHR;
356
357#[cfg(feature = "VK_KHR_surface")]
358#[rustfmt::skip]
359pub type VkCompositeAlphaFlagsKHR = VkFlags;
360#[cfg(feature = "VK_KHR_surface")]
361#[rustfmt::skip]
362pub type VkCompositeAlphaFlagBitsKHR = VkFlags;
363#[cfg(feature = "VK_KHR_surface")]
364#[rustfmt::skip]
365pub const VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000001;
366#[cfg(feature = "VK_KHR_surface")]
367#[rustfmt::skip]
368pub const VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000002;
369#[cfg(feature = "VK_KHR_surface")]
370#[rustfmt::skip]
371pub const VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000004;
372#[cfg(feature = "VK_KHR_surface")]
373#[rustfmt::skip]
374pub const VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 0x00000008;
375
376#[rustfmt::skip]
377pub type VkCullModeFlags = VkFlags;
378#[rustfmt::skip]
379pub type VkCullModeFlagBits = VkFlags;
380#[rustfmt::skip]
381pub const VK_CULL_MODE_FRONT_BIT: VkCullModeFlagBits = 0x00000001;
382#[rustfmt::skip]
383pub const VK_CULL_MODE_BACK_BIT: VkCullModeFlagBits = 0x00000002;
384
385#[cfg(feature = "VK_EXT_debug_report")]
386#[rustfmt::skip]
387pub type VkDebugReportFlagsEXT = VkFlags;
388#[cfg(feature = "VK_EXT_debug_report")]
389#[rustfmt::skip]
390pub type VkDebugReportFlagBitsEXT = VkFlags;
391#[cfg(feature = "VK_EXT_debug_report")]
392#[rustfmt::skip]
393pub const VK_DEBUG_REPORT_INFORMATION_BIT_EXT: VkDebugReportFlagBitsEXT = 0x00000001;
394#[cfg(feature = "VK_EXT_debug_report")]
395#[rustfmt::skip]
396pub const VK_DEBUG_REPORT_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 0x00000002;
397#[cfg(feature = "VK_EXT_debug_report")]
398#[rustfmt::skip]
399pub const VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 0x00000004;
400#[cfg(feature = "VK_EXT_debug_report")]
401#[rustfmt::skip]
402pub const VK_DEBUG_REPORT_ERROR_BIT_EXT: VkDebugReportFlagBitsEXT = 0x00000008;
403#[cfg(feature = "VK_EXT_debug_report")]
404#[rustfmt::skip]
405pub const VK_DEBUG_REPORT_DEBUG_BIT_EXT: VkDebugReportFlagBitsEXT = 0x00000010;
406
407#[cfg(feature = "VK_EXT_debug_utils")]
408#[rustfmt::skip]
409pub type VkDebugUtilsMessageSeverityFlagsEXT = VkFlags;
410#[cfg(feature = "VK_EXT_debug_utils")]
411#[rustfmt::skip]
412pub type VkDebugUtilsMessageSeverityFlagBitsEXT = VkFlags;
413#[cfg(feature = "VK_EXT_debug_utils")]
414#[rustfmt::skip]
415pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 0x00000001;
416#[cfg(feature = "VK_EXT_debug_utils")]
417#[rustfmt::skip]
418pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 0x00000010;
419#[cfg(feature = "VK_EXT_debug_utils")]
420#[rustfmt::skip]
421pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 0x00000100;
422#[cfg(feature = "VK_EXT_debug_utils")]
423#[rustfmt::skip]
424pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 0x00001000;
425
426#[cfg(feature = "VK_EXT_debug_utils")]
427#[rustfmt::skip]
428pub type VkDebugUtilsMessageTypeFlagsEXT = VkFlags;
429#[cfg(feature = "VK_EXT_debug_utils")]
430#[rustfmt::skip]
431pub type VkDebugUtilsMessageTypeFlagBitsEXT = VkFlags;
432#[cfg(feature = "VK_EXT_debug_utils")]
433#[rustfmt::skip]
434pub const VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 0x00000001;
435#[cfg(feature = "VK_EXT_debug_utils")]
436#[rustfmt::skip]
437pub const VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 0x00000002;
438#[cfg(feature = "VK_EXT_debug_utils")]
439#[rustfmt::skip]
440pub const VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 0x00000004;
441
442#[cfg(feature = "VK_EXT_debug_utils")]
443#[rustfmt::skip]
444pub type VkDebugUtilsMessengerCallbackDataFlagsEXT = VkFlags;
445#[cfg(feature = "VK_EXT_debug_utils")]
446#[rustfmt::skip]
447pub type VkDebugUtilsMessengerCallbackDataFlagBitsEXT = VkFlags;
448
449#[cfg(feature = "VK_EXT_debug_utils")]
450#[rustfmt::skip]
451pub type VkDebugUtilsMessengerCreateFlagsEXT = VkFlags;
452#[cfg(feature = "VK_EXT_debug_utils")]
453#[rustfmt::skip]
454pub type VkDebugUtilsMessengerCreateFlagBitsEXT = VkFlags;
455
456#[rustfmt::skip]
457pub type VkDependencyFlags = VkFlags;
458#[rustfmt::skip]
459pub type VkDependencyFlagBits = VkFlags;
460#[rustfmt::skip]
461pub const VK_DEPENDENCY_BY_REGION_BIT: VkDependencyFlagBits = 0x00000001;
462#[cfg(feature = "VK_KHR_multiview")]
463#[rustfmt::skip]
464pub const VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR: VkDependencyFlagBits = 0x00000002;
465#[cfg(feature = "Allow1_1APIs")]
466#[rustfmt::skip]
467pub const VK_DEPENDENCY_VIEW_LOCAL_BIT: VkDependencyFlagBits = 0x00000002;
468#[cfg(feature = "VK_KHR_device_group")]
469#[rustfmt::skip]
470pub const VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR: VkDependencyFlagBits = 0x00000004;
471#[cfg(feature = "Allow1_1APIs")]
472#[rustfmt::skip]
473pub const VK_DEPENDENCY_DEVICE_GROUP_BIT: VkDependencyFlagBits = 0x00000004;
474
475#[rustfmt::skip]
476pub type VkDescriptorPoolCreateFlags = VkFlags;
477#[rustfmt::skip]
478pub type VkDescriptorPoolCreateFlagBits = VkFlags;
479#[rustfmt::skip]
480pub const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: VkDescriptorPoolCreateFlagBits = 0x00000001;
481
482#[rustfmt::skip]
483pub type VkDescriptorPoolResetFlags = VkFlags;
484#[rustfmt::skip]
485pub type VkDescriptorPoolResetFlagBits = VkFlags;
486
487#[rustfmt::skip]
488pub type VkDescriptorSetLayoutCreateFlags = VkFlags;
489#[rustfmt::skip]
490pub type VkDescriptorSetLayoutCreateFlagBits = VkFlags;
491
492#[cfg(feature = "VK_KHR_descriptor_update_template")]
493#[rustfmt::skip]
494pub type VkDescriptorUpdateTemplateCreateFlagsKHR = VkFlags;
495#[cfg(feature = "Allow1_1APIs")]
496#[rustfmt::skip]
497pub type VkDescriptorUpdateTemplateCreateFlags = VkDescriptorUpdateTemplateCreateFlagsKHR;
498#[cfg(feature = "VK_KHR_descriptor_update_template")]
499#[rustfmt::skip]
500pub type VkDescriptorUpdateTemplateCreateFlagBitsKHR = VkFlags;
501#[cfg(feature = "Allow1_1APIs")]
502#[rustfmt::skip]
503pub type VkDescriptorUpdateTemplateCreateFlagBits = VkDescriptorUpdateTemplateCreateFlagBitsKHR;
504
505#[rustfmt::skip]
506pub type VkDeviceCreateFlags = VkFlags;
507#[rustfmt::skip]
508pub type VkDeviceCreateFlagBits = VkFlags;
509
510#[cfg(feature = "VK_KHR_device_group")]
511#[cfg(feature = "VK_KHR_surface")]
512#[rustfmt::skip]
513pub type VkDeviceGroupPresentModeFlagsKHR = VkFlags;
514#[cfg(feature = "VK_KHR_device_group")]
515#[cfg(feature = "VK_KHR_surface")]
516#[rustfmt::skip]
517pub type VkDeviceGroupPresentModeFlagBitsKHR = VkFlags;
518
519#[rustfmt::skip]
520pub type VkDeviceQueueCreateFlags = VkFlags;
521#[rustfmt::skip]
522pub type VkDeviceQueueCreateFlagBits = VkFlags;
523#[rustfmt::skip]
524pub const VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT: VkDeviceQueueCreateFlagBits = 0x00000001;
525
526#[cfg(feature = "VK_KHR_display")]
527#[rustfmt::skip]
528pub type VkDisplayModeCreateFlagsKHR = VkFlags;
529#[cfg(feature = "VK_KHR_display")]
530#[rustfmt::skip]
531pub type VkDisplayModeCreateFlagBitsKHR = VkFlags;
532
533#[cfg(feature = "VK_KHR_display")]
534#[rustfmt::skip]
535pub type VkDisplayPlaneAlphaFlagsKHR = VkFlags;
536#[cfg(feature = "VK_KHR_display")]
537#[rustfmt::skip]
538pub type VkDisplayPlaneAlphaFlagBitsKHR = VkFlags;
539#[cfg(feature = "VK_KHR_display")]
540#[rustfmt::skip]
541pub const VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 0x00000001;
542#[cfg(feature = "VK_KHR_display")]
543#[rustfmt::skip]
544pub const VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 0x00000002;
545#[cfg(feature = "VK_KHR_display")]
546#[rustfmt::skip]
547pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 0x00000004;
548#[cfg(feature = "VK_KHR_display")]
549#[rustfmt::skip]
550pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 0x00000008;
551
552#[cfg(feature = "VK_KHR_display")]
553#[rustfmt::skip]
554pub type VkDisplaySurfaceCreateFlagsKHR = VkFlags;
555#[cfg(feature = "VK_KHR_display")]
556#[rustfmt::skip]
557pub type VkDisplaySurfaceCreateFlagBitsKHR = VkFlags;
558
559#[rustfmt::skip]
560pub type VkEventCreateFlags = VkFlags;
561#[rustfmt::skip]
562pub type VkEventCreateFlagBits = VkFlags;
563
564#[cfg(feature = "VK_KHR_external_fence_capabilities")]
565#[rustfmt::skip]
566pub type VkExternalFenceFeatureFlagsKHR = VkFlags;
567#[cfg(feature = "Allow1_1APIs")]
568#[rustfmt::skip]
569pub type VkExternalFenceFeatureFlags = VkExternalFenceFeatureFlagsKHR;
570#[cfg(feature = "VK_KHR_external_fence_capabilities")]
571#[rustfmt::skip]
572pub type VkExternalFenceFeatureFlagBitsKHR = VkFlags;
573#[cfg(feature = "Allow1_1APIs")]
574#[rustfmt::skip]
575pub type VkExternalFenceFeatureFlagBits = VkExternalFenceFeatureFlagBitsKHR;
576#[cfg(feature = "VK_KHR_external_fence_capabilities")]
577#[rustfmt::skip]
578pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBitsKHR = 0x00000001;
579#[cfg(feature = "Allow1_1APIs")]
580#[rustfmt::skip]
581pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT: VkExternalFenceFeatureFlagBitsKHR = 0x00000001;
582#[cfg(feature = "VK_KHR_external_fence_capabilities")]
583#[rustfmt::skip]
584pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBitsKHR = 0x00000002;
585#[cfg(feature = "Allow1_1APIs")]
586#[rustfmt::skip]
587pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT: VkExternalFenceFeatureFlagBitsKHR = 0x00000002;
588
589#[cfg(feature = "VK_KHR_external_fence_capabilities")]
590#[rustfmt::skip]
591pub type VkExternalFenceHandleTypeFlagsKHR = VkFlags;
592#[cfg(feature = "Allow1_1APIs")]
593#[rustfmt::skip]
594pub type VkExternalFenceHandleTypeFlags = VkExternalFenceHandleTypeFlagsKHR;
595#[cfg(feature = "VK_KHR_external_fence_capabilities")]
596#[rustfmt::skip]
597pub type VkExternalFenceHandleTypeFlagBitsKHR = VkFlags;
598#[cfg(feature = "Allow1_1APIs")]
599#[rustfmt::skip]
600pub type VkExternalFenceHandleTypeFlagBits = VkExternalFenceHandleTypeFlagBitsKHR;
601#[cfg(feature = "VK_KHR_external_fence_capabilities")]
602#[rustfmt::skip]
603pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000001;
604#[cfg(feature = "Allow1_1APIs")]
605#[rustfmt::skip]
606pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000001;
607#[cfg(feature = "VK_KHR_external_fence_capabilities")]
608#[rustfmt::skip]
609pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000002;
610#[cfg(feature = "Allow1_1APIs")]
611#[rustfmt::skip]
612pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000002;
613#[cfg(feature = "VK_KHR_external_fence_capabilities")]
614#[rustfmt::skip]
615pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000004;
616#[cfg(feature = "Allow1_1APIs")]
617#[rustfmt::skip]
618pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000004;
619#[cfg(feature = "VK_KHR_external_fence_capabilities")]
620#[rustfmt::skip]
621pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000008;
622#[cfg(feature = "Allow1_1APIs")]
623#[rustfmt::skip]
624pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalFenceHandleTypeFlagBitsKHR = 0x00000008;
625
626#[cfg(feature = "VK_KHR_external_memory_capabilities")]
627#[rustfmt::skip]
628pub type VkExternalMemoryFeatureFlagsKHR = VkFlags;
629#[cfg(feature = "Allow1_1APIs")]
630#[rustfmt::skip]
631pub type VkExternalMemoryFeatureFlags = VkExternalMemoryFeatureFlagsKHR;
632#[cfg(feature = "VK_KHR_external_memory_capabilities")]
633#[rustfmt::skip]
634pub type VkExternalMemoryFeatureFlagBitsKHR = VkFlags;
635#[cfg(feature = "Allow1_1APIs")]
636#[rustfmt::skip]
637pub type VkExternalMemoryFeatureFlagBits = VkExternalMemoryFeatureFlagBitsKHR;
638#[cfg(feature = "VK_KHR_external_memory_capabilities")]
639#[rustfmt::skip]
640pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR: VkExternalMemoryFeatureFlagBitsKHR = 0x00000001;
641#[cfg(feature = "Allow1_1APIs")]
642#[rustfmt::skip]
643pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT: VkExternalMemoryFeatureFlagBitsKHR = 0x00000001;
644#[cfg(feature = "VK_KHR_external_memory_capabilities")]
645#[rustfmt::skip]
646pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBitsKHR = 0x00000002;
647#[cfg(feature = "Allow1_1APIs")]
648#[rustfmt::skip]
649pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT: VkExternalMemoryFeatureFlagBitsKHR = 0x00000002;
650#[cfg(feature = "VK_KHR_external_memory_capabilities")]
651#[rustfmt::skip]
652pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBitsKHR = 0x00000004;
653#[cfg(feature = "Allow1_1APIs")]
654#[rustfmt::skip]
655pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT: VkExternalMemoryFeatureFlagBitsKHR = 0x00000004;
656
657#[cfg(feature = "VK_KHR_external_memory_capabilities")]
658#[rustfmt::skip]
659pub type VkExternalMemoryHandleTypeFlagsKHR = VkFlags;
660#[cfg(feature = "Allow1_1APIs")]
661#[rustfmt::skip]
662pub type VkExternalMemoryHandleTypeFlags = VkExternalMemoryHandleTypeFlagsKHR;
663#[cfg(feature = "VK_KHR_external_memory_capabilities")]
664#[rustfmt::skip]
665pub type VkExternalMemoryHandleTypeFlagBitsKHR = VkFlags;
666#[cfg(feature = "Allow1_1APIs")]
667#[rustfmt::skip]
668pub type VkExternalMemoryHandleTypeFlagBits = VkExternalMemoryHandleTypeFlagBitsKHR;
669#[cfg(feature = "VK_KHR_external_memory_capabilities")]
670#[rustfmt::skip]
671pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000001;
672#[cfg(feature = "Allow1_1APIs")]
673#[rustfmt::skip]
674pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000001;
675#[cfg(feature = "VK_KHR_external_memory_capabilities")]
676#[rustfmt::skip]
677pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000002;
678#[cfg(feature = "Allow1_1APIs")]
679#[rustfmt::skip]
680pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000002;
681#[cfg(feature = "VK_KHR_external_memory_capabilities")]
682#[rustfmt::skip]
683pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000004;
684#[cfg(feature = "Allow1_1APIs")]
685#[rustfmt::skip]
686pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000004;
687#[cfg(feature = "VK_KHR_external_memory_capabilities")]
688#[rustfmt::skip]
689pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000008;
690#[cfg(feature = "Allow1_1APIs")]
691#[rustfmt::skip]
692pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000008;
693#[cfg(feature = "VK_KHR_external_memory_capabilities")]
694#[rustfmt::skip]
695pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000010;
696#[cfg(feature = "Allow1_1APIs")]
697#[rustfmt::skip]
698pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000010;
699#[cfg(feature = "VK_KHR_external_memory_capabilities")]
700#[rustfmt::skip]
701pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000020;
702#[cfg(feature = "Allow1_1APIs")]
703#[rustfmt::skip]
704pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000020;
705#[cfg(feature = "VK_KHR_external_memory_capabilities")]
706#[rustfmt::skip]
707pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000040;
708#[cfg(feature = "Allow1_1APIs")]
709#[rustfmt::skip]
710pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT: VkExternalMemoryHandleTypeFlagBitsKHR = 0x00000040;
711
712#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
713#[rustfmt::skip]
714pub type VkExternalSemaphoreFeatureFlagsKHR = VkFlags;
715#[cfg(feature = "Allow1_1APIs")]
716#[rustfmt::skip]
717pub type VkExternalSemaphoreFeatureFlags = VkExternalSemaphoreFeatureFlagsKHR;
718#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
719#[rustfmt::skip]
720pub type VkExternalSemaphoreFeatureFlagBitsKHR = VkFlags;
721#[cfg(feature = "Allow1_1APIs")]
722#[rustfmt::skip]
723pub type VkExternalSemaphoreFeatureFlagBits = VkExternalSemaphoreFeatureFlagBitsKHR;
724#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
725#[rustfmt::skip]
726pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBitsKHR = 0x00000001;
727#[cfg(feature = "Allow1_1APIs")]
728#[rustfmt::skip]
729pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBitsKHR = 0x00000001;
730#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
731#[rustfmt::skip]
732pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBitsKHR = 0x00000002;
733#[cfg(feature = "Allow1_1APIs")]
734#[rustfmt::skip]
735pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBitsKHR = 0x00000002;
736
737#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
738#[rustfmt::skip]
739pub type VkExternalSemaphoreHandleTypeFlagsKHR = VkFlags;
740#[cfg(feature = "Allow1_1APIs")]
741#[rustfmt::skip]
742pub type VkExternalSemaphoreHandleTypeFlags = VkExternalSemaphoreHandleTypeFlagsKHR;
743#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
744#[rustfmt::skip]
745pub type VkExternalSemaphoreHandleTypeFlagBitsKHR = VkFlags;
746#[cfg(feature = "Allow1_1APIs")]
747#[rustfmt::skip]
748pub type VkExternalSemaphoreHandleTypeFlagBits = VkExternalSemaphoreHandleTypeFlagBitsKHR;
749#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
750#[rustfmt::skip]
751pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000001;
752#[cfg(feature = "Allow1_1APIs")]
753#[rustfmt::skip]
754pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000001;
755#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
756#[rustfmt::skip]
757pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000002;
758#[cfg(feature = "Allow1_1APIs")]
759#[rustfmt::skip]
760pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000002;
761#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
762#[rustfmt::skip]
763pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000004;
764#[cfg(feature = "Allow1_1APIs")]
765#[rustfmt::skip]
766pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000004;
767#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
768#[rustfmt::skip]
769pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000008;
770#[cfg(feature = "Allow1_1APIs")]
771#[rustfmt::skip]
772pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000008;
773#[cfg(feature = "Allow1_1APIs")]
774#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
775#[rustfmt::skip]
776pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000008;
777#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
778#[rustfmt::skip]
779pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000010;
780#[cfg(feature = "Allow1_1APIs")]
781#[rustfmt::skip]
782pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalSemaphoreHandleTypeFlagBitsKHR = 0x00000010;
783
784#[rustfmt::skip]
785pub type VkFenceCreateFlags = VkFlags;
786#[rustfmt::skip]
787pub type VkFenceCreateFlagBits = VkFlags;
788#[rustfmt::skip]
789pub const VK_FENCE_CREATE_SIGNALED_BIT: VkFenceCreateFlagBits = 0x00000001;
790
791#[cfg(feature = "VK_KHR_external_fence")]
792#[rustfmt::skip]
793pub type VkFenceImportFlagsKHR = VkFlags;
794#[cfg(feature = "Allow1_1APIs")]
795#[rustfmt::skip]
796pub type VkFenceImportFlags = VkFenceImportFlagsKHR;
797#[cfg(feature = "VK_KHR_external_fence")]
798#[rustfmt::skip]
799pub type VkFenceImportFlagBitsKHR = VkFlags;
800#[cfg(feature = "Allow1_1APIs")]
801#[rustfmt::skip]
802pub type VkFenceImportFlagBits = VkFenceImportFlagBitsKHR;
803#[cfg(feature = "VK_KHR_external_fence")]
804#[rustfmt::skip]
805pub const VK_FENCE_IMPORT_TEMPORARY_BIT_KHR: VkFenceImportFlagBitsKHR = 0x00000001;
806#[cfg(feature = "Allow1_1APIs")]
807#[rustfmt::skip]
808pub const VK_FENCE_IMPORT_TEMPORARY_BIT: VkFenceImportFlagBitsKHR = 0x00000001;
809
810#[rustfmt::skip]
811pub type VkFormatFeatureFlags = VkFlags;
812#[rustfmt::skip]
813pub type VkFormatFeatureFlagBits = VkFlags;
814#[rustfmt::skip]
815pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT: VkFormatFeatureFlagBits = 0x00000001;
816#[rustfmt::skip]
817pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT: VkFormatFeatureFlagBits = 0x00000002;
818#[rustfmt::skip]
819pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlagBits = 0x00000004;
820#[rustfmt::skip]
821pub const VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 0x00000008;
822#[rustfmt::skip]
823pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 0x00000010;
824#[rustfmt::skip]
825pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlagBits = 0x00000020;
826#[rustfmt::skip]
827pub const VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT: VkFormatFeatureFlagBits = 0x00000040;
828#[rustfmt::skip]
829pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 0x00000080;
830#[rustfmt::skip]
831pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlagBits = 0x00000100;
832#[rustfmt::skip]
833pub const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 0x00000200;
834#[rustfmt::skip]
835pub const VK_FORMAT_FEATURE_BLIT_SRC_BIT: VkFormatFeatureFlagBits = 0x00000400;
836#[rustfmt::skip]
837pub const VK_FORMAT_FEATURE_BLIT_DST_BIT: VkFormatFeatureFlagBits = 0x00000800;
838#[rustfmt::skip]
839pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlagBits = 0x00001000;
840#[cfg(feature = "VK_KHR_maintenance1")]
841#[rustfmt::skip]
842pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlagBits = 0x00004000;
843#[cfg(feature = "Allow1_1APIs")]
844#[rustfmt::skip]
845pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT: VkFormatFeatureFlagBits = 0x00004000;
846#[cfg(feature = "VK_KHR_maintenance1")]
847#[rustfmt::skip]
848pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlagBits = 0x00008000;
849#[cfg(feature = "Allow1_1APIs")]
850#[rustfmt::skip]
851pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT: VkFormatFeatureFlagBits = 0x00008000;
852#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
853#[rustfmt::skip]
854pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = 0x00020000;
855#[cfg(feature = "Allow1_1APIs")]
856#[rustfmt::skip]
857pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 0x00020000;
858#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
859#[rustfmt::skip]
860pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlagBits = 0x00040000;
861#[cfg(feature = "Allow1_1APIs")]
862#[rustfmt::skip]
863pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlagBits = 0x00040000;
864#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
865#[rustfmt::skip]
866pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: VkFormatFeatureFlagBits = 0x00080000;
867#[cfg(feature = "Allow1_1APIs")]
868#[rustfmt::skip]
869pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlagBits = 0x00080000;
870#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
871#[rustfmt::skip]
872pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: VkFormatFeatureFlagBits = 0x00100000;
873#[cfg(feature = "Allow1_1APIs")]
874#[rustfmt::skip]
875pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlagBits = 0x00100000;
876#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
877#[rustfmt::skip]
878pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: VkFormatFeatureFlagBits = 0x00200000;
879#[cfg(feature = "Allow1_1APIs")]
880#[rustfmt::skip]
881pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlagBits = 0x00200000;
882#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
883#[rustfmt::skip]
884pub const VK_FORMAT_FEATURE_DISJOINT_BIT_KHR: VkFormatFeatureFlagBits = 0x00400000;
885#[cfg(feature = "Allow1_1APIs")]
886#[rustfmt::skip]
887pub const VK_FORMAT_FEATURE_DISJOINT_BIT: VkFormatFeatureFlagBits = 0x00400000;
888#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
889#[rustfmt::skip]
890pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = 0x00800000;
891#[cfg(feature = "Allow1_1APIs")]
892#[rustfmt::skip]
893pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 0x00800000;
894
895#[rustfmt::skip]
896pub type VkFramebufferCreateFlags = VkFlags;
897#[rustfmt::skip]
898pub type VkFramebufferCreateFlagBits = VkFlags;
899
900#[rustfmt::skip]
901pub type VkInstanceCreateFlags = VkFlags;
902#[rustfmt::skip]
903pub type VkInstanceCreateFlagBits = VkFlags;
904#[cfg(feature = "VK_KHR_portability_enumeration")]
905#[rustfmt::skip]
906pub const VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR: VkInstanceCreateFlagBits = 0x00000001;
907#[cfg(feature = "Allow1_1APIs")]
908#[rustfmt::skip]
909pub const VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT: VkInstanceCreateFlagBits = 0x00000001;
910
911#[rustfmt::skip]
912pub type VkImageAspectFlags = VkFlags;
913#[rustfmt::skip]
914pub type VkImageAspectFlagBits = VkFlags;
915#[rustfmt::skip]
916pub const VK_IMAGE_ASPECT_COLOR_BIT: VkImageAspectFlagBits = 0x00000001;
917#[rustfmt::skip]
918pub const VK_IMAGE_ASPECT_DEPTH_BIT: VkImageAspectFlagBits = 0x00000002;
919#[rustfmt::skip]
920pub const VK_IMAGE_ASPECT_STENCIL_BIT: VkImageAspectFlagBits = 0x00000004;
921#[rustfmt::skip]
922pub const VK_IMAGE_ASPECT_METADATA_BIT: VkImageAspectFlagBits = 0x00000008;
923#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
924#[rustfmt::skip]
925pub const VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: VkImageAspectFlagBits = 0x00000010;
926#[cfg(feature = "Allow1_1APIs")]
927#[rustfmt::skip]
928pub const VK_IMAGE_ASPECT_PLANE_0_BIT: VkImageAspectFlagBits = 0x00000010;
929#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
930#[rustfmt::skip]
931pub const VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: VkImageAspectFlagBits = 0x00000020;
932#[cfg(feature = "Allow1_1APIs")]
933#[rustfmt::skip]
934pub const VK_IMAGE_ASPECT_PLANE_1_BIT: VkImageAspectFlagBits = 0x00000020;
935#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
936#[rustfmt::skip]
937pub const VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: VkImageAspectFlagBits = 0x00000040;
938#[cfg(feature = "Allow1_1APIs")]
939#[rustfmt::skip]
940pub const VK_IMAGE_ASPECT_PLANE_2_BIT: VkImageAspectFlagBits = 0x00000040;
941
942#[rustfmt::skip]
943pub type VkImageUsageFlags = VkFlags;
944#[rustfmt::skip]
945pub type VkImageUsageFlagBits = VkFlags;
946#[rustfmt::skip]
947pub const VK_IMAGE_USAGE_TRANSFER_SRC_BIT: VkImageUsageFlagBits = 0x00000001;
948#[rustfmt::skip]
949pub const VK_IMAGE_USAGE_TRANSFER_DST_BIT: VkImageUsageFlagBits = 0x00000002;
950#[rustfmt::skip]
951pub const VK_IMAGE_USAGE_SAMPLED_BIT: VkImageUsageFlagBits = 0x00000004;
952#[rustfmt::skip]
953pub const VK_IMAGE_USAGE_STORAGE_BIT: VkImageUsageFlagBits = 0x00000008;
954#[rustfmt::skip]
955pub const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: VkImageUsageFlagBits = 0x00000010;
956#[rustfmt::skip]
957pub const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: VkImageUsageFlagBits = 0x00000020;
958#[rustfmt::skip]
959pub const VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: VkImageUsageFlagBits = 0x00000040;
960#[rustfmt::skip]
961pub const VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT: VkImageUsageFlagBits = 0x00000080;
962
963#[rustfmt::skip]
964pub type VkImageCreateFlags = VkFlags;
965#[rustfmt::skip]
966pub type VkImageCreateFlagBits = VkFlags;
967#[rustfmt::skip]
968pub const VK_IMAGE_CREATE_SPARSE_BINDING_BIT: VkImageCreateFlagBits = 0x00000001;
969#[rustfmt::skip]
970pub const VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT: VkImageCreateFlagBits = 0x00000002;
971#[rustfmt::skip]
972pub const VK_IMAGE_CREATE_SPARSE_ALIASED_BIT: VkImageCreateFlagBits = 0x00000004;
973#[rustfmt::skip]
974pub const VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT: VkImageCreateFlagBits = 0x00000008;
975#[rustfmt::skip]
976pub const VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT: VkImageCreateFlagBits = 0x00000010;
977#[cfg(feature = "VK_KHR_maintenance1")]
978#[rustfmt::skip]
979pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = 0x00000020;
980#[cfg(feature = "Allow1_1APIs")]
981#[rustfmt::skip]
982pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT: VkImageCreateFlagBits = 0x00000020;
983#[cfg(feature = "VK_KHR_bind_memory2")]
984#[cfg(feature = "VK_KHR_device_group")]
985#[rustfmt::skip]
986pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkImageCreateFlagBits = 0x00000040;
987#[cfg(feature = "Allow1_1APIs")]
988#[rustfmt::skip]
989pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT: VkImageCreateFlagBits = 0x00000040;
990#[cfg(feature = "VK_KHR_maintenance2")]
991#[rustfmt::skip]
992pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = 0x00000080;
993#[cfg(feature = "Allow1_1APIs")]
994#[rustfmt::skip]
995pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT: VkImageCreateFlagBits = 0x00000080;
996#[cfg(feature = "VK_KHR_maintenance2")]
997#[rustfmt::skip]
998pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR: VkImageCreateFlagBits = 0x00000100;
999#[cfg(feature = "Allow1_1APIs")]
1000#[rustfmt::skip]
1001pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT: VkImageCreateFlagBits = 0x00000100;
1002#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
1003#[rustfmt::skip]
1004pub const VK_IMAGE_CREATE_DISJOINT_BIT_KHR: VkImageCreateFlagBits = 0x00000200;
1005#[cfg(feature = "Allow1_1APIs")]
1006#[rustfmt::skip]
1007pub const VK_IMAGE_CREATE_DISJOINT_BIT: VkImageCreateFlagBits = 0x00000200;
1008#[cfg(feature = "VK_KHR_bind_memory2")]
1009#[rustfmt::skip]
1010pub const VK_IMAGE_CREATE_ALIAS_BIT_KHR: VkImageCreateFlagBits = 0x00000400;
1011#[cfg(feature = "Allow1_1APIs")]
1012#[rustfmt::skip]
1013pub const VK_IMAGE_CREATE_ALIAS_BIT: VkImageCreateFlagBits = 0x00000400;
1014#[rustfmt::skip]
1015pub const VK_IMAGE_CREATE_PROTECTED_BIT: VkImageCreateFlagBits = 0x00000800;
1016
1017#[rustfmt::skip]
1018pub type VkImageViewCreateFlags = VkFlags;
1019#[rustfmt::skip]
1020pub type VkImageViewCreateFlagBits = VkFlags;
1021
1022#[cfg(feature = "VK_KHR_device_group")]
1023#[rustfmt::skip]
1024pub type VkMemoryAllocateFlagsKHR = VkFlags;
1025#[cfg(feature = "Allow1_1APIs")]
1026#[rustfmt::skip]
1027pub type VkMemoryAllocateFlags = VkMemoryAllocateFlagsKHR;
1028#[cfg(feature = "VK_KHR_device_group")]
1029#[rustfmt::skip]
1030pub type VkMemoryAllocateFlagBitsKHR = VkFlags;
1031#[cfg(feature = "Allow1_1APIs")]
1032#[rustfmt::skip]
1033pub type VkMemoryAllocateFlagBits = VkMemoryAllocateFlagBitsKHR;
1034#[cfg(feature = "VK_KHR_device_group")]
1035#[rustfmt::skip]
1036pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR: VkMemoryAllocateFlagBitsKHR = 0x00000001;
1037#[cfg(feature = "Allow1_1APIs")]
1038#[rustfmt::skip]
1039pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT: VkMemoryAllocateFlagBitsKHR = 0x00000001;
1040
1041#[rustfmt::skip]
1042pub type VkMemoryHeapFlags = VkFlags;
1043#[rustfmt::skip]
1044pub type VkMemoryHeapFlagBits = VkFlags;
1045#[rustfmt::skip]
1046pub const VK_MEMORY_HEAP_DEVICE_LOCAL_BIT: VkMemoryHeapFlagBits = 0x00000001;
1047#[cfg(feature = "Allow1_1APIs")]
1048#[rustfmt::skip]
1049pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT: VkMemoryHeapFlagBits = 0x00000002;
1050
1051#[rustfmt::skip]
1052pub type VkMemoryPropertyFlags = VkFlags;
1053#[rustfmt::skip]
1054pub type VkMemoryPropertyFlagBits = VkFlags;
1055#[rustfmt::skip]
1056pub const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT: VkMemoryPropertyFlagBits = 0x00000001;
1057#[rustfmt::skip]
1058pub const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT: VkMemoryPropertyFlagBits = 0x00000002;
1059#[rustfmt::skip]
1060pub const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT: VkMemoryPropertyFlagBits = 0x00000004;
1061#[rustfmt::skip]
1062pub const VK_MEMORY_PROPERTY_HOST_CACHED_BIT: VkMemoryPropertyFlagBits = 0x00000008;
1063#[rustfmt::skip]
1064pub const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: VkMemoryPropertyFlagBits = 0x00000010;
1065#[rustfmt::skip]
1066pub const VK_MEMORY_PROPERTY_PROTECTED_BIT: VkMemoryPropertyFlagBits = 0x00000020;
1067
1068#[rustfmt::skip]
1069pub type VkMemoryMapFlags = VkFlags;
1070#[rustfmt::skip]
1071pub type VkMemoryMapFlagBits = VkFlags;
1072
1073#[cfg(feature = "VK_EXT_metal_surface")]
1074#[rustfmt::skip]
1075pub type VkMetalSurfaceCreateFlagsEXT = VkFlags;
1076#[cfg(feature = "VK_EXT_metal_surface")]
1077#[rustfmt::skip]
1078pub type VkMetalSurfaceCreateFlagBitsEXT = VkFlags;
1079
1080#[cfg(feature = "VK_KHR_device_group")]
1081#[rustfmt::skip]
1082pub type VkPeerMemoryFeatureFlagsKHR = VkFlags;
1083#[cfg(feature = "Allow1_1APIs")]
1084#[rustfmt::skip]
1085pub type VkPeerMemoryFeatureFlags = VkPeerMemoryFeatureFlagsKHR;
1086#[cfg(feature = "VK_KHR_device_group")]
1087#[rustfmt::skip]
1088pub type VkPeerMemoryFeatureFlagBitsKHR = VkFlags;
1089#[cfg(feature = "Allow1_1APIs")]
1090#[rustfmt::skip]
1091pub type VkPeerMemoryFeatureFlagBits = VkPeerMemoryFeatureFlagBitsKHR;
1092#[cfg(feature = "VK_KHR_device_group")]
1093#[rustfmt::skip]
1094pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBitsKHR = 0x00000001;
1095#[cfg(feature = "Allow1_1APIs")]
1096#[rustfmt::skip]
1097pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT: VkPeerMemoryFeatureFlagBitsKHR = 0x00000001;
1098#[cfg(feature = "VK_KHR_device_group")]
1099#[rustfmt::skip]
1100pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR: VkPeerMemoryFeatureFlagBitsKHR = 0x00000002;
1101#[cfg(feature = "Allow1_1APIs")]
1102#[rustfmt::skip]
1103pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT: VkPeerMemoryFeatureFlagBitsKHR = 0x00000002;
1104#[cfg(feature = "VK_KHR_device_group")]
1105#[rustfmt::skip]
1106pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBitsKHR = 0x00000004;
1107#[cfg(feature = "Allow1_1APIs")]
1108#[rustfmt::skip]
1109pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT: VkPeerMemoryFeatureFlagBitsKHR = 0x00000004;
1110#[cfg(feature = "VK_KHR_device_group")]
1111#[rustfmt::skip]
1112pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR: VkPeerMemoryFeatureFlagBitsKHR = 0x00000008;
1113#[cfg(feature = "Allow1_1APIs")]
1114#[rustfmt::skip]
1115pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT: VkPeerMemoryFeatureFlagBitsKHR = 0x00000008;
1116
1117#[rustfmt::skip]
1118pub type VkPipelineCacheCreateFlags = VkFlags;
1119#[rustfmt::skip]
1120pub type VkPipelineCacheCreateFlagBits = VkFlags;
1121
1122#[rustfmt::skip]
1123pub type VkPipelineCreateFlags = VkFlags;
1124#[rustfmt::skip]
1125pub type VkPipelineCreateFlagBits = VkFlags;
1126#[rustfmt::skip]
1127pub const VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlagBits = 0x00000001;
1128#[rustfmt::skip]
1129pub const VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlagBits = 0x00000002;
1130#[rustfmt::skip]
1131pub const VK_PIPELINE_CREATE_DERIVATIVE_BIT: VkPipelineCreateFlagBits = 0x00000004;
1132#[cfg(feature = "VK_KHR_device_group")]
1133#[rustfmt::skip]
1134pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlagBits = 0x00000008;
1135#[cfg(feature = "Allow1_1APIs")]
1136#[rustfmt::skip]
1137pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlagBits = 0x00000008;
1138#[cfg(feature = "VK_KHR_device_group")]
1139#[rustfmt::skip]
1140pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlagBits = 0x00000010;
1141#[cfg(feature = "Allow1_1APIs")]
1142#[rustfmt::skip]
1143pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT: VkPipelineCreateFlagBits = 0x00000010;
1144
1145#[rustfmt::skip]
1146pub type VkPipelineLayoutCreateFlags = VkFlags;
1147#[rustfmt::skip]
1148pub type VkPipelineLayoutCreateFlagBits = VkFlags;
1149
1150#[rustfmt::skip]
1151pub type VkPipelineDepthStencilStateCreateFlags = VkFlags;
1152#[rustfmt::skip]
1153pub type VkPipelineDepthStencilStateCreateFlagBits = VkFlags;
1154
1155#[rustfmt::skip]
1156pub type VkPipelineDynamicStateCreateFlags = VkFlags;
1157#[rustfmt::skip]
1158pub type VkPipelineDynamicStateCreateFlagBits = VkFlags;
1159
1160#[rustfmt::skip]
1161pub type VkPipelineColorBlendStateCreateFlags = VkFlags;
1162#[rustfmt::skip]
1163pub type VkPipelineColorBlendStateCreateFlagBits = VkFlags;
1164
1165#[rustfmt::skip]
1166pub type VkPipelineMultisampleStateCreateFlags = VkFlags;
1167#[rustfmt::skip]
1168pub type VkPipelineMultisampleStateCreateFlagBits = VkFlags;
1169
1170#[rustfmt::skip]
1171pub type VkPipelineRasterizationStateCreateFlags = VkFlags;
1172#[rustfmt::skip]
1173pub type VkPipelineRasterizationStateCreateFlagBits = VkFlags;
1174
1175#[rustfmt::skip]
1176pub type VkPipelineViewportStateCreateFlags = VkFlags;
1177#[rustfmt::skip]
1178pub type VkPipelineViewportStateCreateFlagBits = VkFlags;
1179
1180#[rustfmt::skip]
1181pub type VkPipelineTessellationStateCreateFlags = VkFlags;
1182#[rustfmt::skip]
1183pub type VkPipelineTessellationStateCreateFlagBits = VkFlags;
1184
1185#[rustfmt::skip]
1186pub type VkPipelineInputAssemblyStateCreateFlags = VkFlags;
1187#[rustfmt::skip]
1188pub type VkPipelineInputAssemblyStateCreateFlagBits = VkFlags;
1189
1190#[rustfmt::skip]
1191pub type VkPipelineVertexInputStateCreateFlags = VkFlags;
1192#[rustfmt::skip]
1193pub type VkPipelineVertexInputStateCreateFlagBits = VkFlags;
1194
1195#[rustfmt::skip]
1196pub type VkPipelineShaderStageCreateFlags = VkFlags;
1197#[rustfmt::skip]
1198pub type VkPipelineShaderStageCreateFlagBits = VkFlags;
1199
1200#[rustfmt::skip]
1201pub type VkPipelineStageFlags = VkFlags;
1202#[rustfmt::skip]
1203pub type VkPipelineStageFlagBits = VkFlags;
1204#[rustfmt::skip]
1205pub const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits = 0x00000001;
1206#[rustfmt::skip]
1207pub const VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits = 0x00000002;
1208#[rustfmt::skip]
1209pub const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: VkPipelineStageFlagBits = 0x00000004;
1210#[rustfmt::skip]
1211pub const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: VkPipelineStageFlagBits = 0x00000008;
1212#[rustfmt::skip]
1213pub const VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits = 0x00000010;
1214#[rustfmt::skip]
1215pub const VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits = 0x00000020;
1216#[rustfmt::skip]
1217pub const VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits = 0x00000040;
1218#[rustfmt::skip]
1219pub const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits = 0x00000080;
1220#[rustfmt::skip]
1221pub const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 0x00000100;
1222#[rustfmt::skip]
1223pub const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 0x00000200;
1224#[rustfmt::skip]
1225pub const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits = 0x00000400;
1226#[rustfmt::skip]
1227pub const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits = 0x00000800;
1228#[rustfmt::skip]
1229pub const VK_PIPELINE_STAGE_TRANSFER_BIT: VkPipelineStageFlagBits = 0x00001000;
1230#[rustfmt::skip]
1231pub const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits = 0x00002000;
1232#[rustfmt::skip]
1233pub const VK_PIPELINE_STAGE_HOST_BIT: VkPipelineStageFlagBits = 0x00004000;
1234#[rustfmt::skip]
1235pub const VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits = 0x00008000;
1236#[rustfmt::skip]
1237pub const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT: VkPipelineStageFlagBits = 0x00010000;
1238
1239#[cfg(feature = "VK_KHR_synchronization2")]
1240#[rustfmt::skip]
1241pub type VkPipelineStageFlags2KHR = VkFlags64;
1242#[cfg(feature = "Allow1_3APIs")]
1243#[rustfmt::skip]
1244pub type VkPipelineStageFlags2 = VkPipelineStageFlags2KHR;
1245#[cfg(feature = "VK_KHR_synchronization2")]
1246#[rustfmt::skip]
1247pub type VkPipelineStageFlagBits2KHR = VkFlags64;
1248#[cfg(feature = "Allow1_3APIs")]
1249#[rustfmt::skip]
1250pub type VkPipelineStageFlagBits2 = VkPipelineStageFlagBits2KHR;
1251#[cfg(feature = "VK_KHR_synchronization2")]
1252#[rustfmt::skip]
1253pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000001;
1254#[cfg(feature = "Allow1_3APIs")]
1255#[rustfmt::skip]
1256pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000001;
1257#[cfg(feature = "VK_KHR_synchronization2")]
1258#[rustfmt::skip]
1259pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000002;
1260#[cfg(feature = "Allow1_3APIs")]
1261#[rustfmt::skip]
1262pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000002;
1263#[cfg(feature = "VK_KHR_synchronization2")]
1264#[rustfmt::skip]
1265pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000004;
1266#[cfg(feature = "Allow1_3APIs")]
1267#[rustfmt::skip]
1268pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000004;
1269#[cfg(feature = "VK_KHR_synchronization2")]
1270#[rustfmt::skip]
1271pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000008;
1272#[cfg(feature = "Allow1_3APIs")]
1273#[rustfmt::skip]
1274pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000008;
1275#[cfg(feature = "VK_KHR_synchronization2")]
1276#[rustfmt::skip]
1277pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000010;
1278#[cfg(feature = "Allow1_3APIs")]
1279#[rustfmt::skip]
1280pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000010;
1281#[cfg(feature = "VK_KHR_synchronization2")]
1282#[rustfmt::skip]
1283pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000020;
1284#[cfg(feature = "Allow1_3APIs")]
1285#[rustfmt::skip]
1286pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000020;
1287#[cfg(feature = "VK_KHR_synchronization2")]
1288#[rustfmt::skip]
1289pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000040;
1290#[cfg(feature = "Allow1_3APIs")]
1291#[rustfmt::skip]
1292pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000040;
1293#[cfg(feature = "VK_KHR_synchronization2")]
1294#[rustfmt::skip]
1295pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000080;
1296#[cfg(feature = "Allow1_3APIs")]
1297#[rustfmt::skip]
1298pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000080;
1299#[cfg(feature = "VK_KHR_synchronization2")]
1300#[rustfmt::skip]
1301pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000100;
1302#[cfg(feature = "Allow1_3APIs")]
1303#[rustfmt::skip]
1304pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000100;
1305#[cfg(feature = "VK_KHR_synchronization2")]
1306#[rustfmt::skip]
1307pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000200;
1308#[cfg(feature = "Allow1_3APIs")]
1309#[rustfmt::skip]
1310pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000200;
1311#[cfg(feature = "VK_KHR_synchronization2")]
1312#[rustfmt::skip]
1313pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000400;
1314#[cfg(feature = "Allow1_3APIs")]
1315#[rustfmt::skip]
1316pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000400;
1317#[cfg(feature = "VK_KHR_synchronization2")]
1318#[rustfmt::skip]
1319pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000000800;
1320#[cfg(feature = "Allow1_3APIs")]
1321#[rustfmt::skip]
1322pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000000800;
1323#[cfg(feature = "VK_KHR_synchronization2")]
1324#[rustfmt::skip]
1325pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000001000;
1326#[cfg(feature = "Allow1_3APIs")]
1327#[rustfmt::skip]
1328pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000001000;
1329#[cfg(feature = "VK_KHR_synchronization2")]
1330#[rustfmt::skip]
1331pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000002000;
1332#[cfg(feature = "Allow1_3APIs")]
1333#[rustfmt::skip]
1334pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000002000;
1335#[cfg(feature = "VK_KHR_synchronization2")]
1336#[rustfmt::skip]
1337pub const VK_PIPELINE_STAGE_2_HOST_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000004000;
1338#[cfg(feature = "Allow1_3APIs")]
1339#[rustfmt::skip]
1340pub const VK_PIPELINE_STAGE_2_HOST_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000004000;
1341#[cfg(feature = "VK_KHR_synchronization2")]
1342#[rustfmt::skip]
1343pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000008000;
1344#[cfg(feature = "Allow1_3APIs")]
1345#[rustfmt::skip]
1346pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000008000;
1347#[cfg(feature = "VK_KHR_synchronization2")]
1348#[rustfmt::skip]
1349pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000000010000;
1350#[cfg(feature = "Allow1_3APIs")]
1351#[rustfmt::skip]
1352pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT: VkPipelineStageFlagBits2KHR = 0x0000000000010000;
1353#[cfg(feature = "VK_KHR_synchronization2")]
1354#[rustfmt::skip]
1355pub const VK_PIPELINE_STAGE_2_COPY_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000100000000;
1356#[cfg(feature = "Allow1_3APIs")]
1357#[rustfmt::skip]
1358pub const VK_PIPELINE_STAGE_2_COPY_BIT: VkPipelineStageFlagBits2KHR = 0x0000000100000000;
1359#[cfg(feature = "VK_KHR_synchronization2")]
1360#[rustfmt::skip]
1361pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000200000000;
1362#[cfg(feature = "Allow1_3APIs")]
1363#[rustfmt::skip]
1364pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT: VkPipelineStageFlagBits2KHR = 0x0000000200000000;
1365#[cfg(feature = "VK_KHR_synchronization2")]
1366#[rustfmt::skip]
1367pub const VK_PIPELINE_STAGE_2_BLIT_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000400000000;
1368#[cfg(feature = "Allow1_3APIs")]
1369#[rustfmt::skip]
1370pub const VK_PIPELINE_STAGE_2_BLIT_BIT: VkPipelineStageFlagBits2KHR = 0x0000000400000000;
1371#[cfg(feature = "VK_KHR_synchronization2")]
1372#[rustfmt::skip]
1373pub const VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000000800000000;
1374#[cfg(feature = "Allow1_3APIs")]
1375#[rustfmt::skip]
1376pub const VK_PIPELINE_STAGE_2_CLEAR_BIT: VkPipelineStageFlagBits2KHR = 0x0000000800000000;
1377#[cfg(feature = "VK_KHR_synchronization2")]
1378#[rustfmt::skip]
1379pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000001000000000;
1380#[cfg(feature = "Allow1_3APIs")]
1381#[rustfmt::skip]
1382pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT: VkPipelineStageFlagBits2KHR = 0x0000001000000000;
1383#[cfg(feature = "VK_KHR_synchronization2")]
1384#[rustfmt::skip]
1385pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000002000000000;
1386#[cfg(feature = "Allow1_3APIs")]
1387#[rustfmt::skip]
1388pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT: VkPipelineStageFlagBits2KHR = 0x0000002000000000;
1389#[cfg(feature = "VK_KHR_synchronization2")]
1390#[rustfmt::skip]
1391pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR: VkPipelineStageFlagBits2KHR = 0x0000004000000000;
1392#[cfg(feature = "Allow1_3APIs")]
1393#[rustfmt::skip]
1394pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT: VkPipelineStageFlagBits2KHR = 0x0000004000000000;
1395
1396#[rustfmt::skip]
1397pub type VkQueryControlFlags = VkFlags;
1398#[rustfmt::skip]
1399pub type VkQueryControlFlagBits = VkFlags;
1400#[rustfmt::skip]
1401pub const VK_QUERY_CONTROL_PRECISE_BIT: VkQueryControlFlagBits = 0x00000001;
1402
1403#[rustfmt::skip]
1404pub type VkQueryPipelineStatisticFlags = VkFlags;
1405#[rustfmt::skip]
1406pub type VkQueryPipelineStatisticFlagBits = VkFlags;
1407#[rustfmt::skip]
1408pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: VkQueryPipelineStatisticFlagBits = 0x00000001;
1409#[rustfmt::skip]
1410pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 0x00000002;
1411#[rustfmt::skip]
1412pub const VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 0x00000004;
1413#[rustfmt::skip]
1414pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 0x00000008;
1415#[rustfmt::skip]
1416pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 0x00000010;
1417#[rustfmt::skip]
1418pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 0x00000020;
1419#[rustfmt::skip]
1420pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 0x00000040;
1421#[rustfmt::skip]
1422pub const VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 0x00000080;
1423#[rustfmt::skip]
1424pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: VkQueryPipelineStatisticFlagBits = 0x00000100;
1425#[rustfmt::skip]
1426pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 0x00000200;
1427#[rustfmt::skip]
1428pub const VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 0x00000400;
1429
1430#[rustfmt::skip]
1431pub type VkQueryPoolCreateFlags = VkFlags;
1432#[rustfmt::skip]
1433pub type VkQueryPoolCreateFlagBits = VkFlags;
1434
1435#[rustfmt::skip]
1436pub type VkQueryResultFlags = VkFlags;
1437#[rustfmt::skip]
1438pub type VkQueryResultFlagBits = VkFlags;
1439#[rustfmt::skip]
1440pub const VK_QUERY_RESULT_64_BIT: VkQueryResultFlagBits = 0x00000001;
1441#[rustfmt::skip]
1442pub const VK_QUERY_RESULT_WAIT_BIT: VkQueryResultFlagBits = 0x00000002;
1443#[rustfmt::skip]
1444pub const VK_QUERY_RESULT_WITH_AVAILABILITY_BIT: VkQueryResultFlagBits = 0x00000004;
1445#[rustfmt::skip]
1446pub const VK_QUERY_RESULT_PARTIAL_BIT: VkQueryResultFlagBits = 0x00000008;
1447
1448#[rustfmt::skip]
1449pub type VkQueueFlags = VkFlags;
1450#[rustfmt::skip]
1451pub type VkQueueFlagBits = VkFlags;
1452#[rustfmt::skip]
1453pub const VK_QUEUE_GRAPHICS_BIT: VkQueueFlagBits = 0x00000001;
1454#[rustfmt::skip]
1455pub const VK_QUEUE_COMPUTE_BIT: VkQueueFlagBits = 0x00000002;
1456#[rustfmt::skip]
1457pub const VK_QUEUE_TRANSFER_BIT: VkQueueFlagBits = 0x00000004;
1458#[rustfmt::skip]
1459pub const VK_QUEUE_SPARSE_BINDING_BIT: VkQueueFlagBits = 0x00000008;
1460#[rustfmt::skip]
1461pub const VK_QUEUE_PROTECTED_BIT: VkQueueFlagBits = 0x00000010;
1462
1463#[rustfmt::skip]
1464pub type VkRenderPassCreateFlags = VkFlags;
1465#[rustfmt::skip]
1466pub type VkRenderPassCreateFlagBits = VkFlags;
1467
1468#[rustfmt::skip]
1469pub type VkSampleCountFlags = VkFlags;
1470#[rustfmt::skip]
1471pub type VkSampleCountFlagBits = VkFlags;
1472#[rustfmt::skip]
1473pub const VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlagBits = 0x00000001;
1474#[rustfmt::skip]
1475pub const VK_SAMPLE_COUNT_2_BIT: VkSampleCountFlagBits = 0x00000002;
1476#[rustfmt::skip]
1477pub const VK_SAMPLE_COUNT_4_BIT: VkSampleCountFlagBits = 0x00000004;
1478#[rustfmt::skip]
1479pub const VK_SAMPLE_COUNT_8_BIT: VkSampleCountFlagBits = 0x00000008;
1480#[rustfmt::skip]
1481pub const VK_SAMPLE_COUNT_16_BIT: VkSampleCountFlagBits = 0x00000010;
1482#[rustfmt::skip]
1483pub const VK_SAMPLE_COUNT_32_BIT: VkSampleCountFlagBits = 0x00000020;
1484#[rustfmt::skip]
1485pub const VK_SAMPLE_COUNT_64_BIT: VkSampleCountFlagBits = 0x00000040;
1486
1487#[rustfmt::skip]
1488pub type VkSamplerCreateFlags = VkFlags;
1489#[rustfmt::skip]
1490pub type VkSamplerCreateFlagBits = VkFlags;
1491
1492#[rustfmt::skip]
1493pub type VkSemaphoreCreateFlags = VkFlags;
1494#[rustfmt::skip]
1495pub type VkSemaphoreCreateFlagBits = VkFlags;
1496
1497#[cfg(feature = "VK_KHR_external_semaphore")]
1498#[rustfmt::skip]
1499pub type VkSemaphoreImportFlagsKHR = VkFlags;
1500#[cfg(feature = "Allow1_1APIs")]
1501#[rustfmt::skip]
1502pub type VkSemaphoreImportFlags = VkSemaphoreImportFlagsKHR;
1503#[cfg(feature = "VK_KHR_external_semaphore")]
1504#[rustfmt::skip]
1505pub type VkSemaphoreImportFlagBitsKHR = VkFlags;
1506#[cfg(feature = "Allow1_1APIs")]
1507#[rustfmt::skip]
1508pub type VkSemaphoreImportFlagBits = VkSemaphoreImportFlagBitsKHR;
1509#[cfg(feature = "VK_KHR_external_semaphore")]
1510#[rustfmt::skip]
1511pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR: VkSemaphoreImportFlagBitsKHR = 0x00000001;
1512#[cfg(feature = "Allow1_1APIs")]
1513#[rustfmt::skip]
1514pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT: VkSemaphoreImportFlagBitsKHR = 0x00000001;
1515
1516#[rustfmt::skip]
1517pub type VkShaderModuleCreateFlags = VkFlags;
1518#[rustfmt::skip]
1519pub type VkShaderModuleCreateFlagBits = VkFlags;
1520
1521#[rustfmt::skip]
1522pub type VkShaderStageFlags = VkFlags;
1523#[rustfmt::skip]
1524pub type VkShaderStageFlagBits = VkFlags;
1525#[rustfmt::skip]
1526pub const VK_SHADER_STAGE_VERTEX_BIT: VkShaderStageFlagBits = 0x00000001;
1527#[rustfmt::skip]
1528pub const VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: VkShaderStageFlagBits = 0x00000002;
1529#[rustfmt::skip]
1530pub const VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: VkShaderStageFlagBits = 0x00000004;
1531#[rustfmt::skip]
1532pub const VK_SHADER_STAGE_GEOMETRY_BIT: VkShaderStageFlagBits = 0x00000008;
1533#[rustfmt::skip]
1534pub const VK_SHADER_STAGE_FRAGMENT_BIT: VkShaderStageFlagBits = 0x00000010;
1535#[rustfmt::skip]
1536pub const VK_SHADER_STAGE_COMPUTE_BIT: VkShaderStageFlagBits = 0x00000020;
1537
1538#[rustfmt::skip]
1539pub type VkSparseMemoryBindFlags = VkFlags;
1540#[rustfmt::skip]
1541pub type VkSparseMemoryBindFlagBits = VkFlags;
1542#[rustfmt::skip]
1543pub const VK_SPARSE_MEMORY_BIND_METADATA_BIT: VkSparseMemoryBindFlagBits = 0x00000001;
1544
1545#[rustfmt::skip]
1546pub type VkSparseImageFormatFlags = VkFlags;
1547#[rustfmt::skip]
1548pub type VkSparseImageFormatFlagBits = VkFlags;
1549#[rustfmt::skip]
1550pub const VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: VkSparseImageFormatFlagBits = 0x00000001;
1551#[rustfmt::skip]
1552pub const VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: VkSparseImageFormatFlagBits = 0x00000002;
1553#[rustfmt::skip]
1554pub const VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: VkSparseImageFormatFlagBits = 0x00000004;
1555
1556#[rustfmt::skip]
1557pub type VkStencilFaceFlags = VkFlags;
1558#[rustfmt::skip]
1559pub type VkStencilFaceFlagBits = VkFlags;
1560#[rustfmt::skip]
1561pub const VK_STENCIL_FACE_FRONT_BIT: VkStencilFaceFlagBits = 0x00000001;
1562#[rustfmt::skip]
1563pub const VK_STENCIL_FACE_BACK_BIT: VkStencilFaceFlagBits = 0x00000002;
1564
1565#[cfg(feature = "Allow1_1APIs")]
1566#[rustfmt::skip]
1567pub type VkSubgroupFeatureFlags = VkFlags;
1568#[cfg(feature = "Allow1_1APIs")]
1569#[rustfmt::skip]
1570pub type VkSubgroupFeatureFlagBits = VkFlags;
1571#[cfg(feature = "Allow1_1APIs")]
1572#[rustfmt::skip]
1573pub const VK_SUBGROUP_FEATURE_BASIC_BIT: VkSubgroupFeatureFlagBits = 0x00000001;
1574#[cfg(feature = "Allow1_1APIs")]
1575#[rustfmt::skip]
1576pub const VK_SUBGROUP_FEATURE_VOTE_BIT: VkSubgroupFeatureFlagBits = 0x00000002;
1577#[cfg(feature = "Allow1_1APIs")]
1578#[rustfmt::skip]
1579pub const VK_SUBGROUP_FEATURE_ARITHMETIC_BIT: VkSubgroupFeatureFlagBits = 0x00000004;
1580#[cfg(feature = "Allow1_1APIs")]
1581#[rustfmt::skip]
1582pub const VK_SUBGROUP_FEATURE_BALLOT_BIT: VkSubgroupFeatureFlagBits = 0x00000008;
1583#[cfg(feature = "Allow1_1APIs")]
1584#[rustfmt::skip]
1585pub const VK_SUBGROUP_FEATURE_SHUFFLE_BIT: VkSubgroupFeatureFlagBits = 0x00000010;
1586#[cfg(feature = "Allow1_1APIs")]
1587#[rustfmt::skip]
1588pub const VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: VkSubgroupFeatureFlagBits = 0x00000020;
1589#[cfg(feature = "Allow1_1APIs")]
1590#[rustfmt::skip]
1591pub const VK_SUBGROUP_FEATURE_CLUSTERED_BIT: VkSubgroupFeatureFlagBits = 0x00000040;
1592#[cfg(feature = "Allow1_1APIs")]
1593#[rustfmt::skip]
1594pub const VK_SUBGROUP_FEATURE_QUAD_BIT: VkSubgroupFeatureFlagBits = 0x00000080;
1595
1596#[cfg(feature = "VK_KHR_synchronization2")]
1597#[rustfmt::skip]
1598pub type VkSubmitFlagsKHR = VkFlags;
1599#[cfg(feature = "Allow1_3APIs")]
1600#[rustfmt::skip]
1601pub type VkSubmitFlags = VkSubmitFlagsKHR;
1602#[cfg(feature = "VK_KHR_synchronization2")]
1603#[rustfmt::skip]
1604pub type VkSubmitFlagBitsKHR = VkFlags;
1605#[cfg(feature = "Allow1_3APIs")]
1606#[rustfmt::skip]
1607pub type VkSubmitFlagBits = VkSubmitFlagBitsKHR;
1608#[cfg(feature = "VK_KHR_synchronization2")]
1609#[rustfmt::skip]
1610pub const VK_SUBMIT_PROTECTED_BIT_KHR: VkSubmitFlagBitsKHR = 0x00000001;
1611#[cfg(feature = "Allow1_3APIs")]
1612#[rustfmt::skip]
1613pub const VK_SUBMIT_PROTECTED_BIT: VkSubmitFlagBitsKHR = 0x00000001;
1614
1615#[rustfmt::skip]
1616pub type VkSubpassDescriptionFlags = VkFlags;
1617#[rustfmt::skip]
1618pub type VkSubpassDescriptionFlagBits = VkFlags;
1619
1620#[cfg(feature = "VK_KHR_surface")]
1621#[rustfmt::skip]
1622pub type VkSurfaceTransformFlagsKHR = VkFlags;
1623#[cfg(feature = "VK_KHR_surface")]
1624#[rustfmt::skip]
1625pub type VkSurfaceTransformFlagBitsKHR = VkFlags;
1626#[cfg(feature = "VK_KHR_surface")]
1627#[rustfmt::skip]
1628pub const VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000001;
1629#[cfg(feature = "VK_KHR_surface")]
1630#[rustfmt::skip]
1631pub const VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000002;
1632#[cfg(feature = "VK_KHR_surface")]
1633#[rustfmt::skip]
1634pub const VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000004;
1635#[cfg(feature = "VK_KHR_surface")]
1636#[rustfmt::skip]
1637pub const VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000008;
1638#[cfg(feature = "VK_KHR_surface")]
1639#[rustfmt::skip]
1640pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000010;
1641#[cfg(feature = "VK_KHR_surface")]
1642#[rustfmt::skip]
1643pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000020;
1644#[cfg(feature = "VK_KHR_surface")]
1645#[rustfmt::skip]
1646pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000040;
1647#[cfg(feature = "VK_KHR_surface")]
1648#[rustfmt::skip]
1649pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000080;
1650#[cfg(feature = "VK_KHR_surface")]
1651#[rustfmt::skip]
1652pub const VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 0x00000100;
1653
1654#[cfg(feature = "VK_KHR_swapchain")]
1655#[rustfmt::skip]
1656pub type VkSwapchainCreateFlagsKHR = VkFlags;
1657#[cfg(feature = "VK_KHR_swapchain")]
1658#[rustfmt::skip]
1659pub type VkSwapchainCreateFlagBitsKHR = VkFlags;
1660#[cfg(feature = "VK_KHR_device_group")]
1661#[cfg(feature = "VK_KHR_swapchain")]
1662#[rustfmt::skip]
1663pub const VK_SWAPCHAIN_CREATE_SPLIT_INSTNACE_BIND_REGIONS_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 0x00000001;
1664
1665#[cfg(feature = "VK_KHR_wayland_surface")]
1666#[rustfmt::skip]
1667pub type VkWaylandSurfaceCreateFlagsKHR = VkFlags;
1668#[cfg(feature = "VK_KHR_wayland_surface")]
1669#[rustfmt::skip]
1670pub type VkWaylandSurfaceCreateFlagBitsKHR = VkFlags;
1671
1672#[cfg(feature = "VK_KHR_win32_surface")]
1673#[rustfmt::skip]
1674pub type VkWin32SurfaceCreateFlagsKHR = VkFlags;
1675#[cfg(feature = "VK_KHR_win32_surface")]
1676#[rustfmt::skip]
1677pub type VkWin32SurfaceCreateFlagBitsKHR = VkFlags;
1678
1679#[cfg(feature = "VK_KHR_xcb_surface")]
1680#[rustfmt::skip]
1681pub type VkXcbSurfaceCreateFlagsKHR = VkFlags;
1682#[cfg(feature = "VK_KHR_xcb_surface")]
1683#[rustfmt::skip]
1684pub type VkXcbSurfaceCreateFlagBitsKHR = VkFlags;
1685
1686#[cfg(feature = "VK_KHR_xlib_surface")]
1687#[rustfmt::skip]
1688pub type VkXlibSurfaceCreateFlagsKHR = VkFlags;
1689#[cfg(feature = "VK_KHR_xlib_surface")]
1690#[rustfmt::skip]
1691pub type VkXlibSurfaceCreateFlagBitsKHR = VkFlags;
1692#[rustfmt::skip]
1693pub const VK_SHADER_STAGE_ALL_GRAPHICS: VkShaderStageFlags = 0x0000001f;
1694#[rustfmt::skip]
1695pub const VK_SHADER_STAGE_ALL: VkShaderStageFlags = 0x7fffffff;
1696#[rustfmt::skip]
1697pub const VK_CULL_MODE_NONE: VkCullModeFlags = 0;
1698#[rustfmt::skip]
1699pub const VK_CULL_MODE_FRONT_AND_BACK: VkCullModeFlags = 3;
1700#[rustfmt::skip]
1701pub const VK_STENCIL_FACE_FRONT_AND_BACK: VkStencilFaceFlags = 3;
1702#[cfg(feature = "VK_KHR_synchronization2")]
1703#[rustfmt::skip]
1704pub const VK_PIPELINE_STAGE_2_NONE_KHR: VkPipelineStageFlagBits2KHR = 0;
1705#[cfg(feature = "Allow1_3APIs")]
1706#[rustfmt::skip]
1707pub const VK_PIPELINE_STAGE_2_NONE: VkPipelineStageFlagBits2 = 0;
1708#[cfg(feature = "VK_KHR_synchronization2")]
1709#[rustfmt::skip]
1710pub const VK_ACCESS_2_NONE_KHR: VkAccessFlagBits2KHR = 0;
1711#[cfg(feature = "Allow1_3APIs")]
1712#[rustfmt::skip]
1713pub const VK_ACCESS_2_NONE: VkAccessFlagBits2 = 0;
1714
1715#[repr(transparent)]
1716#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1717#[rustfmt::skip]
1718pub struct VkInstance(pub *mut core::ffi::c_void, pub core::marker::PhantomData<*mut u8>);
1719#[rustfmt::skip]
1720impl crate::VkRawHandle for VkInstance {
1721    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_INSTANCE;
1722    const NULL: Self = Self(core::ptr::null_mut(), core::marker::PhantomData);
1723
1724    #[inline(always)]
1725    fn raw_handle_value(&self) -> u64 {
1726        self.0 as usize as _
1727    }
1728}
1729#[rustfmt::skip]
1730pub const VK_OBJECT_TYPE_INSTANCE: VkObjectType = 1;
1731
1732#[repr(transparent)]
1733#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1734#[rustfmt::skip]
1735pub struct VkPhysicalDevice(pub *mut core::ffi::c_void, pub core::marker::PhantomData<*mut u8>);
1736#[rustfmt::skip]
1737impl crate::VkRawHandle for VkPhysicalDevice {
1738    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_PHYSICAL_DEVICE;
1739    const NULL: Self = Self(core::ptr::null_mut(), core::marker::PhantomData);
1740
1741    #[inline(always)]
1742    fn raw_handle_value(&self) -> u64 {
1743        self.0 as usize as _
1744    }
1745}
1746#[rustfmt::skip]
1747pub const VK_OBJECT_TYPE_PHYSICAL_DEVICE: VkObjectType = 2;
1748
1749#[repr(transparent)]
1750#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1751#[rustfmt::skip]
1752pub struct VkDevice(pub *mut core::ffi::c_void, pub core::marker::PhantomData<*mut u8>);
1753#[rustfmt::skip]
1754impl crate::VkRawHandle for VkDevice {
1755    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DEVICE;
1756    const NULL: Self = Self(core::ptr::null_mut(), core::marker::PhantomData);
1757
1758    #[inline(always)]
1759    fn raw_handle_value(&self) -> u64 {
1760        self.0 as usize as _
1761    }
1762}
1763#[rustfmt::skip]
1764pub const VK_OBJECT_TYPE_DEVICE: VkObjectType = 3;
1765
1766#[repr(transparent)]
1767#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1768#[rustfmt::skip]
1769pub struct VkQueue(pub *mut core::ffi::c_void, pub core::marker::PhantomData<*mut u8>);
1770#[rustfmt::skip]
1771impl crate::VkRawHandle for VkQueue {
1772    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_QUEUE;
1773    const NULL: Self = Self(core::ptr::null_mut(), core::marker::PhantomData);
1774
1775    #[inline(always)]
1776    fn raw_handle_value(&self) -> u64 {
1777        self.0 as usize as _
1778    }
1779}
1780#[rustfmt::skip]
1781pub const VK_OBJECT_TYPE_QUEUE: VkObjectType = 4;
1782
1783#[repr(transparent)]
1784#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1785#[rustfmt::skip]
1786pub struct VkCommandBuffer(pub *mut core::ffi::c_void, pub core::marker::PhantomData<*mut u8>);
1787#[rustfmt::skip]
1788impl crate::VkRawHandle for VkCommandBuffer {
1789    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_COMMAND_BUFFER;
1790    const NULL: Self = Self(core::ptr::null_mut(), core::marker::PhantomData);
1791
1792    #[inline(always)]
1793    fn raw_handle_value(&self) -> u64 {
1794        self.0 as usize as _
1795    }
1796}
1797#[rustfmt::skip]
1798pub const VK_OBJECT_TYPE_COMMAND_BUFFER: VkObjectType = 6;
1799
1800#[repr(transparent)]
1801#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1802#[rustfmt::skip]
1803pub struct VkDeviceMemory(pub u64, pub core::marker::PhantomData<*mut u8>);
1804#[rustfmt::skip]
1805impl crate::VkRawHandle for VkDeviceMemory {
1806    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DEVICE_MEMORY;
1807    const NULL: Self = Self(0, core::marker::PhantomData);
1808
1809    #[inline(always)]
1810    fn raw_handle_value(&self) -> u64 {
1811        self.0
1812    }
1813}
1814#[rustfmt::skip]
1815pub const VK_OBJECT_TYPE_DEVICE_MEMORY: VkObjectType = 8;
1816
1817#[repr(transparent)]
1818#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1819#[rustfmt::skip]
1820pub struct VkCommandPool(pub u64, pub core::marker::PhantomData<*mut u8>);
1821#[rustfmt::skip]
1822impl crate::VkRawHandle for VkCommandPool {
1823    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_COMMAND_POOL;
1824    const NULL: Self = Self(0, core::marker::PhantomData);
1825
1826    #[inline(always)]
1827    fn raw_handle_value(&self) -> u64 {
1828        self.0
1829    }
1830}
1831#[rustfmt::skip]
1832pub const VK_OBJECT_TYPE_COMMAND_POOL: VkObjectType = 25;
1833
1834#[repr(transparent)]
1835#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1836#[rustfmt::skip]
1837pub struct VkBuffer(pub u64, pub core::marker::PhantomData<*mut u8>);
1838#[rustfmt::skip]
1839impl crate::VkRawHandle for VkBuffer {
1840    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_BUFFER;
1841    const NULL: Self = Self(0, core::marker::PhantomData);
1842
1843    #[inline(always)]
1844    fn raw_handle_value(&self) -> u64 {
1845        self.0
1846    }
1847}
1848#[rustfmt::skip]
1849pub const VK_OBJECT_TYPE_BUFFER: VkObjectType = 9;
1850
1851#[repr(transparent)]
1852#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1853#[rustfmt::skip]
1854pub struct VkBufferView(pub u64, pub core::marker::PhantomData<*mut u8>);
1855#[rustfmt::skip]
1856impl crate::VkRawHandle for VkBufferView {
1857    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_BUFFER_VIEW;
1858    const NULL: Self = Self(0, core::marker::PhantomData);
1859
1860    #[inline(always)]
1861    fn raw_handle_value(&self) -> u64 {
1862        self.0
1863    }
1864}
1865#[rustfmt::skip]
1866pub const VK_OBJECT_TYPE_BUFFER_VIEW: VkObjectType = 13;
1867
1868#[repr(transparent)]
1869#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1870#[rustfmt::skip]
1871pub struct VkImage(pub u64, pub core::marker::PhantomData<*mut u8>);
1872#[rustfmt::skip]
1873impl crate::VkRawHandle for VkImage {
1874    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_IMAGE;
1875    const NULL: Self = Self(0, core::marker::PhantomData);
1876
1877    #[inline(always)]
1878    fn raw_handle_value(&self) -> u64 {
1879        self.0
1880    }
1881}
1882#[rustfmt::skip]
1883pub const VK_OBJECT_TYPE_IMAGE: VkObjectType = 10;
1884
1885#[repr(transparent)]
1886#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1887#[rustfmt::skip]
1888pub struct VkImageView(pub u64, pub core::marker::PhantomData<*mut u8>);
1889#[rustfmt::skip]
1890impl crate::VkRawHandle for VkImageView {
1891    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_IMAGE_VIEW;
1892    const NULL: Self = Self(0, core::marker::PhantomData);
1893
1894    #[inline(always)]
1895    fn raw_handle_value(&self) -> u64 {
1896        self.0
1897    }
1898}
1899#[rustfmt::skip]
1900pub const VK_OBJECT_TYPE_IMAGE_VIEW: VkObjectType = 14;
1901
1902#[repr(transparent)]
1903#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1904#[rustfmt::skip]
1905pub struct VkShaderModule(pub u64, pub core::marker::PhantomData<*mut u8>);
1906#[rustfmt::skip]
1907impl crate::VkRawHandle for VkShaderModule {
1908    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_SHADER_MODULE;
1909    const NULL: Self = Self(0, core::marker::PhantomData);
1910
1911    #[inline(always)]
1912    fn raw_handle_value(&self) -> u64 {
1913        self.0
1914    }
1915}
1916#[rustfmt::skip]
1917pub const VK_OBJECT_TYPE_SHADER_MODULE: VkObjectType = 15;
1918
1919#[repr(transparent)]
1920#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1921#[rustfmt::skip]
1922pub struct VkPipeline(pub u64, pub core::marker::PhantomData<*mut u8>);
1923#[rustfmt::skip]
1924impl crate::VkRawHandle for VkPipeline {
1925    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_PIPELINE;
1926    const NULL: Self = Self(0, core::marker::PhantomData);
1927
1928    #[inline(always)]
1929    fn raw_handle_value(&self) -> u64 {
1930        self.0
1931    }
1932}
1933#[rustfmt::skip]
1934pub const VK_OBJECT_TYPE_PIPELINE: VkObjectType = 19;
1935
1936#[repr(transparent)]
1937#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1938#[rustfmt::skip]
1939pub struct VkPipelineLayout(pub u64, pub core::marker::PhantomData<*mut u8>);
1940#[rustfmt::skip]
1941impl crate::VkRawHandle for VkPipelineLayout {
1942    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_PIPELINE_LAYOUT;
1943    const NULL: Self = Self(0, core::marker::PhantomData);
1944
1945    #[inline(always)]
1946    fn raw_handle_value(&self) -> u64 {
1947        self.0
1948    }
1949}
1950#[rustfmt::skip]
1951pub const VK_OBJECT_TYPE_PIPELINE_LAYOUT: VkObjectType = 17;
1952
1953#[repr(transparent)]
1954#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1955#[rustfmt::skip]
1956pub struct VkSampler(pub u64, pub core::marker::PhantomData<*mut u8>);
1957#[rustfmt::skip]
1958impl crate::VkRawHandle for VkSampler {
1959    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_SAMPLER;
1960    const NULL: Self = Self(0, core::marker::PhantomData);
1961
1962    #[inline(always)]
1963    fn raw_handle_value(&self) -> u64 {
1964        self.0
1965    }
1966}
1967#[rustfmt::skip]
1968pub const VK_OBJECT_TYPE_SAMPLER: VkObjectType = 21;
1969
1970#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
1971#[repr(transparent)]
1972#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1973#[rustfmt::skip]
1974pub struct VkSamplerYcbcrConversionKHR(pub u64, pub core::marker::PhantomData<*mut u8>);
1975#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
1976#[rustfmt::skip]
1977impl crate::VkRawHandle for VkSamplerYcbcrConversionKHR {
1978    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR;
1979    const NULL: Self = Self(0, core::marker::PhantomData);
1980
1981    #[inline(always)]
1982    fn raw_handle_value(&self) -> u64 {
1983        self.0
1984    }
1985}
1986#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
1987#[rustfmt::skip]
1988pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR: VkObjectType = 1000156000;
1989#[cfg(feature = "Allow1_1APIs")]
1990#[rustfmt::skip]
1991pub type VkSamplerYcbcrConversion = VkSamplerYcbcrConversionKHR;
1992#[cfg(feature = "Allow1_1APIs")]
1993#[rustfmt::skip]
1994pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: VkObjectType = 1000156000;
1995
1996#[repr(transparent)]
1997#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
1998#[rustfmt::skip]
1999pub struct VkDescriptorSet(pub u64, pub core::marker::PhantomData<*mut u8>);
2000#[rustfmt::skip]
2001impl crate::VkRawHandle for VkDescriptorSet {
2002    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_SET;
2003    const NULL: Self = Self(0, core::marker::PhantomData);
2004
2005    #[inline(always)]
2006    fn raw_handle_value(&self) -> u64 {
2007        self.0
2008    }
2009}
2010#[rustfmt::skip]
2011pub const VK_OBJECT_TYPE_DESCRIPTOR_SET: VkObjectType = 23;
2012
2013#[repr(transparent)]
2014#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2015#[rustfmt::skip]
2016pub struct VkDescriptorSetLayout(pub u64, pub core::marker::PhantomData<*mut u8>);
2017#[rustfmt::skip]
2018impl crate::VkRawHandle for VkDescriptorSetLayout {
2019    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT;
2020    const NULL: Self = Self(0, core::marker::PhantomData);
2021
2022    #[inline(always)]
2023    fn raw_handle_value(&self) -> u64 {
2024        self.0
2025    }
2026}
2027#[rustfmt::skip]
2028pub const VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: VkObjectType = 20;
2029
2030#[repr(transparent)]
2031#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2032#[rustfmt::skip]
2033pub struct VkDescriptorPool(pub u64, pub core::marker::PhantomData<*mut u8>);
2034#[rustfmt::skip]
2035impl crate::VkRawHandle for VkDescriptorPool {
2036    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_POOL;
2037    const NULL: Self = Self(0, core::marker::PhantomData);
2038
2039    #[inline(always)]
2040    fn raw_handle_value(&self) -> u64 {
2041        self.0
2042    }
2043}
2044#[rustfmt::skip]
2045pub const VK_OBJECT_TYPE_DESCRIPTOR_POOL: VkObjectType = 22;
2046
2047#[cfg(feature = "VK_KHR_descriptor_update_template")]
2048#[repr(transparent)]
2049#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2050#[rustfmt::skip]
2051pub struct VkDescriptorUpdateTemplateKHR(pub u64, pub core::marker::PhantomData<*mut u8>);
2052#[cfg(feature = "VK_KHR_descriptor_update_template")]
2053#[rustfmt::skip]
2054impl crate::VkRawHandle for VkDescriptorUpdateTemplateKHR {
2055    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR;
2056    const NULL: Self = Self(0, core::marker::PhantomData);
2057
2058    #[inline(always)]
2059    fn raw_handle_value(&self) -> u64 {
2060        self.0
2061    }
2062}
2063#[cfg(feature = "VK_KHR_descriptor_update_template")]
2064#[rustfmt::skip]
2065pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR: VkObjectType = 1000085000;
2066#[cfg(feature = "Allow1_1APIs")]
2067#[rustfmt::skip]
2068pub type VkDescriptorUpdateTemplate = VkDescriptorUpdateTemplateKHR;
2069#[cfg(feature = "Allow1_1APIs")]
2070#[rustfmt::skip]
2071pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: VkObjectType = 1000085000;
2072
2073#[repr(transparent)]
2074#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2075#[rustfmt::skip]
2076pub struct VkFence(pub u64, pub core::marker::PhantomData<*mut u8>);
2077#[rustfmt::skip]
2078impl crate::VkRawHandle for VkFence {
2079    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_FENCE;
2080    const NULL: Self = Self(0, core::marker::PhantomData);
2081
2082    #[inline(always)]
2083    fn raw_handle_value(&self) -> u64 {
2084        self.0
2085    }
2086}
2087#[rustfmt::skip]
2088pub const VK_OBJECT_TYPE_FENCE: VkObjectType = 7;
2089
2090#[repr(transparent)]
2091#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2092#[rustfmt::skip]
2093pub struct VkSemaphore(pub u64, pub core::marker::PhantomData<*mut u8>);
2094#[rustfmt::skip]
2095impl crate::VkRawHandle for VkSemaphore {
2096    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_SEMAPHORE;
2097    const NULL: Self = Self(0, core::marker::PhantomData);
2098
2099    #[inline(always)]
2100    fn raw_handle_value(&self) -> u64 {
2101        self.0
2102    }
2103}
2104#[rustfmt::skip]
2105pub const VK_OBJECT_TYPE_SEMAPHORE: VkObjectType = 5;
2106
2107#[repr(transparent)]
2108#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2109#[rustfmt::skip]
2110pub struct VkEvent(pub u64, pub core::marker::PhantomData<*mut u8>);
2111#[rustfmt::skip]
2112impl crate::VkRawHandle for VkEvent {
2113    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_EVENT;
2114    const NULL: Self = Self(0, core::marker::PhantomData);
2115
2116    #[inline(always)]
2117    fn raw_handle_value(&self) -> u64 {
2118        self.0
2119    }
2120}
2121#[rustfmt::skip]
2122pub const VK_OBJECT_TYPE_EVENT: VkObjectType = 11;
2123
2124#[repr(transparent)]
2125#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2126#[rustfmt::skip]
2127pub struct VkQueryPool(pub u64, pub core::marker::PhantomData<*mut u8>);
2128#[rustfmt::skip]
2129impl crate::VkRawHandle for VkQueryPool {
2130    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_QUERY_POOL;
2131    const NULL: Self = Self(0, core::marker::PhantomData);
2132
2133    #[inline(always)]
2134    fn raw_handle_value(&self) -> u64 {
2135        self.0
2136    }
2137}
2138#[rustfmt::skip]
2139pub const VK_OBJECT_TYPE_QUERY_POOL: VkObjectType = 12;
2140
2141#[repr(transparent)]
2142#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2143#[rustfmt::skip]
2144pub struct VkFramebuffer(pub u64, pub core::marker::PhantomData<*mut u8>);
2145#[rustfmt::skip]
2146impl crate::VkRawHandle for VkFramebuffer {
2147    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_FRAMEBUFFER;
2148    const NULL: Self = Self(0, core::marker::PhantomData);
2149
2150    #[inline(always)]
2151    fn raw_handle_value(&self) -> u64 {
2152        self.0
2153    }
2154}
2155#[rustfmt::skip]
2156pub const VK_OBJECT_TYPE_FRAMEBUFFER: VkObjectType = 24;
2157
2158#[repr(transparent)]
2159#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2160#[rustfmt::skip]
2161pub struct VkRenderPass(pub u64, pub core::marker::PhantomData<*mut u8>);
2162#[rustfmt::skip]
2163impl crate::VkRawHandle for VkRenderPass {
2164    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_RENDER_PASS;
2165    const NULL: Self = Self(0, core::marker::PhantomData);
2166
2167    #[inline(always)]
2168    fn raw_handle_value(&self) -> u64 {
2169        self.0
2170    }
2171}
2172#[rustfmt::skip]
2173pub const VK_OBJECT_TYPE_RENDER_PASS: VkObjectType = 18;
2174
2175#[repr(transparent)]
2176#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2177#[rustfmt::skip]
2178pub struct VkPipelineCache(pub u64, pub core::marker::PhantomData<*mut u8>);
2179#[rustfmt::skip]
2180impl crate::VkRawHandle for VkPipelineCache {
2181    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_PIPELINE_CACHE;
2182    const NULL: Self = Self(0, core::marker::PhantomData);
2183
2184    #[inline(always)]
2185    fn raw_handle_value(&self) -> u64 {
2186        self.0
2187    }
2188}
2189#[rustfmt::skip]
2190pub const VK_OBJECT_TYPE_PIPELINE_CACHE: VkObjectType = 16;
2191
2192#[cfg(feature = "VK_KHR_display")]
2193#[repr(transparent)]
2194#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2195#[rustfmt::skip]
2196pub struct VkDisplayKHR(pub u64, pub core::marker::PhantomData<*mut u8>);
2197#[cfg(feature = "VK_KHR_display")]
2198#[rustfmt::skip]
2199impl crate::VkRawHandle for VkDisplayKHR {
2200    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DISPLAY_KHR;
2201    const NULL: Self = Self(0, core::marker::PhantomData);
2202
2203    #[inline(always)]
2204    fn raw_handle_value(&self) -> u64 {
2205        self.0
2206    }
2207}
2208#[cfg(feature = "VK_KHR_display")]
2209#[rustfmt::skip]
2210pub const VK_OBJECT_TYPE_DISPLAY_KHR: VkObjectType = 1000002000;
2211
2212#[cfg(feature = "VK_KHR_display")]
2213#[repr(transparent)]
2214#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2215#[rustfmt::skip]
2216pub struct VkDisplayModeKHR(pub u64, pub core::marker::PhantomData<*mut u8>);
2217#[cfg(feature = "VK_KHR_display")]
2218#[rustfmt::skip]
2219impl crate::VkRawHandle for VkDisplayModeKHR {
2220    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DISPLAY_MODE_KHR;
2221    const NULL: Self = Self(0, core::marker::PhantomData);
2222
2223    #[inline(always)]
2224    fn raw_handle_value(&self) -> u64 {
2225        self.0
2226    }
2227}
2228#[cfg(feature = "VK_KHR_display")]
2229#[rustfmt::skip]
2230pub const VK_OBJECT_TYPE_DISPLAY_MODE_KHR: VkObjectType = 1000002001;
2231
2232#[cfg(feature = "VK_KHR_surface")]
2233#[repr(transparent)]
2234#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2235#[rustfmt::skip]
2236pub struct VkSurfaceKHR(pub u64, pub core::marker::PhantomData<*mut u8>);
2237#[cfg(feature = "VK_KHR_surface")]
2238#[rustfmt::skip]
2239impl crate::VkRawHandle for VkSurfaceKHR {
2240    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_SURFACE_KHR;
2241    const NULL: Self = Self(0, core::marker::PhantomData);
2242
2243    #[inline(always)]
2244    fn raw_handle_value(&self) -> u64 {
2245        self.0
2246    }
2247}
2248#[cfg(feature = "VK_KHR_surface")]
2249#[rustfmt::skip]
2250pub const VK_OBJECT_TYPE_SURFACE_KHR: VkObjectType = 1000000000;
2251
2252#[cfg(feature = "VK_KHR_swapchain")]
2253#[repr(transparent)]
2254#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2255#[rustfmt::skip]
2256pub struct VkSwapchainKHR(pub u64, pub core::marker::PhantomData<*mut u8>);
2257#[cfg(feature = "VK_KHR_swapchain")]
2258#[rustfmt::skip]
2259impl crate::VkRawHandle for VkSwapchainKHR {
2260    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_SWAPCHAIN_KHR;
2261    const NULL: Self = Self(0, core::marker::PhantomData);
2262
2263    #[inline(always)]
2264    fn raw_handle_value(&self) -> u64 {
2265        self.0
2266    }
2267}
2268#[cfg(feature = "VK_KHR_swapchain")]
2269#[rustfmt::skip]
2270pub const VK_OBJECT_TYPE_SWAPCHAIN_KHR: VkObjectType = 1000001000;
2271
2272#[cfg(feature = "VK_EXT_debug_report")]
2273#[repr(transparent)]
2274#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2275#[rustfmt::skip]
2276pub struct VkDebugReportCallbackEXT(pub u64, pub core::marker::PhantomData<*mut u8>);
2277#[cfg(feature = "VK_EXT_debug_report")]
2278#[rustfmt::skip]
2279impl crate::VkRawHandle for VkDebugReportCallbackEXT {
2280    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT;
2281    const NULL: Self = Self(0, core::marker::PhantomData);
2282
2283    #[inline(always)]
2284    fn raw_handle_value(&self) -> u64 {
2285        self.0
2286    }
2287}
2288#[cfg(feature = "VK_EXT_debug_report")]
2289#[rustfmt::skip]
2290pub const VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: VkObjectType = 1000011000;
2291
2292#[cfg(feature = "VK_EXT_debug_utils")]
2293#[repr(transparent)]
2294#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2295#[rustfmt::skip]
2296pub struct VkDebugUtilsMessengerEXT(pub u64, pub core::marker::PhantomData<*mut u8>);
2297#[cfg(feature = "VK_EXT_debug_utils")]
2298#[rustfmt::skip]
2299impl crate::VkRawHandle for VkDebugUtilsMessengerEXT {
2300    const OBJECT_TYPE: VkObjectType = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT;
2301    const NULL: Self = Self(0, core::marker::PhantomData);
2302
2303    #[inline(always)]
2304    fn raw_handle_value(&self) -> u64 {
2305        self.0
2306    }
2307}
2308#[cfg(feature = "VK_EXT_debug_utils")]
2309#[rustfmt::skip]
2310pub const VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: VkObjectType = 1000128000;
2311#[rustfmt::skip]
2312pub const VK_LOD_CLAMP_NONE: f32 = 1000.0;
2313#[rustfmt::skip]
2314pub const VK_REMAINING_MIP_LEVELS: u32 = 0xffff_ffff;
2315#[rustfmt::skip]
2316pub const VK_REMAINING_ARRAY_LAYERS: u32 = 0xffff_ffff;
2317#[rustfmt::skip]
2318pub const VK_WHOLE_SIZE: u64 = !0;
2319#[rustfmt::skip]
2320pub const VK_ATTACHMENT_UNUSED: u32 = 0xffff_ffff;
2321#[rustfmt::skip]
2322pub const VK_TRUE: VkBool32 = 1;
2323#[rustfmt::skip]
2324pub const VK_FALSE: VkBool32 = 0;
2325#[rustfmt::skip]
2326pub const VK_QUEUE_FAMILY_IGNORED: u32 = 0xffff_ffff;
2327#[rustfmt::skip]
2328pub const VK_SUBPASS_EXTERNAL: u32 = 0xffff_ffff;
2329#[rustfmt::skip]
2330pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: usize = 256;
2331#[rustfmt::skip]
2332pub const VK_UUID_SIZE: usize = 16;
2333#[rustfmt::skip]
2334pub const VK_MAX_MEMORY_TYPES: usize = 32;
2335#[rustfmt::skip]
2336pub const VK_MAX_MEMORY_HEAPS: usize = 16;
2337#[rustfmt::skip]
2338pub const VK_MAX_EXTENSION_NAME_SIZE: usize = 256;
2339#[rustfmt::skip]
2340pub const VK_MAX_DESCRIPTION_SIZE: usize = 256;
2341#[cfg(any(feature = "VK_KHR_external_fence_capabilities", feature = "VK_KHR_external_memory_capabilities", feature = "VK_KHR_external_semaphore_capabilities"))]
2342#[rustfmt::skip]
2343pub const VK_LUID_SIZE_KHR: usize = 8;
2344#[cfg(feature = "Allow1_1APIs")]
2345#[rustfmt::skip]
2346pub const VK_LUID_SIZE: usize = 8;
2347#[cfg(feature = "VK_KHR_external_memory")]
2348#[rustfmt::skip]
2349pub const VK_QUEUE_FAMILY_EXTERNAL_KHR: u32 = !1;
2350#[cfg(feature = "Allow1_1APIs")]#[rustfmt::skip]
2351pub const VK_QUEUE_FAMILY_EXTERNAL: u32 = !1;
2352#[cfg(feature = "VK_KHR_device_group_creation")]
2353#[rustfmt::skip]
2354pub const VK_MAX_DEVICE_GROUP_SIZE_KHR: usize = 32;
2355#[cfg(feature = "Allow1_1APIs")]
2356#[rustfmt::skip]
2357pub const VK_MAX_DEVICE_GROUP_SIZE: usize = 32;
2358
2359#[repr(transparent)]
2360#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
2361pub struct VkResult(pub i32);
2362#[rustfmt::skip]
2363pub const VK_SUCCESS: VkResult = VkResult(0);
2364#[rustfmt::skip]
2365pub const VK_NOT_READY: VkResult = VkResult(1);
2366#[rustfmt::skip]
2367pub const VK_TIMEOUT: VkResult = VkResult(2);
2368#[rustfmt::skip]
2369pub const VK_EVENT_SET: VkResult = VkResult(3);
2370#[rustfmt::skip]
2371pub const VK_EVENT_RESET: VkResult = VkResult(4);
2372#[rustfmt::skip]
2373pub const VK_INCOMPLETE: VkResult = VkResult(5);
2374#[rustfmt::skip]
2375pub const VK_ERROR_OUT_OF_HOST_MEMORY: VkResult = VkResult(-1);
2376#[rustfmt::skip]
2377pub const VK_ERROR_OUT_OF_DEVICE_MEMORY: VkResult = VkResult(-2);
2378#[rustfmt::skip]
2379pub const VK_ERROR_INITIALIZATION_FAILED: VkResult = VkResult(-3);
2380#[rustfmt::skip]
2381pub const VK_ERROR_DEVICE_LOST: VkResult = VkResult(-4);
2382#[rustfmt::skip]
2383pub const VK_ERROR_MEMORY_MAP_FAILED: VkResult = VkResult(-5);
2384#[rustfmt::skip]
2385pub const VK_ERROR_LAYER_NOT_PRESENT: VkResult = VkResult(-6);
2386#[rustfmt::skip]
2387pub const VK_ERROR_EXTENSION_NOT_PRESENT: VkResult = VkResult(-7);
2388#[rustfmt::skip]
2389pub const VK_ERROR_FEATURE_NOT_PRESENT: VkResult = VkResult(-8);
2390#[rustfmt::skip]
2391pub const VK_ERROR_INCOMPATIBLE_DRIVER: VkResult = VkResult(-9);
2392#[rustfmt::skip]
2393pub const VK_ERROR_TOO_MANY_OBJECTS: VkResult = VkResult(-10);
2394#[rustfmt::skip]
2395pub const VK_ERROR_FORMAT_NOT_SUPPORTED: VkResult = VkResult(-11);
2396#[rustfmt::skip]
2397pub const VK_ERROR_FRAGMENTED_POOL: VkResult = VkResult(-12);
2398#[rustfmt::skip]
2399pub const VK_ERROR_UNKNOWN: VkResult = VkResult(-13);
2400#[cfg(feature = "VK_KHR_surface")]
2401#[rustfmt::skip]
2402pub const VK_ERROR_SURFACE_LOST_KHR: VkResult = VkResult(-1000000000);
2403#[cfg(feature = "VK_KHR_surface")]
2404#[rustfmt::skip]
2405pub const VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: VkResult = VkResult(-1000000001);
2406#[cfg(feature = "VK_KHR_swapchain")]
2407#[rustfmt::skip]
2408pub const VK_SUBOPTIMAL_KHR: VkResult = VkResult(1000001003);
2409#[cfg(feature = "VK_KHR_swapchain")]
2410#[rustfmt::skip]
2411pub const VK_ERROR_OUT_OF_DATE_KHR: VkResult = VkResult(-1000001004);
2412#[cfg(feature = "VK_KHR_display_swapchain")]
2413#[rustfmt::skip]
2414pub const VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: VkResult = VkResult(-1000003001);
2415#[cfg(feature = "VK_KHR_external_memory")]
2416#[rustfmt::skip]
2417pub const VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR: VkResult = VkResult(-1000072003);
2418#[cfg(feature = "Allow1_1APIs")]
2419#[rustfmt::skip]
2420pub const VK_ERROR_INVALID_EXTERNAL_HANDLE: VkResult = VkResult(-1000072003);
2421#[cfg(feature = "VK_KHR_maintenance1")]
2422#[rustfmt::skip]
2423pub const VK_ERROR_OUT_OF_POOL_MEMORY_KHR: VkResult = VkResult(-1000069000);
2424#[cfg(feature = "Allow1_1APIs")]
2425#[rustfmt::skip]
2426pub const VK_ERROR_OUT_OF_POOL_MEMORY: VkResult = VkResult(-1000069000);
2427
2428#[rustfmt::skip]
2429pub type VkStructureType = i32;
2430#[rustfmt::skip]
2431pub type VkObjectType = i32;
2432
2433#[rustfmt::skip]
2434pub type VkAttachmentLoadOp = i32;
2435#[rustfmt::skip]
2436pub const VK_ATTACHMENT_LOAD_OP_LOAD: VkAttachmentLoadOp = 0;
2437#[rustfmt::skip]
2438pub const VK_ATTACHMENT_LOAD_OP_CLEAR: VkAttachmentLoadOp = 1;
2439#[rustfmt::skip]
2440pub const VK_ATTACHMENT_LOAD_OP_DONT_CARE: VkAttachmentLoadOp = 2;
2441
2442#[rustfmt::skip]
2443pub type VkAttachmentStoreOp = i32;
2444#[rustfmt::skip]
2445pub const VK_ATTACHMENT_STORE_OP_STORE: VkAttachmentStoreOp = 0;
2446#[rustfmt::skip]
2447pub const VK_ATTACHMENT_STORE_OP_DONT_CARE: VkAttachmentStoreOp = 1;
2448
2449#[rustfmt::skip]
2450pub type VkBlendFactor = i32;
2451#[rustfmt::skip]
2452pub const VK_BLEND_FACTOR_ZERO: VkBlendFactor = 0;
2453#[rustfmt::skip]
2454pub const VK_BLEND_FACTOR_ONE: VkBlendFactor = 1;
2455#[rustfmt::skip]
2456pub const VK_BLEND_FACTOR_SRC_COLOR: VkBlendFactor = 2;
2457#[rustfmt::skip]
2458pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: VkBlendFactor = 3;
2459#[rustfmt::skip]
2460pub const VK_BLEND_FACTOR_DST_COLOR: VkBlendFactor = 4;
2461#[rustfmt::skip]
2462pub const VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR: VkBlendFactor = 5;
2463#[rustfmt::skip]
2464pub const VK_BLEND_FACTOR_SRC_ALPHA: VkBlendFactor = 6;
2465#[rustfmt::skip]
2466pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: VkBlendFactor = 7;
2467#[rustfmt::skip]
2468pub const VK_BLEND_FACTOR_DST_ALPHA: VkBlendFactor = 8;
2469#[rustfmt::skip]
2470pub const VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: VkBlendFactor = 9;
2471#[rustfmt::skip]
2472pub const VK_BLEND_FACTOR_CONSTANT_COLOR: VkBlendFactor = 10;
2473#[rustfmt::skip]
2474pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: VkBlendFactor = 11;
2475#[rustfmt::skip]
2476pub const VK_BLEND_FACTOR_CONSTANT_ALPHA: VkBlendFactor = 12;
2477#[rustfmt::skip]
2478pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: VkBlendFactor = 13;
2479#[rustfmt::skip]
2480pub const VK_BLEND_FACTOR_SRC_ALPHA_STAURATE: VkBlendFactor = 14;
2481#[rustfmt::skip]
2482pub const VK_BLEND_FACTOR_SRC1_COLOR: VkBlendFactor = 15;
2483#[rustfmt::skip]
2484pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: VkBlendFactor = 16;
2485#[rustfmt::skip]
2486pub const VK_BLEND_FACTOR_SRC1_ALPHA: VkBlendFactor = 17;
2487#[rustfmt::skip]
2488pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: VkBlendFactor = 18;
2489
2490#[rustfmt::skip]
2491pub type VkBlendOp = i32;
2492#[rustfmt::skip]
2493pub const VK_BLEND_OP_ADD: VkBlendOp = 0;
2494#[rustfmt::skip]
2495pub const VK_BLEND_OP_SUBTRACT: VkBlendOp = 1;
2496#[rustfmt::skip]
2497pub const VK_BLEND_OP_REVERSE_SUBTRACT: VkBlendOp = 2;
2498#[rustfmt::skip]
2499pub const VK_BLEND_OP_MIN: VkBlendOp = 3;
2500#[rustfmt::skip]
2501pub const VK_BLEND_OP_MAX: VkBlendOp = 4;
2502
2503#[rustfmt::skip]
2504pub type VkBorderColor = i32;
2505#[rustfmt::skip]
2506pub const VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: VkBorderColor = 0;
2507#[rustfmt::skip]
2508pub const VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: VkBorderColor = 1;
2509#[rustfmt::skip]
2510pub const VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: VkBorderColor = 2;
2511#[rustfmt::skip]
2512pub const VK_BORDER_COLOR_INT_OPAQUE_BLACK: VkBorderColor = 3;
2513#[rustfmt::skip]
2514pub const VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: VkBorderColor = 4;
2515#[rustfmt::skip]
2516pub const VK_BORDER_COLOR_INT_OPAQUE_WHITE: VkBorderColor = 5;
2517
2518#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
2519#[rustfmt::skip]
2520pub type VkChromaLocationKHR = i32;
2521#[cfg(feature = "Allow1_1APIs")]
2522#[rustfmt::skip]
2523#[rustfmt::skip]
2524pub type VkChromaLocation = i32;
2525#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
2526#[rustfmt::skip]
2527pub const VK_CHROMA_LOCATION_COSITED_EVEN_KHR: VkChromaLocationKHR = 0;
2528#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
2529#[cfg(feature = "Allow1_1APIs")]
2530#[rustfmt::skip]
2531pub const VK_CHROMA_LOCATION_COSITED_EVEN: VkChromaLocationKHR = 0;
2532#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
2533#[rustfmt::skip]
2534pub const VK_CHROMA_LOCATION_MIDPOINT_KHR: VkChromaLocationKHR = 1;
2535#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
2536#[cfg(feature = "Allow1_1APIs")]
2537#[rustfmt::skip]
2538pub const VK_CHROMA_LOCATION_MIDPOINT: VkChromaLocationKHR = 1;
2539
2540#[cfg(feature = "VK_KHR_surface")]
2541#[rustfmt::skip]
2542pub type VkColorSpaceKHR = i32;
2543#[cfg(feature = "VK_KHR_surface")]
2544#[rustfmt::skip]
2545pub const VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = 0;
2546
2547#[rustfmt::skip]
2548pub type VkCommandBufferLevel = i32;
2549#[rustfmt::skip]
2550pub const VK_COMMAND_BUFFER_LEVEL_PRIMARY: VkCommandBufferLevel = 0;
2551#[rustfmt::skip]
2552pub const VK_COMMAND_BUFFER_LEVEL_SECONDARY: VkCommandBufferLevel = 1;
2553
2554#[rustfmt::skip]
2555pub type VkCompareOp = i32;
2556#[rustfmt::skip]
2557pub const VK_COMPARE_OP_NEVER: VkCompareOp = 0;
2558#[rustfmt::skip]
2559pub const VK_COMPARE_OP_LESS: VkCompareOp = 1;
2560#[rustfmt::skip]
2561pub const VK_COMPARE_OP_EQUAL: VkCompareOp = 2;
2562#[rustfmt::skip]
2563pub const VK_COMPARE_OP_LESS_OR_EQUAL: VkCompareOp = 3;
2564#[rustfmt::skip]
2565pub const VK_COMPARE_OP_GREATER: VkCompareOp = 4;
2566#[rustfmt::skip]
2567pub const VK_COMPARE_OP_NOT_EQUAL: VkCompareOp = 5;
2568#[rustfmt::skip]
2569pub const VK_COMPARE_OP_GREATER_OR_EQUAL: VkCompareOp = 6;
2570#[rustfmt::skip]
2571pub const VK_COMPARE_OP_ALWAYS: VkCompareOp = 7;
2572
2573#[rustfmt::skip]
2574pub type VkComponentSwizzle = i32;
2575#[rustfmt::skip]
2576pub const VK_COMPONENT_SWIZZLE_IDENTITY: VkComponentSwizzle = 0;
2577#[rustfmt::skip]
2578pub const VK_COMPONENT_SWIZZLE_ZERO: VkComponentSwizzle = 1;
2579#[rustfmt::skip]
2580pub const VK_COMPONENT_SWIZZLE_ONE: VkComponentSwizzle = 2;
2581#[rustfmt::skip]
2582pub const VK_COMPONENT_SWIZZLE_R: VkComponentSwizzle = 3;
2583#[rustfmt::skip]
2584pub const VK_COMPONENT_SWIZZLE_G: VkComponentSwizzle = 4;
2585#[rustfmt::skip]
2586pub const VK_COMPONENT_SWIZZLE_B: VkComponentSwizzle = 5;
2587#[rustfmt::skip]
2588pub const VK_COMPONENT_SWIZZLE_A: VkComponentSwizzle = 6;
2589
2590#[cfg(feature = "VK_EXT_debug_report")]
2591#[rustfmt::skip]
2592pub type VkDebugReportObjectTypeEXT = i32;
2593#[cfg(feature = "VK_EXT_debug_report")]
2594#[rustfmt::skip]
2595pub const VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: VkDebugReportObjectTypeEXT = 0;
2596#[cfg(feature = "VK_EXT_debug_report")]
2597#[rustfmt::skip]
2598pub const VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: VkDebugReportObjectTypeEXT = 1;
2599#[cfg(feature = "VK_EXT_debug_report")]
2600#[rustfmt::skip]
2601pub const VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: VkDebugReportObjectTypeEXT = 2;
2602#[cfg(feature = "VK_EXT_debug_report")]
2603#[rustfmt::skip]
2604pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: VkDebugReportObjectTypeEXT = 3;
2605#[cfg(feature = "VK_EXT_debug_report")]
2606#[rustfmt::skip]
2607pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: VkDebugReportObjectTypeEXT = 4;
2608#[cfg(feature = "VK_EXT_debug_report")]
2609#[rustfmt::skip]
2610pub const VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: VkDebugReportObjectTypeEXT = 5;
2611#[cfg(feature = "VK_EXT_debug_report")]
2612#[rustfmt::skip]
2613pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: VkDebugReportObjectTypeEXT = 6;
2614#[cfg(feature = "VK_EXT_debug_report")]
2615#[rustfmt::skip]
2616pub const VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: VkDebugReportObjectTypeEXT = 7;
2617#[cfg(feature = "VK_EXT_debug_report")]
2618#[rustfmt::skip]
2619pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: VkDebugReportObjectTypeEXT = 8;
2620#[cfg(feature = "VK_EXT_debug_report")]
2621#[rustfmt::skip]
2622pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: VkDebugReportObjectTypeEXT = 9;
2623#[cfg(feature = "VK_EXT_debug_report")]
2624#[rustfmt::skip]
2625pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: VkDebugReportObjectTypeEXT = 10;
2626#[cfg(feature = "VK_EXT_debug_report")]
2627#[rustfmt::skip]
2628pub const VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: VkDebugReportObjectTypeEXT = 11;
2629#[cfg(feature = "VK_EXT_debug_report")]
2630#[rustfmt::skip]
2631pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: VkDebugReportObjectTypeEXT = 12;
2632#[cfg(feature = "VK_EXT_debug_report")]
2633#[rustfmt::skip]
2634pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: VkDebugReportObjectTypeEXT = 13;
2635#[cfg(feature = "VK_EXT_debug_report")]
2636#[rustfmt::skip]
2637pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: VkDebugReportObjectTypeEXT = 14;
2638#[cfg(feature = "VK_EXT_debug_report")]
2639#[rustfmt::skip]
2640pub const VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: VkDebugReportObjectTypeEXT = 15;
2641#[cfg(feature = "VK_EXT_debug_report")]
2642#[rustfmt::skip]
2643pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: VkDebugReportObjectTypeEXT = 16;
2644#[cfg(feature = "VK_EXT_debug_report")]
2645#[rustfmt::skip]
2646pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 17;
2647#[cfg(feature = "VK_EXT_debug_report")]
2648#[rustfmt::skip]
2649pub const VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: VkDebugReportObjectTypeEXT = 18;
2650#[cfg(feature = "VK_EXT_debug_report")]
2651#[rustfmt::skip]
2652pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: VkDebugReportObjectTypeEXT = 19;
2653#[cfg(feature = "VK_EXT_debug_report")]
2654#[rustfmt::skip]
2655pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 20;
2656#[cfg(feature = "VK_EXT_debug_report")]
2657#[rustfmt::skip]
2658pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: VkDebugReportObjectTypeEXT = 21;
2659#[cfg(feature = "VK_EXT_debug_report")]
2660#[rustfmt::skip]
2661pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: VkDebugReportObjectTypeEXT = 22;
2662#[cfg(feature = "VK_EXT_debug_report")]
2663#[rustfmt::skip]
2664pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: VkDebugReportObjectTypeEXT = 23;
2665#[cfg(feature = "VK_EXT_debug_report")]
2666#[rustfmt::skip]
2667pub const VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: VkDebugReportObjectTypeEXT = 24;
2668#[cfg(feature = "VK_EXT_debug_report")]
2669#[rustfmt::skip]
2670pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: VkDebugReportObjectTypeEXT = 25;
2671#[cfg(feature = "VK_EXT_debug_report")]
2672#[rustfmt::skip]
2673pub const VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: VkDebugReportObjectTypeEXT = 26;
2674#[cfg(feature = "VK_EXT_debug_report")]
2675#[rustfmt::skip]
2676pub const VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: VkDebugReportObjectTypeEXT = 27;
2677#[cfg(feature = "VK_EXT_debug_report")]
2678#[rustfmt::skip]
2679pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: VkDebugReportObjectTypeEXT = 28;
2680#[cfg(feature = "VK_EXT_debug_report")]
2681#[rustfmt::skip]
2682pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: VkDebugReportObjectTypeEXT = 29;
2683#[cfg(feature = "VK_EXT_debug_report")]
2684#[rustfmt::skip]
2685pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: VkDebugReportObjectTypeEXT = 30;
2686#[cfg(feature = "VK_EXT_debug_report")]
2687#[rustfmt::skip]
2688pub const VK_DEBUG_REPORT_OBJECT_TYPE_OBJECT_TABLE_NVX_EXT: VkDebugReportObjectTypeEXT = 31;
2689#[cfg(feature = "VK_EXT_debug_report")]
2690#[rustfmt::skip]
2691pub const VK_DEBUG_REPORT_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NVX_EXT: VkDebugReportObjectTypeEXT = 32;
2692#[cfg(feature = "VK_EXT_debug_report")]
2693#[rustfmt::skip]
2694pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: VkDebugReportObjectTypeEXT = 33;
2695#[cfg(feature = "VK_EXT_debug_report")]
2696#[cfg(feature = "VK_KHR_descriptor_update_template")]
2697#[rustfmt::skip]
2698pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR: VkDebugReportObjectTypeEXT = 1000085000;
2699#[cfg(feature = "VK_EXT_debug_report")]
2700#[cfg(feature = "Allow1_1APIs")]
2701#[rustfmt::skip]
2702pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: VkDebugReportObjectTypeEXT = 1000085000;
2703#[cfg(feature = "VK_EXT_debug_report")]
2704#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
2705#[rustfmt::skip]
2706pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR: VkDebugReportObjectTypeEXT = 1000156000;
2707#[cfg(feature = "VK_EXT_debug_report")]
2708#[cfg(feature = "Allow1_1APIs")]
2709#[rustfmt::skip]
2710pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: VkDebugReportObjectTypeEXT = 1000156000;
2711
2712#[rustfmt::skip]
2713pub type VkDescriptorType = i32;
2714#[rustfmt::skip]
2715pub const VK_DESCRIPTOR_TYPE_SAMPLER: VkDescriptorType = 0;
2716#[rustfmt::skip]
2717pub const VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: VkDescriptorType = 1;
2718#[rustfmt::skip]
2719pub const VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: VkDescriptorType = 2;
2720#[rustfmt::skip]
2721pub const VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: VkDescriptorType = 3;
2722#[rustfmt::skip]
2723pub const VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: VkDescriptorType = 4;
2724#[rustfmt::skip]
2725pub const VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: VkDescriptorType = 5;
2726#[rustfmt::skip]
2727pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: VkDescriptorType = 6;
2728#[rustfmt::skip]
2729pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: VkDescriptorType = 7;
2730#[rustfmt::skip]
2731pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: VkDescriptorType = 8;
2732#[rustfmt::skip]
2733pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: VkDescriptorType = 9;
2734#[rustfmt::skip]
2735pub const VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: VkDescriptorType = 10;
2736
2737#[cfg(feature = "VK_KHR_descriptor_update_template")]
2738#[rustfmt::skip]
2739pub type VkDescriptorUpdateTemplateTypeKHR = i32;
2740#[cfg(feature = "Allow1_1APIs")]
2741#[rustfmt::skip]
2742#[rustfmt::skip]
2743pub type VkDescriptorUpdateTemplateType = i32;
2744#[cfg(feature = "VK_KHR_descriptor_update_template")]
2745#[rustfmt::skip]
2746pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR: VkDescriptorUpdateTemplateTypeKHR = 0;
2747#[cfg(feature = "VK_KHR_descriptor_update_template")]
2748#[cfg(feature = "Allow1_1APIs")]
2749#[rustfmt::skip]
2750pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: VkDescriptorUpdateTemplateTypeKHR = 0;
2751
2752#[rustfmt::skip]
2753pub type VkDynamicState = i32;
2754#[rustfmt::skip]
2755pub const VK_DYNAMIC_STATE_VIEWPORT: VkDynamicState = 0;
2756#[rustfmt::skip]
2757pub const VK_DYNAMIC_STATE_SCISSOR: VkDynamicState = 1;
2758#[rustfmt::skip]
2759pub const VK_DYNAMIC_STATE_LINE_WIDTH: VkDynamicState = 2;
2760#[rustfmt::skip]
2761pub const VK_DYNAMIC_STATE_DEPTH_BIAS: VkDynamicState = 3;
2762#[rustfmt::skip]
2763pub const VK_DYNAMIC_STATE_BLEND_CONSTANTS: VkDynamicState = 4;
2764#[rustfmt::skip]
2765pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS: VkDynamicState = 5;
2766#[rustfmt::skip]
2767pub const VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: VkDynamicState = 6;
2768#[rustfmt::skip]
2769pub const VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: VkDynamicState = 7;
2770#[rustfmt::skip]
2771pub const VK_DYNAMIC_STATE_STENCIL_REFERENCE: VkDynamicState = 8;
2772
2773#[rustfmt::skip]
2774pub type VkFilter = i32;
2775#[rustfmt::skip]
2776pub const VK_FILTER_NEAREST: VkFilter = 0;
2777#[rustfmt::skip]
2778pub const VK_FILTER_LINEAR: VkFilter = 1;
2779
2780#[rustfmt::skip]
2781pub type VkFrontFace = i32;
2782#[rustfmt::skip]
2783pub const VK_FRONT_FACE_COUNTER_CLOCKWISE: VkFrontFace = 0;
2784#[rustfmt::skip]
2785pub const VK_FRONT_FACE_CLOCKWISE: VkFrontFace = 1;
2786
2787#[rustfmt::skip]
2788pub type VkImageLayout = i32;
2789#[rustfmt::skip]
2790pub const VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = 0;
2791#[rustfmt::skip]
2792pub const VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = 1;
2793#[rustfmt::skip]
2794pub const VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = 2;
2795#[rustfmt::skip]
2796pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 3;
2797#[rustfmt::skip]
2798pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 4;
2799#[rustfmt::skip]
2800pub const VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = 5;
2801#[rustfmt::skip]
2802pub const VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = 6;
2803#[rustfmt::skip]
2804pub const VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = 7;
2805#[rustfmt::skip]
2806pub const VK_IMAGE_LAYOUT_PREINITIALIZED: VkImageLayout = 8;
2807#[cfg(feature = "VK_KHR_swapchain")]
2808#[rustfmt::skip]
2809pub const VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = 1000001002;
2810#[cfg(feature = "VK_KHR_maintenance2")]
2811#[rustfmt::skip]
2812pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = 1000117000;
2813#[cfg(feature = "Allow1_1APIs")]
2814#[rustfmt::skip]
2815pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000117000;
2816#[cfg(feature = "VK_KHR_maintenance2")]
2817#[rustfmt::skip]
2818pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = 1000117001;
2819#[cfg(feature = "Allow1_1APIs")]
2820#[rustfmt::skip]
2821pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000117001;
2822
2823#[rustfmt::skip]
2824pub type VkImageTiling = i32;
2825#[rustfmt::skip]
2826pub const VK_IMAGE_TILING_OPTIMAL: VkImageTiling = 0;
2827#[rustfmt::skip]
2828pub const VK_IMAGE_TILING_LINEAR: VkImageTiling = 1;
2829
2830#[rustfmt::skip]
2831pub type VkImageType = i32;
2832#[rustfmt::skip]
2833pub const VK_IMAGE_TYPE_1D: VkImageType = 0;
2834#[rustfmt::skip]
2835pub const VK_IMAGE_TYPE_2D: VkImageType = 1;
2836#[rustfmt::skip]
2837pub const VK_IMAGE_TYPE_3D: VkImageType = 2;
2838
2839#[rustfmt::skip]
2840pub type VkImageViewType = i32;
2841#[rustfmt::skip]
2842pub const VK_IMAGE_VIEW_TYPE_1D: VkImageViewType = 0;
2843#[rustfmt::skip]
2844pub const VK_IMAGE_VIEW_TYPE_2D: VkImageViewType = 1;
2845#[rustfmt::skip]
2846pub const VK_IMAGE_VIEW_TYPE_3D: VkImageViewType = 2;
2847#[rustfmt::skip]
2848pub const VK_IMAGE_VIEW_TYPE_CUBE: VkImageViewType = 3;
2849#[rustfmt::skip]
2850pub const VK_IMAGE_VIEW_TYPE_1D_ARRAY: VkImageViewType = 4;
2851#[rustfmt::skip]
2852pub const VK_IMAGE_VIEW_TYPE_2D_ARRAY: VkImageViewType = 5;
2853#[rustfmt::skip]
2854pub const VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: VkImageViewType = 6;
2855
2856#[rustfmt::skip]
2857pub type VkIndexType = i32;
2858#[rustfmt::skip]
2859pub const VK_INDEX_TYPE_UINT16: VkIndexType = 0;
2860#[rustfmt::skip]
2861pub const VK_INDEX_TYPE_UINT32: VkIndexType = 1;
2862
2863#[rustfmt::skip]
2864pub type VkLogicOp = i32;
2865#[rustfmt::skip]
2866pub const VK_LOGIC_OP_CLEAR: VkLogicOp = 0;
2867#[rustfmt::skip]
2868pub const VK_LOGIC_OP_AND: VkLogicOp = 1;
2869#[rustfmt::skip]
2870pub const VK_LOGIC_OP_AND_REVERSE: VkLogicOp = 2;
2871#[rustfmt::skip]
2872pub const VK_LOGIC_OP_COPY: VkLogicOp = 3;
2873#[rustfmt::skip]
2874pub const VK_LOGIC_OP_AND_INVERTED: VkLogicOp = 4;
2875#[rustfmt::skip]
2876pub const VK_LOGIC_OP_NO_OP: VkLogicOp = 5;
2877#[rustfmt::skip]
2878pub const VK_LOGIC_OP_XOR: VkLogicOp = 6;
2879#[rustfmt::skip]
2880pub const VK_LOGIC_OP_OR: VkLogicOp = 7;
2881#[rustfmt::skip]
2882pub const VK_LOGIC_OP_NOR: VkLogicOp = 8;
2883#[rustfmt::skip]
2884pub const VK_LOGIC_OP_EQUIVALENT: VkLogicOp = 9;
2885#[rustfmt::skip]
2886pub const VK_LOGIC_OP_INVERT: VkLogicOp = 10;
2887#[rustfmt::skip]
2888pub const VK_LOGIC_OP_OR_REVERSE: VkLogicOp = 11;
2889#[rustfmt::skip]
2890pub const VK_LOGIC_OP_COPY_INVERTED: VkLogicOp = 12;
2891#[rustfmt::skip]
2892pub const VK_LOGIC_OP_OR_INVERTED: VkLogicOp = 13;
2893#[rustfmt::skip]
2894pub const VK_LOGIC_OP_NAND: VkLogicOp = 14;
2895#[rustfmt::skip]
2896pub const VK_LOGIC_OP_SET: VkLogicOp = 15;
2897
2898#[rustfmt::skip]
2899pub type VkInternalAllocationType = i32;
2900#[rustfmt::skip]
2901pub const VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE: VkInternalAllocationType = 0;
2902
2903#[rustfmt::skip]
2904pub type VkPhysicalDeviceType = i32;
2905#[rustfmt::skip]
2906pub const VK_PHYSICAL_DEVICE_TYPE_OTHER: VkPhysicalDeviceType = 0;
2907#[rustfmt::skip]
2908pub const VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: VkPhysicalDeviceType = 1;
2909#[rustfmt::skip]
2910pub const VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: VkPhysicalDeviceType = 2;
2911#[rustfmt::skip]
2912pub const VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: VkPhysicalDeviceType = 3;
2913#[rustfmt::skip]
2914pub const VK_PHYSICAL_DEVICE_TYPE_CPU: VkPhysicalDeviceType = 4;
2915
2916#[rustfmt::skip]
2917pub type VkPipelineBindPoint = i32;
2918#[rustfmt::skip]
2919pub const VK_PIPELINE_BIND_POINT_GRAPHICS: VkPipelineBindPoint = 0;
2920#[rustfmt::skip]
2921pub const VK_PIPELINE_BIND_POINT_COMPUTE: VkPipelineBindPoint = 1;
2922
2923#[cfg(feature = "VK_KHR_maintenance2")]
2924#[rustfmt::skip]
2925pub type VkPointClippingBehaviorKHR = i32;
2926#[cfg(feature = "Allow1_1APIs")]
2927#[rustfmt::skip]
2928#[rustfmt::skip]
2929pub type VkPointClippingBehavior = i32;
2930#[cfg(feature = "VK_KHR_maintenance2")]
2931#[rustfmt::skip]
2932pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR: VkPointClippingBehaviorKHR = 0;
2933#[cfg(feature = "VK_KHR_maintenance2")]
2934#[cfg(feature = "Allow1_1APIs")]
2935#[rustfmt::skip]
2936pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: VkPointClippingBehaviorKHR = 0;
2937#[cfg(feature = "VK_KHR_maintenance2")]
2938#[rustfmt::skip]
2939pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_KHR: VkPointClippingBehaviorKHR = 1;
2940#[cfg(feature = "VK_KHR_maintenance2")]
2941#[cfg(feature = "Allow1_1APIs")]
2942#[rustfmt::skip]
2943pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES: VkPointClippingBehaviorKHR = 1;
2944
2945#[rustfmt::skip]
2946pub type VkPolygonMode = i32;
2947#[rustfmt::skip]
2948pub const VK_POLYGON_MODE_FILL: VkPolygonMode = 0;
2949#[rustfmt::skip]
2950pub const VK_POLYGON_MODE_LINE: VkPolygonMode = 1;
2951#[rustfmt::skip]
2952pub const VK_POLYGON_MODE_POINT: VkPolygonMode = 2;
2953
2954#[cfg(feature = "VK_KHR_surface")]
2955#[rustfmt::skip]
2956pub type VkPresentModeKHR = i32;
2957#[cfg(feature = "VK_KHR_surface")]
2958#[rustfmt::skip]
2959pub const VK_PRESENT_MODE_IMMEDIATE_KHR: VkPresentModeKHR = 0;
2960#[cfg(feature = "VK_KHR_surface")]
2961#[rustfmt::skip]
2962pub const VK_PRESENT_MODE_MAILBOX_KHR: VkPresentModeKHR = 1;
2963#[cfg(feature = "VK_KHR_surface")]
2964#[rustfmt::skip]
2965pub const VK_PRESENT_MODE_FIFO_KHR: VkPresentModeKHR = 2;
2966#[cfg(feature = "VK_KHR_surface")]
2967#[rustfmt::skip]
2968pub const VK_PRESENT_MODE_FIFO_RELAXED_KHR: VkPresentModeKHR = 3;
2969
2970#[rustfmt::skip]
2971pub type VkPrimitiveTopology = i32;
2972#[rustfmt::skip]
2973pub const VK_PRIMITIVE_TOPOLOGY_POINT_LIST: VkPrimitiveTopology = 0;
2974#[rustfmt::skip]
2975pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST: VkPrimitiveTopology = 1;
2976#[rustfmt::skip]
2977pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: VkPrimitiveTopology = 2;
2978#[rustfmt::skip]
2979pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: VkPrimitiveTopology = 3;
2980#[rustfmt::skip]
2981pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: VkPrimitiveTopology = 4;
2982#[rustfmt::skip]
2983pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN: VkPrimitiveTopology = 5;
2984#[rustfmt::skip]
2985pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 6;
2986#[rustfmt::skip]
2987pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 7;
2988#[rustfmt::skip]
2989pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 8;
2990#[rustfmt::skip]
2991pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 9;
2992#[rustfmt::skip]
2993pub const VK_PRIMITIVE_TOPOLOGY_PATCH_LIST: VkPrimitiveTopology = 10;
2994
2995#[rustfmt::skip]
2996pub type VkQueryType = i32;
2997#[rustfmt::skip]
2998pub const VK_QUERY_TYPE_OCCLUSION: VkQueryType = 0;
2999#[rustfmt::skip]
3000pub const VK_QUERY_TYPE_PIPELINE_STATISTICS: VkQueryType = 1;
3001#[rustfmt::skip]
3002pub const VK_QUERY_TYPE_TIMESTAMP: VkQueryType = 2;
3003
3004#[rustfmt::skip]
3005pub type VkSamplerAddressMode = i32;
3006#[rustfmt::skip]
3007pub const VK_SAMPLER_ADDRESS_MODE_REPEAT: VkSamplerAddressMode = 0;
3008#[rustfmt::skip]
3009pub const VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: VkSamplerAddressMode = 1;
3010#[rustfmt::skip]
3011pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: VkSamplerAddressMode = 2;
3012#[rustfmt::skip]
3013pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: VkSamplerAddressMode = 3;
3014#[rustfmt::skip]
3015pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: VkSamplerAddressMode = 4;
3016
3017#[rustfmt::skip]
3018pub type VkSamplerMipmapMode = i32;
3019#[rustfmt::skip]
3020pub const VK_SAMPLER_MIPMAP_MODE_NEAREST: VkSamplerMipmapMode = 0;
3021#[rustfmt::skip]
3022pub const VK_SAMPLER_MIPMAP_MODE_LINEAR: VkSamplerMipmapMode = 1;
3023
3024#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3025#[rustfmt::skip]
3026pub type VkSamplerYcbcrModelConversionKHR = i32;
3027#[cfg(feature = "Allow1_1APIs")]
3028#[rustfmt::skip]
3029#[rustfmt::skip]
3030pub type VkSamplerYcbcrModelConversion = i32;
3031#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3032#[rustfmt::skip]
3033pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR: VkSamplerYcbcrModelConversionKHR = 0;
3034#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3035#[cfg(feature = "Allow1_1APIs")]
3036#[rustfmt::skip]
3037pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: VkSamplerYcbcrModelConversionKHR = 0;
3038#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3039#[rustfmt::skip]
3040pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR: VkSamplerYcbcrModelConversionKHR = 1;
3041#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3042#[cfg(feature = "Allow1_1APIs")]
3043#[rustfmt::skip]
3044pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: VkSamplerYcbcrModelConversionKHR = 1;
3045#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3046#[rustfmt::skip]
3047pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR: VkSamplerYcbcrModelConversionKHR = 2;
3048#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3049#[cfg(feature = "Allow1_1APIs")]
3050#[rustfmt::skip]
3051pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: VkSamplerYcbcrModelConversionKHR = 2;
3052#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3053#[rustfmt::skip]
3054pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR: VkSamplerYcbcrModelConversionKHR = 3;
3055#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3056#[cfg(feature = "Allow1_1APIs")]
3057#[rustfmt::skip]
3058pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: VkSamplerYcbcrModelConversionKHR = 3;
3059#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3060#[rustfmt::skip]
3061pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR: VkSamplerYcbcrModelConversionKHR = 4;
3062#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3063#[cfg(feature = "Allow1_1APIs")]
3064#[rustfmt::skip]
3065pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: VkSamplerYcbcrModelConversionKHR = 4;
3066
3067#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3068#[rustfmt::skip]
3069pub type VkSamplerYcbcrRangeKHR = i32;
3070#[cfg(feature = "Allow1_1APIs")]
3071#[rustfmt::skip]
3072#[rustfmt::skip]
3073pub type VkSamplerYcbcrRange = i32;
3074#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3075#[rustfmt::skip]
3076pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR: VkSamplerYcbcrRangeKHR = 0;
3077#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3078#[cfg(feature = "Allow1_1APIs")]
3079#[rustfmt::skip]
3080pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL: VkSamplerYcbcrRangeKHR = 0;
3081#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3082#[rustfmt::skip]
3083pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR: VkSamplerYcbcrRangeKHR = 1;
3084#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3085#[cfg(feature = "Allow1_1APIs")]
3086#[rustfmt::skip]
3087pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW: VkSamplerYcbcrRangeKHR = 1;
3088
3089#[rustfmt::skip]
3090pub type VkSharingMode = i32;
3091#[rustfmt::skip]
3092pub const VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = 0;
3093#[rustfmt::skip]
3094pub const VK_SHARING_MODE_CONCURRENT: VkSharingMode = 1;
3095
3096#[rustfmt::skip]
3097pub type VkStencilOp = i32;
3098#[rustfmt::skip]
3099pub const VK_STENCIL_OP_KEEP: VkStencilOp = 0;
3100#[rustfmt::skip]
3101pub const VK_STENCIL_OP_ZERO: VkStencilOp = 1;
3102#[rustfmt::skip]
3103pub const VK_STENCIL_OP_REPLACE: VkStencilOp = 2;
3104#[rustfmt::skip]
3105pub const VK_STENCIL_OP_INCREMENT_AND_CLAMP: VkStencilOp = 3;
3106#[rustfmt::skip]
3107pub const VK_STENCIL_OP_DECREMENT_AND_CLAMP: VkStencilOp = 4;
3108#[rustfmt::skip]
3109pub const VK_STENCIL_OP_INVERT: VkStencilOp = 5;
3110#[rustfmt::skip]
3111pub const VK_STENCIL_OP_INCREMENT_AND_WRAP: VkStencilOp = 6;
3112#[rustfmt::skip]
3113pub const VK_STENCIL_OP_DECREMENT_AND_WRAP: VkStencilOp = 7;
3114
3115#[rustfmt::skip]
3116pub type VkSubpassContents = i32;
3117#[rustfmt::skip]
3118pub const VK_SUBPASS_CONTENTS_INLINE: VkSubpassContents = 0;
3119#[rustfmt::skip]
3120pub const VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: VkSubpassContents = 1;
3121
3122#[rustfmt::skip]
3123pub type VkSystemAllocationScope = i32;
3124#[rustfmt::skip]
3125pub const VK_SYSTEM_ALLOCATION_SCOPE_COMMAND: VkSystemAllocationScope = 0;
3126#[rustfmt::skip]
3127pub const VK_SYSTEM_ALLOCATION_SCOPE_OBJECT: VkSystemAllocationScope = 1;
3128#[rustfmt::skip]
3129pub const VK_SYSTEM_ALLOCATION_SCOPE_CACHE: VkSystemAllocationScope = 2;
3130#[rustfmt::skip]
3131pub const VK_SYSTEM_ALLOCATION_SCOPE_DEVICE: VkSystemAllocationScope = 3;
3132#[rustfmt::skip]
3133pub const VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE: VkSystemAllocationScope = 4;
3134
3135#[cfg(feature = "VK_KHR_maintenance2")]
3136#[rustfmt::skip]
3137pub type VkTessellationDomainOriginKHR = i32;
3138#[cfg(feature = "Allow1_1APIs")]
3139#[rustfmt::skip]
3140#[rustfmt::skip]
3141pub type VkTessellationDomainOrigin = i32;
3142#[cfg(feature = "VK_KHR_maintenance2")]
3143#[rustfmt::skip]
3144pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR: VkTessellationDomainOriginKHR = 0;
3145#[cfg(feature = "VK_KHR_maintenance2")]
3146#[cfg(feature = "Allow1_1APIs")]
3147#[rustfmt::skip]
3148pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT: VkTessellationDomainOriginKHR = 0;
3149#[cfg(feature = "VK_KHR_maintenance2")]
3150#[rustfmt::skip]
3151pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR: VkTessellationDomainOriginKHR = 1;
3152#[cfg(feature = "VK_KHR_maintenance2")]
3153#[cfg(feature = "Allow1_1APIs")]
3154#[rustfmt::skip]
3155pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT: VkTessellationDomainOriginKHR = 1;
3156
3157#[rustfmt::skip]
3158pub type VkVertexInputRate = i32;
3159#[rustfmt::skip]
3160pub const VK_VERTEX_INPUT_RATE_VERTEX: VkVertexInputRate = 0;
3161#[rustfmt::skip]
3162pub const VK_VERTEX_INPUT_RATE_INSTANCE: VkVertexInputRate = 1;
3163
3164#[rustfmt::skip]
3165pub type VkFormat = i32;
3166#[rustfmt::skip]
3167pub const VK_FORMAT_UNDEFINED: VkFormat = 0;
3168pub const VK_FORMAT_R4G4_UNORM_PACK8: VkFormat = 1;
3169pub const VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormat = 2;
3170pub const VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormat = 3;
3171pub const VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormat = 4;
3172pub const VK_FORMAT_B5G6R5_UNORM_PACK16: VkFormat = 5;
3173pub const VK_FORMAT_R5G5B5A1_UNORM_PACK16: VkFormat = 6;
3174pub const VK_FORMAT_B5G5R5A1_UNORM_PACK16: VkFormat = 7;
3175pub const VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormat = 8;
3176pub const VK_FORMAT_R8_UNORM: VkFormat = 9;
3177pub const VK_FORMAT_R8_SNORM: VkFormat = 10;
3178pub const VK_FORMAT_R8_USCALED: VkFormat = 11;
3179pub const VK_FORMAT_R8_SSCALED: VkFormat = 12;
3180pub const VK_FORMAT_R8_UINT: VkFormat = 13;
3181pub const VK_FORMAT_R8_SINT: VkFormat = 14;
3182pub const VK_FORMAT_R8_SRGB: VkFormat = 15;
3183pub const VK_FORMAT_R8G8_UNORM: VkFormat = 16;
3184pub const VK_FORMAT_R8G8_SNORM: VkFormat = 17;
3185pub const VK_FORMAT_R8G8_USCALED: VkFormat = 18;
3186pub const VK_FORMAT_R8G8_SSCALED: VkFormat = 19;
3187pub const VK_FORMAT_R8G8_UINT: VkFormat = 20;
3188pub const VK_FORMAT_R8G8_SINT: VkFormat = 21;
3189pub const VK_FORMAT_R8G8_SRGB: VkFormat = 22;
3190pub const VK_FORMAT_R8G8B8_UNORM: VkFormat = 23;
3191pub const VK_FORMAT_R8G8B8_SNORM: VkFormat = 24;
3192pub const VK_FORMAT_R8G8B8_USCALED: VkFormat = 25;
3193pub const VK_FORMAT_R8G8B8_SSCALED: VkFormat = 26;
3194pub const VK_FORMAT_R8G8B8_UINT: VkFormat = 27;
3195pub const VK_FORMAT_R8G8B8_SINT: VkFormat = 28;
3196pub const VK_FORMAT_R8G8B8_SRGB: VkFormat = 29;
3197pub const VK_FORMAT_B8G8R8_UNORM: VkFormat = 30;
3198pub const VK_FORMAT_B8G8R8_SNORM: VkFormat = 31;
3199pub const VK_FORMAT_B8G8R8_USCALED: VkFormat = 32;
3200pub const VK_FORMAT_B8G8R8_SSCALED: VkFormat = 33;
3201pub const VK_FORMAT_B8G8R8_UINT: VkFormat = 34;
3202pub const VK_FORMAT_B8G8R8_SINT: VkFormat = 35;
3203pub const VK_FORMAT_B8G8R8_SRGB: VkFormat = 36;
3204pub const VK_FORMAT_R8G8B8A8_UNORM: VkFormat = 37;
3205pub const VK_FORMAT_R8G8B8A8_SNORM: VkFormat = 38;
3206pub const VK_FORMAT_R8G8B8A8_USCALED: VkFormat = 39;
3207pub const VK_FORMAT_R8G8B8A8_SSCALED: VkFormat = 40;
3208pub const VK_FORMAT_R8G8B8A8_UINT: VkFormat = 41;
3209pub const VK_FORMAT_R8G8B8A8_SINT: VkFormat = 42;
3210pub const VK_FORMAT_R8G8B8A8_SRGB: VkFormat = 43;
3211pub const VK_FORMAT_B8G8R8A8_UNORM: VkFormat = 44;
3212pub const VK_FORMAT_B8G8R8A8_SNORM: VkFormat = 45;
3213pub const VK_FORMAT_B8G8R8A8_USCALED: VkFormat = 46;
3214pub const VK_FORMAT_B8G8R8A8_SSCALED: VkFormat = 47;
3215pub const VK_FORMAT_B8G8R8A8_UINT: VkFormat = 48;
3216pub const VK_FORMAT_B8G8R8A8_SINT: VkFormat = 49;
3217pub const VK_FORMAT_B8G8R8A8_SRGB: VkFormat = 50;
3218pub const VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormat = 51;
3219pub const VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormat = 52;
3220pub const VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormat = 53;
3221pub const VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormat = 54;
3222pub const VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormat = 55;
3223pub const VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormat = 56;
3224pub const VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormat = 57;
3225pub const VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormat = 58;
3226pub const VK_FORMAT_A2R10G10B10_SNORM_PACK32: VkFormat = 59;
3227pub const VK_FORMAT_A2R10G10B10_USCALED_PACK32: VkFormat = 60;
3228pub const VK_FORMAT_A2R10G10B10_SSCALED_PACK32: VkFormat = 61;
3229pub const VK_FORMAT_A2R10G10B10_UINT_PACK32: VkFormat = 62;
3230pub const VK_FORMAT_A2R10G10B10_SINT_PACK32: VkFormat = 63;
3231pub const VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormat = 64;
3232pub const VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormat = 65;
3233pub const VK_FORMAT_A2B10G10R10_USCALED_PACK32: VkFormat = 66;
3234pub const VK_FORMAT_A2B10G10R10_SSCALED_PACK32: VkFormat = 67;
3235pub const VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormat = 68;
3236pub const VK_FORMAT_A2B10G10R10_SINT_PACK32: VkFormat = 69;
3237pub const VK_FORMAT_R16_UNORM: VkFormat = 70;
3238pub const VK_FORMAT_R16_SNORM: VkFormat = 71;
3239pub const VK_FORMAT_R16_USCALED: VkFormat = 72;
3240pub const VK_FORMAT_R16_SSCALED: VkFormat = 73;
3241pub const VK_FORMAT_R16_UINT: VkFormat = 74;
3242pub const VK_FORMAT_R16_SINT: VkFormat = 75;
3243pub const VK_FORMAT_R16_SFLOAT: VkFormat = 76;
3244pub const VK_FORMAT_R16G16_UNORM: VkFormat = 77;
3245pub const VK_FORMAT_R16G16_SNORM: VkFormat = 78;
3246pub const VK_FORMAT_R16G16_USCALED: VkFormat = 79;
3247pub const VK_FORMAT_R16G16_SSCALED: VkFormat = 80;
3248pub const VK_FORMAT_R16G16_UINT: VkFormat = 81;
3249pub const VK_FORMAT_R16G16_SINT: VkFormat = 82;
3250pub const VK_FORMAT_R16G16_SFLOAT: VkFormat = 83;
3251pub const VK_FORMAT_R16G16B16_UNORM: VkFormat = 84;
3252pub const VK_FORMAT_R16G16B16_SNORM: VkFormat = 85;
3253pub const VK_FORMAT_R16G16B16_USCALED: VkFormat = 86;
3254pub const VK_FORMAT_R16G16B16_SSCALED: VkFormat = 87;
3255pub const VK_FORMAT_R16G16B16_UINT: VkFormat = 88;
3256pub const VK_FORMAT_R16G16B16_SINT: VkFormat = 89;
3257pub const VK_FORMAT_R16G16B16_SFLOAT: VkFormat = 90;
3258pub const VK_FORMAT_R16G16B16A16_UNORM: VkFormat = 91;
3259pub const VK_FORMAT_R16G16B16A16_SNORM: VkFormat = 92;
3260pub const VK_FORMAT_R16G16B16A16_USCALED: VkFormat = 93;
3261pub const VK_FORMAT_R16G16B16A16_SSCALED: VkFormat = 94;
3262pub const VK_FORMAT_R16G16B16A16_UINT: VkFormat = 95;
3263pub const VK_FORMAT_R16G16B16A16_SINT: VkFormat = 96;
3264pub const VK_FORMAT_R16G16B16A16_SFLOAT: VkFormat = 97;
3265pub const VK_FORMAT_R32_UINT: VkFormat = 98;
3266pub const VK_FORMAT_R32_SINT: VkFormat = 99;
3267pub const VK_FORMAT_R32_SFLOAT: VkFormat = 100;
3268pub const VK_FORMAT_R32G32_UINT: VkFormat = 101;
3269pub const VK_FORMAT_R32G32_SINT: VkFormat = 102;
3270pub const VK_FORMAT_R32G32_SFLOAT: VkFormat = 103;
3271pub const VK_FORMAT_R32G32B32_UINT: VkFormat = 104;
3272pub const VK_FORMAT_R32G32B32_SINT: VkFormat = 105;
3273pub const VK_FORMAT_R32G32B32_SFLOAT: VkFormat = 106;
3274pub const VK_FORMAT_R32G32B32A32_UINT: VkFormat = 107;
3275pub const VK_FORMAT_R32G32B32A32_SINT: VkFormat = 108;
3276pub const VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = 109;
3277pub const VK_FORMAT_R64_UINT: VkFormat = 110;
3278pub const VK_FORMAT_R64_SINT: VkFormat = 111;
3279pub const VK_FORMAT_R64_SFLOAT: VkFormat = 112;
3280pub const VK_FORMAT_R64G64_UINT: VkFormat = 113;
3281pub const VK_FORMAT_R64G64_SINT: VkFormat = 114;
3282pub const VK_FORMAT_R64G64_SFLOAT: VkFormat = 115;
3283pub const VK_FORMAT_R64G64B64_UINT: VkFormat = 116;
3284pub const VK_FORMAT_R64G64B64_SINT: VkFormat = 117;
3285pub const VK_FORMAT_R64G64B64_SFLOAT: VkFormat = 118;
3286pub const VK_FORMAT_R64G64B64A64_UINT: VkFormat = 119;
3287pub const VK_FORMAT_R64G64B64A64_SINT: VkFormat = 120;
3288pub const VK_FORMAT_R64G64B64A64_SFLOAT: VkFormat = 121;
3289pub const VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormat = 122;
3290pub const VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormat = 123;
3291pub const VK_FORMAT_D16_UNORM: VkFormat = 124;
3292pub const VK_FORMAT_X8_D24_UNORM_PACK32: VkFormat = 125;
3293pub const VK_FORMAT_D32_SFLOAT: VkFormat = 126;
3294pub const VK_FORMAT_S8_UINT: VkFormat = 127;
3295pub const VK_FORMAT_D16_UNORM_S8_UINT: VkFormat = 128;
3296pub const VK_FORMAT_D24_UNORM_S8_UINT: VkFormat = 129;
3297pub const VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormat = 130;
3298pub const VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormat = 131;
3299pub const VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormat = 132;
3300pub const VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormat = 133;
3301pub const VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormat = 134;
3302pub const VK_FORMAT_BC2_UNORM_BLOCK: VkFormat = 135;
3303pub const VK_FORMAT_BC2_SRGB_BLOCK: VkFormat = 136;
3304pub const VK_FORMAT_BC3_UNORM_BLOCK: VkFormat = 137;
3305pub const VK_FORMAT_BC3_SRGB_BLOCK: VkFormat = 138;
3306pub const VK_FORMAT_BC4_UNORM_BLOCK: VkFormat = 139;
3307pub const VK_FORMAT_BC4_SNORM_BLOCK: VkFormat = 140;
3308pub const VK_FORMAT_BC5_UNORM_BLOCK: VkFormat = 141;
3309pub const VK_FORMAT_BC5_SNORM_BLOCK: VkFormat = 142;
3310pub const VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormat = 143;
3311pub const VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormat = 144;
3312pub const VK_FORMAT_BC7_UNORM_BLOCK: VkFormat = 145;
3313pub const VK_FORMAT_BC7_SRGB_BLOCK: VkFormat = 146;
3314pub const VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormat = 147;
3315pub const VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormat = 148;
3316pub const VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormat = 149;
3317pub const VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormat = 150;
3318pub const VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormat = 151;
3319pub const VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormat = 152;
3320pub const VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormat = 153;
3321pub const VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormat = 154;
3322pub const VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormat = 155;
3323pub const VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormat = 156;
3324pub const VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormat = 157;
3325pub const VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormat = 158;
3326pub const VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormat = 159;
3327pub const VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormat = 160;
3328pub const VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormat = 161;
3329pub const VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormat = 162;
3330pub const VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormat = 163;
3331pub const VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormat = 164;
3332pub const VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormat = 165;
3333pub const VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormat = 166;
3334pub const VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormat = 167;
3335pub const VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormat = 168;
3336pub const VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormat = 169;
3337pub const VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormat = 170;
3338pub const VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormat = 171;
3339pub const VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormat = 172;
3340pub const VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormat = 173;
3341pub const VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormat = 174;
3342pub const VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormat = 175;
3343pub const VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormat = 176;
3344pub const VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormat = 177;
3345pub const VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormat = 178;
3346pub const VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormat = 179;
3347pub const VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormat = 180;
3348pub const VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormat = 181;
3349pub const VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormat = 182;
3350pub const VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormat = 183;
3351pub const VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormat = 184;
3352#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3353pub const VK_FORMAT_G8B8G8R8_422_UNORM_KHR: VkFormat = 1000156000;
3354#[cfg(feature = "Allow1_1APIs")]
3355pub const VK_FORMAT_G8B8G8R8_422_UNORM: VkFormat = 1000156000;
3356#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3357pub const VK_FORMAT_B8G8R8G8_422_UNORM_KHR: VkFormat = 1000156001;
3358#[cfg(feature = "Allow1_1APIs")]
3359pub const VK_FORMAT_B8G8R8G8_422_UNORM: VkFormat = 1000156001;
3360#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3361pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: VkFormat = 1000156002;
3362#[cfg(feature = "Allow1_1APIs")]
3363pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: VkFormat = 1000156002;
3364#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3365pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: VkFormat = 1000156003;
3366#[cfg(feature = "Allow1_1APIs")]
3367pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: VkFormat = 1000156003;
3368#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3369pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: VkFormat = 1000156004;
3370#[cfg(feature = "Allow1_1APIs")]
3371pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: VkFormat = 1000156004;
3372#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3373pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: VkFormat = 1000156005;
3374#[cfg(feature = "Allow1_1APIs")]
3375pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: VkFormat = 1000156005;
3376#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3377pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: VkFormat = 1000156006;
3378#[cfg(feature = "Allow1_1APIs")]
3379pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: VkFormat = 1000156006;
3380#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3381pub const VK_FORMAT_R10X6_UNORM_PACK16_KHR: VkFormat = 1000156007;
3382#[cfg(feature = "Allow1_1APIs")]
3383pub const VK_FORMAT_R10X6_UNORM_PACK16: VkFormat = 1000156007;
3384#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3385pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: VkFormat = 1000156008;
3386#[cfg(feature = "Allow1_1APIs")]
3387pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16: VkFormat = 1000156008;
3388#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3389pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: VkFormat = 1000156009;
3390#[cfg(feature = "Allow1_1APIs")]
3391pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: VkFormat = 1000156009;
3392#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3393pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: VkFormat = 1000156010;
3394#[cfg(feature = "Allow1_1APIs")]
3395pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: VkFormat = 1000156010;
3396#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3397pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: VkFormat = 1000156011;
3398#[cfg(feature = "Allow1_1APIs")]
3399pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: VkFormat = 1000156011;
3400#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3401pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156012;
3402#[cfg(feature = "Allow1_1APIs")]
3403pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156012;
3404#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3405pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156013;
3406#[cfg(feature = "Allow1_1APIs")]
3407pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156013;
3408#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3409pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156014;
3410#[cfg(feature = "Allow1_1APIs")]
3411pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156014;
3412#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3413pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156015;
3414#[cfg(feature = "Allow1_1APIs")]
3415pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156015;
3416#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3417pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = 1000156016;
3418#[cfg(feature = "Allow1_1APIs")]
3419pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156016;
3420#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3421pub const VK_FORMAT_R12X4_UNORM_PACK16_KHR: VkFormat = 1000156017;
3422#[cfg(feature = "Allow1_1APIs")]
3423pub const VK_FORMAT_R12X4_UNORM_PACK16: VkFormat = 1000156017;
3424#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3425pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: VkFormat = 1000156018;
3426#[cfg(feature = "Allow1_1APIs")]
3427pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16: VkFormat = 1000156018;
3428#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3429pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: VkFormat = 1000156019;
3430#[cfg(feature = "Allow1_1APIs")]
3431pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: VkFormat = 1000156019;
3432#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3433pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: VkFormat = 1000156020;
3434#[cfg(feature = "Allow1_1APIs")]
3435pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: VkFormat = 1000156020;
3436#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3437pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: VkFormat = 1000156021;
3438#[cfg(feature = "Allow1_1APIs")]
3439pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: VkFormat = 1000156021;
3440#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3441pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156022;
3442#[cfg(feature = "Allow1_1APIs")]
3443pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156022;
3444#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3445pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = 1000156023;
3446#[cfg(feature = "Allow1_1APIs")]
3447pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156023;
3448#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3449pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156024;
3450#[cfg(feature = "Allow1_1APIs")]
3451pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156024;
3452#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3453pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = 1000156025;
3454#[cfg(feature = "Allow1_1APIs")]
3455pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156025;
3456#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3457pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = 1000156026;
3458#[cfg(feature = "Allow1_1APIs")]
3459pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156026;
3460#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3461pub const VK_FORMAT_G16B16G16R16_422_UNORM_KHR: VkFormat = 1000156027;
3462#[cfg(feature = "Allow1_1APIs")]
3463pub const VK_FORMAT_G16B16G16R16_422_UNORM: VkFormat = 1000156027;
3464#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3465pub const VK_FORMAT_B16G16R16G16_422_UNORM_KHR: VkFormat = 1000156028;
3466#[cfg(feature = "Allow1_1APIs")]
3467pub const VK_FORMAT_B16G16R16G16_422_UNORM: VkFormat = 1000156028;
3468#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3469pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: VkFormat = 1000156029;
3470#[cfg(feature = "Allow1_1APIs")]
3471pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: VkFormat = 1000156029;
3472#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3473pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: VkFormat = 1000156030;
3474#[cfg(feature = "Allow1_1APIs")]
3475pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: VkFormat = 1000156030;
3476#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3477pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: VkFormat = 1000156031;
3478#[cfg(feature = "Allow1_1APIs")]
3479pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: VkFormat = 1000156031;
3480#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3481pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: VkFormat = 1000156032;
3482#[cfg(feature = "Allow1_1APIs")]
3483pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: VkFormat = 1000156032;
3484#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
3485pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: VkFormat = 1000156033;
3486#[cfg(feature = "Allow1_1APIs")]
3487pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: VkFormat = 1000156033;
3488
3489#[rustfmt::skip]
3490pub type PFN_vkInternalAllocationNotification = extern "system" fn(pUserData: *mut core::ffi::c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
3491
3492#[rustfmt::skip]
3493pub type PFN_vkInternalFreeNotification = extern "system" fn(pUserData: *mut core::ffi::c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
3494
3495#[rustfmt::skip]
3496pub type PFN_vkReallocationFunction = extern "system" fn(pUserData: *mut core::ffi::c_void, pOriginal: *mut core::ffi::c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut core::ffi::c_void;
3497
3498#[rustfmt::skip]
3499pub type PFN_vkAllocationFunction = extern "system" fn(pUserData: *mut core::ffi::c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut core::ffi::c_void;
3500
3501#[rustfmt::skip]
3502pub type PFN_vkFreeFunction = extern "system" fn(pUserData: *mut core::ffi::c_void, pMemory: *mut core::ffi::c_void);
3503
3504#[rustfmt::skip]
3505pub type PFN_vkVoidFunction = extern "system" fn();
3506
3507#[cfg(feature = "VK_EXT_debug_report")]
3508#[rustfmt::skip]
3509pub type PFN_vkDebugReportCallbackEXT = extern "system" fn(flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const core::ffi::c_char, pMessage: *const core::ffi::c_char, pUserData: *mut core::ffi::c_void) -> VkBool32;
3510
3511#[cfg(feature = "VK_EXT_debug_utils")]
3512#[rustfmt::skip]
3513pub type PFN_vkDebugUtilsMessengerCallbackEXT = extern "system" fn(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT, pUserData: *mut core::ffi::c_void) -> VkBool32;
3514
3515#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3516#[derive(Debug, Clone)]
3517#[repr(C)]
3518#[rustfmt::skip]
3519pub struct VkAcquireNextImageInfoKHR {
3520    pub sType: VkStructureType,
3521    pub pNext: *const core::ffi::c_void,
3522    pub swapchain: VkSwapchainKHR,
3523    pub timeout: u64,
3524    pub semaphore: VkSemaphore,
3525    pub fence: VkFence,
3526    pub deviceMask: u32,
3527}
3528#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3529#[rustfmt::skip]
3530pub const VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: VkStructureType = 1000060010;
3531#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3532#[rustfmt::skip]
3533unsafe impl crate::VulkanStructure for VkAcquireNextImageInfoKHR {
3534    #[inline(always)]
3535    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3536        unsafe { core::mem::transmute(self) }
3537    }
3538
3539    #[inline(always)]
3540    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3541        unsafe { core::mem::transmute(self) }
3542    }
3543}
3544#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3545#[rustfmt::skip]
3546unsafe impl crate::TypedVulkanStructure for VkAcquireNextImageInfoKHR {
3547    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR;
3548}
3549
3550#[derive(Debug, Clone)]
3551#[repr(C)]
3552#[rustfmt::skip]
3553pub struct VkAllocationCallbacks {
3554    pub pUserData: *mut core::ffi::c_void,
3555    pub pfnAllocation: PFN_vkAllocationFunction,
3556    pub pfnReallocation: PFN_vkReallocationFunction,
3557    pub pfnFree: PFN_vkFreeFunction,
3558    pub pfnInternalAllocation: Option<PFN_vkInternalAllocationNotification>,
3559    pub pfnInternalFree: Option<PFN_vkInternalFreeNotification>,
3560}
3561
3562#[cfg(all(feature = "VK_KHR_android_surface"))]
3563#[derive(Debug, Clone)]
3564#[repr(C)]
3565#[rustfmt::skip]
3566pub struct VkAndroidSurfaceCreateInfoKHR {
3567    pub sType: VkStructureType,
3568    pub pNext: *const core::ffi::c_void,
3569    pub flags: VkAndroidSurfaceCreateFlagsKHR,
3570    pub window: *mut android::ANativeWindow,
3571}
3572#[cfg(all(feature = "VK_KHR_android_surface"))]
3573#[rustfmt::skip]
3574pub const VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000008000;
3575#[cfg(all(feature = "VK_KHR_android_surface"))]
3576#[rustfmt::skip]
3577unsafe impl crate::VulkanStructure for VkAndroidSurfaceCreateInfoKHR {
3578    #[inline(always)]
3579    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3580        unsafe { core::mem::transmute(self) }
3581    }
3582
3583    #[inline(always)]
3584    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3585        unsafe { core::mem::transmute(self) }
3586    }
3587}
3588#[cfg(all(feature = "VK_KHR_android_surface"))]
3589#[rustfmt::skip]
3590unsafe impl crate::TypedVulkanStructure for VkAndroidSurfaceCreateInfoKHR {
3591    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR;
3592}
3593
3594#[derive(Debug, Clone)]
3595#[repr(C)]
3596#[rustfmt::skip]
3597pub struct VkApplicationInfo {
3598    pub sType: VkStructureType,
3599    pub pNext: *const core::ffi::c_void,
3600    pub pApplicationName: *const core::ffi::c_char,
3601    pub applicationVersion: u32,
3602    pub pEngineName: *const core::ffi::c_char,
3603    pub engineVersion: u32,
3604    pub apiVersion: u32,
3605}
3606#[rustfmt::skip]
3607pub const VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = 0;
3608#[rustfmt::skip]
3609unsafe impl crate::VulkanStructure for VkApplicationInfo {
3610    #[inline(always)]
3611    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3612        unsafe { core::mem::transmute(self) }
3613    }
3614
3615    #[inline(always)]
3616    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3617        unsafe { core::mem::transmute(self) }
3618    }
3619}
3620#[rustfmt::skip]
3621unsafe impl crate::TypedVulkanStructure for VkApplicationInfo {
3622    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
3623}
3624
3625#[derive(Debug, Clone)]
3626#[repr(C)]
3627#[rustfmt::skip]
3628pub struct VkAttachmentDescription {
3629    pub flags: VkAttachmentDescriptionFlags,
3630    pub format: VkFormat,
3631    pub samples: VkSampleCountFlagBits,
3632    pub loadOp: VkAttachmentLoadOp,
3633    pub storeOp: VkAttachmentStoreOp,
3634    pub stencilLoadOp: VkAttachmentLoadOp,
3635    pub stencilStoreOp: VkAttachmentStoreOp,
3636    pub initialLayout: VkImageLayout,
3637    pub finalLayout: VkImageLayout,
3638}
3639
3640#[derive(Debug, Clone, Copy)]
3641#[repr(C)]
3642#[rustfmt::skip]
3643pub struct VkAttachmentReference {
3644    pub attachment: u32,
3645    pub layout: VkImageLayout,
3646}
3647
3648#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3649#[derive(Debug, Clone)]
3650#[repr(C)]
3651#[rustfmt::skip]
3652pub struct VkBindBufferMemoryDeviceGroupInfoKHR {
3653    pub sType: VkStructureType,
3654    pub pNext: *const core::ffi::c_void,
3655    pub deviceIndexCount: u32,
3656    pub pDeviceIndices: *const u32,
3657}
3658#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3659#[rustfmt::skip]
3660pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = 1000060013;
3661#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3662#[rustfmt::skip]
3663unsafe impl crate::VulkanStructure for VkBindBufferMemoryDeviceGroupInfoKHR {
3664    #[inline(always)]
3665    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3666        unsafe { core::mem::transmute(self) }
3667    }
3668
3669    #[inline(always)]
3670    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3671        unsafe { core::mem::transmute(self) }
3672    }
3673}
3674#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3675#[rustfmt::skip]
3676unsafe impl crate::TypedVulkanStructure for VkBindBufferMemoryDeviceGroupInfoKHR {
3677    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR;
3678}
3679#[cfg(feature = "Allow1_1APIs")]
3680#[rustfmt::skip]
3681pub type VkBindBufferMemoryDeviceGroupInfo = VkBindBufferMemoryDeviceGroupInfoKHR;
3682#[cfg(feature = "Allow1_1APIs")]
3683#[rustfmt::skip]
3684pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR;
3685
3686#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3687#[derive(Debug, Clone)]
3688#[repr(C)]
3689#[rustfmt::skip]
3690pub struct VkBindBufferMemoryInfoKHR {
3691    pub sType: VkStructureType,
3692    pub pNext: *const core::ffi::c_void,
3693    pub buffer: VkBuffer,
3694    pub memory: VkDeviceMemory,
3695    pub memoryOffset: VkDeviceSize,
3696}
3697#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3698#[rustfmt::skip]
3699pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR: VkStructureType = 1000157000;
3700#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3701#[rustfmt::skip]
3702unsafe impl crate::VulkanStructure for VkBindBufferMemoryInfoKHR {
3703    #[inline(always)]
3704    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3705        unsafe { core::mem::transmute(self) }
3706    }
3707
3708    #[inline(always)]
3709    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3710        unsafe { core::mem::transmute(self) }
3711    }
3712}
3713#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3714#[rustfmt::skip]
3715unsafe impl crate::TypedVulkanStructure for VkBindBufferMemoryInfoKHR {
3716    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR;
3717}
3718#[cfg(feature = "Allow1_1APIs")]
3719#[rustfmt::skip]
3720pub type VkBindBufferMemoryInfo = VkBindBufferMemoryInfoKHR;
3721#[cfg(feature = "Allow1_1APIs")]
3722#[rustfmt::skip]
3723pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR;
3724
3725#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3726#[derive(Debug, Clone)]
3727#[repr(C)]
3728#[rustfmt::skip]
3729pub struct VkBindImageMemoryDeviceGroupInfoKHR {
3730    pub sType: VkStructureType,
3731    pub pNext: *const core::ffi::c_void,
3732    pub deviceIndexCount: u32,
3733    pub pDeviceIndices: *const u32,
3734    pub splitInstanceBindRegionCount: u32,
3735    pub pSplitInstanceBindRegions: *const VkRect2D,
3736}
3737#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3738#[rustfmt::skip]
3739pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = 1000060014;
3740#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3741#[rustfmt::skip]
3742unsafe impl crate::VulkanStructure for VkBindImageMemoryDeviceGroupInfoKHR {
3743    #[inline(always)]
3744    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3745        unsafe { core::mem::transmute(self) }
3746    }
3747
3748    #[inline(always)]
3749    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3750        unsafe { core::mem::transmute(self) }
3751    }
3752}
3753#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_bind_memory2"))]
3754#[rustfmt::skip]
3755unsafe impl crate::TypedVulkanStructure for VkBindImageMemoryDeviceGroupInfoKHR {
3756    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR;
3757}
3758#[cfg(feature = "Allow1_1APIs")]
3759#[rustfmt::skip]
3760pub type VkBindImageMemoryDeviceGroupInfo = VkBindImageMemoryDeviceGroupInfoKHR;
3761#[cfg(feature = "Allow1_1APIs")]
3762#[rustfmt::skip]
3763pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR;
3764
3765#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3766#[derive(Debug, Clone)]
3767#[repr(C)]
3768#[rustfmt::skip]
3769pub struct VkBindImageMemoryInfoKHR {
3770    pub sType: VkStructureType,
3771    pub pNext: *const core::ffi::c_void,
3772    pub image: VkImage,
3773    pub memory: VkDeviceMemory,
3774    pub memoryOffset: VkDeviceSize,
3775}
3776#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3777#[rustfmt::skip]
3778pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR: VkStructureType = 1000157001;
3779#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3780#[rustfmt::skip]
3781unsafe impl crate::VulkanStructure for VkBindImageMemoryInfoKHR {
3782    #[inline(always)]
3783    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3784        unsafe { core::mem::transmute(self) }
3785    }
3786
3787    #[inline(always)]
3788    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3789        unsafe { core::mem::transmute(self) }
3790    }
3791}
3792#[cfg(all(feature = "VK_KHR_bind_memory2"))]
3793#[rustfmt::skip]
3794unsafe impl crate::TypedVulkanStructure for VkBindImageMemoryInfoKHR {
3795    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR;
3796}
3797#[cfg(feature = "Allow1_1APIs")]
3798#[rustfmt::skip]
3799pub type VkBindImageMemoryInfo = VkBindImageMemoryInfoKHR;
3800#[cfg(feature = "Allow1_1APIs")]
3801#[rustfmt::skip]
3802pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR;
3803
3804#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3805#[derive(Debug, Clone)]
3806#[repr(C)]
3807#[rustfmt::skip]
3808pub struct VkBindImageMemorySwapchainInfoKHR {
3809    pub sType: VkStructureType,
3810    pub pNext: *const core::ffi::c_void,
3811    pub swapchain: VkSwapchainKHR,
3812    pub imageIndex: u32,
3813}
3814#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3815#[rustfmt::skip]
3816pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: VkStructureType = 1000060009;
3817#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3818#[rustfmt::skip]
3819unsafe impl crate::VulkanStructure for VkBindImageMemorySwapchainInfoKHR {
3820    #[inline(always)]
3821    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3822        unsafe { core::mem::transmute(self) }
3823    }
3824
3825    #[inline(always)]
3826    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3827        unsafe { core::mem::transmute(self) }
3828    }
3829}
3830#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
3831#[rustfmt::skip]
3832unsafe impl crate::TypedVulkanStructure for VkBindImageMemorySwapchainInfoKHR {
3833    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR;
3834}
3835
3836#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
3837#[derive(Debug, Clone)]
3838#[repr(C)]
3839#[rustfmt::skip]
3840pub struct VkBindImagePlaneMemoryInfoKHR {
3841    pub sType: VkStructureType,
3842    pub pNext: *const core::ffi::c_void,
3843    pub planeAspect: VkImageAspectFlags,
3844}
3845#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
3846#[rustfmt::skip]
3847pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR: VkStructureType = 1000156002;
3848#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
3849#[rustfmt::skip]
3850unsafe impl crate::VulkanStructure for VkBindImagePlaneMemoryInfoKHR {
3851    #[inline(always)]
3852    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3853        unsafe { core::mem::transmute(self) }
3854    }
3855
3856    #[inline(always)]
3857    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3858        unsafe { core::mem::transmute(self) }
3859    }
3860}
3861#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
3862#[rustfmt::skip]
3863unsafe impl crate::TypedVulkanStructure for VkBindImagePlaneMemoryInfoKHR {
3864    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR;
3865}
3866#[cfg(feature = "Allow1_1APIs")]
3867#[rustfmt::skip]
3868pub type VkBindImagePlaneMemoryInfo = VkBindImagePlaneMemoryInfoKHR;
3869#[cfg(feature = "Allow1_1APIs")]
3870#[rustfmt::skip]
3871pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR;
3872
3873#[derive(Debug, Clone)]
3874#[repr(C)]
3875#[rustfmt::skip]
3876pub struct VkBindSparseInfo {
3877    pub sType: VkStructureType,
3878    pub pNext: *const core::ffi::c_void,
3879    pub waitSemaphoreCount: u32,
3880    pub pWaitSemaphores: *const VkSemaphore,
3881    pub bufferBindCount: u32,
3882    pub pBufferBinds: *const VkSparseBufferMemoryBindInfo,
3883    pub imageOpaqueBindCount: u32,
3884    pub pImageOpaqueBinds: *const VkSparseImageOpaqueMemoryBindInfo,
3885    pub imageBindCount: u32,
3886    pub pImageBinds: *const VkSparseImageMemoryBindInfo,
3887    pub signalSemaphoreCount: u32,
3888    pub pSignalSemaphores: *const VkSemaphore,
3889}
3890#[rustfmt::skip]
3891pub const VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: VkStructureType = 7;
3892#[rustfmt::skip]
3893unsafe impl crate::VulkanStructure for VkBindSparseInfo {
3894    #[inline(always)]
3895    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3896        unsafe { core::mem::transmute(self) }
3897    }
3898
3899    #[inline(always)]
3900    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3901        unsafe { core::mem::transmute(self) }
3902    }
3903}
3904#[rustfmt::skip]
3905unsafe impl crate::TypedVulkanStructure for VkBindSparseInfo {
3906    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BIND_SPARSE_INFO;
3907}
3908
3909#[derive(Debug, Clone)]
3910#[repr(C)]
3911#[rustfmt::skip]
3912pub struct VkBufferCopy {
3913    pub srcOffset: VkDeviceSize,
3914    pub dstOffset: VkDeviceSize,
3915    pub size: VkDeviceSize,
3916}
3917
3918#[derive(Debug, Clone)]
3919#[repr(C)]
3920#[rustfmt::skip]
3921pub struct VkBufferCreateInfo {
3922    pub sType: VkStructureType,
3923    pub pNext: *const core::ffi::c_void,
3924    pub flags: VkBufferCreateFlags,
3925    pub size: VkDeviceSize,
3926    pub usage: VkBufferUsageFlags,
3927    pub sharingMode: VkSharingMode,
3928    pub queueFamilyIndexCount: u32,
3929    pub pQueueFamilyIndices: *const u32,
3930}
3931#[rustfmt::skip]
3932pub const VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = 12;
3933#[rustfmt::skip]
3934unsafe impl crate::VulkanStructure for VkBufferCreateInfo {
3935    #[inline(always)]
3936    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3937        unsafe { core::mem::transmute(self) }
3938    }
3939
3940    #[inline(always)]
3941    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3942        unsafe { core::mem::transmute(self) }
3943    }
3944}
3945#[rustfmt::skip]
3946unsafe impl crate::TypedVulkanStructure for VkBufferCreateInfo {
3947    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
3948}
3949
3950#[derive(Debug, Clone)]
3951#[repr(C)]
3952#[rustfmt::skip]
3953pub struct VkBufferImageCopy {
3954    pub bufferOffset: VkDeviceSize,
3955    pub bufferRowLength: u32,
3956    pub bufferImageHeight: u32,
3957    pub imageSubresource: VkImageSubresourceLayers,
3958    pub imageOffset: VkOffset3D,
3959    pub imageExtent: VkExtent3D,
3960}
3961
3962#[derive(Debug, Clone)]
3963#[repr(C)]
3964#[rustfmt::skip]
3965pub struct VkBufferMemoryBarrier {
3966    pub sType: VkStructureType,
3967    pub pNext: *const core::ffi::c_void,
3968    pub srcAccessMask: VkAccessFlags,
3969    pub dstAccessMask: VkAccessFlags,
3970    pub srcQueueFamilyIndex: u32,
3971    pub dstQueueFamilyIndex: u32,
3972    pub buffer: VkBuffer,
3973    pub offset: VkDeviceSize,
3974    pub size: VkDeviceSize,
3975}
3976#[rustfmt::skip]
3977pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = 44;
3978#[rustfmt::skip]
3979unsafe impl crate::VulkanStructure for VkBufferMemoryBarrier {
3980    #[inline(always)]
3981    fn as_generic(&self) -> &crate::GenericVulkanStructure {
3982        unsafe { core::mem::transmute(self) }
3983    }
3984
3985    #[inline(always)]
3986    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
3987        unsafe { core::mem::transmute(self) }
3988    }
3989}
3990#[rustfmt::skip]
3991unsafe impl crate::TypedVulkanStructure for VkBufferMemoryBarrier {
3992    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER;
3993}
3994
3995#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
3996#[derive(Debug, Clone)]
3997#[repr(C)]
3998#[rustfmt::skip]
3999pub struct VkBufferMemoryRequirementsInfo2KHR {
4000    pub sType: VkStructureType,
4001    pub pNext: *const core::ffi::c_void,
4002    pub buffer: VkBuffer,
4003}
4004#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
4005#[rustfmt::skip]
4006pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = 1000146000;
4007#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
4008#[rustfmt::skip]
4009unsafe impl crate::VulkanStructure for VkBufferMemoryRequirementsInfo2KHR {
4010    #[inline(always)]
4011    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4012        unsafe { core::mem::transmute(self) }
4013    }
4014
4015    #[inline(always)]
4016    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4017        unsafe { core::mem::transmute(self) }
4018    }
4019}
4020#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
4021#[rustfmt::skip]
4022unsafe impl crate::TypedVulkanStructure for VkBufferMemoryRequirementsInfo2KHR {
4023    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR;
4024}
4025#[cfg(feature = "Allow1_1APIs")]
4026#[rustfmt::skip]
4027pub type VkBufferMemoryRequirementsInfo2 = VkBufferMemoryRequirementsInfo2KHR;
4028#[cfg(feature = "Allow1_1APIs")]
4029#[rustfmt::skip]
4030pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR;
4031
4032#[derive(Debug, Clone)]
4033#[repr(C)]
4034#[rustfmt::skip]
4035pub struct VkBufferViewCreateInfo {
4036    pub sType: VkStructureType,
4037    pub pNext: *const core::ffi::c_void,
4038    pub flags: VkBufferViewCreateFlags,
4039    pub buffer: VkBuffer,
4040    pub format: VkFormat,
4041    pub offset: VkDeviceSize,
4042    pub range: VkDeviceSize,
4043}
4044#[rustfmt::skip]
4045pub const VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: VkStructureType = 13;
4046#[rustfmt::skip]
4047unsafe impl crate::VulkanStructure for VkBufferViewCreateInfo {
4048    #[inline(always)]
4049    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4050        unsafe { core::mem::transmute(self) }
4051    }
4052
4053    #[inline(always)]
4054    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4055        unsafe { core::mem::transmute(self) }
4056    }
4057}
4058#[rustfmt::skip]
4059unsafe impl crate::TypedVulkanStructure for VkBufferViewCreateInfo {
4060    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO;
4061}
4062
4063#[derive(Clone)]
4064#[repr(C)]
4065#[rustfmt::skip]
4066pub struct VkClearAttachment {
4067    pub aspectMask: VkImageAspectFlags,
4068    pub colorAttachment: u32,
4069    pub clearValue: VkClearValue,
4070}
4071
4072#[derive(Debug, Clone, Copy)]
4073#[repr(C)]
4074#[rustfmt::skip]
4075pub struct VkClearDepthStencilValue {
4076    pub depth: core::ffi::c_float,
4077    pub stencil: u32,
4078}
4079
4080#[derive(Debug, Clone)]
4081#[repr(C)]
4082#[rustfmt::skip]
4083pub struct VkClearRect {
4084    pub rect: VkRect2D,
4085    pub baseArrayLayer: u32,
4086    pub layerCount: u32,
4087}
4088
4089#[derive(Debug, Clone)]
4090#[repr(C)]
4091#[rustfmt::skip]
4092pub struct VkCommandBufferAllocateInfo {
4093    pub sType: VkStructureType,
4094    pub pNext: *const core::ffi::c_void,
4095    pub commandPool: VkCommandPool,
4096    pub level: VkCommandBufferLevel,
4097    pub commandBufferCount: u32,
4098}
4099#[rustfmt::skip]
4100pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = 40;
4101#[rustfmt::skip]
4102unsafe impl crate::VulkanStructure for VkCommandBufferAllocateInfo {
4103    #[inline(always)]
4104    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4105        unsafe { core::mem::transmute(self) }
4106    }
4107
4108    #[inline(always)]
4109    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4110        unsafe { core::mem::transmute(self) }
4111    }
4112}
4113#[rustfmt::skip]
4114unsafe impl crate::TypedVulkanStructure for VkCommandBufferAllocateInfo {
4115    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
4116}
4117
4118#[derive(Debug, Clone)]
4119#[repr(C)]
4120#[rustfmt::skip]
4121pub struct VkCommandBufferBeginInfo {
4122    pub sType: VkStructureType,
4123    pub pNext: *const core::ffi::c_void,
4124    pub flags: VkCommandBufferUsageFlags,
4125    pub pInheritanceInfo: *const VkCommandBufferInheritanceInfo,
4126}
4127#[rustfmt::skip]
4128pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 42;
4129#[rustfmt::skip]
4130unsafe impl crate::VulkanStructure for VkCommandBufferBeginInfo {
4131    #[inline(always)]
4132    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4133        unsafe { core::mem::transmute(self) }
4134    }
4135
4136    #[inline(always)]
4137    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4138        unsafe { core::mem::transmute(self) }
4139    }
4140}
4141#[rustfmt::skip]
4142unsafe impl crate::TypedVulkanStructure for VkCommandBufferBeginInfo {
4143    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
4144}
4145
4146#[derive(Debug, Clone)]
4147#[repr(C)]
4148#[rustfmt::skip]
4149pub struct VkCommandBufferInheritanceInfo {
4150    pub sType: VkStructureType,
4151    pub pNext: *const core::ffi::c_void,
4152    pub renderPass: VkRenderPass,
4153    pub subpass: u32,
4154    pub framebuffer: VkFramebuffer,
4155    pub occlusionQueryEnable: VkBool32,
4156    pub queryFlags: VkQueryControlFlags,
4157    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
4158}
4159#[rustfmt::skip]
4160pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: VkStructureType = 41;
4161#[rustfmt::skip]
4162unsafe impl crate::VulkanStructure for VkCommandBufferInheritanceInfo {
4163    #[inline(always)]
4164    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4165        unsafe { core::mem::transmute(self) }
4166    }
4167
4168    #[inline(always)]
4169    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4170        unsafe { core::mem::transmute(self) }
4171    }
4172}
4173#[rustfmt::skip]
4174unsafe impl crate::TypedVulkanStructure for VkCommandBufferInheritanceInfo {
4175    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO;
4176}
4177
4178#[derive(Debug, Clone)]
4179#[repr(C)]
4180#[rustfmt::skip]
4181pub struct VkCommandPoolCreateInfo {
4182    pub sType: VkStructureType,
4183    pub pNext: *const core::ffi::c_void,
4184    pub flags: VkCommandPoolCreateFlags,
4185    pub queueFamilyIndex: u32,
4186}
4187#[rustfmt::skip]
4188pub const VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = 39;
4189#[rustfmt::skip]
4190unsafe impl crate::VulkanStructure for VkCommandPoolCreateInfo {
4191    #[inline(always)]
4192    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4193        unsafe { core::mem::transmute(self) }
4194    }
4195
4196    #[inline(always)]
4197    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4198        unsafe { core::mem::transmute(self) }
4199    }
4200}
4201#[rustfmt::skip]
4202unsafe impl crate::TypedVulkanStructure for VkCommandPoolCreateInfo {
4203    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
4204}
4205
4206#[derive(Debug, Clone, Copy)]
4207#[repr(C)]
4208#[rustfmt::skip]
4209pub struct VkComponentMapping {
4210    pub r: VkComponentSwizzle,
4211    pub g: VkComponentSwizzle,
4212    pub b: VkComponentSwizzle,
4213    pub a: VkComponentSwizzle,
4214}
4215
4216#[derive(Debug, Clone)]
4217#[repr(C)]
4218#[rustfmt::skip]
4219pub struct VkComputePipelineCreateInfo {
4220    pub sType: VkStructureType,
4221    pub pNext: *const core::ffi::c_void,
4222    pub flags: VkPipelineCreateFlags,
4223    pub stage: VkPipelineShaderStageCreateInfo,
4224    pub layout: VkPipelineLayout,
4225    pub basePipelineHandle: VkPipeline,
4226    pub basePipelineIndex: i32,
4227}
4228#[rustfmt::skip]
4229pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = 29;
4230#[rustfmt::skip]
4231unsafe impl crate::VulkanStructure for VkComputePipelineCreateInfo {
4232    #[inline(always)]
4233    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4234        unsafe { core::mem::transmute(self) }
4235    }
4236
4237    #[inline(always)]
4238    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4239        unsafe { core::mem::transmute(self) }
4240    }
4241}
4242#[rustfmt::skip]
4243unsafe impl crate::TypedVulkanStructure for VkComputePipelineCreateInfo {
4244    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO;
4245}
4246
4247#[derive(Debug, Clone)]
4248#[repr(C)]
4249#[rustfmt::skip]
4250pub struct VkCopyDescriptorSet {
4251    pub sType: VkStructureType,
4252    pub pNext: *const core::ffi::c_void,
4253    pub srcSet: VkDescriptorSet,
4254    pub srcBinding: u32,
4255    pub srcArrayElement: u32,
4256    pub dstSet: VkDescriptorSet,
4257    pub dstBinding: u32,
4258    pub dstArrayElement: u32,
4259    pub descriptorCount: u32,
4260}
4261#[rustfmt::skip]
4262pub const VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: VkStructureType = 36;
4263#[rustfmt::skip]
4264unsafe impl crate::VulkanStructure for VkCopyDescriptorSet {
4265    #[inline(always)]
4266    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4267        unsafe { core::mem::transmute(self) }
4268    }
4269
4270    #[inline(always)]
4271    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4272        unsafe { core::mem::transmute(self) }
4273    }
4274}
4275#[rustfmt::skip]
4276unsafe impl crate::TypedVulkanStructure for VkCopyDescriptorSet {
4277    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET;
4278}
4279
4280#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
4281#[derive(Debug, Clone)]
4282#[repr(C)]
4283#[rustfmt::skip]
4284pub struct VkD3D12FenceSubmitInfoKHR {
4285    pub sType: VkStructureType,
4286    pub pNext: *const core::ffi::c_void,
4287    pub waitSemaphoreValuesCount: u32,
4288    pub pWaitSemaphoreValues: *const u64,
4289    pub signalSemaphoreValuesCount: u32,
4290    pub pSignalSemaphoreValues: *const u64,
4291}
4292#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
4293#[rustfmt::skip]
4294pub const VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: VkStructureType = 1000078002;
4295#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
4296#[rustfmt::skip]
4297unsafe impl crate::VulkanStructure for VkD3D12FenceSubmitInfoKHR {
4298    #[inline(always)]
4299    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4300        unsafe { core::mem::transmute(self) }
4301    }
4302
4303    #[inline(always)]
4304    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4305        unsafe { core::mem::transmute(self) }
4306    }
4307}
4308#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
4309#[rustfmt::skip]
4310unsafe impl crate::TypedVulkanStructure for VkD3D12FenceSubmitInfoKHR {
4311    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR;
4312}
4313
4314#[cfg(all(feature = "VK_EXT_debug_report"))]
4315#[derive(Debug, Clone)]
4316#[repr(C)]
4317#[rustfmt::skip]
4318pub struct VkDebugReportCallbackCreateInfoEXT {
4319    pub sType: VkStructureType,
4320    pub pNext: *const core::ffi::c_void,
4321    pub flags: VkDebugReportFlagsEXT,
4322    pub pfnCallback: PFN_vkDebugReportCallbackEXT,
4323    pub pUserData: *mut core::ffi::c_void,
4324}
4325#[cfg(all(feature = "VK_EXT_debug_report"))]
4326#[rustfmt::skip]
4327pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: VkStructureType = 1000011000;
4328#[cfg(all(feature = "VK_EXT_debug_report"))]
4329#[rustfmt::skip]
4330unsafe impl crate::VulkanStructure for VkDebugReportCallbackCreateInfoEXT {
4331    #[inline(always)]
4332    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4333        unsafe { core::mem::transmute(self) }
4334    }
4335
4336    #[inline(always)]
4337    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4338        unsafe { core::mem::transmute(self) }
4339    }
4340}
4341#[cfg(all(feature = "VK_EXT_debug_report"))]
4342#[rustfmt::skip]
4343unsafe impl crate::TypedVulkanStructure for VkDebugReportCallbackCreateInfoEXT {
4344    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
4345}
4346
4347#[cfg(all(feature = "VK_EXT_debug_utils"))]
4348#[derive(Debug, Clone)]
4349#[repr(C)]
4350#[rustfmt::skip]
4351pub struct VkDebugUtilsLabelEXT {
4352    pub sType: VkStructureType,
4353    pub pNext: *const core::ffi::c_void,
4354    pub pLabelName: *const core::ffi::c_char,
4355    pub pColor: [core::ffi::c_float; 4],
4356}
4357#[cfg(all(feature = "VK_EXT_debug_utils"))]
4358#[rustfmt::skip]
4359pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: VkStructureType = 1000128002;
4360#[cfg(all(feature = "VK_EXT_debug_utils"))]
4361#[rustfmt::skip]
4362unsafe impl crate::VulkanStructure for VkDebugUtilsLabelEXT {
4363    #[inline(always)]
4364    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4365        unsafe { core::mem::transmute(self) }
4366    }
4367
4368    #[inline(always)]
4369    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4370        unsafe { core::mem::transmute(self) }
4371    }
4372}
4373#[cfg(all(feature = "VK_EXT_debug_utils"))]
4374#[rustfmt::skip]
4375unsafe impl crate::TypedVulkanStructure for VkDebugUtilsLabelEXT {
4376    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT;
4377}
4378
4379#[cfg(all(feature = "VK_EXT_debug_utils"))]
4380#[derive(Debug, Clone)]
4381#[repr(C)]
4382#[rustfmt::skip]
4383pub struct VkDebugUtilsMessengerCallbackDataEXT {
4384    pub sType: VkStructureType,
4385    pub pNext: *const core::ffi::c_void,
4386    pub flags: VkDebugUtilsMessengerCallbackDataFlagsEXT,
4387    pub pMessageIdName: *const core::ffi::c_char,
4388    pub messageIdNumber: i32,
4389    pub pMessage: *const core::ffi::c_char,
4390    pub queueLabelCount: u32,
4391    pub pQueueLabels: *const VkDebugUtilsLabelEXT,
4392    pub cmdBufLabelCount: u32,
4393    pub pCmdBufLabels: *const VkDebugUtilsLabelEXT,
4394    pub objectCount: u32,
4395    pub pObjects: *const VkDebugUtilsObjectNameInfoEXT,
4396}
4397#[cfg(all(feature = "VK_EXT_debug_utils"))]
4398#[rustfmt::skip]
4399pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: VkStructureType = 1000128003;
4400#[cfg(all(feature = "VK_EXT_debug_utils"))]
4401#[rustfmt::skip]
4402unsafe impl crate::VulkanStructure for VkDebugUtilsMessengerCallbackDataEXT {
4403    #[inline(always)]
4404    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4405        unsafe { core::mem::transmute(self) }
4406    }
4407
4408    #[inline(always)]
4409    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4410        unsafe { core::mem::transmute(self) }
4411    }
4412}
4413#[cfg(all(feature = "VK_EXT_debug_utils"))]
4414#[rustfmt::skip]
4415unsafe impl crate::TypedVulkanStructure for VkDebugUtilsMessengerCallbackDataEXT {
4416    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT;
4417}
4418
4419#[cfg(all(feature = "VK_EXT_debug_utils"))]
4420#[derive(Debug, Clone)]
4421#[repr(C)]
4422#[rustfmt::skip]
4423pub struct VkDebugUtilsMessengerCreateInfoEXT {
4424    pub sType: VkStructureType,
4425    pub pNext: *const core::ffi::c_void,
4426    pub flags: VkDebugUtilsMessengerCreateFlagsEXT,
4427    pub messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT,
4428    pub messageType: VkDebugUtilsMessageTypeFlagsEXT,
4429    pub pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT,
4430    pub pUserData: *mut core::ffi::c_void,
4431}
4432#[cfg(all(feature = "VK_EXT_debug_utils"))]
4433#[rustfmt::skip]
4434pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: VkStructureType = 1000128004;
4435#[cfg(all(feature = "VK_EXT_debug_utils"))]
4436#[rustfmt::skip]
4437unsafe impl crate::VulkanStructure for VkDebugUtilsMessengerCreateInfoEXT {
4438    #[inline(always)]
4439    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4440        unsafe { core::mem::transmute(self) }
4441    }
4442
4443    #[inline(always)]
4444    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4445        unsafe { core::mem::transmute(self) }
4446    }
4447}
4448#[cfg(all(feature = "VK_EXT_debug_utils"))]
4449#[rustfmt::skip]
4450unsafe impl crate::TypedVulkanStructure for VkDebugUtilsMessengerCreateInfoEXT {
4451    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
4452}
4453
4454#[cfg(all(feature = "VK_EXT_debug_utils"))]
4455#[derive(Debug, Clone)]
4456#[repr(C)]
4457#[rustfmt::skip]
4458pub struct VkDebugUtilsObjectNameInfoEXT {
4459    pub sType: VkStructureType,
4460    pub pNext: *const core::ffi::c_void,
4461    pub objectType: VkObjectType,
4462    pub objectHandle: u64,
4463    pub pObjectName: *const core::ffi::c_char,
4464}
4465#[cfg(all(feature = "VK_EXT_debug_utils"))]
4466#[rustfmt::skip]
4467pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: VkStructureType = 1000128000;
4468#[cfg(all(feature = "VK_EXT_debug_utils"))]
4469#[rustfmt::skip]
4470unsafe impl crate::VulkanStructure for VkDebugUtilsObjectNameInfoEXT {
4471    #[inline(always)]
4472    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4473        unsafe { core::mem::transmute(self) }
4474    }
4475
4476    #[inline(always)]
4477    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4478        unsafe { core::mem::transmute(self) }
4479    }
4480}
4481#[cfg(all(feature = "VK_EXT_debug_utils"))]
4482#[rustfmt::skip]
4483unsafe impl crate::TypedVulkanStructure for VkDebugUtilsObjectNameInfoEXT {
4484    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT;
4485}
4486
4487#[cfg(all(feature = "VK_EXT_debug_utils"))]
4488#[derive(Debug, Clone)]
4489#[repr(C)]
4490#[rustfmt::skip]
4491pub struct VkDebugUtilsObjectTagInfoEXT {
4492    pub sType: VkStructureType,
4493    pub pNext: *const core::ffi::c_void,
4494    pub objectType: VkObjectType,
4495    pub objectHandle: u64,
4496    pub tagName: u64,
4497    pub tagSize: u64,
4498    pub pTag: *const core::ffi::c_void,
4499}
4500#[cfg(all(feature = "VK_EXT_debug_utils"))]
4501#[rustfmt::skip]
4502pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: VkStructureType = 1000128001;
4503#[cfg(all(feature = "VK_EXT_debug_utils"))]
4504#[rustfmt::skip]
4505unsafe impl crate::VulkanStructure for VkDebugUtilsObjectTagInfoEXT {
4506    #[inline(always)]
4507    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4508        unsafe { core::mem::transmute(self) }
4509    }
4510
4511    #[inline(always)]
4512    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4513        unsafe { core::mem::transmute(self) }
4514    }
4515}
4516#[cfg(all(feature = "VK_EXT_debug_utils"))]
4517#[rustfmt::skip]
4518unsafe impl crate::TypedVulkanStructure for VkDebugUtilsObjectTagInfoEXT {
4519    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT;
4520}
4521
4522#[derive(Debug, Clone)]
4523#[repr(C)]
4524#[rustfmt::skip]
4525pub struct VkDescriptorBufferInfo {
4526    pub buffer: VkBuffer,
4527    pub offset: VkDeviceSize,
4528    pub range: VkDeviceSize,
4529}
4530
4531#[derive(Debug, Clone)]
4532#[repr(C)]
4533#[rustfmt::skip]
4534pub struct VkDescriptorImageInfo {
4535    pub sampler: VkSampler,
4536    pub imageView: VkImageView,
4537    pub imageLayout: VkImageLayout,
4538}
4539
4540#[derive(Debug, Clone)]
4541#[repr(C)]
4542#[rustfmt::skip]
4543pub struct VkDescriptorPoolCreateInfo {
4544    pub sType: VkStructureType,
4545    pub pNext: *const core::ffi::c_void,
4546    pub flags: VkDescriptorPoolCreateFlags,
4547    pub maxSets: u32,
4548    pub poolSizeCount: u32,
4549    pub pPoolSizes: *const VkDescriptorPoolSize,
4550}
4551#[rustfmt::skip]
4552pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = 33;
4553#[rustfmt::skip]
4554unsafe impl crate::VulkanStructure for VkDescriptorPoolCreateInfo {
4555    #[inline(always)]
4556    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4557        unsafe { core::mem::transmute(self) }
4558    }
4559
4560    #[inline(always)]
4561    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4562        unsafe { core::mem::transmute(self) }
4563    }
4564}
4565#[rustfmt::skip]
4566unsafe impl crate::TypedVulkanStructure for VkDescriptorPoolCreateInfo {
4567    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
4568}
4569
4570#[derive(Debug, Clone)]
4571#[repr(C)]
4572#[rustfmt::skip]
4573pub struct VkDescriptorPoolSize {
4574    pub r#type: VkDescriptorType,
4575    pub descriptorCount: u32,
4576}
4577
4578#[derive(Debug, Clone)]
4579#[repr(C)]
4580#[rustfmt::skip]
4581pub struct VkDescriptorSetAllocateInfo {
4582    pub sType: VkStructureType,
4583    pub pNext: *const core::ffi::c_void,
4584    pub descriptorPool: VkDescriptorPool,
4585    pub descriptorSetCount: u32,
4586    pub pSetLayouts: *const VkDescriptorSetLayout,
4587}
4588#[rustfmt::skip]
4589pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = 34;
4590#[rustfmt::skip]
4591unsafe impl crate::VulkanStructure for VkDescriptorSetAllocateInfo {
4592    #[inline(always)]
4593    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4594        unsafe { core::mem::transmute(self) }
4595    }
4596
4597    #[inline(always)]
4598    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4599        unsafe { core::mem::transmute(self) }
4600    }
4601}
4602#[rustfmt::skip]
4603unsafe impl crate::TypedVulkanStructure for VkDescriptorSetAllocateInfo {
4604    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
4605}
4606
4607#[derive(Debug, Clone)]
4608#[repr(C)]
4609#[rustfmt::skip]
4610pub struct VkDescriptorSetLayoutBinding {
4611    pub binding: u32,
4612    pub descriptorType: VkDescriptorType,
4613    pub descriptorCount: u32,
4614    pub stageFlags: VkShaderStageFlags,
4615    pub pImmutableSamplers: *const VkSampler,
4616}
4617
4618#[derive(Debug, Clone)]
4619#[repr(C)]
4620#[rustfmt::skip]
4621pub struct VkDescriptorSetLayoutCreateInfo {
4622    pub sType: VkStructureType,
4623    pub pNext: *const core::ffi::c_void,
4624    pub flags: VkDescriptorSetLayoutCreateFlags,
4625    pub bindingCount: u32,
4626    pub pBindings: *const VkDescriptorSetLayoutBinding,
4627}
4628#[rustfmt::skip]
4629pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = 32;
4630#[rustfmt::skip]
4631unsafe impl crate::VulkanStructure for VkDescriptorSetLayoutCreateInfo {
4632    #[inline(always)]
4633    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4634        unsafe { core::mem::transmute(self) }
4635    }
4636
4637    #[inline(always)]
4638    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4639        unsafe { core::mem::transmute(self) }
4640    }
4641}
4642#[rustfmt::skip]
4643unsafe impl crate::TypedVulkanStructure for VkDescriptorSetLayoutCreateInfo {
4644    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
4645}
4646
4647#[cfg(all(feature = "VK_KHR_maintenance3"))]
4648#[derive(Debug, Clone)]
4649#[repr(C)]
4650#[rustfmt::skip]
4651pub struct VkDescriptorSetLayoutSupportKHR {
4652    pub sType: VkStructureType,
4653    pub pNext: *mut core::ffi::c_void,
4654    pub supported: VkBool32,
4655}
4656#[cfg(all(feature = "VK_KHR_maintenance3"))]
4657#[rustfmt::skip]
4658pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: VkStructureType = 1000168001;
4659#[cfg(all(feature = "VK_KHR_maintenance3"))]
4660#[rustfmt::skip]
4661unsafe impl crate::VulkanSinkStructure for VkDescriptorSetLayoutSupportKHR {
4662    #[inline(always)]
4663    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
4664        unsafe { core::mem::transmute(self) }
4665    }
4666
4667    #[inline(always)]
4668    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
4669        unsafe { core::mem::transmute(self) }
4670    }
4671}
4672#[cfg(all(feature = "VK_KHR_maintenance3"))]
4673#[rustfmt::skip]
4674unsafe impl crate::TypedVulkanSinkStructure for VkDescriptorSetLayoutSupportKHR {
4675    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR;
4676}
4677#[cfg(feature = "Allow1_1APIs")]
4678#[rustfmt::skip]
4679pub type VkDescriptorSetLayoutSupport = VkDescriptorSetLayoutSupportKHR;
4680#[cfg(feature = "Allow1_1APIs")]
4681#[rustfmt::skip]
4682pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR;
4683
4684#[cfg(all(feature = "VK_KHR_descriptor_update_template"))]
4685#[derive(Debug, Clone)]
4686#[repr(C)]
4687#[rustfmt::skip]
4688pub struct VkDescriptorUpdateTemplateCreateInfoKHR {
4689    pub sType: VkStructureType,
4690    pub pNext: *const core::ffi::c_void,
4691    pub flags: VkDescriptorUpdateTemplateCreateFlagsKHR,
4692    pub descriptorUpdateEntryCount: u32,
4693    pub pDescriptorUpdateEntries: *const VkDescriptorUpdateTemplateEntryKHR,
4694    pub templateType: VkDescriptorUpdateTemplateTypeKHR,
4695    pub descriptorSetLayout: VkDescriptorSetLayout,
4696    pub pipelineBindPoint: VkPipelineBindPoint,
4697    pub pipelineLayout: VkPipelineLayout,
4698    pub set: u32,
4699}
4700#[cfg(all(feature = "VK_KHR_descriptor_update_template"))]
4701#[rustfmt::skip]
4702pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: VkStructureType = 1000085000;
4703#[cfg(all(feature = "VK_KHR_descriptor_update_template"))]
4704#[rustfmt::skip]
4705unsafe impl crate::VulkanStructure for VkDescriptorUpdateTemplateCreateInfoKHR {
4706    #[inline(always)]
4707    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4708        unsafe { core::mem::transmute(self) }
4709    }
4710
4711    #[inline(always)]
4712    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4713        unsafe { core::mem::transmute(self) }
4714    }
4715}
4716#[cfg(all(feature = "VK_KHR_descriptor_update_template"))]
4717#[rustfmt::skip]
4718unsafe impl crate::TypedVulkanStructure for VkDescriptorUpdateTemplateCreateInfoKHR {
4719    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR;
4720}
4721#[cfg(feature = "Allow1_1APIs")]
4722#[rustfmt::skip]
4723pub type VkDescriptorUpdateTemplateCreateInfo = VkDescriptorUpdateTemplateCreateInfoKHR;
4724#[cfg(feature = "Allow1_1APIs")]
4725#[rustfmt::skip]
4726pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR;
4727
4728#[cfg(all(feature = "VK_KHR_descriptor_update_template"))]
4729#[derive(Debug, Clone)]
4730#[repr(C)]
4731#[rustfmt::skip]
4732pub struct VkDescriptorUpdateTemplateEntryKHR {
4733    pub dstBinding: u32,
4734    pub dstArrayElement: u32,
4735    pub descriptorCount: u32,
4736    pub descriptorType: VkDescriptorType,
4737    pub offset: usize,
4738    pub stride: usize,
4739}
4740#[cfg(feature = "Allow1_1APIs")]
4741#[rustfmt::skip]
4742pub type VkDescriptorUpdateTemplateEntry = VkDescriptorUpdateTemplateEntryKHR;
4743
4744#[derive(Debug, Clone)]
4745#[repr(C)]
4746#[rustfmt::skip]
4747pub struct VkDeviceCreateInfo {
4748    pub sType: VkStructureType,
4749    pub pNext: *const core::ffi::c_void,
4750    pub flags: VkDeviceCreateFlags,
4751    pub queueCreateInfoCount: u32,
4752    pub pQueueCreateInfos: *const VkDeviceQueueCreateInfo,
4753    pub enabledLayerCount: u32,
4754    pub ppEnabledLayerNames: *const *const core::ffi::c_char,
4755    pub enabledExtensionCount: u32,
4756    pub ppEnabledExtensionNames: *const *const core::ffi::c_char,
4757    pub pEnabledFeatures: *const VkPhysicalDeviceFeatures,
4758}
4759#[rustfmt::skip]
4760pub const VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = 3;
4761#[rustfmt::skip]
4762unsafe impl crate::VulkanStructure for VkDeviceCreateInfo {
4763    #[inline(always)]
4764    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4765        unsafe { core::mem::transmute(self) }
4766    }
4767
4768    #[inline(always)]
4769    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4770        unsafe { core::mem::transmute(self) }
4771    }
4772}
4773#[rustfmt::skip]
4774unsafe impl crate::TypedVulkanStructure for VkDeviceCreateInfo {
4775    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
4776}
4777
4778#[cfg(all(feature = "VK_KHR_device_group"))]
4779#[derive(Debug, Clone)]
4780#[repr(C)]
4781#[rustfmt::skip]
4782pub struct VkDeviceGroupBindSparseInfoKHR {
4783    pub sType: VkStructureType,
4784    pub pNext: *const core::ffi::c_void,
4785    pub resourceDeviceIndex: u32,
4786    pub memoryDeviceIndex: u32,
4787}
4788#[cfg(all(feature = "VK_KHR_device_group"))]
4789#[rustfmt::skip]
4790pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR: VkStructureType = 1000060006;
4791#[cfg(all(feature = "VK_KHR_device_group"))]
4792#[rustfmt::skip]
4793unsafe impl crate::VulkanStructure for VkDeviceGroupBindSparseInfoKHR {
4794    #[inline(always)]
4795    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4796        unsafe { core::mem::transmute(self) }
4797    }
4798
4799    #[inline(always)]
4800    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4801        unsafe { core::mem::transmute(self) }
4802    }
4803}
4804#[cfg(all(feature = "VK_KHR_device_group"))]
4805#[rustfmt::skip]
4806unsafe impl crate::TypedVulkanStructure for VkDeviceGroupBindSparseInfoKHR {
4807    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR;
4808}
4809#[cfg(feature = "Allow1_1APIs")]
4810#[rustfmt::skip]
4811pub type VkDeviceGroupBindSparseInfo = VkDeviceGroupBindSparseInfoKHR;
4812#[cfg(feature = "Allow1_1APIs")]
4813#[rustfmt::skip]
4814pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR;
4815
4816#[cfg(all(feature = "VK_KHR_device_group"))]
4817#[derive(Debug, Clone)]
4818#[repr(C)]
4819#[rustfmt::skip]
4820pub struct VkDeviceGroupCommandBufferBeginInfoKHR {
4821    pub sType: VkStructureType,
4822    pub pNext: *const core::ffi::c_void,
4823    pub deviceMask: u32,
4824}
4825#[cfg(all(feature = "VK_KHR_device_group"))]
4826#[rustfmt::skip]
4827pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: VkStructureType = 1000060004;
4828#[cfg(all(feature = "VK_KHR_device_group"))]
4829#[rustfmt::skip]
4830unsafe impl crate::VulkanStructure for VkDeviceGroupCommandBufferBeginInfoKHR {
4831    #[inline(always)]
4832    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4833        unsafe { core::mem::transmute(self) }
4834    }
4835
4836    #[inline(always)]
4837    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4838        unsafe { core::mem::transmute(self) }
4839    }
4840}
4841#[cfg(all(feature = "VK_KHR_device_group"))]
4842#[rustfmt::skip]
4843unsafe impl crate::TypedVulkanStructure for VkDeviceGroupCommandBufferBeginInfoKHR {
4844    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR;
4845}
4846#[cfg(feature = "Allow1_1APIs")]
4847#[rustfmt::skip]
4848pub type VkDeviceGroupCommandBufferBeginInfo = VkDeviceGroupCommandBufferBeginInfoKHR;
4849#[cfg(feature = "Allow1_1APIs")]
4850#[rustfmt::skip]
4851pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR;
4852
4853#[cfg(all(feature = "VK_KHR_device_group_creation"))]
4854#[derive(Debug, Clone)]
4855#[repr(C)]
4856#[rustfmt::skip]
4857pub struct VkDeviceGroupCreateInfoKHR {
4858    pub sType: VkStructureType,
4859    pub pNext: *const core::ffi::c_void,
4860    pub physicalDeviceCount: u32,
4861    pub pPhysicalDevices: *const VkPhysicalDevice,
4862}
4863#[cfg(all(feature = "VK_KHR_device_group_creation"))]
4864#[rustfmt::skip]
4865pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_CREATE_INFO_KHR: VkStructureType = 1000070001;
4866#[cfg(all(feature = "VK_KHR_device_group_creation"))]
4867#[rustfmt::skip]
4868unsafe impl crate::VulkanStructure for VkDeviceGroupCreateInfoKHR {
4869    #[inline(always)]
4870    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4871        unsafe { core::mem::transmute(self) }
4872    }
4873
4874    #[inline(always)]
4875    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4876        unsafe { core::mem::transmute(self) }
4877    }
4878}
4879#[cfg(all(feature = "VK_KHR_device_group_creation"))]
4880#[rustfmt::skip]
4881unsafe impl crate::TypedVulkanStructure for VkDeviceGroupCreateInfoKHR {
4882    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_CREATE_INFO_KHR;
4883}
4884#[cfg(feature = "Allow1_1APIs")]
4885#[rustfmt::skip]
4886pub type VkDeviceGroupCreateInfo = VkDeviceGroupCreateInfoKHR;
4887#[cfg(feature = "Allow1_1APIs")]
4888#[rustfmt::skip]
4889pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_CREATE_INFO_KHR;
4890
4891#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_surface"))]
4892#[derive(Debug, Clone)]
4893#[repr(C)]
4894#[rustfmt::skip]
4895pub struct VkDeviceGroupPresentCapabilitiesKHR {
4896    pub sType: VkStructureType,
4897    pub pNext: *mut core::ffi::c_void,
4898    pub presentMask: [u32; VK_MAX_DEVICE_GROUP_SIZE_KHR],
4899    pub modes: VkDeviceGroupPresentModeFlagsKHR,
4900}
4901#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_surface"))]
4902#[rustfmt::skip]
4903pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: VkStructureType = 1000060007;
4904#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_surface"))]
4905#[rustfmt::skip]
4906unsafe impl crate::VulkanSinkStructure for VkDeviceGroupPresentCapabilitiesKHR {
4907    #[inline(always)]
4908    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
4909        unsafe { core::mem::transmute(self) }
4910    }
4911
4912    #[inline(always)]
4913    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
4914        unsafe { core::mem::transmute(self) }
4915    }
4916}
4917#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_surface"))]
4918#[rustfmt::skip]
4919unsafe impl crate::TypedVulkanSinkStructure for VkDeviceGroupPresentCapabilitiesKHR {
4920    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR;
4921}
4922
4923#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
4924#[derive(Debug, Clone)]
4925#[repr(C)]
4926#[rustfmt::skip]
4927pub struct VkDeviceGroupPresentInfoKHR {
4928    pub sType: VkStructureType,
4929    pub pNext: *const core::ffi::c_void,
4930    pub swapchainCount: u32,
4931    pub pDeviceMasks: *const u32,
4932    pub mode: VkDeviceGroupPresentModeFlagBitsKHR,
4933}
4934#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
4935#[rustfmt::skip]
4936pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: VkStructureType = 1000060011;
4937#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
4938#[rustfmt::skip]
4939unsafe impl crate::VulkanStructure for VkDeviceGroupPresentInfoKHR {
4940    #[inline(always)]
4941    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4942        unsafe { core::mem::transmute(self) }
4943    }
4944
4945    #[inline(always)]
4946    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4947        unsafe { core::mem::transmute(self) }
4948    }
4949}
4950#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
4951#[rustfmt::skip]
4952unsafe impl crate::TypedVulkanStructure for VkDeviceGroupPresentInfoKHR {
4953    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR;
4954}
4955
4956#[cfg(all(feature = "VK_KHR_device_group"))]
4957#[derive(Debug, Clone)]
4958#[repr(C)]
4959#[rustfmt::skip]
4960pub struct VkDeviceGroupRenderPassBeginInfoKHR {
4961    pub sType: VkStructureType,
4962    pub pNext: *const core::ffi::c_void,
4963    pub deviceMask: u32,
4964    pub deviceRenderAreaCount: u32,
4965    pub pDeviceRenderAreas: *const VkRect2D,
4966}
4967#[cfg(all(feature = "VK_KHR_device_group"))]
4968#[rustfmt::skip]
4969pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: VkStructureType = 1000060003;
4970#[cfg(all(feature = "VK_KHR_device_group"))]
4971#[rustfmt::skip]
4972unsafe impl crate::VulkanStructure for VkDeviceGroupRenderPassBeginInfoKHR {
4973    #[inline(always)]
4974    fn as_generic(&self) -> &crate::GenericVulkanStructure {
4975        unsafe { core::mem::transmute(self) }
4976    }
4977
4978    #[inline(always)]
4979    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
4980        unsafe { core::mem::transmute(self) }
4981    }
4982}
4983#[cfg(all(feature = "VK_KHR_device_group"))]
4984#[rustfmt::skip]
4985unsafe impl crate::TypedVulkanStructure for VkDeviceGroupRenderPassBeginInfoKHR {
4986    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR;
4987}
4988#[cfg(feature = "Allow1_1APIs")]
4989#[rustfmt::skip]
4990pub type VkDeviceGroupRenderPassBeginInfo = VkDeviceGroupRenderPassBeginInfoKHR;
4991#[cfg(feature = "Allow1_1APIs")]
4992#[rustfmt::skip]
4993pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR;
4994
4995#[cfg(all(feature = "VK_KHR_device_group"))]
4996#[derive(Debug, Clone)]
4997#[repr(C)]
4998#[rustfmt::skip]
4999pub struct VkDeviceGroupSubmitInfoKHR {
5000    pub sType: VkStructureType,
5001    pub pNext: *const core::ffi::c_void,
5002    pub waitSemaphoreCount: u32,
5003    pub pWaitSemaphoreDeviceIndices: *const u32,
5004    pub commandBufferCount: u32,
5005    pub pCommandBufferDeviceMasks: *const u32,
5006    pub signalSemaphoreCount: u32,
5007    pub pSignalSemaphoreDeviceIndices: *const u32,
5008}
5009#[cfg(all(feature = "VK_KHR_device_group"))]
5010#[rustfmt::skip]
5011pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR: VkStructureType = 1000060005;
5012#[cfg(all(feature = "VK_KHR_device_group"))]
5013#[rustfmt::skip]
5014unsafe impl crate::VulkanStructure for VkDeviceGroupSubmitInfoKHR {
5015    #[inline(always)]
5016    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5017        unsafe { core::mem::transmute(self) }
5018    }
5019
5020    #[inline(always)]
5021    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5022        unsafe { core::mem::transmute(self) }
5023    }
5024}
5025#[cfg(all(feature = "VK_KHR_device_group"))]
5026#[rustfmt::skip]
5027unsafe impl crate::TypedVulkanStructure for VkDeviceGroupSubmitInfoKHR {
5028    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR;
5029}
5030#[cfg(feature = "Allow1_1APIs")]
5031#[rustfmt::skip]
5032pub type VkDeviceGroupSubmitInfo = VkDeviceGroupSubmitInfoKHR;
5033#[cfg(feature = "Allow1_1APIs")]
5034#[rustfmt::skip]
5035pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR;
5036
5037#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
5038#[derive(Debug, Clone)]
5039#[repr(C)]
5040#[rustfmt::skip]
5041pub struct VkDeviceGroupSwapchainCreateInfoKHR {
5042    pub sType: VkStructureType,
5043    pub pNext: *const core::ffi::c_void,
5044    pub modes: VkDeviceGroupPresentModeFlagsKHR,
5045}
5046#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
5047#[rustfmt::skip]
5048pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060012;
5049#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
5050#[rustfmt::skip]
5051unsafe impl crate::VulkanStructure for VkDeviceGroupSwapchainCreateInfoKHR {
5052    #[inline(always)]
5053    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5054        unsafe { core::mem::transmute(self) }
5055    }
5056
5057    #[inline(always)]
5058    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5059        unsafe { core::mem::transmute(self) }
5060    }
5061}
5062#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
5063#[rustfmt::skip]
5064unsafe impl crate::TypedVulkanStructure for VkDeviceGroupSwapchainCreateInfoKHR {
5065    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR;
5066}
5067
5068#[derive(Debug, Clone)]
5069#[repr(C)]
5070#[rustfmt::skip]
5071pub struct VkDeviceQueueCreateInfo {
5072    pub sType: VkStructureType,
5073    pub pNext: *const core::ffi::c_void,
5074    pub flags: VkDeviceQueueCreateFlags,
5075    pub queueFamilyIndex: u32,
5076    pub queueCount: u32,
5077    pub pQueuePriorities: *const core::ffi::c_float,
5078}
5079#[rustfmt::skip]
5080pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = 2;
5081#[rustfmt::skip]
5082unsafe impl crate::VulkanStructure for VkDeviceQueueCreateInfo {
5083    #[inline(always)]
5084    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5085        unsafe { core::mem::transmute(self) }
5086    }
5087
5088    #[inline(always)]
5089    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5090        unsafe { core::mem::transmute(self) }
5091    }
5092}
5093#[rustfmt::skip]
5094unsafe impl crate::TypedVulkanStructure for VkDeviceQueueCreateInfo {
5095    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
5096}
5097
5098#[derive(Debug, Clone)]
5099#[repr(C)]
5100#[rustfmt::skip]
5101pub struct VkDispatchIndirectCommand {
5102    pub x: u32,
5103    pub y: u32,
5104    pub z: u32,
5105}
5106
5107#[cfg(all(feature = "VK_KHR_display"))]
5108#[derive(Debug, Clone)]
5109#[repr(C)]
5110#[rustfmt::skip]
5111pub struct VkDisplayModeCreateInfoKHR {
5112    pub sType: VkStructureType,
5113    pub pNext: *const core::ffi::c_void,
5114    pub flags: VkDisplayModeCreateFlagsKHR,
5115    pub parameters: VkDisplayModeParametersKHR,
5116}
5117#[cfg(all(feature = "VK_KHR_display"))]
5118#[rustfmt::skip]
5119pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: VkStructureType = 1000002000;
5120#[cfg(all(feature = "VK_KHR_display"))]
5121#[rustfmt::skip]
5122unsafe impl crate::VulkanStructure for VkDisplayModeCreateInfoKHR {
5123    #[inline(always)]
5124    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5125        unsafe { core::mem::transmute(self) }
5126    }
5127
5128    #[inline(always)]
5129    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5130        unsafe { core::mem::transmute(self) }
5131    }
5132}
5133#[cfg(all(feature = "VK_KHR_display"))]
5134#[rustfmt::skip]
5135unsafe impl crate::TypedVulkanStructure for VkDisplayModeCreateInfoKHR {
5136    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR;
5137}
5138
5139#[cfg(all(feature = "VK_KHR_display"))]
5140#[derive(Debug, Clone)]
5141#[repr(C)]
5142#[rustfmt::skip]
5143pub struct VkDisplayModeParametersKHR {
5144    pub visibleRegion: VkExtent2D,
5145    pub refreshRate: u32,
5146}
5147
5148#[cfg(all(feature = "VK_KHR_display"))]
5149#[derive(Debug, Clone)]
5150#[repr(C)]
5151#[rustfmt::skip]
5152pub struct VkDisplayModePropertiesKHR {
5153    pub displayMode: VkDisplayModeKHR,
5154    pub parameters: VkDisplayModeParametersKHR,
5155}
5156
5157#[cfg(all(feature = "VK_KHR_display"))]
5158#[derive(Debug, Clone)]
5159#[repr(C)]
5160#[rustfmt::skip]
5161pub struct VkDisplayPlaneCapabilitiesKHR {
5162    pub supportedAlpha: VkDisplayPlaneAlphaFlagsKHR,
5163    pub minSrcPosition: VkOffset2D,
5164    pub maxSrcPosition: VkOffset2D,
5165    pub minSrcExtent: VkExtent2D,
5166    pub maxSrcExtent: VkExtent2D,
5167    pub minDstPosition: VkOffset2D,
5168    pub maxDstPosition: VkOffset2D,
5169    pub minDstExtent: VkExtent2D,
5170    pub maxDstExtent: VkExtent2D,
5171}
5172
5173#[cfg(all(feature = "VK_KHR_display"))]
5174#[derive(Debug, Clone)]
5175#[repr(C)]
5176#[rustfmt::skip]
5177pub struct VkDisplayPlanePropertiesKHR {
5178    pub currentDisplay: VkDisplayKHR,
5179    pub currentStackIndex: u32,
5180}
5181
5182#[cfg(all(feature = "VK_KHR_display_swapchain"))]
5183#[derive(Debug, Clone)]
5184#[repr(C)]
5185#[rustfmt::skip]
5186pub struct VkDisplayPresentInfoKHR {
5187    pub sType: VkStructureType,
5188    pub pNext: *const core::ffi::c_void,
5189    pub srcRect: VkRect2D,
5190    pub dstRect: VkRect2D,
5191    pub persistent: VkBool32,
5192}
5193#[cfg(all(feature = "VK_KHR_display_swapchain"))]
5194#[rustfmt::skip]
5195pub const VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: VkStructureType = 1000003000;
5196#[cfg(all(feature = "VK_KHR_display_swapchain"))]
5197#[rustfmt::skip]
5198unsafe impl crate::VulkanStructure for VkDisplayPresentInfoKHR {
5199    #[inline(always)]
5200    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5201        unsafe { core::mem::transmute(self) }
5202    }
5203
5204    #[inline(always)]
5205    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5206        unsafe { core::mem::transmute(self) }
5207    }
5208}
5209#[cfg(all(feature = "VK_KHR_display_swapchain"))]
5210#[rustfmt::skip]
5211unsafe impl crate::TypedVulkanStructure for VkDisplayPresentInfoKHR {
5212    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR;
5213}
5214
5215#[cfg(all(feature = "VK_KHR_display"))]
5216#[derive(Debug, Clone)]
5217#[repr(C)]
5218#[rustfmt::skip]
5219pub struct VkDisplayPropertiesKHR {
5220    pub display: VkDisplayKHR,
5221    pub displayName: *const core::ffi::c_char,
5222    pub physicalDimensions: VkExtent2D,
5223    pub physicalResolution: VkExtent2D,
5224    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
5225    pub planeReorderPossible: VkBool32,
5226    pub persistentContent: VkBool32,
5227}
5228
5229#[cfg(all(feature = "VK_KHR_display"))]
5230#[derive(Debug, Clone)]
5231#[repr(C)]
5232#[rustfmt::skip]
5233pub struct VkDisplaySurfaceCreateInfoKHR {
5234    pub sType: VkStructureType,
5235    pub pNext: *const core::ffi::c_void,
5236    pub flags: VkDisplaySurfaceCreateFlagsKHR,
5237    pub displayMode: VkDisplayModeKHR,
5238    pub planeIndex: u32,
5239    pub planeStackIndex: u32,
5240    pub transform: VkSurfaceTransformFlagBitsKHR,
5241    pub globalAlpha: core::ffi::c_float,
5242    pub alphaMode: VkDisplayPlaneAlphaFlagBitsKHR,
5243    pub imageExtent: VkExtent2D,
5244}
5245#[cfg(all(feature = "VK_KHR_display"))]
5246#[rustfmt::skip]
5247pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000002001;
5248#[cfg(all(feature = "VK_KHR_display"))]
5249#[rustfmt::skip]
5250unsafe impl crate::VulkanStructure for VkDisplaySurfaceCreateInfoKHR {
5251    #[inline(always)]
5252    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5253        unsafe { core::mem::transmute(self) }
5254    }
5255
5256    #[inline(always)]
5257    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5258        unsafe { core::mem::transmute(self) }
5259    }
5260}
5261#[cfg(all(feature = "VK_KHR_display"))]
5262#[rustfmt::skip]
5263unsafe impl crate::TypedVulkanStructure for VkDisplaySurfaceCreateInfoKHR {
5264    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
5265}
5266
5267#[derive(Debug, Clone)]
5268#[repr(C)]
5269#[rustfmt::skip]
5270pub struct VkDrawIndexedIndirectCommand {
5271    pub indexCount: u32,
5272    pub instanceCount: u32,
5273    pub firstIndex: u32,
5274    pub vertexOffset: i32,
5275    pub firstInstance: u32,
5276}
5277
5278#[derive(Debug, Clone)]
5279#[repr(C)]
5280#[rustfmt::skip]
5281pub struct VkDrawIndirectCommand {
5282    pub vertexCount: u32,
5283    pub instanceCount: u32,
5284    pub firstVertex: u32,
5285    pub firstInstance: u32,
5286}
5287
5288#[derive(Debug, Clone)]
5289#[repr(C)]
5290#[rustfmt::skip]
5291pub struct VkEventCreateInfo {
5292    pub sType: VkStructureType,
5293    pub pNext: *const core::ffi::c_void,
5294    pub flags: VkEventCreateFlags,
5295}
5296#[rustfmt::skip]
5297pub const VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: VkStructureType = 10;
5298#[rustfmt::skip]
5299unsafe impl crate::VulkanStructure for VkEventCreateInfo {
5300    #[inline(always)]
5301    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5302        unsafe { core::mem::transmute(self) }
5303    }
5304
5305    #[inline(always)]
5306    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5307        unsafe { core::mem::transmute(self) }
5308    }
5309}
5310#[rustfmt::skip]
5311unsafe impl crate::TypedVulkanStructure for VkEventCreateInfo {
5312    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EVENT_CREATE_INFO;
5313}
5314
5315#[cfg(all(feature = "VK_KHR_external_fence"))]
5316#[derive(Debug, Clone)]
5317#[repr(C)]
5318#[rustfmt::skip]
5319pub struct VkExportFenceCreateInfoKHR {
5320    pub handleTypes: VkExternalFenceHandleTypeFlagsKHR,
5321}
5322#[cfg(feature = "Allow1_1APIs")]
5323#[rustfmt::skip]
5324pub type VkExportFenceCreateInfo = VkExportFenceCreateInfoKHR;
5325
5326#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5327#[derive(Debug, Clone)]
5328#[repr(C)]
5329#[rustfmt::skip]
5330pub struct VkExportFenceWin32HandleInfoKHR {
5331    pub sType: VkStructureType,
5332    pub pNext: *const core::ffi::c_void,
5333    pub pAttributes: *const windows::Win32::Security::SECURITY_ATTRIBUTES,
5334    pub dwAccess: u32,
5335    pub name: windows::core::PCWSTR,
5336}
5337#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5338#[rustfmt::skip]
5339pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000114001;
5340#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5341#[rustfmt::skip]
5342unsafe impl crate::VulkanStructure for VkExportFenceWin32HandleInfoKHR {
5343    #[inline(always)]
5344    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5345        unsafe { core::mem::transmute(self) }
5346    }
5347
5348    #[inline(always)]
5349    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5350        unsafe { core::mem::transmute(self) }
5351    }
5352}
5353#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5354#[rustfmt::skip]
5355unsafe impl crate::TypedVulkanStructure for VkExportFenceWin32HandleInfoKHR {
5356    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR;
5357}
5358
5359#[cfg(all(feature = "VK_KHR_external_memory"))]
5360#[derive(Debug, Clone)]
5361#[repr(C)]
5362#[rustfmt::skip]
5363pub struct VkVkExportMemoryAllocateInfoKHR {
5364    pub sType: VkStructureType,
5365    pub pNext: *const core::ffi::c_void,
5366    pub handleTypes: VkExternalMemoryHandleTypeFlagsKHR,
5367}
5368#[cfg(all(feature = "VK_KHR_external_memory"))]
5369#[rustfmt::skip]
5370pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: VkStructureType = 1000072002;
5371#[cfg(all(feature = "VK_KHR_external_memory"))]
5372#[rustfmt::skip]
5373unsafe impl crate::VulkanStructure for VkVkExportMemoryAllocateInfoKHR {
5374    #[inline(always)]
5375    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5376        unsafe { core::mem::transmute(self) }
5377    }
5378
5379    #[inline(always)]
5380    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5381        unsafe { core::mem::transmute(self) }
5382    }
5383}
5384#[cfg(all(feature = "VK_KHR_external_memory"))]
5385#[rustfmt::skip]
5386unsafe impl crate::TypedVulkanStructure for VkVkExportMemoryAllocateInfoKHR {
5387    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
5388}
5389#[cfg(feature = "Allow1_1APIs")]
5390#[rustfmt::skip]
5391pub type VkVkExportMemoryAllocateInfo = VkVkExportMemoryAllocateInfoKHR;
5392#[cfg(feature = "Allow1_1APIs")]
5393#[rustfmt::skip]
5394pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR;
5395
5396#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
5397#[derive(Debug, Clone)]
5398#[repr(C)]
5399#[rustfmt::skip]
5400pub struct VkExportMemoryWin32HandleInfoKHR {
5401    pub sType: VkStructureType,
5402    pub pNext: *const core::ffi::c_void,
5403    pub pAttributes: *const windows::Win32::Security::SECURITY_ATTRIBUTES,
5404    pub dwAccess: u32,
5405    pub name: windows::core::PCWSTR,
5406}
5407#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
5408#[rustfmt::skip]
5409pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000073001;
5410#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
5411#[rustfmt::skip]
5412unsafe impl crate::VulkanStructure for VkExportMemoryWin32HandleInfoKHR {
5413    #[inline(always)]
5414    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5415        unsafe { core::mem::transmute(self) }
5416    }
5417
5418    #[inline(always)]
5419    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5420        unsafe { core::mem::transmute(self) }
5421    }
5422}
5423#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
5424#[rustfmt::skip]
5425unsafe impl crate::TypedVulkanStructure for VkExportMemoryWin32HandleInfoKHR {
5426    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
5427}
5428
5429#[cfg(all(feature = "VK_KHR_external_semaphore"))]
5430#[derive(Debug, Clone)]
5431#[repr(C)]
5432#[rustfmt::skip]
5433pub struct VkExportSemaphoreCreateInfoKHR {
5434    pub sType: VkStructureType,
5435    pub pNext: *const core::ffi::c_void,
5436    pub handleType: VkExternalSemaphoreHandleTypeFlagsKHR,
5437}
5438#[cfg(all(feature = "VK_KHR_external_semaphore"))]
5439#[rustfmt::skip]
5440pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR: VkStructureType = 1000077000;
5441#[cfg(all(feature = "VK_KHR_external_semaphore"))]
5442#[rustfmt::skip]
5443unsafe impl crate::VulkanStructure for VkExportSemaphoreCreateInfoKHR {
5444    #[inline(always)]
5445    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5446        unsafe { core::mem::transmute(self) }
5447    }
5448
5449    #[inline(always)]
5450    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5451        unsafe { core::mem::transmute(self) }
5452    }
5453}
5454#[cfg(all(feature = "VK_KHR_external_semaphore"))]
5455#[rustfmt::skip]
5456unsafe impl crate::TypedVulkanStructure for VkExportSemaphoreCreateInfoKHR {
5457    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR;
5458}
5459#[cfg(feature = "Allow1_1APIs")]
5460#[rustfmt::skip]
5461pub type VkExportSemaphoreCreateInfo = VkExportSemaphoreCreateInfoKHR;
5462#[cfg(feature = "Allow1_1APIs")]
5463#[rustfmt::skip]
5464pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR;
5465
5466#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
5467#[derive(Debug, Clone)]
5468#[repr(C)]
5469#[rustfmt::skip]
5470pub struct VkExportSemaphoreWin32HandleInfoKHR {
5471    pub sType: VkStructureType,
5472    pub pNext: *const core::ffi::c_void,
5473    pub pAttributes: *const windows::Win32::Security::SECURITY_ATTRIBUTES,
5474    pub dwAccess: u32,
5475    pub name: windows::core::PCWSTR,
5476}
5477#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
5478#[rustfmt::skip]
5479pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000078001;
5480#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
5481#[rustfmt::skip]
5482unsafe impl crate::VulkanStructure for VkExportSemaphoreWin32HandleInfoKHR {
5483    #[inline(always)]
5484    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5485        unsafe { core::mem::transmute(self) }
5486    }
5487
5488    #[inline(always)]
5489    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5490        unsafe { core::mem::transmute(self) }
5491    }
5492}
5493#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
5494#[rustfmt::skip]
5495unsafe impl crate::TypedVulkanStructure for VkExportSemaphoreWin32HandleInfoKHR {
5496    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
5497}
5498
5499#[derive(Debug, Clone)]
5500#[repr(C)]
5501#[rustfmt::skip]
5502pub struct VkExtensionProperties {
5503    pub extensionName: crate::ffi_helper::FixedCStrBuffer<VK_MAX_EXTENSION_NAME_SIZE>,
5504    pub specVersion: u32,
5505}
5506
5507#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
5508#[repr(C)]
5509#[rustfmt::skip]
5510pub struct VkExtent2D {
5511    pub width: u32,
5512    pub height: u32,
5513}
5514
5515#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
5516#[repr(C)]
5517#[rustfmt::skip]
5518pub struct VkExtent3D {
5519    pub width: u32,
5520    pub height: u32,
5521    pub depth: u32,
5522}
5523
5524#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5525#[derive(Debug, Clone)]
5526#[repr(C)]
5527#[rustfmt::skip]
5528pub struct VkExternalBufferPropertiesKHR {
5529    pub sType: VkStructureType,
5530    pub pNext: *mut core::ffi::c_void,
5531    pub externalMemoryProperties: VkExternalMemoryPropertiesKHR,
5532}
5533#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5534#[rustfmt::skip]
5535pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR: VkStructureType = 1000071003;
5536#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5537#[rustfmt::skip]
5538unsafe impl crate::VulkanSinkStructure for VkExternalBufferPropertiesKHR {
5539    #[inline(always)]
5540    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
5541        unsafe { core::mem::transmute(self) }
5542    }
5543
5544    #[inline(always)]
5545    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
5546        unsafe { core::mem::transmute(self) }
5547    }
5548}
5549#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5550#[rustfmt::skip]
5551unsafe impl crate::TypedVulkanSinkStructure for VkExternalBufferPropertiesKHR {
5552    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR;
5553}
5554#[cfg(feature = "Allow1_1APIs")]
5555#[rustfmt::skip]
5556pub type VkExternalBufferProperties = VkExternalBufferPropertiesKHR;
5557#[cfg(feature = "Allow1_1APIs")]
5558#[rustfmt::skip]
5559pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR;
5560
5561#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
5562#[derive(Debug, Clone)]
5563#[repr(C)]
5564#[rustfmt::skip]
5565pub struct VkExternalFencePropertiesKHR {
5566    pub sType: VkStructureType,
5567    pub pNext: *mut core::ffi::c_void,
5568    pub exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlagsKHR,
5569    pub compatibleHandleTypes: VkExternalFenceHandleTypeFlagsKHR,
5570    pub externalFenceFeatures: VkExternalFenceFeatureFlagsKHR,
5571}
5572#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
5573#[rustfmt::skip]
5574pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR: VkStructureType = 1000112001;
5575#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
5576#[rustfmt::skip]
5577unsafe impl crate::VulkanSinkStructure for VkExternalFencePropertiesKHR {
5578    #[inline(always)]
5579    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
5580        unsafe { core::mem::transmute(self) }
5581    }
5582
5583    #[inline(always)]
5584    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
5585        unsafe { core::mem::transmute(self) }
5586    }
5587}
5588#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
5589#[rustfmt::skip]
5590unsafe impl crate::TypedVulkanSinkStructure for VkExternalFencePropertiesKHR {
5591    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR;
5592}
5593#[cfg(feature = "Allow1_1APIs")]
5594#[rustfmt::skip]
5595pub type VkExternalFenceProperties = VkExternalFencePropertiesKHR;
5596#[cfg(feature = "Allow1_1APIs")]
5597#[rustfmt::skip]
5598pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR;
5599
5600#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5601#[derive(Debug, Clone)]
5602#[repr(C)]
5603#[rustfmt::skip]
5604pub struct VkExternalImageFormatPropertiesKHR {
5605    pub sType: VkStructureType,
5606    pub pNext: *mut core::ffi::c_void,
5607    pub externalMemoryProperties: VkExternalMemoryPropertiesKHR,
5608}
5609#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5610#[rustfmt::skip]
5611pub const VK_STRUCTURE_TYPE_EXTERANL_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = 1000071001;
5612#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5613#[rustfmt::skip]
5614unsafe impl crate::VulkanSinkStructure for VkExternalImageFormatPropertiesKHR {
5615    #[inline(always)]
5616    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
5617        unsafe { core::mem::transmute(self) }
5618    }
5619
5620    #[inline(always)]
5621    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
5622        unsafe { core::mem::transmute(self) }
5623    }
5624}
5625#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5626#[rustfmt::skip]
5627unsafe impl crate::TypedVulkanSinkStructure for VkExternalImageFormatPropertiesKHR {
5628    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXTERANL_IMAGE_FORMAT_PROPERTIES_KHR;
5629}
5630#[cfg(feature = "Allow1_1APIs")]
5631#[rustfmt::skip]
5632pub type VkExternalImageFormatProperties = VkExternalImageFormatPropertiesKHR;
5633#[cfg(feature = "Allow1_1APIs")]
5634#[rustfmt::skip]
5635pub const VK_STRUCTURE_TYPE_EXTERANL_IMAGE_FORMAT_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_EXTERANL_IMAGE_FORMAT_PROPERTIES_KHR;
5636
5637#[cfg(all(feature = "VK_KHR_external_memory"))]
5638#[derive(Debug, Clone)]
5639#[repr(C)]
5640#[rustfmt::skip]
5641pub struct VkExternalMemoryBufferCreateInfoKHR {
5642    pub sType: VkStructureType,
5643    pub pNext: *const core::ffi::c_void,
5644    pub handleTypes: VkExternalMemoryHandleTypeFlagsKHR,
5645}
5646#[cfg(all(feature = "VK_KHR_external_memory"))]
5647#[rustfmt::skip]
5648pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: VkStructureType = 1000072000;
5649#[cfg(all(feature = "VK_KHR_external_memory"))]
5650#[rustfmt::skip]
5651unsafe impl crate::VulkanStructure for VkExternalMemoryBufferCreateInfoKHR {
5652    #[inline(always)]
5653    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5654        unsafe { core::mem::transmute(self) }
5655    }
5656
5657    #[inline(always)]
5658    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5659        unsafe { core::mem::transmute(self) }
5660    }
5661}
5662#[cfg(all(feature = "VK_KHR_external_memory"))]
5663#[rustfmt::skip]
5664unsafe impl crate::TypedVulkanStructure for VkExternalMemoryBufferCreateInfoKHR {
5665    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR;
5666}
5667#[cfg(feature = "Allow1_1APIs")]
5668#[rustfmt::skip]
5669pub type VkExternalMemoryBufferCreateInfo = VkExternalMemoryBufferCreateInfoKHR;
5670#[cfg(feature = "Allow1_1APIs")]
5671#[rustfmt::skip]
5672pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR;
5673
5674#[cfg(all(feature = "VK_KHR_external_memory"))]
5675#[derive(Debug, Clone)]
5676#[repr(C)]
5677#[rustfmt::skip]
5678pub struct VkExternalMemoryImageCreateInfoKHR {
5679    pub sType: VkStructureType,
5680    pub pNext: *const core::ffi::c_void,
5681    pub handleTypes: VkExternalMemoryHandleTypeFlagsKHR,
5682}
5683#[cfg(all(feature = "VK_KHR_external_memory"))]
5684#[rustfmt::skip]
5685pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: VkStructureType = 1000072001;
5686#[cfg(all(feature = "VK_KHR_external_memory"))]
5687#[rustfmt::skip]
5688unsafe impl crate::VulkanStructure for VkExternalMemoryImageCreateInfoKHR {
5689    #[inline(always)]
5690    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5691        unsafe { core::mem::transmute(self) }
5692    }
5693
5694    #[inline(always)]
5695    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5696        unsafe { core::mem::transmute(self) }
5697    }
5698}
5699#[cfg(all(feature = "VK_KHR_external_memory"))]
5700#[rustfmt::skip]
5701unsafe impl crate::TypedVulkanStructure for VkExternalMemoryImageCreateInfoKHR {
5702    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR;
5703}
5704#[cfg(feature = "Allow1_1APIs")]
5705#[rustfmt::skip]
5706pub type VkExternalMemoryImageCreateInfo = VkExternalMemoryImageCreateInfoKHR;
5707#[cfg(feature = "Allow1_1APIs")]
5708#[rustfmt::skip]
5709pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR;
5710
5711#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
5712#[derive(Debug, Clone)]
5713#[repr(C)]
5714#[rustfmt::skip]
5715pub struct VkExternalMemoryPropertiesKHR {
5716    pub externalMemoryFeatures: VkExternalMemoryFeatureFlagsKHR,
5717    pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsKHR,
5718    pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsKHR,
5719}
5720#[cfg(feature = "Allow1_1APIs")]
5721#[rustfmt::skip]
5722pub type VkExternalMemoryProperties = VkExternalMemoryPropertiesKHR;
5723
5724#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
5725#[derive(Debug, Clone)]
5726#[repr(C)]
5727#[rustfmt::skip]
5728pub struct VkExternalSemaphorePropertiesKHR {
5729    pub sType: VkStructureType,
5730    pub pNext: *mut core::ffi::c_void,
5731    pub exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlagsKHR,
5732    pub compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlagsKHR,
5733    pub externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlagsKHR,
5734}
5735#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
5736#[rustfmt::skip]
5737pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR: VkStructureType = 1000076001;
5738#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
5739#[rustfmt::skip]
5740unsafe impl crate::VulkanSinkStructure for VkExternalSemaphorePropertiesKHR {
5741    #[inline(always)]
5742    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
5743        unsafe { core::mem::transmute(self) }
5744    }
5745
5746    #[inline(always)]
5747    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
5748        unsafe { core::mem::transmute(self) }
5749    }
5750}
5751#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
5752#[rustfmt::skip]
5753unsafe impl crate::TypedVulkanSinkStructure for VkExternalSemaphorePropertiesKHR {
5754    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR;
5755}
5756#[cfg(feature = "Allow1_1APIs")]
5757#[rustfmt::skip]
5758pub type VkExternalSemaphoreProperties = VkExternalSemaphorePropertiesKHR;
5759#[cfg(feature = "Allow1_1APIs")]
5760#[rustfmt::skip]
5761pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR;
5762
5763#[derive(Debug, Clone)]
5764#[repr(C)]
5765#[rustfmt::skip]
5766pub struct VkFenceCreateInfo {
5767    pub sType: VkStructureType,
5768    pub pNext: *const core::ffi::c_void,
5769    pub flags: VkFenceCreateFlags,
5770}
5771#[rustfmt::skip]
5772pub const VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: VkStructureType = 8;
5773#[rustfmt::skip]
5774unsafe impl crate::VulkanStructure for VkFenceCreateInfo {
5775    #[inline(always)]
5776    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5777        unsafe { core::mem::transmute(self) }
5778    }
5779
5780    #[inline(always)]
5781    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5782        unsafe { core::mem::transmute(self) }
5783    }
5784}
5785#[rustfmt::skip]
5786unsafe impl crate::TypedVulkanStructure for VkFenceCreateInfo {
5787    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
5788}
5789
5790#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
5791#[derive(Debug, Clone)]
5792#[repr(C)]
5793#[rustfmt::skip]
5794pub struct VkFenceGetFdInfoKHR {
5795    pub sType: VkStructureType,
5796    pub pNext: *const core::ffi::c_void,
5797    pub fence: VkFence,
5798    pub handleType: VkExternalFenceHandleTypeFlagsKHR,
5799}
5800#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
5801#[rustfmt::skip]
5802pub const VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: VkStructureType = 1000115001;
5803#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
5804#[rustfmt::skip]
5805unsafe impl crate::VulkanStructure for VkFenceGetFdInfoKHR {
5806    #[inline(always)]
5807    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5808        unsafe { core::mem::transmute(self) }
5809    }
5810
5811    #[inline(always)]
5812    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5813        unsafe { core::mem::transmute(self) }
5814    }
5815}
5816#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
5817#[rustfmt::skip]
5818unsafe impl crate::TypedVulkanStructure for VkFenceGetFdInfoKHR {
5819    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR;
5820}
5821
5822#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5823#[derive(Debug, Clone)]
5824#[repr(C)]
5825#[rustfmt::skip]
5826pub struct VkFenceGetWin32HandleInfoKHR {
5827    pub sType: VkStructureType,
5828    pub pNext: *const core::ffi::c_void,
5829    pub fence: VkFence,
5830    pub handleType: VkExternalFenceHandleTypeFlagsKHR,
5831}
5832#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5833#[rustfmt::skip]
5834pub const VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000114002;
5835#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5836#[rustfmt::skip]
5837unsafe impl crate::VulkanStructure for VkFenceGetWin32HandleInfoKHR {
5838    #[inline(always)]
5839    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5840        unsafe { core::mem::transmute(self) }
5841    }
5842
5843    #[inline(always)]
5844    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5845        unsafe { core::mem::transmute(self) }
5846    }
5847}
5848#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
5849#[rustfmt::skip]
5850unsafe impl crate::TypedVulkanStructure for VkFenceGetWin32HandleInfoKHR {
5851    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR;
5852}
5853
5854#[derive(Debug, Clone)]
5855#[repr(C)]
5856#[rustfmt::skip]
5857pub struct VkFormatProperties {
5858    pub linearTilingFeatures: VkFormatFeatureFlags,
5859    pub optimalTilingFeatures: VkFormatFeatureFlags,
5860    pub bufferFeatures: VkFormatFeatureFlags,
5861}
5862
5863#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
5864#[derive(Debug, Clone)]
5865#[repr(C)]
5866#[rustfmt::skip]
5867pub struct VkFormatProperties2KHR {
5868    pub sType: VkStructureType,
5869    pub pNext: *mut core::ffi::c_void,
5870    pub formatProperties: VkFormatProperties,
5871}
5872#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
5873#[rustfmt::skip]
5874pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: VkStructureType = 1000059002;
5875#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
5876#[rustfmt::skip]
5877unsafe impl crate::VulkanSinkStructure for VkFormatProperties2KHR {
5878    #[inline(always)]
5879    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
5880        unsafe { core::mem::transmute(self) }
5881    }
5882
5883    #[inline(always)]
5884    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
5885        unsafe { core::mem::transmute(self) }
5886    }
5887}
5888#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
5889#[rustfmt::skip]
5890unsafe impl crate::TypedVulkanSinkStructure for VkFormatProperties2KHR {
5891    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR;
5892}
5893#[cfg(feature = "Allow1_1APIs")]
5894#[rustfmt::skip]
5895pub type VkFormatProperties2 = VkFormatProperties2KHR;
5896#[cfg(feature = "Allow1_1APIs")]
5897#[rustfmt::skip]
5898pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR;
5899
5900#[derive(Debug, Clone)]
5901#[repr(C)]
5902#[rustfmt::skip]
5903pub struct VkFramebufferCreateInfo {
5904    pub sType: VkStructureType,
5905    pub pNext: *const core::ffi::c_void,
5906    pub flags: VkFramebufferCreateFlags,
5907    pub renderPass: VkRenderPass,
5908    pub attachmentCount: u32,
5909    pub pAttachments: *const VkImageView,
5910    pub width: u32,
5911    pub height: u32,
5912    pub layers: u32,
5913}
5914#[rustfmt::skip]
5915pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: VkStructureType = 37;
5916#[rustfmt::skip]
5917unsafe impl crate::VulkanStructure for VkFramebufferCreateInfo {
5918    #[inline(always)]
5919    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5920        unsafe { core::mem::transmute(self) }
5921    }
5922
5923    #[inline(always)]
5924    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5925        unsafe { core::mem::transmute(self) }
5926    }
5927}
5928#[rustfmt::skip]
5929unsafe impl crate::TypedVulkanStructure for VkFramebufferCreateInfo {
5930    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
5931}
5932
5933#[derive(Debug, Clone)]
5934#[repr(C)]
5935#[rustfmt::skip]
5936pub struct VkGraphicsPipelineCreateInfo {
5937    pub sType: VkStructureType,
5938    pub pNext: *const core::ffi::c_void,
5939    pub flags: VkPipelineCreateFlags,
5940    pub stageCount: u32,
5941    pub pStages: *const VkPipelineShaderStageCreateInfo,
5942    pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
5943    pub pInputAssemblyState: *const VkPipelineInputAssemblyStateCreateInfo,
5944    pub pTessellationState: *const VkPipelineTessellationStateCreateInfo,
5945    pub pViewportState: *const VkPipelineViewportStateCreateInfo,
5946    pub pRasterizationState: *const VkPipelineRasterizationStateCreateInfo,
5947    pub pMultisampleState: *const VkPipelineMultisampleStateCreateInfo,
5948    pub pDepthStencilState: *const VkPipelineDepthStencilStateCreateInfo,
5949    pub pColorBlendState: *const VkPipelineColorBlendStateCreateInfo,
5950    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
5951    pub layout: VkPipelineLayout,
5952    pub renderPass: VkRenderPass,
5953    pub subpass: u32,
5954    pub basePipelineHandle: VkPipeline,
5955    pub basePipelineIndex: i32,
5956}
5957#[rustfmt::skip]
5958pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = 28;
5959#[rustfmt::skip]
5960unsafe impl crate::VulkanStructure for VkGraphicsPipelineCreateInfo {
5961    #[inline(always)]
5962    fn as_generic(&self) -> &crate::GenericVulkanStructure {
5963        unsafe { core::mem::transmute(self) }
5964    }
5965
5966    #[inline(always)]
5967    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
5968        unsafe { core::mem::transmute(self) }
5969    }
5970}
5971#[rustfmt::skip]
5972unsafe impl crate::TypedVulkanStructure for VkGraphicsPipelineCreateInfo {
5973    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
5974}
5975
5976#[derive(Debug, Clone)]
5977#[repr(C)]
5978#[rustfmt::skip]
5979pub struct VkImageBlit {
5980    pub srcSubresource: VkImageSubresourceLayers,
5981    pub srcOffsets: [VkOffset3D; 2],
5982    pub dstSubresource: VkImageSubresourceLayers,
5983    pub dstOffsets: [VkOffset3D; 2],
5984}
5985
5986#[derive(Debug, Clone)]
5987#[repr(C)]
5988#[rustfmt::skip]
5989pub struct VkImageCopy {
5990    pub srcSubresource: VkImageSubresourceLayers,
5991    pub srcOffset: VkOffset3D,
5992    pub dstSubresource: VkImageSubresourceLayers,
5993    pub dstOffset: VkOffset3D,
5994    pub extent: VkExtent3D,
5995}
5996
5997#[derive(Debug, Clone)]
5998#[repr(C)]
5999#[rustfmt::skip]
6000pub struct VkImageCreateInfo {
6001    pub sType: VkStructureType,
6002    pub pNext: *const core::ffi::c_void,
6003    pub flags: VkImageCreateFlags,
6004    pub imageType: VkImageType,
6005    pub format: VkFormat,
6006    pub extent: VkExtent3D,
6007    pub mipLevels: u32,
6008    pub arrayLayers: u32,
6009    pub samples: VkSampleCountFlagBits,
6010    pub tiling: VkImageTiling,
6011    pub usage: VkImageUsageFlags,
6012    pub sharingMode: VkSharingMode,
6013    pub queueFamilyIndexCount: u32,
6014    pub pQueueFamilyIndices: *const u32,
6015    pub initialLayout: VkImageLayout,
6016}
6017#[rustfmt::skip]
6018pub const VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = 14;
6019#[rustfmt::skip]
6020unsafe impl crate::VulkanStructure for VkImageCreateInfo {
6021    #[inline(always)]
6022    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6023        unsafe { core::mem::transmute(self) }
6024    }
6025
6026    #[inline(always)]
6027    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6028        unsafe { core::mem::transmute(self) }
6029    }
6030}
6031#[rustfmt::skip]
6032unsafe impl crate::TypedVulkanStructure for VkImageCreateInfo {
6033    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
6034}
6035
6036#[derive(Debug, Clone)]
6037#[repr(C)]
6038#[rustfmt::skip]
6039pub struct VkImageFormatProperties {
6040    pub maxExtent: VkExtent3D,
6041    pub maxMipLevels: u32,
6042    pub maxArrayLayers: u32,
6043    pub sampleCounts: VkSampleCountFlags,
6044    pub maxResourceSize: VkDeviceSize,
6045}
6046
6047#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
6048#[derive(Debug, Clone)]
6049#[repr(C)]
6050#[rustfmt::skip]
6051pub struct VkImageFormatProperties2KHR {
6052    pub sType: VkStructureType,
6053    pub pNext: *mut core::ffi::c_void,
6054    pub imageFormatProperties: VkImageFormatProperties,
6055}
6056#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
6057#[rustfmt::skip]
6058pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = 1000059003;
6059#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
6060#[rustfmt::skip]
6061unsafe impl crate::VulkanSinkStructure for VkImageFormatProperties2KHR {
6062    #[inline(always)]
6063    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
6064        unsafe { core::mem::transmute(self) }
6065    }
6066
6067    #[inline(always)]
6068    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
6069        unsafe { core::mem::transmute(self) }
6070    }
6071}
6072#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
6073#[rustfmt::skip]
6074unsafe impl crate::TypedVulkanSinkStructure for VkImageFormatProperties2KHR {
6075    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR;
6076}
6077#[cfg(feature = "Allow1_1APIs")]
6078#[rustfmt::skip]
6079pub type VkImageFormatProperties2 = VkImageFormatProperties2KHR;
6080#[cfg(feature = "Allow1_1APIs")]
6081#[rustfmt::skip]
6082pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR;
6083
6084#[derive(Debug, Clone)]
6085#[repr(C)]
6086#[rustfmt::skip]
6087pub struct VkImageMemoryBarrier {
6088    pub sType: VkStructureType,
6089    pub pNext: *const core::ffi::c_void,
6090    pub srcAccessMask: VkAccessFlags,
6091    pub dstAccessMask: VkAccessFlags,
6092    pub oldLayout: VkImageLayout,
6093    pub newLayout: VkImageLayout,
6094    pub srcQueueFamilyIndex: u32,
6095    pub dstQueueFamilyIndex: u32,
6096    pub image: VkImage,
6097    pub subresourceRange: VkImageSubresourceRange,
6098}
6099#[rustfmt::skip]
6100pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = 45;
6101#[rustfmt::skip]
6102unsafe impl crate::VulkanStructure for VkImageMemoryBarrier {
6103    #[inline(always)]
6104    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6105        unsafe { core::mem::transmute(self) }
6106    }
6107
6108    #[inline(always)]
6109    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6110        unsafe { core::mem::transmute(self) }
6111    }
6112}
6113#[rustfmt::skip]
6114unsafe impl crate::TypedVulkanStructure for VkImageMemoryBarrier {
6115    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
6116}
6117
6118#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6119#[derive(Debug, Clone)]
6120#[repr(C)]
6121#[rustfmt::skip]
6122pub struct VkImageMemoryRequirementsInfo2KHR {
6123    pub sType: VkStructureType,
6124    pub pNext: *const core::ffi::c_void,
6125    pub image: VkImage,
6126}
6127#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6128#[rustfmt::skip]
6129pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = 1000146001;
6130#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6131#[rustfmt::skip]
6132unsafe impl crate::VulkanStructure for VkImageMemoryRequirementsInfo2KHR {
6133    #[inline(always)]
6134    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6135        unsafe { core::mem::transmute(self) }
6136    }
6137
6138    #[inline(always)]
6139    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6140        unsafe { core::mem::transmute(self) }
6141    }
6142}
6143#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6144#[rustfmt::skip]
6145unsafe impl crate::TypedVulkanStructure for VkImageMemoryRequirementsInfo2KHR {
6146    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR;
6147}
6148#[cfg(feature = "Allow1_1APIs")]
6149#[rustfmt::skip]
6150pub type VkImageMemoryRequirementsInfo2 = VkImageMemoryRequirementsInfo2KHR;
6151#[cfg(feature = "Allow1_1APIs")]
6152#[rustfmt::skip]
6153pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR;
6154
6155#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
6156#[derive(Debug, Clone)]
6157#[repr(C)]
6158#[rustfmt::skip]
6159pub struct VkImagePlaneMemoryRequirementsInfoKHR {
6160    pub sType: VkStructureType,
6161    pub pNext: *const core::ffi::c_void,
6162    pub planeAspect: VkImageAspectFlagBits,
6163}
6164#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
6165#[rustfmt::skip]
6166pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: VkStructureType = 1000156002;
6167#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
6168#[rustfmt::skip]
6169unsafe impl crate::VulkanStructure for VkImagePlaneMemoryRequirementsInfoKHR {
6170    #[inline(always)]
6171    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6172        unsafe { core::mem::transmute(self) }
6173    }
6174
6175    #[inline(always)]
6176    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6177        unsafe { core::mem::transmute(self) }
6178    }
6179}
6180#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
6181#[rustfmt::skip]
6182unsafe impl crate::TypedVulkanStructure for VkImagePlaneMemoryRequirementsInfoKHR {
6183    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR;
6184}
6185#[cfg(feature = "Allow1_1APIs")]
6186#[rustfmt::skip]
6187pub type VkImagePlaneMemoryRequirementsInfo = VkImagePlaneMemoryRequirementsInfoKHR;
6188#[cfg(feature = "Allow1_1APIs")]
6189#[rustfmt::skip]
6190pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR;
6191
6192#[derive(Debug, Clone)]
6193#[repr(C)]
6194#[rustfmt::skip]
6195pub struct VkImageResolve {
6196    pub srcSubresource: VkImageSubresourceLayers,
6197    pub srcOffset: VkOffset3D,
6198    pub dstSubresource: VkImageSubresourceLayers,
6199    pub dstOffset: VkOffset3D,
6200    pub extent: VkExtent3D,
6201}
6202
6203#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6204#[derive(Debug, Clone)]
6205#[repr(C)]
6206#[rustfmt::skip]
6207pub struct VkImageSparseMemoryRequirementsInfo2KHR {
6208    pub sType: VkStructureType,
6209    pub pNext: *const core::ffi::c_void,
6210    pub image: VkImage,
6211}
6212#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6213#[rustfmt::skip]
6214pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = 1000146002;
6215#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6216#[rustfmt::skip]
6217unsafe impl crate::VulkanStructure for VkImageSparseMemoryRequirementsInfo2KHR {
6218    #[inline(always)]
6219    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6220        unsafe { core::mem::transmute(self) }
6221    }
6222
6223    #[inline(always)]
6224    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6225        unsafe { core::mem::transmute(self) }
6226    }
6227}
6228#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6229#[rustfmt::skip]
6230unsafe impl crate::TypedVulkanStructure for VkImageSparseMemoryRequirementsInfo2KHR {
6231    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR;
6232}
6233#[cfg(feature = "Allow1_1APIs")]
6234#[rustfmt::skip]
6235pub type VkImageSparseMemoryRequirementsInfo2 = VkImageSparseMemoryRequirementsInfo2KHR;
6236#[cfg(feature = "Allow1_1APIs")]
6237#[rustfmt::skip]
6238pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR;
6239
6240#[derive(Debug, Clone)]
6241#[repr(C)]
6242#[rustfmt::skip]
6243pub struct VkImageSubresource {
6244    pub aspectMask: VkImageAspectFlags,
6245    pub mipLevel: u32,
6246    pub arrayLayer: u32,
6247}
6248
6249#[derive(Debug, Clone)]
6250#[repr(C)]
6251#[rustfmt::skip]
6252pub struct VkImageSubresourceLayers {
6253    pub aspectMask: VkImageAspectFlags,
6254    pub mipLevel: u32,
6255    pub baseArrayLayer: u32,
6256    pub layerCount: u32,
6257}
6258
6259#[derive(Debug, Clone)]
6260#[repr(C)]
6261#[rustfmt::skip]
6262pub struct VkImageSubresourceRange {
6263    pub aspectMask: VkImageAspectFlags,
6264    pub baseMipLevel: u32,
6265    pub levelCount: u32,
6266    pub baseArrayLayer: u32,
6267    pub layerCount: u32,
6268}
6269
6270#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
6271#[derive(Debug, Clone)]
6272#[repr(C)]
6273#[rustfmt::skip]
6274pub struct VkImageSwapchainCreateInfoKHR {
6275    pub sType: VkStructureType,
6276    pub pNext: *const core::ffi::c_void,
6277    pub swapchain: VkSwapchainKHR,
6278}
6279#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
6280#[rustfmt::skip]
6281pub const VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060008;
6282#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
6283#[rustfmt::skip]
6284unsafe impl crate::VulkanStructure for VkImageSwapchainCreateInfoKHR {
6285    #[inline(always)]
6286    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6287        unsafe { core::mem::transmute(self) }
6288    }
6289
6290    #[inline(always)]
6291    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6292        unsafe { core::mem::transmute(self) }
6293    }
6294}
6295#[cfg(all(feature = "VK_KHR_device_group", feature = "VK_KHR_swapchain"))]
6296#[rustfmt::skip]
6297unsafe impl crate::TypedVulkanStructure for VkImageSwapchainCreateInfoKHR {
6298    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR;
6299}
6300
6301#[derive(Debug, Clone)]
6302#[repr(C)]
6303#[rustfmt::skip]
6304pub struct VkImageViewCreateInfo {
6305    pub sType: VkStructureType,
6306    pub pNext: *const core::ffi::c_void,
6307    pub flags: VkImageViewCreateFlags,
6308    pub image: VkImage,
6309    pub viewType: VkImageViewType,
6310    pub format: VkFormat,
6311    pub components: VkComponentMapping,
6312    pub subresourceRange: VkImageSubresourceRange,
6313}
6314#[rustfmt::skip]
6315pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = 15;
6316#[rustfmt::skip]
6317unsafe impl crate::VulkanStructure for VkImageViewCreateInfo {
6318    #[inline(always)]
6319    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6320        unsafe { core::mem::transmute(self) }
6321    }
6322
6323    #[inline(always)]
6324    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6325        unsafe { core::mem::transmute(self) }
6326    }
6327}
6328#[rustfmt::skip]
6329unsafe impl crate::TypedVulkanStructure for VkImageViewCreateInfo {
6330    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
6331}
6332
6333#[cfg(all(feature = "VK_KHR_maintenance2"))]
6334#[derive(Debug, Clone)]
6335#[repr(C)]
6336#[rustfmt::skip]
6337pub struct VkImageViewUsageCreateInfoKHR {
6338    pub sType: VkStructureType,
6339    pub pNext: *const core::ffi::c_void,
6340    pub sliceOffset: u32,
6341    pub sliceCount: u32,
6342}
6343#[cfg(all(feature = "VK_KHR_maintenance2"))]
6344#[rustfmt::skip]
6345pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR: VkStructureType = 1000117002;
6346#[cfg(all(feature = "VK_KHR_maintenance2"))]
6347#[rustfmt::skip]
6348unsafe impl crate::VulkanStructure for VkImageViewUsageCreateInfoKHR {
6349    #[inline(always)]
6350    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6351        unsafe { core::mem::transmute(self) }
6352    }
6353
6354    #[inline(always)]
6355    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6356        unsafe { core::mem::transmute(self) }
6357    }
6358}
6359#[cfg(all(feature = "VK_KHR_maintenance2"))]
6360#[rustfmt::skip]
6361unsafe impl crate::TypedVulkanStructure for VkImageViewUsageCreateInfoKHR {
6362    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR;
6363}
6364#[cfg(feature = "Allow1_1APIs")]
6365#[rustfmt::skip]
6366pub type VkImageViewUsageCreateInfo = VkImageViewUsageCreateInfoKHR;
6367#[cfg(feature = "Allow1_1APIs")]
6368#[rustfmt::skip]
6369pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR;
6370
6371#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
6372#[derive(Debug, Clone)]
6373#[repr(C)]
6374#[rustfmt::skip]
6375pub struct VkImportFenceFdInfoKHR {
6376    pub sType: VkStructureType,
6377    pub pNext: *const core::ffi::c_void,
6378    pub fence: VkFence,
6379    pub flags: VkFenceImportFlagsKHR,
6380    pub handleType: VkExternalFenceHandleTypeFlagsKHR,
6381    pub fd: core::ffi::c_int,
6382}
6383#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
6384#[rustfmt::skip]
6385pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: VkStructureType = 1000115000;
6386#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
6387#[rustfmt::skip]
6388unsafe impl crate::VulkanStructure for VkImportFenceFdInfoKHR {
6389    #[inline(always)]
6390    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6391        unsafe { core::mem::transmute(self) }
6392    }
6393
6394    #[inline(always)]
6395    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6396        unsafe { core::mem::transmute(self) }
6397    }
6398}
6399#[cfg(all(feature = "VK_KHR_external_fence_fd"))]
6400#[rustfmt::skip]
6401unsafe impl crate::TypedVulkanStructure for VkImportFenceFdInfoKHR {
6402    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR;
6403}
6404
6405#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
6406#[derive(Debug, Clone)]
6407#[repr(C)]
6408#[rustfmt::skip]
6409pub struct VkImportFenceWin32HandleInfoKHR {
6410    pub sType: VkStructureType,
6411    pub pNext: *const core::ffi::c_void,
6412    pub fence: VkFence,
6413    pub flags: VkFenceImportFlagsKHR,
6414    pub handleType: VkExternalFenceHandleTypeFlagsKHR,
6415    pub handle: windows::Win32::Foundation::HANDLE,
6416    pub name: windows::core::PCWSTR,
6417}
6418#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
6419#[rustfmt::skip]
6420pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000114000;
6421#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
6422#[rustfmt::skip]
6423unsafe impl crate::VulkanStructure for VkImportFenceWin32HandleInfoKHR {
6424    #[inline(always)]
6425    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6426        unsafe { core::mem::transmute(self) }
6427    }
6428
6429    #[inline(always)]
6430    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6431        unsafe { core::mem::transmute(self) }
6432    }
6433}
6434#[cfg(all(feature = "VK_KHR_external_fence_win32"))]
6435#[rustfmt::skip]
6436unsafe impl crate::TypedVulkanStructure for VkImportFenceWin32HandleInfoKHR {
6437    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR;
6438}
6439
6440#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6441#[derive(Debug, Clone)]
6442#[repr(C)]
6443#[rustfmt::skip]
6444pub struct VkImportMemoryFdInfoKHR {
6445    pub sType: VkStructureType,
6446    pub pNext: *const core::ffi::c_void,
6447    pub handleType: VkExternalMemoryHandleTypeFlagsKHR,
6448    pub fd: core::ffi::c_int,
6449}
6450#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6451#[rustfmt::skip]
6452pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: VkStructureType = 1000074000;
6453#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6454#[rustfmt::skip]
6455unsafe impl crate::VulkanStructure for VkImportMemoryFdInfoKHR {
6456    #[inline(always)]
6457    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6458        unsafe { core::mem::transmute(self) }
6459    }
6460
6461    #[inline(always)]
6462    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6463        unsafe { core::mem::transmute(self) }
6464    }
6465}
6466#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6467#[rustfmt::skip]
6468unsafe impl crate::TypedVulkanStructure for VkImportMemoryFdInfoKHR {
6469    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR;
6470}
6471
6472#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6473#[derive(Debug, Clone)]
6474#[repr(C)]
6475#[rustfmt::skip]
6476pub struct VkImportMemoryWin32HandleInfoKHR {
6477    pub sType: VkStructureType,
6478    pub pNext: *const core::ffi::c_void,
6479    pub handleType: VkExternalMemoryHandleTypeFlagsKHR,
6480    pub handle: windows::Win32::Foundation::HANDLE,
6481    pub name: windows::core::PCWSTR,
6482}
6483#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6484#[rustfmt::skip]
6485pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000073000;
6486#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6487#[rustfmt::skip]
6488unsafe impl crate::VulkanStructure for VkImportMemoryWin32HandleInfoKHR {
6489    #[inline(always)]
6490    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6491        unsafe { core::mem::transmute(self) }
6492    }
6493
6494    #[inline(always)]
6495    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6496        unsafe { core::mem::transmute(self) }
6497    }
6498}
6499#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6500#[rustfmt::skip]
6501unsafe impl crate::TypedVulkanStructure for VkImportMemoryWin32HandleInfoKHR {
6502    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR;
6503}
6504
6505#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
6506#[derive(Debug, Clone)]
6507#[repr(C)]
6508#[rustfmt::skip]
6509pub struct VkImportSemaphoreFdInfoKHR {
6510    pub sType: VkStructureType,
6511    pub pNext: *const core::ffi::c_void,
6512    pub semaphore: VkSemaphore,
6513    pub flags: VkSemaphoreImportFlagsKHR,
6514    pub handleType: VkExternalSemaphoreHandleTypeFlagsKHR,
6515    pub fd: core::ffi::c_int,
6516}
6517#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
6518#[rustfmt::skip]
6519pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: VkStructureType = 1000079000;
6520#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
6521#[rustfmt::skip]
6522unsafe impl crate::VulkanStructure for VkImportSemaphoreFdInfoKHR {
6523    #[inline(always)]
6524    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6525        unsafe { core::mem::transmute(self) }
6526    }
6527
6528    #[inline(always)]
6529    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6530        unsafe { core::mem::transmute(self) }
6531    }
6532}
6533#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
6534#[rustfmt::skip]
6535unsafe impl crate::TypedVulkanStructure for VkImportSemaphoreFdInfoKHR {
6536    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR;
6537}
6538
6539#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
6540#[derive(Debug, Clone)]
6541#[repr(C)]
6542#[rustfmt::skip]
6543pub struct VkImportSemaphoreWin32HandleInfoKHR {
6544    pub sType: VkStructureType,
6545    pub pNext: *const core::ffi::c_void,
6546    pub semaphore: VkSemaphore,
6547    pub flags: VkSemaphoreImportFlagsKHR,
6548    pub handleType: VkExternalSemaphoreHandleTypeFlagsKHR,
6549    pub handle: windows::Win32::Foundation::HANDLE,
6550    pub name: windows::core::PCWSTR,
6551}
6552#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
6553#[rustfmt::skip]
6554pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000078000;
6555#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
6556#[rustfmt::skip]
6557unsafe impl crate::VulkanStructure for VkImportSemaphoreWin32HandleInfoKHR {
6558    #[inline(always)]
6559    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6560        unsafe { core::mem::transmute(self) }
6561    }
6562
6563    #[inline(always)]
6564    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6565        unsafe { core::mem::transmute(self) }
6566    }
6567}
6568#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
6569#[rustfmt::skip]
6570unsafe impl crate::TypedVulkanStructure for VkImportSemaphoreWin32HandleInfoKHR {
6571    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR;
6572}
6573
6574#[cfg(all(feature = "VK_KHR_maintenance2"))]
6575#[derive(Debug, Clone)]
6576#[repr(C)]
6577#[rustfmt::skip]
6578pub struct VkInputAttachmentAspectReferenceKHR {
6579    pub subpass: u32,
6580    pub inputAttachmentIndex: u32,
6581    pub aspectMask: VkImageAspectFlags,
6582}
6583#[cfg(feature = "Allow1_1APIs")]
6584#[rustfmt::skip]
6585pub type VkInputAttachmentAspectReference = VkInputAttachmentAspectReferenceKHR;
6586
6587#[derive(Debug, Clone)]
6588#[repr(C)]
6589#[rustfmt::skip]
6590pub struct VkInstanceCreateInfo {
6591    pub sType: VkStructureType,
6592    pub pNext: *const core::ffi::c_void,
6593    pub flags: VkInstanceCreateFlags,
6594    pub pApplicationInfo: *const VkApplicationInfo,
6595    pub enabledLayerCount: u32,
6596    pub ppEnabledLayerNames: *const *const core::ffi::c_char,
6597    pub enabledExtensionCount: u32,
6598    pub ppEnabledExtensionNames: *const *const core::ffi::c_char,
6599}
6600#[rustfmt::skip]
6601pub const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = 1;
6602#[rustfmt::skip]
6603unsafe impl crate::VulkanStructure for VkInstanceCreateInfo {
6604    #[inline(always)]
6605    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6606        unsafe { core::mem::transmute(self) }
6607    }
6608
6609    #[inline(always)]
6610    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6611        unsafe { core::mem::transmute(self) }
6612    }
6613}
6614#[rustfmt::skip]
6615unsafe impl crate::TypedVulkanStructure for VkInstanceCreateInfo {
6616    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
6617}
6618
6619#[derive(Debug, Clone)]
6620#[repr(C)]
6621#[rustfmt::skip]
6622pub struct VkLayerProperties {
6623    pub layerName: crate::ffi_helper::FixedCStrBuffer<VK_MAX_EXTENSION_NAME_SIZE>,
6624    pub specVersion: u32,
6625    pub implementationVersion: u32,
6626    pub description: crate::ffi_helper::FixedCStrBuffer<VK_MAX_DESCRIPTION_SIZE>,
6627}
6628
6629#[derive(Debug, Clone)]
6630#[repr(C)]
6631#[rustfmt::skip]
6632pub struct VkMappedMemoryRange {
6633    pub sType: VkStructureType,
6634    pub pNext: *const core::ffi::c_void,
6635    pub memory: VkDeviceMemory,
6636    pub offset: VkDeviceSize,
6637    pub size: VkDeviceSize,
6638}
6639#[rustfmt::skip]
6640pub const VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = 6;
6641#[rustfmt::skip]
6642unsafe impl crate::VulkanStructure for VkMappedMemoryRange {
6643    #[inline(always)]
6644    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6645        unsafe { core::mem::transmute(self) }
6646    }
6647
6648    #[inline(always)]
6649    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6650        unsafe { core::mem::transmute(self) }
6651    }
6652}
6653#[rustfmt::skip]
6654unsafe impl crate::TypedVulkanStructure for VkMappedMemoryRange {
6655    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE;
6656}
6657
6658#[cfg(all(feature = "VK_KHR_device_group"))]
6659#[derive(Debug, Clone)]
6660#[repr(C)]
6661#[rustfmt::skip]
6662pub struct VkMemoryAllocateFlagsInfoKHR {
6663    pub sType: VkStructureType,
6664    pub pNext: *const core::ffi::c_void,
6665    pub flags: VkMemoryAllocateFlags,
6666    pub deviceMask: u32,
6667}
6668#[cfg(all(feature = "VK_KHR_device_group"))]
6669#[rustfmt::skip]
6670pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR: VkStructureType = 1000060000;
6671#[cfg(all(feature = "VK_KHR_device_group"))]
6672#[rustfmt::skip]
6673unsafe impl crate::VulkanStructure for VkMemoryAllocateFlagsInfoKHR {
6674    #[inline(always)]
6675    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6676        unsafe { core::mem::transmute(self) }
6677    }
6678
6679    #[inline(always)]
6680    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6681        unsafe { core::mem::transmute(self) }
6682    }
6683}
6684#[cfg(all(feature = "VK_KHR_device_group"))]
6685#[rustfmt::skip]
6686unsafe impl crate::TypedVulkanStructure for VkMemoryAllocateFlagsInfoKHR {
6687    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR;
6688}
6689#[cfg(feature = "Allow1_1APIs")]
6690#[rustfmt::skip]
6691pub type VkMemoryAllocateFlagsInfo = VkMemoryAllocateFlagsInfoKHR;
6692#[cfg(feature = "Allow1_1APIs")]
6693#[rustfmt::skip]
6694pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR;
6695
6696#[derive(Debug, Clone)]
6697#[repr(C)]
6698#[rustfmt::skip]
6699pub struct VkMemoryAllocateInfo {
6700    pub sType: VkStructureType,
6701    pub pNext: *const core::ffi::c_void,
6702    pub allocationSize: VkDeviceSize,
6703    pub memoryTypeIndex: u32,
6704}
6705#[rustfmt::skip]
6706pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = 5;
6707#[rustfmt::skip]
6708unsafe impl crate::VulkanStructure for VkMemoryAllocateInfo {
6709    #[inline(always)]
6710    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6711        unsafe { core::mem::transmute(self) }
6712    }
6713
6714    #[inline(always)]
6715    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6716        unsafe { core::mem::transmute(self) }
6717    }
6718}
6719#[rustfmt::skip]
6720unsafe impl crate::TypedVulkanStructure for VkMemoryAllocateInfo {
6721    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
6722}
6723
6724#[derive(Debug, Clone)]
6725#[repr(C)]
6726#[rustfmt::skip]
6727pub struct VkMemoryBarrier {
6728    pub sType: VkStructureType,
6729    pub pNext: *const core::ffi::c_void,
6730    pub srcAccessMask: VkAccessFlags,
6731    pub dstAccessMask: VkAccessFlags,
6732}
6733#[rustfmt::skip]
6734pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = 46;
6735#[rustfmt::skip]
6736unsafe impl crate::VulkanStructure for VkMemoryBarrier {
6737    #[inline(always)]
6738    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6739        unsafe { core::mem::transmute(self) }
6740    }
6741
6742    #[inline(always)]
6743    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6744        unsafe { core::mem::transmute(self) }
6745    }
6746}
6747#[rustfmt::skip]
6748unsafe impl crate::TypedVulkanStructure for VkMemoryBarrier {
6749    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER;
6750}
6751
6752#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6753#[derive(Debug, Clone)]
6754#[repr(C)]
6755#[rustfmt::skip]
6756pub struct VkMemoryDedicatedAllocateInfoKHR {
6757    pub sType: VkStructureType,
6758    pub pNext: *const core::ffi::c_void,
6759    pub image: VkImage,
6760    pub buffer: VkBuffer,
6761}
6762#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6763#[rustfmt::skip]
6764pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: VkStructureType = 1000127001;
6765#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6766#[rustfmt::skip]
6767unsafe impl crate::VulkanStructure for VkMemoryDedicatedAllocateInfoKHR {
6768    #[inline(always)]
6769    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6770        unsafe { core::mem::transmute(self) }
6771    }
6772
6773    #[inline(always)]
6774    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6775        unsafe { core::mem::transmute(self) }
6776    }
6777}
6778#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6779#[rustfmt::skip]
6780unsafe impl crate::TypedVulkanStructure for VkMemoryDedicatedAllocateInfoKHR {
6781    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR;
6782}
6783#[cfg(feature = "Allow1_1APIs")]
6784#[rustfmt::skip]
6785pub type VkMemoryDedicatedAllocateInfo = VkMemoryDedicatedAllocateInfoKHR;
6786#[cfg(feature = "Allow1_1APIs")]
6787#[rustfmt::skip]
6788pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR;
6789
6790#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6791#[derive(Debug, Clone)]
6792#[repr(C)]
6793#[rustfmt::skip]
6794pub struct VkMemoryDedicatedRequirementsKHR {
6795    pub sType: VkStructureType,
6796    pub pNext: *mut core::ffi::c_void,
6797    pub prefersDedicatedAllocation: VkBool32,
6798    pub requiresDedicatedAllocation: VkBool32,
6799}
6800#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6801#[rustfmt::skip]
6802pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: VkStructureType = 1000127000;
6803#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6804#[rustfmt::skip]
6805unsafe impl crate::VulkanSinkStructure for VkMemoryDedicatedRequirementsKHR {
6806    #[inline(always)]
6807    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
6808        unsafe { core::mem::transmute(self) }
6809    }
6810
6811    #[inline(always)]
6812    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
6813        unsafe { core::mem::transmute(self) }
6814    }
6815}
6816#[cfg(all(feature = "VK_KHR_dedicated_allocation"))]
6817#[rustfmt::skip]
6818unsafe impl crate::TypedVulkanSinkStructure for VkMemoryDedicatedRequirementsKHR {
6819    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR;
6820}
6821#[cfg(feature = "Allow1_1APIs")]
6822#[rustfmt::skip]
6823pub type VkMemoryDedicatedRequirements = VkMemoryDedicatedRequirementsKHR;
6824#[cfg(feature = "Allow1_1APIs")]
6825#[rustfmt::skip]
6826pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR;
6827
6828#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6829#[derive(Debug, Clone)]
6830#[repr(C)]
6831#[rustfmt::skip]
6832pub struct VkMemoryFdPropertiesKHR {
6833    pub sType: VkStructureType,
6834    pub pNext: *mut core::ffi::c_void,
6835    pub memoryTypeBits: u32,
6836}
6837#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6838#[rustfmt::skip]
6839pub const VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: VkStructureType = 1000074001;
6840#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6841#[rustfmt::skip]
6842unsafe impl crate::VulkanSinkStructure for VkMemoryFdPropertiesKHR {
6843    #[inline(always)]
6844    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
6845        unsafe { core::mem::transmute(self) }
6846    }
6847
6848    #[inline(always)]
6849    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
6850        unsafe { core::mem::transmute(self) }
6851    }
6852}
6853#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6854#[rustfmt::skip]
6855unsafe impl crate::TypedVulkanSinkStructure for VkMemoryFdPropertiesKHR {
6856    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR;
6857}
6858
6859#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6860#[derive(Debug, Clone)]
6861#[repr(C)]
6862#[rustfmt::skip]
6863pub struct VkMemoryGetFdInfoKHR {
6864    pub sType: VkStructureType,
6865    pub pNext: *const core::ffi::c_void,
6866    pub memory: VkDeviceMemory,
6867    pub handleType: VkExternalMemoryHandleTypeFlagsKHR,
6868}
6869#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6870#[rustfmt::skip]
6871pub const VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = 1000074002;
6872#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6873#[rustfmt::skip]
6874unsafe impl crate::VulkanStructure for VkMemoryGetFdInfoKHR {
6875    #[inline(always)]
6876    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6877        unsafe { core::mem::transmute(self) }
6878    }
6879
6880    #[inline(always)]
6881    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6882        unsafe { core::mem::transmute(self) }
6883    }
6884}
6885#[cfg(all(feature = "VK_KHR_external_memory_fd"))]
6886#[rustfmt::skip]
6887unsafe impl crate::TypedVulkanStructure for VkMemoryGetFdInfoKHR {
6888    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR;
6889}
6890
6891#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6892#[derive(Debug, Clone)]
6893#[repr(C)]
6894#[rustfmt::skip]
6895pub struct VkMemoryGetWin32HandleInfoKHR {
6896    pub sType: VkStructureType,
6897    pub pNext: *const core::ffi::c_void,
6898    pub memory: VkDeviceMemory,
6899    pub handleType: VkExternalMemoryHandleTypeFlagsKHR,
6900}
6901#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6902#[rustfmt::skip]
6903pub const VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000073003;
6904#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6905#[rustfmt::skip]
6906unsafe impl crate::VulkanStructure for VkMemoryGetWin32HandleInfoKHR {
6907    #[inline(always)]
6908    fn as_generic(&self) -> &crate::GenericVulkanStructure {
6909        unsafe { core::mem::transmute(self) }
6910    }
6911
6912    #[inline(always)]
6913    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
6914        unsafe { core::mem::transmute(self) }
6915    }
6916}
6917#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6918#[rustfmt::skip]
6919unsafe impl crate::TypedVulkanStructure for VkMemoryGetWin32HandleInfoKHR {
6920    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR;
6921}
6922
6923#[derive(Debug, Clone)]
6924#[repr(C)]
6925#[rustfmt::skip]
6926pub struct VkMemoryRequirements {
6927    pub size: VkDeviceSize,
6928    pub alignment: VkDeviceSize,
6929    pub memoryTypeBits: u32,
6930}
6931
6932#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6933#[derive(Debug, Clone)]
6934#[repr(C)]
6935#[rustfmt::skip]
6936pub struct VkMemoryRequirements2KHR {
6937    pub sType: VkStructureType,
6938    pub pNext: *mut core::ffi::c_void,
6939    pub memoryRequirements: VkMemoryRequirements,
6940}
6941#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6942#[rustfmt::skip]
6943pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = 1000146003;
6944#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6945#[rustfmt::skip]
6946unsafe impl crate::VulkanSinkStructure for VkMemoryRequirements2KHR {
6947    #[inline(always)]
6948    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
6949        unsafe { core::mem::transmute(self) }
6950    }
6951
6952    #[inline(always)]
6953    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
6954        unsafe { core::mem::transmute(self) }
6955    }
6956}
6957#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
6958#[rustfmt::skip]
6959unsafe impl crate::TypedVulkanSinkStructure for VkMemoryRequirements2KHR {
6960    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR;
6961}
6962#[cfg(feature = "Allow1_1APIs")]
6963#[rustfmt::skip]
6964pub type VkMemoryRequirements2 = VkMemoryRequirements2KHR;
6965#[cfg(feature = "Allow1_1APIs")]
6966#[rustfmt::skip]
6967pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR;
6968
6969#[derive(Debug, Clone)]
6970#[repr(C)]
6971#[rustfmt::skip]
6972pub struct VkMemoryType {
6973    pub propertyFlags: VkMemoryPropertyFlags,
6974    pub heapIndex: u32,
6975}
6976
6977#[derive(Debug, Clone)]
6978#[repr(C)]
6979#[rustfmt::skip]
6980pub struct VkMemoryHeap {
6981    pub size: VkDeviceSize,
6982    pub flags: VkMemoryHeapFlags,
6983}
6984
6985#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6986#[derive(Debug, Clone)]
6987#[repr(C)]
6988#[rustfmt::skip]
6989pub struct VkMemoryWin32HandlePropertiesKHR {
6990    pub sType: VkStructureType,
6991    pub pNext: *mut core::ffi::c_void,
6992    pub memoryTypeBits: u32,
6993}
6994#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6995#[rustfmt::skip]
6996pub const VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: VkStructureType = 1000073002;
6997#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
6998#[rustfmt::skip]
6999unsafe impl crate::VulkanSinkStructure for VkMemoryWin32HandlePropertiesKHR {
7000    #[inline(always)]
7001    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7002        unsafe { core::mem::transmute(self) }
7003    }
7004
7005    #[inline(always)]
7006    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7007        unsafe { core::mem::transmute(self) }
7008    }
7009}
7010#[cfg(all(feature = "VK_KHR_external_memory_win32"))]
7011#[rustfmt::skip]
7012unsafe impl crate::TypedVulkanSinkStructure for VkMemoryWin32HandlePropertiesKHR {
7013    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR;
7014}
7015
7016#[cfg(all(feature = "VK_EXT_metal_surface"))]
7017#[derive(Debug, Clone)]
7018#[repr(C)]
7019#[rustfmt::skip]
7020pub struct VkMetalSurfaceCreateInfoEXT {
7021    pub sType: VkStructureType,
7022    pub pNext: *const core::ffi::c_void,
7023    pub flags: VkMetalSurfaceCreateFlagsEXT,
7024    pub pLayer: *const core::ffi::c_void,
7025}
7026#[cfg(all(feature = "VK_EXT_metal_surface"))]
7027#[rustfmt::skip]
7028pub const VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: VkStructureType = 1000217000;
7029#[cfg(all(feature = "VK_EXT_metal_surface"))]
7030#[rustfmt::skip]
7031unsafe impl crate::VulkanStructure for VkMetalSurfaceCreateInfoEXT {
7032    #[inline(always)]
7033    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7034        unsafe { core::mem::transmute(self) }
7035    }
7036
7037    #[inline(always)]
7038    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7039        unsafe { core::mem::transmute(self) }
7040    }
7041}
7042#[cfg(all(feature = "VK_EXT_metal_surface"))]
7043#[rustfmt::skip]
7044unsafe impl crate::TypedVulkanStructure for VkMetalSurfaceCreateInfoEXT {
7045    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT;
7046}
7047
7048#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
7049#[repr(C)]
7050#[rustfmt::skip]
7051pub struct VkOffset2D {
7052    pub x: i32,
7053    pub y: i32,
7054}
7055
7056#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
7057#[repr(C)]
7058#[rustfmt::skip]
7059pub struct VkOffset3D {
7060    pub x: i32,
7061    pub y: i32,
7062    pub z: i32,
7063}
7064
7065#[cfg(all(feature = "VK_KHR_16bit_storage"))]
7066#[derive(Debug, Clone)]
7067#[repr(C)]
7068#[rustfmt::skip]
7069pub struct VkPhysicalDevice16BitStorageFeaturesKHR {
7070    pub sType: VkStructureType,
7071    pub pNext: *mut core::ffi::c_void,
7072    pub storageBuffer16BitAccess: VkBool32,
7073    pub uniformAndStorageBuffer16BitAccess: VkBool32,
7074    pub storagePushConstant16: VkBool32,
7075    pub storageInputOutput16: VkBool32,
7076}
7077#[cfg(all(feature = "VK_KHR_16bit_storage"))]
7078#[rustfmt::skip]
7079pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: VkStructureType = 1000083000;
7080#[cfg(all(feature = "VK_KHR_16bit_storage"))]
7081#[rustfmt::skip]
7082unsafe impl crate::VulkanStructure for VkPhysicalDevice16BitStorageFeaturesKHR {
7083    #[inline(always)]
7084    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7085        unsafe { core::mem::transmute(self) }
7086    }
7087
7088    #[inline(always)]
7089    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7090        unsafe { core::mem::transmute(self) }
7091    }
7092}
7093#[cfg(all(feature = "VK_KHR_16bit_storage"))]
7094#[rustfmt::skip]
7095unsafe impl crate::TypedVulkanStructure for VkPhysicalDevice16BitStorageFeaturesKHR {
7096    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR;
7097}
7098#[cfg(all(feature = "VK_KHR_16bit_storage"))]
7099#[rustfmt::skip]
7100unsafe impl crate::VulkanSinkStructure for VkPhysicalDevice16BitStorageFeaturesKHR {
7101    #[inline(always)]
7102    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7103        unsafe { core::mem::transmute(self) }
7104    }
7105
7106    #[inline(always)]
7107    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7108        unsafe { core::mem::transmute(self) }
7109    }
7110}
7111#[cfg(all(feature = "VK_KHR_16bit_storage"))]
7112#[rustfmt::skip]
7113unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDevice16BitStorageFeaturesKHR {
7114    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR;
7115}
7116#[cfg(feature = "Allow1_1APIs")]
7117#[rustfmt::skip]
7118pub type VkPhysicalDevice16BitStorageFeatures = VkPhysicalDevice16BitStorageFeaturesKHR;
7119#[cfg(feature = "Allow1_1APIs")]
7120#[rustfmt::skip]
7121pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR;
7122
7123#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7124#[derive(Debug, Clone)]
7125#[repr(C)]
7126#[rustfmt::skip]
7127pub struct VkPhysicalDeviceExternalBufferInfoKHR {
7128    pub sType: VkStructureType,
7129    pub pNext: *const core::ffi::c_void,
7130    pub flags: VkBufferCreateFlags,
7131    pub usage: VkBufferUsageFlags,
7132    pub handleType: VkExternalMemoryHandleTypeFlagsKHR,
7133}
7134#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7135#[rustfmt::skip]
7136pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: VkStructureType = 1000071002;
7137#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7138#[rustfmt::skip]
7139unsafe impl crate::VulkanStructure for VkPhysicalDeviceExternalBufferInfoKHR {
7140    #[inline(always)]
7141    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7142        unsafe { core::mem::transmute(self) }
7143    }
7144
7145    #[inline(always)]
7146    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7147        unsafe { core::mem::transmute(self) }
7148    }
7149}
7150#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7151#[rustfmt::skip]
7152unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceExternalBufferInfoKHR {
7153    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR;
7154}
7155#[cfg(feature = "Allow1_1APIs")]
7156#[rustfmt::skip]
7157pub type VkPhysicalDeviceExternalBufferInfo = VkPhysicalDeviceExternalBufferInfoKHR;
7158#[cfg(feature = "Allow1_1APIs")]
7159#[rustfmt::skip]
7160pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR;
7161
7162#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
7163#[derive(Debug, Clone)]
7164#[repr(C)]
7165#[rustfmt::skip]
7166pub struct VkPhysicalDeviceExternalFenceInfoKHR {
7167    pub sType: VkStructureType,
7168    pub pNext: *const core::ffi::c_void,
7169    pub handleType: VkExternalFenceHandleTypeFlagsKHR,
7170}
7171#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
7172#[rustfmt::skip]
7173pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: VkStructureType = 1000112000;
7174#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
7175#[rustfmt::skip]
7176unsafe impl crate::VulkanStructure for VkPhysicalDeviceExternalFenceInfoKHR {
7177    #[inline(always)]
7178    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7179        unsafe { core::mem::transmute(self) }
7180    }
7181
7182    #[inline(always)]
7183    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7184        unsafe { core::mem::transmute(self) }
7185    }
7186}
7187#[cfg(all(feature = "VK_KHR_external_fence_capabilities"))]
7188#[rustfmt::skip]
7189unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceExternalFenceInfoKHR {
7190    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR;
7191}
7192#[cfg(feature = "Allow1_1APIs")]
7193#[rustfmt::skip]
7194pub type VkPhysicalDeviceExternalFenceInfo = VkPhysicalDeviceExternalFenceInfoKHR;
7195#[cfg(feature = "Allow1_1APIs")]
7196#[rustfmt::skip]
7197pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR;
7198
7199#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7200#[derive(Debug, Clone)]
7201#[repr(C)]
7202#[rustfmt::skip]
7203pub struct VkPhysicalDeviceExternalImageFormatInfoKHR {
7204    pub sType: VkStructureType,
7205    pub pNext: *const core::ffi::c_void,
7206    pub handleType: VkExternalMemoryHandleTypeFlagsKHR,
7207}
7208#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7209#[rustfmt::skip]
7210pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: VkStructureType = 1000071000;
7211#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7212#[rustfmt::skip]
7213unsafe impl crate::VulkanStructure for VkPhysicalDeviceExternalImageFormatInfoKHR {
7214    #[inline(always)]
7215    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7216        unsafe { core::mem::transmute(self) }
7217    }
7218
7219    #[inline(always)]
7220    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7221        unsafe { core::mem::transmute(self) }
7222    }
7223}
7224#[cfg(all(feature = "VK_KHR_external_memory_capabilities"))]
7225#[rustfmt::skip]
7226unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceExternalImageFormatInfoKHR {
7227    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR;
7228}
7229#[cfg(feature = "Allow1_1APIs")]
7230#[rustfmt::skip]
7231pub type VkPhysicalDeviceExternalImageFormatInfo = VkPhysicalDeviceExternalImageFormatInfoKHR;
7232#[cfg(feature = "Allow1_1APIs")]
7233#[rustfmt::skip]
7234pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR;
7235
7236#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
7237#[derive(Debug, Clone)]
7238#[repr(C)]
7239#[rustfmt::skip]
7240pub struct VkPhysicalDeviceExternalSemaphoreInfoKHR {
7241    pub sType: VkStructureType,
7242    pub pNext: *const core::ffi::c_void,
7243    pub handleType: VkExternalSemaphoreHandleTypeFlagsKHR,
7244}
7245#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
7246#[rustfmt::skip]
7247pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: VkStructureType = 1000076000;
7248#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
7249#[rustfmt::skip]
7250unsafe impl crate::VulkanStructure for VkPhysicalDeviceExternalSemaphoreInfoKHR {
7251    #[inline(always)]
7252    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7253        unsafe { core::mem::transmute(self) }
7254    }
7255
7256    #[inline(always)]
7257    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7258        unsafe { core::mem::transmute(self) }
7259    }
7260}
7261#[cfg(all(feature = "VK_KHR_external_semaphore_capabilities"))]
7262#[rustfmt::skip]
7263unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceExternalSemaphoreInfoKHR {
7264    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR;
7265}
7266#[cfg(feature = "Allow1_1APIs")]
7267#[rustfmt::skip]
7268pub type VkPhysicalDeviceExternalSemaphoreInfo = VkPhysicalDeviceExternalSemaphoreInfoKHR;
7269#[cfg(feature = "Allow1_1APIs")]
7270#[rustfmt::skip]
7271pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR;
7272
7273#[derive(Debug, Clone)]
7274#[repr(C)]
7275#[rustfmt::skip]
7276pub struct VkPhysicalDeviceFeatures {
7277    pub robustBufferAccess: VkBool32,
7278    pub fullDrawIndexUint32: VkBool32,
7279    pub imageCubeArray: VkBool32,
7280    pub independentBlend: VkBool32,
7281    pub geometryShader: VkBool32,
7282    pub tessellationShader: VkBool32,
7283    pub sampleRateShading: VkBool32,
7284    pub dualSrcBlend: VkBool32,
7285    pub logicOp: VkBool32,
7286    pub multiDrawIndirect: VkBool32,
7287    pub drawIndirectFirstInstance: VkBool32,
7288    pub depthClamp: VkBool32,
7289    pub depthBiasClamp: VkBool32,
7290    pub fillModeNonSolid: VkBool32,
7291    pub depthBounds: VkBool32,
7292    pub wideLines: VkBool32,
7293    pub largePoints: VkBool32,
7294    pub alphaToOne: VkBool32,
7295    pub multiViewport: VkBool32,
7296    pub samplerAnisotropy: VkBool32,
7297    pub textureCompressionETC2: VkBool32,
7298    pub textureCompressionASTC_LDR: VkBool32,
7299    pub textureCompressionBC: VkBool32,
7300    pub occlusionQueryPrecise: VkBool32,
7301    pub pipelineStatisticsQuery: VkBool32,
7302    pub vertexPipelineStoresAndAtomics: VkBool32,
7303    pub fragmentStoresAndAtomics: VkBool32,
7304    pub shaderTessellationAndGeometryPointSize: VkBool32,
7305    pub shaderImageGatherExtended: VkBool32,
7306    pub shaderStorageImageExtendedFormats: VkBool32,
7307    pub shaderStorageImageMultisample: VkBool32,
7308    pub shaderStorageImageReadWithoutFormat: VkBool32,
7309    pub shaderStorageImageWriteWithoutFormat: VkBool32,
7310    pub shaderUniformBufferArrayDynamicIndexing: VkBool32,
7311    pub shaderSampledImageArrayDynamicIndexing: VkBool32,
7312    pub shaderStorageBufferArrayDynamicIndexing: VkBool32,
7313    pub shaderStorageImageArrayDynamicIndexing: VkBool32,
7314    pub shaderClipDistance: VkBool32,
7315    pub shaderCullDistance: VkBool32,
7316    pub shaderFloat64: VkBool32,
7317    pub shaderInt64: VkBool32,
7318    pub shaderInt16: VkBool32,
7319    pub shaderResourceResidency: VkBool32,
7320    pub shaderResourceMinLod: VkBool32,
7321    pub sparseBinding: VkBool32,
7322    pub sparseResidencyBuffer: VkBool32,
7323    pub sparseResidencyImage2D: VkBool32,
7324    pub sparseResidencyImage3D: VkBool32,
7325    pub sparseResidency2Samples: VkBool32,
7326    pub sparseResidency4Samples: VkBool32,
7327    pub sparseResidency8Samples: VkBool32,
7328    pub sparseResidency16Samples: VkBool32,
7329    pub sparseResidencyAliased: VkBool32,
7330    pub variableMultisampleRate: VkBool32,
7331    pub inheritedQueries: VkBool32,
7332}
7333
7334#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7335#[derive(Debug, Clone)]
7336#[repr(C)]
7337#[rustfmt::skip]
7338pub struct VkPhysicalDeviceFeatures2KHR {
7339    pub sType: VkStructureType,
7340    pub pNext: *mut core::ffi::c_void,
7341    pub features: VkPhysicalDeviceFeatures,
7342}
7343#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7344#[rustfmt::skip]
7345pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: VkStructureType = 1000059000;
7346#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7347#[rustfmt::skip]
7348unsafe impl crate::VulkanStructure for VkPhysicalDeviceFeatures2KHR {
7349    #[inline(always)]
7350    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7351        unsafe { core::mem::transmute(self) }
7352    }
7353
7354    #[inline(always)]
7355    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7356        unsafe { core::mem::transmute(self) }
7357    }
7358}
7359#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7360#[rustfmt::skip]
7361unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceFeatures2KHR {
7362    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
7363}
7364#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7365#[rustfmt::skip]
7366unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceFeatures2KHR {
7367    #[inline(always)]
7368    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7369        unsafe { core::mem::transmute(self) }
7370    }
7371
7372    #[inline(always)]
7373    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7374        unsafe { core::mem::transmute(self) }
7375    }
7376}
7377#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7378#[rustfmt::skip]
7379unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceFeatures2KHR {
7380    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
7381}
7382#[cfg(feature = "Allow1_1APIs")]
7383#[rustfmt::skip]
7384pub type VkPhysicalDeviceFeatures2 = VkPhysicalDeviceFeatures2KHR;
7385#[cfg(feature = "Allow1_1APIs")]
7386#[rustfmt::skip]
7387pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
7388
7389#[cfg(all(feature = "VK_KHR_device_group_creation"))]
7390#[derive(Debug, Clone)]
7391#[repr(C)]
7392#[rustfmt::skip]
7393pub struct VkPhysicalDeviceGroupPropertiesKHR {
7394    pub sType: VkStructureType,
7395    pub pNext: *mut core::ffi::c_void,
7396    pub physicalDeviceCount: u32,
7397    pub physicalDevices: [VkPhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE_KHR],
7398    pub subsetAllocation: VkBool32,
7399}
7400#[cfg(all(feature = "VK_KHR_device_group_creation"))]
7401#[rustfmt::skip]
7402pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: VkStructureType = 1000070000;
7403#[cfg(all(feature = "VK_KHR_device_group_creation"))]
7404#[rustfmt::skip]
7405unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceGroupPropertiesKHR {
7406    #[inline(always)]
7407    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7408        unsafe { core::mem::transmute(self) }
7409    }
7410
7411    #[inline(always)]
7412    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7413        unsafe { core::mem::transmute(self) }
7414    }
7415}
7416#[cfg(all(feature = "VK_KHR_device_group_creation"))]
7417#[rustfmt::skip]
7418unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceGroupPropertiesKHR {
7419    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR;
7420}
7421#[cfg(feature = "Allow1_1APIs")]
7422#[rustfmt::skip]
7423pub type VkPhysicalDeviceGroupProperties = VkPhysicalDeviceGroupPropertiesKHR;
7424#[cfg(feature = "Allow1_1APIs")]
7425#[rustfmt::skip]
7426pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR;
7427
7428#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7429#[derive(Debug, Clone)]
7430#[repr(C)]
7431#[rustfmt::skip]
7432pub struct VkPhysicalDeviceImageFormatInfo2KHR {
7433    pub sType: VkStructureType,
7434    pub pNext: *const core::ffi::c_void,
7435    pub format: VkFormat,
7436    pub r#type: VkImageType,
7437    pub tiling: VkImageTiling,
7438    pub usage: VkImageUsageFlags,
7439    pub flags: VkImageCreateFlags,
7440}
7441#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7442#[rustfmt::skip]
7443pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = 1000059004;
7444#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7445#[rustfmt::skip]
7446unsafe impl crate::VulkanStructure for VkPhysicalDeviceImageFormatInfo2KHR {
7447    #[inline(always)]
7448    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7449        unsafe { core::mem::transmute(self) }
7450    }
7451
7452    #[inline(always)]
7453    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7454        unsafe { core::mem::transmute(self) }
7455    }
7456}
7457#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7458#[rustfmt::skip]
7459unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceImageFormatInfo2KHR {
7460    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR;
7461}
7462#[cfg(feature = "Allow1_1APIs")]
7463#[rustfmt::skip]
7464pub type VkPhysicalDeviceImageFormatInfo2 = VkPhysicalDeviceImageFormatInfo2KHR;
7465#[cfg(feature = "Allow1_1APIs")]
7466#[rustfmt::skip]
7467pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR;
7468
7469#[derive(Debug, Clone)]
7470#[repr(C)]
7471#[rustfmt::skip]
7472pub struct VkPhysicalDeviceLimits {
7473    pub maxImageDimension1D: u32,
7474    pub maxImageDimension2D: u32,
7475    pub maxImageDimension3D: u32,
7476    pub maxImageDimensionCube: u32,
7477    pub maxImageArrayLayers: u32,
7478    pub maxTexelBufferElements: u32,
7479    pub maxUniformBufferRange: u32,
7480    pub maxStorageBufferRange: u32,
7481    pub maxPushConstantsSize: u32,
7482    pub maxMemoryAllocationCount: u32,
7483    pub maxSamplerAllocationCount: u32,
7484    pub bufferImageGranularity: VkDeviceSize,
7485    pub sparseAddressSpaceSize: VkDeviceSize,
7486    pub maxBoundDescriptorSets: u32,
7487    pub maxPerStageDescriptorSamplers: u32,
7488    pub maxPerStageDescriptorUniformBuffers: u32,
7489    pub maxPerStageDescriptorStorageBuffers: u32,
7490    pub maxPerStageDescriptorSampledImages: u32,
7491    pub maxPerStageDescriptorStorageImages: u32,
7492    pub maxPerStageDescriptorInputAttachments: u32,
7493    pub maxPerStageResources: u32,
7494    pub maxDescriptorSetSamplers: u32,
7495    pub maxDescriptorSetUniformBuffers: u32,
7496    pub maxDescriptorSetUniformBuffersDynamic: u32,
7497    pub maxDescriptorSetStorageBuffers: u32,
7498    pub maxDescriptorSetStorageBuffersDynamic: u32,
7499    pub maxDescriptorSetSampledImages: u32,
7500    pub maxDescriptorSetStorageImages: u32,
7501    pub maxDescriptorSetInputAttachments: u32,
7502    pub maxVertexInputAttributes: u32,
7503    pub maxVertexInputBindings: u32,
7504    pub maxVertexInputAttributeOffset: u32,
7505    pub maxVertexInputBindingStride: u32,
7506    pub maxVertexOutputComponents: u32,
7507    pub maxTessellationGenerationLevel: u32,
7508    pub maxTessellationPatchSize: u32,
7509    pub maxTessellationControlPerVertexInputComponents: u32,
7510    pub maxTessellationControlPerVertexOutputComponents: u32,
7511    pub maxTessellationControlPerPatchOutputComponents: u32,
7512    pub maxTessellationControlTotalOutputComponents: u32,
7513    pub maxTessellationEvaluationInputComponents: u32,
7514    pub maxTessellationEvaluationOutputComponents: u32,
7515    pub maxGeometryShaderInvocations: u32,
7516    pub maxGeometryInputComponents: u32,
7517    pub maxGeometryOutputComponents: u32,
7518    pub maxGeometryOutputVertices: u32,
7519    pub maxGeometryTotalOutputComponents: u32,
7520    pub maxFragmentInputComponents: u32,
7521    pub maxFragmentOutputAttachments: u32,
7522    pub maxFragmentDualSrcAttachments: u32,
7523    pub maxFragmentCombinedOutputResources: u32,
7524    pub maxComputeSharedMemorySize: u32,
7525    pub maxComputeWorkGroupCount: [u32; 3],
7526    pub maxComputeWorkGroupInvocations: u32,
7527    pub maxComputeWorkGroupSize: [u32; 3],
7528    pub subPixelPrecisionBits: u32,
7529    pub subTexelPrecisionBits: u32,
7530    pub mipmapPrecisionBits: u32,
7531    pub maxDrawIndexedIndexValue: u32,
7532    pub maxDrawIndirectCount: u32,
7533    pub maxSamplerLodBias: core::ffi::c_float,
7534    pub maxSamplerAnisotropy: core::ffi::c_float,
7535    pub maxViewports: u32,
7536    pub maxViewportDimensions: [u32; 2],
7537    pub viewportBoundsRange: [core::ffi::c_float; 2],
7538    pub viewportSubPixelBits: u32,
7539    pub minMemoryMapAlignment: usize,
7540    pub minTexelBufferOffsetAlignment: VkDeviceSize,
7541    pub minUniformBufferOffsetAlignment: VkDeviceSize,
7542    pub minStorageBufferOffsetAlignment: VkDeviceSize,
7543    pub minTexelOffset: i32,
7544    pub maxTexelOffset: u32,
7545    pub minTexelGatherOffset: i32,
7546    pub maxTexelGatherOffset: u32,
7547    pub minInterpolationOffset: core::ffi::c_float,
7548    pub maxInterpolationOffset: core::ffi::c_float,
7549    pub subPixelInterpolationOffsetBits: u32,
7550    pub maxFramebufferWidth: u32,
7551    pub maxFramebufferHeight: u32,
7552    pub maxFramebufferLayers: u32,
7553    pub framebufferColorSampleCounts: VkSampleCountFlags,
7554    pub framebufferDepthSampleCounts: VkSampleCountFlags,
7555    pub framebufferStencilSampleCounts: VkSampleCountFlags,
7556    pub framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
7557    pub maxColorAttachments: u32,
7558    pub sampledImageColorSampleCounts: VkSampleCountFlags,
7559    pub sampledImageIntegerSampleCounts: VkSampleCountFlags,
7560    pub sampledImageDepthSampleCounts: VkSampleCountFlags,
7561    pub sampledImageStencilSampleCounts: VkSampleCountFlags,
7562    pub storageImageSampleCounts: VkSampleCountFlags,
7563    pub maxSampleMaskWords: u32,
7564    pub timestampComputeAndGraphics: VkBool32,
7565    pub timestampPeriod: core::ffi::c_float,
7566    pub maxClipDistances: u32,
7567    pub maxCullDistances: u32,
7568    pub maxCombinedClipAndCullDistances: u32,
7569    pub discreteQueuePriorities: u32,
7570    pub pointSizeRange: [core::ffi::c_float; 2],
7571    pub lineWidthRange: [core::ffi::c_float; 2],
7572    pub pointSizeGranularity: core::ffi::c_float,
7573    pub lineWidthGranularity: core::ffi::c_float,
7574    pub strictLines: VkBool32,
7575    pub standardSampleLocations: VkBool32,
7576    pub optimalBufferCopyOffsetAlignment: VkDeviceSize,
7577    pub optimalBufferCopyRowPitchAlignment: VkDeviceSize,
7578    pub nonCoherentAtomSize: VkDeviceSize,
7579}
7580
7581#[cfg(all(feature = "VK_KHR_maintenance3"))]
7582#[derive(Debug, Clone)]
7583#[repr(C)]
7584#[rustfmt::skip]
7585pub struct VkPhysicalDeviceMaintenance3PropertiesKHR {
7586    pub sType: VkStructureType,
7587    pub pNext: *mut core::ffi::c_void,
7588    pub maxPerSetDescriptors: u32,
7589    pub maxMemoryAllocationSize: VkDeviceSize,
7590}
7591#[cfg(all(feature = "VK_KHR_maintenance3"))]
7592#[rustfmt::skip]
7593pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: VkStructureType = 1000168000;
7594#[cfg(all(feature = "VK_KHR_maintenance3"))]
7595#[rustfmt::skip]
7596unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceMaintenance3PropertiesKHR {
7597    #[inline(always)]
7598    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7599        unsafe { core::mem::transmute(self) }
7600    }
7601
7602    #[inline(always)]
7603    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7604        unsafe { core::mem::transmute(self) }
7605    }
7606}
7607#[cfg(all(feature = "VK_KHR_maintenance3"))]
7608#[rustfmt::skip]
7609unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceMaintenance3PropertiesKHR {
7610    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR;
7611}
7612#[cfg(feature = "Allow1_1APIs")]
7613#[rustfmt::skip]
7614pub type VkPhysicalDeviceMaintenance3Properties = VkPhysicalDeviceMaintenance3PropertiesKHR;
7615#[cfg(feature = "Allow1_1APIs")]
7616#[rustfmt::skip]
7617pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR;
7618
7619#[derive(Debug, Clone)]
7620#[repr(C)]
7621#[rustfmt::skip]
7622pub struct VkPhysicalDeviceMemoryProperties {
7623    pub memoryTypeCount: u32,
7624    pub memoryTypes: [VkMemoryType; VK_MAX_MEMORY_TYPES],
7625    pub memoryHeapCount: u32,
7626    pub memoryHeaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS],
7627}
7628
7629#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7630#[derive(Debug, Clone)]
7631#[repr(C)]
7632#[rustfmt::skip]
7633pub struct VkPhysicalDeviceMemoryProperties2KHR {
7634    pub sType: VkStructureType,
7635    pub pNext: *mut core::ffi::c_void,
7636    pub memoryProperties: VkPhysicalDeviceMemoryProperties,
7637}
7638#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7639#[rustfmt::skip]
7640pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: VkStructureType = 1000059006;
7641#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7642#[rustfmt::skip]
7643unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceMemoryProperties2KHR {
7644    #[inline(always)]
7645    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7646        unsafe { core::mem::transmute(self) }
7647    }
7648
7649    #[inline(always)]
7650    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7651        unsafe { core::mem::transmute(self) }
7652    }
7653}
7654#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7655#[rustfmt::skip]
7656unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceMemoryProperties2KHR {
7657    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR;
7658}
7659#[cfg(feature = "Allow1_1APIs")]
7660#[rustfmt::skip]
7661pub type VkPhysicalDeviceMemoryProperties2 = VkPhysicalDeviceMemoryProperties2KHR;
7662#[cfg(feature = "Allow1_1APIs")]
7663#[rustfmt::skip]
7664pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR;
7665
7666#[cfg(all(feature = "VK_KHR_multiview"))]
7667#[derive(Debug, Clone)]
7668#[repr(C)]
7669#[rustfmt::skip]
7670pub struct VkPhysicalDeviceMultiviewFeaturesKHR {
7671    pub sType: VkStructureType,
7672    pub pNext: *mut core::ffi::c_void,
7673    pub multiview: VkBool32,
7674    pub multiviewGeometryShader: VkBool32,
7675    pub multiviewTessellationShader: VkBool32,
7676}
7677#[cfg(all(feature = "VK_KHR_multiview"))]
7678#[rustfmt::skip]
7679pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: VkStructureType = 1000053001;
7680#[cfg(all(feature = "VK_KHR_multiview"))]
7681#[rustfmt::skip]
7682unsafe impl crate::VulkanStructure for VkPhysicalDeviceMultiviewFeaturesKHR {
7683    #[inline(always)]
7684    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7685        unsafe { core::mem::transmute(self) }
7686    }
7687
7688    #[inline(always)]
7689    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7690        unsafe { core::mem::transmute(self) }
7691    }
7692}
7693#[cfg(all(feature = "VK_KHR_multiview"))]
7694#[rustfmt::skip]
7695unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceMultiviewFeaturesKHR {
7696    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR;
7697}
7698#[cfg(all(feature = "VK_KHR_multiview"))]
7699#[rustfmt::skip]
7700unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceMultiviewFeaturesKHR {
7701    #[inline(always)]
7702    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7703        unsafe { core::mem::transmute(self) }
7704    }
7705
7706    #[inline(always)]
7707    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7708        unsafe { core::mem::transmute(self) }
7709    }
7710}
7711#[cfg(all(feature = "VK_KHR_multiview"))]
7712#[rustfmt::skip]
7713unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceMultiviewFeaturesKHR {
7714    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR;
7715}
7716#[cfg(feature = "Allow1_1APIs")]
7717#[rustfmt::skip]
7718pub type VkPhysicalDeviceMultiviewFeatures = VkPhysicalDeviceMultiviewFeaturesKHR;
7719#[cfg(feature = "Allow1_1APIs")]
7720#[rustfmt::skip]
7721pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR;
7722
7723#[cfg(all(feature = "VK_KHR_multiview"))]
7724#[derive(Debug, Clone)]
7725#[repr(C)]
7726#[rustfmt::skip]
7727pub struct VkPhysicalDeviceMultiviewPropertiesKHR {
7728    pub sType: VkStructureType,
7729    pub pNext: *mut core::ffi::c_void,
7730    pub maxMultiviewViewCount: u32,
7731    pub maxMultiviewInstanceIndex: u32,
7732}
7733#[cfg(all(feature = "VK_KHR_multiview"))]
7734#[rustfmt::skip]
7735pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: VkStructureType = 1000053002;
7736#[cfg(all(feature = "VK_KHR_multiview"))]
7737#[rustfmt::skip]
7738unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceMultiviewPropertiesKHR {
7739    #[inline(always)]
7740    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7741        unsafe { core::mem::transmute(self) }
7742    }
7743
7744    #[inline(always)]
7745    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7746        unsafe { core::mem::transmute(self) }
7747    }
7748}
7749#[cfg(all(feature = "VK_KHR_multiview"))]
7750#[rustfmt::skip]
7751unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceMultiviewPropertiesKHR {
7752    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR;
7753}
7754#[cfg(feature = "Allow1_1APIs")]
7755#[rustfmt::skip]
7756pub type VkPhysicalDeviceMultiviewProperties = VkPhysicalDeviceMultiviewPropertiesKHR;
7757#[cfg(feature = "Allow1_1APIs")]
7758#[rustfmt::skip]
7759pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR;
7760
7761#[cfg(all(feature = "VK_KHR_maintenance2"))]
7762#[derive(Debug, Clone)]
7763#[repr(C)]
7764#[rustfmt::skip]
7765pub struct VkPhysicalDevicePointClippingPropertiesKHR {
7766    pub sType: VkStructureType,
7767    pub pNext: *mut core::ffi::c_void,
7768    pub pointClippingBehavior: VkPointClippingBehaviorKHR,
7769}
7770#[cfg(all(feature = "VK_KHR_maintenance2"))]
7771#[rustfmt::skip]
7772pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: VkStructureType = 1000117000;
7773#[cfg(all(feature = "VK_KHR_maintenance2"))]
7774#[rustfmt::skip]
7775unsafe impl crate::VulkanSinkStructure for VkPhysicalDevicePointClippingPropertiesKHR {
7776    #[inline(always)]
7777    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7778        unsafe { core::mem::transmute(self) }
7779    }
7780
7781    #[inline(always)]
7782    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7783        unsafe { core::mem::transmute(self) }
7784    }
7785}
7786#[cfg(all(feature = "VK_KHR_maintenance2"))]
7787#[rustfmt::skip]
7788unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDevicePointClippingPropertiesKHR {
7789    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR;
7790}
7791#[cfg(feature = "Allow1_1APIs")]
7792#[rustfmt::skip]
7793pub type VkPhysicalDevicePointClippingProperties = VkPhysicalDevicePointClippingPropertiesKHR;
7794#[cfg(feature = "Allow1_1APIs")]
7795#[rustfmt::skip]
7796pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR;
7797
7798#[derive(Debug, Clone)]
7799#[repr(C)]
7800#[rustfmt::skip]
7801pub struct VkPhysicalDeviceProperties {
7802    pub apiVersion: u32,
7803    pub driverVersion: u32,
7804    pub vendorID: u32,
7805    pub deviceID: u32,
7806    pub deviceType: VkPhysicalDeviceType,
7807    pub deviceName: crate::ffi_helper::FixedCStrBuffer<VK_MAX_PHYSICAL_DEVICE_NAME_SIZE>,
7808    pub pipelineCacheUUID: [u8; VK_UUID_SIZE],
7809    pub limits: VkPhysicalDeviceLimits,
7810    pub sparseProperties: VkPhysicalDeviceSparseProperties,
7811}
7812
7813#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7814#[derive(Debug, Clone)]
7815#[repr(C)]
7816#[rustfmt::skip]
7817pub struct VkPhysicalDeviceProperties2KHR {
7818    pub sType: VkStructureType,
7819    pub pNext: *mut core::ffi::c_void,
7820    pub properties: VkPhysicalDeviceProperties,
7821}
7822#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7823#[rustfmt::skip]
7824pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: VkStructureType = 1000059001;
7825#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7826#[rustfmt::skip]
7827unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceProperties2KHR {
7828    #[inline(always)]
7829    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7830        unsafe { core::mem::transmute(self) }
7831    }
7832
7833    #[inline(always)]
7834    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7835        unsafe { core::mem::transmute(self) }
7836    }
7837}
7838#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7839#[rustfmt::skip]
7840unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceProperties2KHR {
7841    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
7842}
7843#[cfg(feature = "Allow1_1APIs")]
7844#[rustfmt::skip]
7845pub type VkPhysicalDeviceProperties2 = VkPhysicalDeviceProperties2KHR;
7846#[cfg(feature = "Allow1_1APIs")]
7847#[rustfmt::skip]
7848pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
7849
7850#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
7851#[derive(Debug, Clone)]
7852#[repr(C)]
7853#[rustfmt::skip]
7854pub struct VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
7855    pub sType: VkStructureType,
7856    pub pNext: *mut core::ffi::c_void,
7857    pub samplerYcbcrConversion: VkBool32,
7858}
7859#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
7860#[rustfmt::skip]
7861pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: VkStructureType = 1000156004;
7862#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
7863#[rustfmt::skip]
7864unsafe impl crate::VulkanStructure for VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
7865    #[inline(always)]
7866    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7867        unsafe { core::mem::transmute(self) }
7868    }
7869
7870    #[inline(always)]
7871    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7872        unsafe { core::mem::transmute(self) }
7873    }
7874}
7875#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
7876#[rustfmt::skip]
7877unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
7878    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
7879}
7880#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
7881#[rustfmt::skip]
7882unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
7883    #[inline(always)]
7884    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
7885        unsafe { core::mem::transmute(self) }
7886    }
7887
7888    #[inline(always)]
7889    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
7890        unsafe { core::mem::transmute(self) }
7891    }
7892}
7893#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
7894#[rustfmt::skip]
7895unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
7896    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
7897}
7898#[cfg(feature = "Allow1_1APIs")]
7899#[rustfmt::skip]
7900pub type VkPhysicalDeviceSamplerYcbcrConversionFeatures = VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
7901#[cfg(feature = "Allow1_1APIs")]
7902#[rustfmt::skip]
7903pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
7904
7905#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7906#[derive(Debug, Clone)]
7907#[repr(C)]
7908#[rustfmt::skip]
7909pub struct VkPhysicalDeviceSparseImageFormatInfo2KHR {
7910    pub sType: VkStructureType,
7911    pub pNext: *const core::ffi::c_void,
7912    pub format: VkFormat,
7913    pub r#type: VkImageType,
7914    pub samples: VkSampleCountFlagBits,
7915    pub usage: VkImageUsageFlags,
7916    pub tiling: VkImageTiling,
7917}
7918#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7919#[rustfmt::skip]
7920pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = 1000059008;
7921#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7922#[rustfmt::skip]
7923unsafe impl crate::VulkanStructure for VkPhysicalDeviceSparseImageFormatInfo2KHR {
7924    #[inline(always)]
7925    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7926        unsafe { core::mem::transmute(self) }
7927    }
7928
7929    #[inline(always)]
7930    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7931        unsafe { core::mem::transmute(self) }
7932    }
7933}
7934#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
7935#[rustfmt::skip]
7936unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceSparseImageFormatInfo2KHR {
7937    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR;
7938}
7939#[cfg(feature = "Allow1_1APIs")]
7940#[rustfmt::skip]
7941pub type VkPhysicalDeviceSparseImageFormatInfo2 = VkPhysicalDeviceSparseImageFormatInfo2KHR;
7942#[cfg(feature = "Allow1_1APIs")]
7943#[rustfmt::skip]
7944pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR;
7945
7946#[derive(Debug, Clone)]
7947#[repr(C)]
7948#[rustfmt::skip]
7949pub struct VkPhysicalDeviceSparseProperties {
7950    pub residencyStandard2DBlockShape: VkBool32,
7951    pub residencyStandard2DMultisampleBlockShape: VkBool32,
7952    pub residencyStandard3DBlockShape: VkBool32,
7953    pub residencyAlignedMipSize: VkBool32,
7954    pub residencyNonResidentStrict: VkBool32,
7955}
7956
7957#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
7958#[derive(Debug, Clone)]
7959#[repr(C)]
7960#[rustfmt::skip]
7961pub struct VkPhysicalDeviceSurfaceInfo2KHR {
7962    pub sType: VkStructureType,
7963    pub pNext: *const core::ffi::c_void,
7964    pub surface: VkSurfaceKHR,
7965}
7966#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
7967#[rustfmt::skip]
7968pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: VkStructureType = 1000119000;
7969#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
7970#[rustfmt::skip]
7971unsafe impl crate::VulkanStructure for VkPhysicalDeviceSurfaceInfo2KHR {
7972    #[inline(always)]
7973    fn as_generic(&self) -> &crate::GenericVulkanStructure {
7974        unsafe { core::mem::transmute(self) }
7975    }
7976
7977    #[inline(always)]
7978    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
7979        unsafe { core::mem::transmute(self) }
7980    }
7981}
7982#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
7983#[rustfmt::skip]
7984unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceSurfaceInfo2KHR {
7985    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR;
7986}
7987
7988#[cfg(all(feature = "VK_KHR_variable_pointers"))]
7989#[derive(Debug, Clone)]
7990#[repr(C)]
7991#[rustfmt::skip]
7992pub struct VkPhysicalDeviceVariablePointersFeaturesKHR {
7993    pub sType: VkStructureType,
7994    pub pNext: *mut core::ffi::c_void,
7995    pub variablePointersStorageBuffer: VkBool32,
7996    pub variablePointers: VkBool32,
7997}
7998#[cfg(all(feature = "VK_KHR_variable_pointers"))]
7999#[rustfmt::skip]
8000pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: VkStructureType = 1000120000;
8001#[cfg(all(feature = "VK_KHR_variable_pointers"))]
8002#[rustfmt::skip]
8003unsafe impl crate::VulkanStructure for VkPhysicalDeviceVariablePointersFeaturesKHR {
8004    #[inline(always)]
8005    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8006        unsafe { core::mem::transmute(self) }
8007    }
8008
8009    #[inline(always)]
8010    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8011        unsafe { core::mem::transmute(self) }
8012    }
8013}
8014#[cfg(all(feature = "VK_KHR_variable_pointers"))]
8015#[rustfmt::skip]
8016unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceVariablePointersFeaturesKHR {
8017    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
8018}
8019#[cfg(all(feature = "VK_KHR_variable_pointers"))]
8020#[rustfmt::skip]
8021unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceVariablePointersFeaturesKHR {
8022    #[inline(always)]
8023    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
8024        unsafe { core::mem::transmute(self) }
8025    }
8026
8027    #[inline(always)]
8028    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
8029        unsafe { core::mem::transmute(self) }
8030    }
8031}
8032#[cfg(all(feature = "VK_KHR_variable_pointers"))]
8033#[rustfmt::skip]
8034unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceVariablePointersFeaturesKHR {
8035    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
8036}
8037#[cfg(feature = "Allow1_1APIs")]
8038#[rustfmt::skip]
8039pub type VkPhysicalDeviceVariablePointersFeatures = VkPhysicalDeviceVariablePointersFeaturesKHR;
8040#[cfg(feature = "Allow1_1APIs")]
8041#[rustfmt::skip]
8042pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
8043
8044#[derive(Debug, Clone)]
8045#[repr(C)]
8046#[rustfmt::skip]
8047pub struct VkPipelineCacheCreateInfo {
8048    pub sType: VkStructureType,
8049    pub pNext: *const core::ffi::c_void,
8050    pub flags: VkPipelineCacheCreateFlags,
8051    pub initialDataSize: usize,
8052    pub pInitialData: *const core::ffi::c_void,
8053}
8054#[rustfmt::skip]
8055pub const VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: VkStructureType = 17;
8056#[rustfmt::skip]
8057unsafe impl crate::VulkanStructure for VkPipelineCacheCreateInfo {
8058    #[inline(always)]
8059    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8060        unsafe { core::mem::transmute(self) }
8061    }
8062
8063    #[inline(always)]
8064    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8065        unsafe { core::mem::transmute(self) }
8066    }
8067}
8068#[rustfmt::skip]
8069unsafe impl crate::TypedVulkanStructure for VkPipelineCacheCreateInfo {
8070    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
8071}
8072
8073#[derive(Debug, Clone)]
8074#[repr(C)]
8075#[rustfmt::skip]
8076pub struct VkPipelineColorBlendAttachmentState {
8077    pub blendEnable: VkBool32,
8078    pub srcColorBlendFactor: VkBlendFactor,
8079    pub dstColorBlendFactor: VkBlendFactor,
8080    pub colorBlendOp: VkBlendOp,
8081    pub srcAlphaBlendFactor: VkBlendFactor,
8082    pub dstAlphaBlendFactor: VkBlendFactor,
8083    pub alphaBlendOp: VkBlendOp,
8084    pub colorWriteMask: VkColorComponentFlags,
8085}
8086
8087#[derive(Debug, Clone)]
8088#[repr(C)]
8089#[rustfmt::skip]
8090pub struct VkPipelineColorBlendStateCreateInfo {
8091    pub sType: VkStructureType,
8092    pub pNext: *const core::ffi::c_void,
8093    pub flags: VkPipelineColorBlendStateCreateFlags,
8094    pub logicOpEnable: VkBool32,
8095    pub logicOp: VkLogicOp,
8096    pub attachmentCount: u32,
8097    pub pAttachments: *const VkPipelineColorBlendAttachmentState,
8098    pub blendConstants: [core::ffi::c_float; 4],
8099}
8100#[rustfmt::skip]
8101pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = 26;
8102#[rustfmt::skip]
8103unsafe impl crate::VulkanStructure for VkPipelineColorBlendStateCreateInfo {
8104    #[inline(always)]
8105    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8106        unsafe { core::mem::transmute(self) }
8107    }
8108
8109    #[inline(always)]
8110    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8111        unsafe { core::mem::transmute(self) }
8112    }
8113}
8114#[rustfmt::skip]
8115unsafe impl crate::TypedVulkanStructure for VkPipelineColorBlendStateCreateInfo {
8116    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
8117}
8118
8119#[derive(Debug, Clone)]
8120#[repr(C)]
8121#[rustfmt::skip]
8122pub struct VkPipelineDepthStencilStateCreateInfo {
8123    pub sType: VkStructureType,
8124    pub pNext: *const core::ffi::c_void,
8125    pub flags: VkPipelineDepthStencilStateCreateFlags,
8126    pub depthTestEnable: VkBool32,
8127    pub depthWriteEnable: VkBool32,
8128    pub depthCompareOp: VkCompareOp,
8129    pub depthBoundsTestEnable: VkBool32,
8130    pub stencilTestEnable: VkBool32,
8131    pub front: VkStencilOpState,
8132    pub back: VkStencilOpState,
8133    pub minDepthBounds: core::ffi::c_float,
8134    pub maxDepthBounds: core::ffi::c_float,
8135}
8136#[rustfmt::skip]
8137pub const VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = 25;
8138#[rustfmt::skip]
8139unsafe impl crate::VulkanStructure for VkPipelineDepthStencilStateCreateInfo {
8140    #[inline(always)]
8141    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8142        unsafe { core::mem::transmute(self) }
8143    }
8144
8145    #[inline(always)]
8146    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8147        unsafe { core::mem::transmute(self) }
8148    }
8149}
8150#[rustfmt::skip]
8151unsafe impl crate::TypedVulkanStructure for VkPipelineDepthStencilStateCreateInfo {
8152    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
8153}
8154
8155#[derive(Debug, Clone)]
8156#[repr(C)]
8157#[rustfmt::skip]
8158pub struct VkPipelineDynamicStateCreateInfo {
8159    pub sType: VkStructureType,
8160    pub pNext: *const core::ffi::c_void,
8161    pub flags: VkPipelineDynamicStateCreateFlags,
8162    pub dynamicStateCount: u32,
8163    pub pDynamicStates: *const VkDynamicState,
8164}
8165#[rustfmt::skip]
8166pub const VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = 27;
8167#[rustfmt::skip]
8168unsafe impl crate::VulkanStructure for VkPipelineDynamicStateCreateInfo {
8169    #[inline(always)]
8170    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8171        unsafe { core::mem::transmute(self) }
8172    }
8173
8174    #[inline(always)]
8175    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8176        unsafe { core::mem::transmute(self) }
8177    }
8178}
8179#[rustfmt::skip]
8180unsafe impl crate::TypedVulkanStructure for VkPipelineDynamicStateCreateInfo {
8181    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
8182}
8183
8184#[derive(Debug, Clone)]
8185#[repr(C)]
8186#[rustfmt::skip]
8187pub struct VkPipelineInputAssemblyStateCreateInfo {
8188    pub sType: VkStructureType,
8189    pub pNext: *const core::ffi::c_void,
8190    pub flags: VkPipelineInputAssemblyStateCreateFlags,
8191    pub topology: VkPrimitiveTopology,
8192    pub primitiveRestartEnable: VkBool32,
8193}
8194#[rustfmt::skip]
8195pub const VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = 20;
8196#[rustfmt::skip]
8197unsafe impl crate::VulkanStructure for VkPipelineInputAssemblyStateCreateInfo {
8198    #[inline(always)]
8199    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8200        unsafe { core::mem::transmute(self) }
8201    }
8202
8203    #[inline(always)]
8204    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8205        unsafe { core::mem::transmute(self) }
8206    }
8207}
8208#[rustfmt::skip]
8209unsafe impl crate::TypedVulkanStructure for VkPipelineInputAssemblyStateCreateInfo {
8210    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
8211}
8212
8213#[derive(Debug, Clone)]
8214#[repr(C)]
8215#[rustfmt::skip]
8216pub struct VkPipelineLayoutCreateInfo {
8217    pub sType: VkStructureType,
8218    pub pNext: *const core::ffi::c_void,
8219    pub flags: VkPipelineLayoutCreateFlags,
8220    pub setLayoutCount: u32,
8221    pub pSetLayouts: *const VkDescriptorSetLayout,
8222    pub pushConstantRangeCount: u32,
8223    pub pPushConstantRanges: *const VkPushConstantRange,
8224}
8225#[rustfmt::skip]
8226pub const VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = 30;
8227#[rustfmt::skip]
8228unsafe impl crate::VulkanStructure for VkPipelineLayoutCreateInfo {
8229    #[inline(always)]
8230    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8231        unsafe { core::mem::transmute(self) }
8232    }
8233
8234    #[inline(always)]
8235    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8236        unsafe { core::mem::transmute(self) }
8237    }
8238}
8239#[rustfmt::skip]
8240unsafe impl crate::TypedVulkanStructure for VkPipelineLayoutCreateInfo {
8241    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
8242}
8243
8244#[derive(Debug, Clone)]
8245#[repr(C)]
8246#[rustfmt::skip]
8247pub struct VkPipelineMultisampleStateCreateInfo {
8248    pub sType: VkStructureType,
8249    pub pNext: *const core::ffi::c_void,
8250    pub flags: VkPipelineMultisampleStateCreateFlags,
8251    pub rasterizationSamples: VkSampleCountFlagBits,
8252    pub sampleShadingEnable: VkBool32,
8253    pub minSampleShading: core::ffi::c_float,
8254    pub pSampleMask: *const VkSampleMask,
8255    pub alphaToCoverageEnable: VkBool32,
8256    pub alphaToOneEnable: VkBool32,
8257}
8258#[rustfmt::skip]
8259pub const VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = 24;
8260#[rustfmt::skip]
8261unsafe impl crate::VulkanStructure for VkPipelineMultisampleStateCreateInfo {
8262    #[inline(always)]
8263    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8264        unsafe { core::mem::transmute(self) }
8265    }
8266
8267    #[inline(always)]
8268    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8269        unsafe { core::mem::transmute(self) }
8270    }
8271}
8272#[rustfmt::skip]
8273unsafe impl crate::TypedVulkanStructure for VkPipelineMultisampleStateCreateInfo {
8274    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
8275}
8276
8277#[derive(Debug, Clone)]
8278#[repr(C)]
8279#[rustfmt::skip]
8280pub struct VkPipelineRasterizationStateCreateInfo {
8281    pub sType: VkStructureType,
8282    pub pNext: *const core::ffi::c_void,
8283    pub flags: VkPipelineRasterizationStateCreateFlags,
8284    pub depthClampEnable: VkBool32,
8285    pub rasterizerDiscardEnable: VkBool32,
8286    pub polygonMode: VkPolygonMode,
8287    pub cullMode: VkCullModeFlags,
8288    pub frontFace: VkFrontFace,
8289    pub depthBiasEnable: VkBool32,
8290    pub depthBiasConstantFactor: core::ffi::c_float,
8291    pub depthBiasClamp: core::ffi::c_float,
8292    pub depthBiasSlopeFactor: core::ffi::c_float,
8293    pub lineWidth: core::ffi::c_float,
8294}
8295#[rustfmt::skip]
8296pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = 23;
8297#[rustfmt::skip]
8298unsafe impl crate::VulkanStructure for VkPipelineRasterizationStateCreateInfo {
8299    #[inline(always)]
8300    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8301        unsafe { core::mem::transmute(self) }
8302    }
8303
8304    #[inline(always)]
8305    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8306        unsafe { core::mem::transmute(self) }
8307    }
8308}
8309#[rustfmt::skip]
8310unsafe impl crate::TypedVulkanStructure for VkPipelineRasterizationStateCreateInfo {
8311    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
8312}
8313
8314#[derive(Debug, Clone)]
8315#[repr(C)]
8316#[rustfmt::skip]
8317pub struct VkPipelineShaderStageCreateInfo {
8318    pub sType: VkStructureType,
8319    pub pNext: *const core::ffi::c_void,
8320    pub flags: VkPipelineShaderStageCreateFlags,
8321    pub stage: VkShaderStageFlagBits,
8322    pub module: VkShaderModule,
8323    pub pName: *const core::ffi::c_char,
8324    pub pSpecializationInfo: *const VkSpecializationInfo,
8325}
8326#[rustfmt::skip]
8327pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = 18;
8328#[rustfmt::skip]
8329unsafe impl crate::VulkanStructure for VkPipelineShaderStageCreateInfo {
8330    #[inline(always)]
8331    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8332        unsafe { core::mem::transmute(self) }
8333    }
8334
8335    #[inline(always)]
8336    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8337        unsafe { core::mem::transmute(self) }
8338    }
8339}
8340#[rustfmt::skip]
8341unsafe impl crate::TypedVulkanStructure for VkPipelineShaderStageCreateInfo {
8342    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
8343}
8344
8345#[cfg(all(feature = "VK_KHR_maintenance2"))]
8346#[derive(Debug, Clone)]
8347#[repr(C)]
8348#[rustfmt::skip]
8349pub struct VkPipelineTessellationDomainOriginStateCreateInfoKHR {
8350    pub sType: VkStructureType,
8351    pub pNext: *const core::ffi::c_void,
8352    pub domainOrigin: VkTessellationDomainOriginKHR,
8353}
8354#[cfg(all(feature = "VK_KHR_maintenance2"))]
8355#[rustfmt::skip]
8356pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: VkStructureType = 1000117003;
8357#[cfg(all(feature = "VK_KHR_maintenance2"))]
8358#[rustfmt::skip]
8359unsafe impl crate::VulkanStructure for VkPipelineTessellationDomainOriginStateCreateInfoKHR {
8360    #[inline(always)]
8361    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8362        unsafe { core::mem::transmute(self) }
8363    }
8364
8365    #[inline(always)]
8366    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8367        unsafe { core::mem::transmute(self) }
8368    }
8369}
8370#[cfg(all(feature = "VK_KHR_maintenance2"))]
8371#[rustfmt::skip]
8372unsafe impl crate::TypedVulkanStructure for VkPipelineTessellationDomainOriginStateCreateInfoKHR {
8373    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR;
8374}
8375#[cfg(feature = "Allow1_1APIs")]
8376#[rustfmt::skip]
8377pub type VkPipelineTessellationDomainOriginStateCreateInfo = VkPipelineTessellationDomainOriginStateCreateInfoKHR;
8378#[cfg(feature = "Allow1_1APIs")]
8379#[rustfmt::skip]
8380pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR;
8381
8382#[derive(Debug, Clone)]
8383#[repr(C)]
8384#[rustfmt::skip]
8385pub struct VkPipelineTessellationStateCreateInfo {
8386    pub sType: VkStructureType,
8387    pub pNext: *const core::ffi::c_void,
8388    pub flags: VkPipelineTessellationStateCreateFlags,
8389    pub patchControlPoints: u32,
8390}
8391#[rustfmt::skip]
8392pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: VkStructureType = 21;
8393#[rustfmt::skip]
8394unsafe impl crate::VulkanStructure for VkPipelineTessellationStateCreateInfo {
8395    #[inline(always)]
8396    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8397        unsafe { core::mem::transmute(self) }
8398    }
8399
8400    #[inline(always)]
8401    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8402        unsafe { core::mem::transmute(self) }
8403    }
8404}
8405#[rustfmt::skip]
8406unsafe impl crate::TypedVulkanStructure for VkPipelineTessellationStateCreateInfo {
8407    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO;
8408}
8409
8410#[derive(Debug, Clone)]
8411#[repr(C)]
8412#[rustfmt::skip]
8413pub struct VkPipelineVertexInputStateCreateInfo {
8414    pub sType: VkStructureType,
8415    pub pNext: *const core::ffi::c_void,
8416    pub flags: VkPipelineVertexInputStateCreateFlags,
8417    pub vertexBindingDescriptionCount: u32,
8418    pub pVertexBindingDescriptions: *const VkVertexInputBindingDescription,
8419    pub vertexAttributeDescriptionCount: u32,
8420    pub pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription,
8421}
8422#[rustfmt::skip]
8423pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = 19;
8424#[rustfmt::skip]
8425unsafe impl crate::VulkanStructure for VkPipelineVertexInputStateCreateInfo {
8426    #[inline(always)]
8427    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8428        unsafe { core::mem::transmute(self) }
8429    }
8430
8431    #[inline(always)]
8432    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8433        unsafe { core::mem::transmute(self) }
8434    }
8435}
8436#[rustfmt::skip]
8437unsafe impl crate::TypedVulkanStructure for VkPipelineVertexInputStateCreateInfo {
8438    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
8439}
8440
8441#[derive(Debug, Clone)]
8442#[repr(C)]
8443#[rustfmt::skip]
8444pub struct VkPipelineViewportStateCreateInfo {
8445    pub sType: VkStructureType,
8446    pub pNext: *const core::ffi::c_void,
8447    pub flags: VkPipelineViewportStateCreateFlags,
8448    pub viewportCount: u32,
8449    pub pViewports: *const VkViewport,
8450    pub scissorCount: u32,
8451    pub pScissors: *const VkRect2D,
8452}
8453#[rustfmt::skip]
8454pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = 22;
8455#[rustfmt::skip]
8456unsafe impl crate::VulkanStructure for VkPipelineViewportStateCreateInfo {
8457    #[inline(always)]
8458    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8459        unsafe { core::mem::transmute(self) }
8460    }
8461
8462    #[inline(always)]
8463    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8464        unsafe { core::mem::transmute(self) }
8465    }
8466}
8467#[rustfmt::skip]
8468unsafe impl crate::TypedVulkanStructure for VkPipelineViewportStateCreateInfo {
8469    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
8470}
8471
8472#[cfg(all(feature = "VK_KHR_swapchain"))]
8473#[derive(Debug, Clone)]
8474#[repr(C)]
8475#[rustfmt::skip]
8476pub struct VkPresentInfoKHR {
8477    pub sType: VkStructureType,
8478    pub pNext: *const core::ffi::c_void,
8479    pub waitSemaphoreCount: u32,
8480    pub pWaitSemaphores: *const VkSemaphore,
8481    pub swapchainCount: u32,
8482    pub pSwapchains: *const VkSwapchainKHR,
8483    pub pImageIndices: *const u32,
8484    pub pResults: *mut VkResult,
8485}
8486#[cfg(all(feature = "VK_KHR_swapchain"))]
8487#[rustfmt::skip]
8488pub const VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = 1000001001;
8489#[cfg(all(feature = "VK_KHR_swapchain"))]
8490#[rustfmt::skip]
8491unsafe impl crate::VulkanStructure for VkPresentInfoKHR {
8492    #[inline(always)]
8493    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8494        unsafe { core::mem::transmute(self) }
8495    }
8496
8497    #[inline(always)]
8498    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8499        unsafe { core::mem::transmute(self) }
8500    }
8501}
8502#[cfg(all(feature = "VK_KHR_swapchain"))]
8503#[rustfmt::skip]
8504unsafe impl crate::TypedVulkanStructure for VkPresentInfoKHR {
8505    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PRESENT_INFO_KHR;
8506}
8507
8508#[derive(Debug, Clone)]
8509#[repr(C)]
8510#[rustfmt::skip]
8511pub struct VkPushConstantRange {
8512    pub stageFlags: VkShaderStageFlags,
8513    pub offset: u32,
8514    pub size: u32,
8515}
8516
8517#[derive(Debug, Clone)]
8518#[repr(C)]
8519#[rustfmt::skip]
8520pub struct VkQueryPoolCreateInfo {
8521    pub sType: VkStructureType,
8522    pub pNext: *const core::ffi::c_void,
8523    pub flags: VkQueryPoolCreateFlags,
8524    pub queryType: VkQueryType,
8525    pub queryCount: u32,
8526    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
8527}
8528#[rustfmt::skip]
8529pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = 11;
8530#[rustfmt::skip]
8531unsafe impl crate::VulkanStructure for VkQueryPoolCreateInfo {
8532    #[inline(always)]
8533    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8534        unsafe { core::mem::transmute(self) }
8535    }
8536
8537    #[inline(always)]
8538    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8539        unsafe { core::mem::transmute(self) }
8540    }
8541}
8542#[rustfmt::skip]
8543unsafe impl crate::TypedVulkanStructure for VkQueryPoolCreateInfo {
8544    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;
8545}
8546
8547#[derive(Debug, Clone)]
8548#[repr(C)]
8549#[rustfmt::skip]
8550pub struct VkQueueFamilyProperties {
8551    pub queueFlags: VkQueueFlags,
8552    pub queueCount: u32,
8553    pub timestampValidBits: u32,
8554    pub minImageTransferGranularity: VkExtent3D,
8555}
8556
8557#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
8558#[derive(Debug, Clone)]
8559#[repr(C)]
8560#[rustfmt::skip]
8561pub struct VkQueueFamilyProperties2KHR {
8562    pub sType: VkStructureType,
8563    pub pNext: *mut core::ffi::c_void,
8564    pub queueFamilyProperties: VkQueueFamilyProperties,
8565}
8566#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
8567#[rustfmt::skip]
8568pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: VkStructureType = 1000059005;
8569#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
8570#[rustfmt::skip]
8571unsafe impl crate::VulkanSinkStructure for VkQueueFamilyProperties2KHR {
8572    #[inline(always)]
8573    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
8574        unsafe { core::mem::transmute(self) }
8575    }
8576
8577    #[inline(always)]
8578    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
8579        unsafe { core::mem::transmute(self) }
8580    }
8581}
8582#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
8583#[rustfmt::skip]
8584unsafe impl crate::TypedVulkanSinkStructure for VkQueueFamilyProperties2KHR {
8585    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
8586}
8587#[cfg(feature = "Allow1_1APIs")]
8588#[rustfmt::skip]
8589pub type VkQueueFamilyProperties2 = VkQueueFamilyProperties2KHR;
8590#[cfg(feature = "Allow1_1APIs")]
8591#[rustfmt::skip]
8592pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
8593
8594#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
8595#[repr(C)]
8596#[rustfmt::skip]
8597pub struct VkRect2D {
8598    pub offset: VkOffset2D,
8599    pub extent: VkExtent2D,
8600}
8601
8602#[derive(Debug, Clone)]
8603#[repr(C)]
8604#[rustfmt::skip]
8605pub struct VkRenderPassBeginInfo {
8606    pub sType: VkStructureType,
8607    pub pNext: *const core::ffi::c_void,
8608    pub renderPass: VkRenderPass,
8609    pub framebuffer: VkFramebuffer,
8610    pub renderArea: VkRect2D,
8611    pub clearValueCount: u32,
8612    pub pClearValues: *const VkClearValue,
8613}
8614#[rustfmt::skip]
8615pub const VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: VkStructureType = 43;
8616#[rustfmt::skip]
8617unsafe impl crate::VulkanStructure for VkRenderPassBeginInfo {
8618    #[inline(always)]
8619    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8620        unsafe { core::mem::transmute(self) }
8621    }
8622
8623    #[inline(always)]
8624    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8625        unsafe { core::mem::transmute(self) }
8626    }
8627}
8628#[rustfmt::skip]
8629unsafe impl crate::TypedVulkanStructure for VkRenderPassBeginInfo {
8630    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
8631}
8632
8633#[derive(Debug, Clone)]
8634#[repr(C)]
8635#[rustfmt::skip]
8636pub struct VkRenderPassCreateInfo {
8637    pub sType: VkStructureType,
8638    pub pNext: *const core::ffi::c_void,
8639    pub flags: VkRenderPassCreateFlags,
8640    pub attachmentCount: u32,
8641    pub pAttachments: *const VkAttachmentDescription,
8642    pub subpassCount: u32,
8643    pub pSubpasses: *const VkSubpassDescription,
8644    pub dependencyCount: u32,
8645    pub pDependencies: *const VkSubpassDependency,
8646}
8647#[rustfmt::skip]
8648pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: VkStructureType = 38;
8649#[rustfmt::skip]
8650unsafe impl crate::VulkanStructure for VkRenderPassCreateInfo {
8651    #[inline(always)]
8652    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8653        unsafe { core::mem::transmute(self) }
8654    }
8655
8656    #[inline(always)]
8657    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8658        unsafe { core::mem::transmute(self) }
8659    }
8660}
8661#[rustfmt::skip]
8662unsafe impl crate::TypedVulkanStructure for VkRenderPassCreateInfo {
8663    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
8664}
8665
8666#[cfg(all(feature = "VK_KHR_maintenance2"))]
8667#[derive(Debug, Clone)]
8668#[repr(C)]
8669#[rustfmt::skip]
8670pub struct VkRenderPassInputAttachmentAspectCreateInfoKHR {
8671    pub sType: VkStructureType,
8672    pub pNext: *const core::ffi::c_void,
8673    pub aspectReferenceCount: u32,
8674    pub pAspectReferences: *const VkInputAttachmentAspectReferenceKHR,
8675}
8676#[cfg(all(feature = "VK_KHR_maintenance2"))]
8677#[rustfmt::skip]
8678pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: VkStructureType = 1000117001;
8679#[cfg(all(feature = "VK_KHR_maintenance2"))]
8680#[rustfmt::skip]
8681unsafe impl crate::VulkanStructure for VkRenderPassInputAttachmentAspectCreateInfoKHR {
8682    #[inline(always)]
8683    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8684        unsafe { core::mem::transmute(self) }
8685    }
8686
8687    #[inline(always)]
8688    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8689        unsafe { core::mem::transmute(self) }
8690    }
8691}
8692#[cfg(all(feature = "VK_KHR_maintenance2"))]
8693#[rustfmt::skip]
8694unsafe impl crate::TypedVulkanStructure for VkRenderPassInputAttachmentAspectCreateInfoKHR {
8695    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR;
8696}
8697#[cfg(feature = "Allow1_1APIs")]
8698#[rustfmt::skip]
8699pub type VkRenderPassInputAttachmentAspectCreateInfo = VkRenderPassInputAttachmentAspectCreateInfoKHR;
8700#[cfg(feature = "Allow1_1APIs")]
8701#[rustfmt::skip]
8702pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR;
8703
8704#[cfg(all(feature = "VK_KHR_multiview"))]
8705#[derive(Debug, Clone)]
8706#[repr(C)]
8707#[rustfmt::skip]
8708pub struct VkRenderPassMultiviewCreateInfoKHR {
8709    pub sType: VkStructureType,
8710    pub pNext: *const core::ffi::c_void,
8711    pub subpassCount: u32,
8712    pub pViewMasks: *const u32,
8713    pub dependencyCount: u32,
8714    pub pViewOffsets: *const i32,
8715    pub correlationMaskCount: u32,
8716    pub pCorrelationMasks: *const u32,
8717}
8718#[cfg(all(feature = "VK_KHR_multiview"))]
8719#[rustfmt::skip]
8720pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: VkStructureType = 1000053000;
8721#[cfg(all(feature = "VK_KHR_multiview"))]
8722#[rustfmt::skip]
8723unsafe impl crate::VulkanStructure for VkRenderPassMultiviewCreateInfoKHR {
8724    #[inline(always)]
8725    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8726        unsafe { core::mem::transmute(self) }
8727    }
8728
8729    #[inline(always)]
8730    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8731        unsafe { core::mem::transmute(self) }
8732    }
8733}
8734#[cfg(all(feature = "VK_KHR_multiview"))]
8735#[rustfmt::skip]
8736unsafe impl crate::TypedVulkanStructure for VkRenderPassMultiviewCreateInfoKHR {
8737    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR;
8738}
8739#[cfg(feature = "Allow1_1APIs")]
8740#[rustfmt::skip]
8741pub type VkRenderPassMultiviewCreateInfo = VkRenderPassMultiviewCreateInfoKHR;
8742#[cfg(feature = "Allow1_1APIs")]
8743#[rustfmt::skip]
8744pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR;
8745
8746#[derive(Debug, Clone)]
8747#[repr(C)]
8748#[rustfmt::skip]
8749pub struct VkSamplerCreateInfo {
8750    pub sType: VkStructureType,
8751    pub pNext: *const core::ffi::c_void,
8752    pub flags: VkSamplerCreateFlags,
8753    pub magFilter: VkFilter,
8754    pub minFilter: VkFilter,
8755    pub mipmapMode: VkSamplerMipmapMode,
8756    pub addressModeU: VkSamplerAddressMode,
8757    pub addressModeV: VkSamplerAddressMode,
8758    pub addressModeW: VkSamplerAddressMode,
8759    pub mipLodBias: core::ffi::c_float,
8760    pub anisotropyEnable: VkBool32,
8761    pub maxAnisotropy: core::ffi::c_float,
8762    pub compareEnable: VkBool32,
8763    pub compareOp: VkCompareOp,
8764    pub minLod: core::ffi::c_float,
8765    pub maxLod: core::ffi::c_float,
8766    pub borderColor: VkBorderColor,
8767    pub unnormalizedCoordinates: VkBool32,
8768}
8769#[rustfmt::skip]
8770pub const VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = 31;
8771#[rustfmt::skip]
8772unsafe impl crate::VulkanStructure for VkSamplerCreateInfo {
8773    #[inline(always)]
8774    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8775        unsafe { core::mem::transmute(self) }
8776    }
8777
8778    #[inline(always)]
8779    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8780        unsafe { core::mem::transmute(self) }
8781    }
8782}
8783#[rustfmt::skip]
8784unsafe impl crate::TypedVulkanStructure for VkSamplerCreateInfo {
8785    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
8786}
8787
8788#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8789#[derive(Debug, Clone)]
8790#[repr(C)]
8791#[rustfmt::skip]
8792pub struct VkSamplerYcbcrConversionCreateInfoKHR {
8793    pub sType: VkStructureType,
8794    pub pNext: *const core::ffi::c_void,
8795    pub format: VkFormat,
8796    pub ycbcrModel: VkSamplerYcbcrModelConversionKHR,
8797    pub ycbcrRange: VkSamplerYcbcrRangeKHR,
8798    pub components: VkComponentMapping,
8799    pub xChromaOffset: VkChromaLocationKHR,
8800    pub yChromaOffset: VkChromaLocationKHR,
8801    pub chromaFilter: VkFilter,
8802    pub forceExplicitReconstruction: VkBool32,
8803}
8804#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8805#[rustfmt::skip]
8806pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: VkStructureType = 1000156000;
8807#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8808#[rustfmt::skip]
8809unsafe impl crate::VulkanStructure for VkSamplerYcbcrConversionCreateInfoKHR {
8810    #[inline(always)]
8811    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8812        unsafe { core::mem::transmute(self) }
8813    }
8814
8815    #[inline(always)]
8816    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8817        unsafe { core::mem::transmute(self) }
8818    }
8819}
8820#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8821#[rustfmt::skip]
8822unsafe impl crate::TypedVulkanStructure for VkSamplerYcbcrConversionCreateInfoKHR {
8823    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR;
8824}
8825#[cfg(feature = "Allow1_1APIs")]
8826#[rustfmt::skip]
8827pub type VkSamplerYcbcrConversionCreateInfo = VkSamplerYcbcrConversionCreateInfoKHR;
8828#[cfg(feature = "Allow1_1APIs")]
8829#[rustfmt::skip]
8830pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR;
8831
8832#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8833#[derive(Debug, Clone)]
8834#[repr(C)]
8835#[rustfmt::skip]
8836pub struct VkSamplerYcbcrConversionImageFormatPropertiesKHR {
8837    pub sType: VkStructureType,
8838    pub pNext: *mut core::ffi::c_void,
8839    pub combinedImageSamplerDescriptorCount: u32,
8840}
8841#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8842#[rustfmt::skip]
8843pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = 1000156005;
8844#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8845#[rustfmt::skip]
8846unsafe impl crate::VulkanSinkStructure for VkSamplerYcbcrConversionImageFormatPropertiesKHR {
8847    #[inline(always)]
8848    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
8849        unsafe { core::mem::transmute(self) }
8850    }
8851
8852    #[inline(always)]
8853    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
8854        unsafe { core::mem::transmute(self) }
8855    }
8856}
8857#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8858#[rustfmt::skip]
8859unsafe impl crate::TypedVulkanSinkStructure for VkSamplerYcbcrConversionImageFormatPropertiesKHR {
8860    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR;
8861}
8862#[cfg(feature = "Allow1_1APIs")]
8863#[rustfmt::skip]
8864pub type VkSamplerYcbcrConversionImageFormatProperties = VkSamplerYcbcrConversionImageFormatPropertiesKHR;
8865#[cfg(feature = "Allow1_1APIs")]
8866#[rustfmt::skip]
8867pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR;
8868
8869#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8870#[derive(Debug, Clone)]
8871#[repr(C)]
8872#[rustfmt::skip]
8873pub struct VkSamplerYcbcrConversionInfoKHR {
8874    pub sType: VkStructureType,
8875    pub pNext: *const core::ffi::c_void,
8876    pub conversion: VkSamplerYcbcrConversion,
8877}
8878#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8879#[rustfmt::skip]
8880pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR: VkStructureType = 1000156001;
8881#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8882#[rustfmt::skip]
8883unsafe impl crate::VulkanStructure for VkSamplerYcbcrConversionInfoKHR {
8884    #[inline(always)]
8885    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8886        unsafe { core::mem::transmute(self) }
8887    }
8888
8889    #[inline(always)]
8890    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8891        unsafe { core::mem::transmute(self) }
8892    }
8893}
8894#[cfg(all(feature = "VK_KHR_sampler_ycbcr_conversion"))]
8895#[rustfmt::skip]
8896unsafe impl crate::TypedVulkanStructure for VkSamplerYcbcrConversionInfoKHR {
8897    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR;
8898}
8899#[cfg(feature = "Allow1_1APIs")]
8900#[rustfmt::skip]
8901pub type VkSamplerYcbcrConversionInfo = VkSamplerYcbcrConversionInfoKHR;
8902#[cfg(feature = "Allow1_1APIs")]
8903#[rustfmt::skip]
8904pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR;
8905
8906#[derive(Debug, Clone)]
8907#[repr(C)]
8908#[rustfmt::skip]
8909pub struct VkSemaphoreCreateInfo {
8910    pub sType: VkStructureType,
8911    pub pNext: *const core::ffi::c_void,
8912    pub flags: VkSemaphoreCreateFlags,
8913}
8914#[rustfmt::skip]
8915pub const VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = 9;
8916#[rustfmt::skip]
8917unsafe impl crate::VulkanStructure for VkSemaphoreCreateInfo {
8918    #[inline(always)]
8919    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8920        unsafe { core::mem::transmute(self) }
8921    }
8922
8923    #[inline(always)]
8924    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8925        unsafe { core::mem::transmute(self) }
8926    }
8927}
8928#[rustfmt::skip]
8929unsafe impl crate::TypedVulkanStructure for VkSemaphoreCreateInfo {
8930    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
8931}
8932
8933#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
8934#[derive(Debug, Clone)]
8935#[repr(C)]
8936#[rustfmt::skip]
8937pub struct VkSemaphoreGetFdInfoKHR {
8938    pub sType: VkStructureType,
8939    pub pNext: *const core::ffi::c_void,
8940    pub semaphore: VkSemaphore,
8941    pub handleType: VkExternalSemaphoreHandleTypeFlagBitsKHR,
8942}
8943#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
8944#[rustfmt::skip]
8945pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = 1000079001;
8946#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
8947#[rustfmt::skip]
8948unsafe impl crate::VulkanStructure for VkSemaphoreGetFdInfoKHR {
8949    #[inline(always)]
8950    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8951        unsafe { core::mem::transmute(self) }
8952    }
8953
8954    #[inline(always)]
8955    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8956        unsafe { core::mem::transmute(self) }
8957    }
8958}
8959#[cfg(all(feature = "VK_KHR_external_semaphore_fd"))]
8960#[rustfmt::skip]
8961unsafe impl crate::TypedVulkanStructure for VkSemaphoreGetFdInfoKHR {
8962    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR;
8963}
8964
8965#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
8966#[derive(Debug, Clone)]
8967#[repr(C)]
8968#[rustfmt::skip]
8969pub struct VkSemaphoreGetWin32HandleInfoKHR {
8970    pub sType: VkStructureType,
8971    pub pNext: *const core::ffi::c_void,
8972    pub semaphore: VkSemaphore,
8973    pub handleType: VkExternalSemaphoreHandleTypeFlagBitsKHR,
8974}
8975#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
8976#[rustfmt::skip]
8977pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: VkStructureType = 1000078003;
8978#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
8979#[rustfmt::skip]
8980unsafe impl crate::VulkanStructure for VkSemaphoreGetWin32HandleInfoKHR {
8981    #[inline(always)]
8982    fn as_generic(&self) -> &crate::GenericVulkanStructure {
8983        unsafe { core::mem::transmute(self) }
8984    }
8985
8986    #[inline(always)]
8987    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
8988        unsafe { core::mem::transmute(self) }
8989    }
8990}
8991#[cfg(all(feature = "VK_KHR_external_semaphore_win32"))]
8992#[rustfmt::skip]
8993unsafe impl crate::TypedVulkanStructure for VkSemaphoreGetWin32HandleInfoKHR {
8994    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR;
8995}
8996
8997#[derive(Debug, Clone)]
8998#[repr(C)]
8999#[rustfmt::skip]
9000pub struct VkShaderModuleCreateInfo {
9001    pub sType: VkStructureType,
9002    pub pNext: *const core::ffi::c_void,
9003    pub flags: VkShaderModuleCreateFlags,
9004    pub codeSize: usize,
9005    pub pCode: *const u32,
9006}
9007#[rustfmt::skip]
9008pub const VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = 16;
9009#[rustfmt::skip]
9010unsafe impl crate::VulkanStructure for VkShaderModuleCreateInfo {
9011    #[inline(always)]
9012    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9013        unsafe { core::mem::transmute(self) }
9014    }
9015
9016    #[inline(always)]
9017    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9018        unsafe { core::mem::transmute(self) }
9019    }
9020}
9021#[rustfmt::skip]
9022unsafe impl crate::TypedVulkanStructure for VkShaderModuleCreateInfo {
9023    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
9024}
9025
9026#[derive(Debug, Clone)]
9027#[repr(C)]
9028#[rustfmt::skip]
9029pub struct VkSparseBufferMemoryBindInfo {
9030    pub buffer: VkBuffer,
9031    pub bindCount: u32,
9032    pub pBinds: *const VkSparseMemoryBind,
9033}
9034
9035#[derive(Debug, Clone)]
9036#[repr(C)]
9037#[rustfmt::skip]
9038pub struct VkSparseImageFormatProperties {
9039    pub aspectMask: VkImageAspectFlags,
9040    pub imageGranularity: VkExtent3D,
9041    pub flags: VkSparseImageFormatFlags,
9042}
9043
9044#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
9045#[derive(Debug, Clone)]
9046#[repr(C)]
9047#[rustfmt::skip]
9048pub struct VkSparseImageFormatProperties2KHR {
9049    pub sType: VkStructureType,
9050    pub pNext: *mut core::ffi::c_void,
9051    pub properties: VkSparseImageFormatProperties,
9052}
9053#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
9054#[rustfmt::skip]
9055pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = 1000059007;
9056#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
9057#[rustfmt::skip]
9058unsafe impl crate::VulkanSinkStructure for VkSparseImageFormatProperties2KHR {
9059    #[inline(always)]
9060    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
9061        unsafe { core::mem::transmute(self) }
9062    }
9063
9064    #[inline(always)]
9065    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
9066        unsafe { core::mem::transmute(self) }
9067    }
9068}
9069#[cfg(all(feature = "VK_KHR_get_physical_device_properties2"))]
9070#[rustfmt::skip]
9071unsafe impl crate::TypedVulkanSinkStructure for VkSparseImageFormatProperties2KHR {
9072    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR;
9073}
9074#[cfg(feature = "Allow1_1APIs")]
9075#[rustfmt::skip]
9076pub type VkSparseImageFormatProperties2 = VkSparseImageFormatProperties2KHR;
9077#[cfg(feature = "Allow1_1APIs")]
9078#[rustfmt::skip]
9079pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR;
9080
9081#[derive(Debug, Clone)]
9082#[repr(C)]
9083#[rustfmt::skip]
9084pub struct VkSparseImageMemoryBind {
9085    pub subresource: VkImageSubresource,
9086    pub offset: VkOffset3D,
9087    pub extent: VkExtent3D,
9088    pub memory: VkDeviceMemory,
9089    pub memoryOffset: VkDeviceSize,
9090    pub flags: VkSparseMemoryBindFlags,
9091}
9092
9093#[derive(Debug, Clone)]
9094#[repr(C)]
9095#[rustfmt::skip]
9096pub struct VkSparseImageMemoryBindInfo {
9097    pub image: VkImage,
9098    pub bindCount: u32,
9099    pub pBinds: *const VkSparseImageMemoryBind,
9100}
9101
9102#[derive(Debug, Clone)]
9103#[repr(C)]
9104#[rustfmt::skip]
9105pub struct VkSparseImageMemoryRequirements {
9106    pub formatProperties: VkSparseImageFormatProperties,
9107    pub imageMipTailFirstLod: u32,
9108    pub imageMipTailSize: VkDeviceSize,
9109    pub imageMipTailOffset: VkDeviceSize,
9110    pub imageMipTailStride: VkDeviceSize,
9111}
9112
9113#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
9114#[derive(Debug, Clone)]
9115#[repr(C)]
9116#[rustfmt::skip]
9117pub struct VkSparseImageMemoryRequirements2KHR {
9118    pub sType: VkStructureType,
9119    pub pNext: *mut core::ffi::c_void,
9120    pub memoryRequirements: VkSparseImageMemoryRequirements,
9121}
9122#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
9123#[rustfmt::skip]
9124pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = 1000146004;
9125#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
9126#[rustfmt::skip]
9127unsafe impl crate::VulkanSinkStructure for VkSparseImageMemoryRequirements2KHR {
9128    #[inline(always)]
9129    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
9130        unsafe { core::mem::transmute(self) }
9131    }
9132
9133    #[inline(always)]
9134    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
9135        unsafe { core::mem::transmute(self) }
9136    }
9137}
9138#[cfg(all(feature = "VK_KHR_get_memory_requirements2"))]
9139#[rustfmt::skip]
9140unsafe impl crate::TypedVulkanSinkStructure for VkSparseImageMemoryRequirements2KHR {
9141    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR;
9142}
9143#[cfg(feature = "Allow1_1APIs")]
9144#[rustfmt::skip]
9145pub type VkSparseImageMemoryRequirements2 = VkSparseImageMemoryRequirements2KHR;
9146#[cfg(feature = "Allow1_1APIs")]
9147#[rustfmt::skip]
9148pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR;
9149
9150#[derive(Debug, Clone)]
9151#[repr(C)]
9152#[rustfmt::skip]
9153pub struct VkSparseImageOpaqueMemoryBindInfo {
9154    pub image: VkImage,
9155    pub bindCount: u32,
9156    pub pBinds: *const VkSparseMemoryBind,
9157}
9158
9159#[derive(Debug, Clone)]
9160#[repr(C)]
9161#[rustfmt::skip]
9162pub struct VkSparseMemoryBind {
9163    pub reosurceOffset: VkDeviceSize,
9164    pub size: VkDeviceSize,
9165    pub memory: VkDeviceMemory,
9166    pub memoryOffset: VkDeviceSize,
9167    pub flags: VkSparseMemoryBindFlags,
9168}
9169
9170#[derive(Debug, Clone)]
9171#[repr(C)]
9172#[rustfmt::skip]
9173pub struct VkSpecializationInfo {
9174    pub mapEntryCount: u32,
9175    pub pMapEntries: *const VkSpecializationMapEntry,
9176    pub dataSize: usize,
9177    pub pData: *const core::ffi::c_void,
9178}
9179
9180#[derive(Debug, Clone)]
9181#[repr(C)]
9182#[rustfmt::skip]
9183pub struct VkSpecializationMapEntry {
9184    pub constantID: u32,
9185    pub offset: u32,
9186    pub size: usize,
9187}
9188
9189#[derive(Debug, Clone)]
9190#[repr(C)]
9191#[rustfmt::skip]
9192pub struct VkStencilOpState {
9193    pub failOp: VkStencilOp,
9194    pub passOp: VkStencilOp,
9195    pub depthFailOp: VkStencilOp,
9196    pub compareOp: VkCompareOp,
9197    pub compareMask: u32,
9198    pub writeMask: u32,
9199    pub reference: u32,
9200}
9201
9202#[derive(Debug, Clone)]
9203#[repr(C)]
9204#[rustfmt::skip]
9205pub struct VkSubmitInfo {
9206    pub sType: VkStructureType,
9207    pub pNext: *const core::ffi::c_void,
9208    pub waitSemaphoreCount: u32,
9209    pub pWaitSemaphores: *const VkSemaphore,
9210    pub pWaitDstStageMask: *const VkPipelineStageFlags,
9211    pub commandBufferCount: u32,
9212    pub pCommandBuffers: *const VkCommandBuffer,
9213    pub signalSemaphoreCount: u32,
9214    pub pSignalSemaphores: *const VkSemaphore,
9215}
9216#[rustfmt::skip]
9217pub const VK_STRUCTURE_TYPE_SUBMIT_INFO: VkStructureType = 4;
9218#[rustfmt::skip]
9219unsafe impl crate::VulkanStructure for VkSubmitInfo {
9220    #[inline(always)]
9221    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9222        unsafe { core::mem::transmute(self) }
9223    }
9224
9225    #[inline(always)]
9226    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9227        unsafe { core::mem::transmute(self) }
9228    }
9229}
9230#[rustfmt::skip]
9231unsafe impl crate::TypedVulkanStructure for VkSubmitInfo {
9232    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
9233}
9234
9235#[derive(Debug, Clone)]
9236#[repr(C)]
9237#[rustfmt::skip]
9238pub struct VkSubpassDependency {
9239    pub srcSubpass: u32,
9240    pub dstSubpass: u32,
9241    pub srcStageMask: VkPipelineStageFlags,
9242    pub dstStageMask: VkPipelineStageFlags,
9243    pub srcAccessMask: VkAccessFlags,
9244    pub dstAccessMask: VkAccessFlags,
9245    pub dependencyFlags: VkDependencyFlags,
9246}
9247
9248#[derive(Debug, Clone)]
9249#[repr(C)]
9250#[rustfmt::skip]
9251pub struct VkSubpassDescription {
9252    pub flags: VkSubpassDescriptionFlags,
9253    pub pipelineBindPoint: VkPipelineBindPoint,
9254    pub inputAttachmentCount: u32,
9255    pub pInputAttachments: *const VkAttachmentReference,
9256    pub colorAttachmentCount: u32,
9257    pub pColorAttachments: *const VkAttachmentReference,
9258    pub pResolveAttachments: *const VkAttachmentReference,
9259    pub pDepthStencilAttachment: *const VkAttachmentReference,
9260    pub preserveAttachmentCount: u32,
9261    pub pPreserveAttachments: *const u32,
9262}
9263
9264#[derive(Debug, Clone)]
9265#[repr(C)]
9266#[rustfmt::skip]
9267pub struct VkSubresourceLayout {
9268    pub offset: VkDeviceSize,
9269    pub size: VkDeviceSize,
9270    pub rowPitch: VkDeviceSize,
9271    pub arrayPitch: VkDeviceSize,
9272    pub depthPitch: VkDeviceSize,
9273}
9274
9275#[cfg(all(feature = "VK_KHR_surface"))]
9276#[derive(Debug, Clone)]
9277#[repr(C)]
9278#[rustfmt::skip]
9279pub struct VkSurfaceCapabilitiesKHR {
9280    pub minImageCount: u32,
9281    pub maxImageCount: u32,
9282    pub currentExtent: VkExtent2D,
9283    pub minImageExtent: VkExtent2D,
9284    pub maxImageExtent: VkExtent2D,
9285    pub maxImageArrayLayers: u32,
9286    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
9287    pub currentTransform: VkSurfaceTransformFlagBitsKHR,
9288    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
9289    pub supportedUsageFlags: VkImageUsageFlags,
9290}
9291
9292#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9293#[derive(Debug, Clone)]
9294#[repr(C)]
9295#[rustfmt::skip]
9296pub struct VkSurfaceCapabilities2KHR {
9297    pub sType: VkStructureType,
9298    pub pNext: *mut core::ffi::c_void,
9299    pub surfaceCapabilities: VkSurfaceCapabilitiesKHR,
9300}
9301#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9302#[rustfmt::skip]
9303pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: VkStructureType = 1000119001;
9304#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9305#[rustfmt::skip]
9306unsafe impl crate::VulkanSinkStructure for VkSurfaceCapabilities2KHR {
9307    #[inline(always)]
9308    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
9309        unsafe { core::mem::transmute(self) }
9310    }
9311
9312    #[inline(always)]
9313    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
9314        unsafe { core::mem::transmute(self) }
9315    }
9316}
9317#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9318#[rustfmt::skip]
9319unsafe impl crate::TypedVulkanSinkStructure for VkSurfaceCapabilities2KHR {
9320    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR;
9321}
9322
9323#[cfg(all(feature = "VK_KHR_surface"))]
9324#[derive(Debug, Clone, Copy)]
9325#[repr(C)]
9326#[rustfmt::skip]
9327pub struct VkSurfaceFormatKHR {
9328    pub format: VkFormat,
9329    pub colorSpace: VkColorSpaceKHR,
9330}
9331
9332#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9333#[derive(Debug, Clone)]
9334#[repr(C)]
9335#[rustfmt::skip]
9336pub struct VkSurfaceFormat2KHR {
9337    pub sType: VkStructureType,
9338    pub pNext: *mut core::ffi::c_void,
9339    pub surfaceFormat: VkSurfaceFormatKHR,
9340}
9341#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9342#[rustfmt::skip]
9343pub const VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: VkStructureType = 1000119002;
9344#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9345#[rustfmt::skip]
9346unsafe impl crate::VulkanSinkStructure for VkSurfaceFormat2KHR {
9347    #[inline(always)]
9348    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
9349        unsafe { core::mem::transmute(self) }
9350    }
9351
9352    #[inline(always)]
9353    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
9354        unsafe { core::mem::transmute(self) }
9355    }
9356}
9357#[cfg(all(feature = "VK_KHR_get_surface_capabilities2"))]
9358#[rustfmt::skip]
9359unsafe impl crate::TypedVulkanSinkStructure for VkSurfaceFormat2KHR {
9360    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR;
9361}
9362
9363#[cfg(all(feature = "VK_KHR_swapchain"))]
9364#[derive(Debug, Clone)]
9365#[repr(C)]
9366#[rustfmt::skip]
9367pub struct VkSwapchainCreateInfoKHR {
9368    pub sType: VkStructureType,
9369    pub pNext: *const core::ffi::c_void,
9370    pub flags: VkSwapchainCreateFlagsKHR,
9371    pub surface: VkSurfaceKHR,
9372    pub minImageCount: u32,
9373    pub imageFormat: VkFormat,
9374    pub imageColorSpace: VkColorSpaceKHR,
9375    pub imageExtent: VkExtent2D,
9376    pub imageArrayLayers: u32,
9377    pub imageUsage: VkImageUsageFlags,
9378    pub imageSharingMode: VkSharingMode,
9379    pub queueFamilyIndexCount: u32,
9380    pub pQueueFamilyIndices: *const u32,
9381    pub preTransform: VkSurfaceTransformFlagBitsKHR,
9382    pub compositeAlpha: VkCompositeAlphaFlagBitsKHR,
9383    pub presentMode: VkPresentModeKHR,
9384    pub clipped: VkBool32,
9385    pub oldSwapchain: VkSwapchainKHR,
9386}
9387#[cfg(all(feature = "VK_KHR_swapchain"))]
9388#[rustfmt::skip]
9389pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000001000;
9390#[cfg(all(feature = "VK_KHR_swapchain"))]
9391#[rustfmt::skip]
9392unsafe impl crate::VulkanStructure for VkSwapchainCreateInfoKHR {
9393    #[inline(always)]
9394    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9395        unsafe { core::mem::transmute(self) }
9396    }
9397
9398    #[inline(always)]
9399    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9400        unsafe { core::mem::transmute(self) }
9401    }
9402}
9403#[cfg(all(feature = "VK_KHR_swapchain"))]
9404#[rustfmt::skip]
9405unsafe impl crate::TypedVulkanStructure for VkSwapchainCreateInfoKHR {
9406    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR;
9407}
9408
9409#[derive(Debug, Clone, Copy)]
9410#[repr(C)]
9411#[rustfmt::skip]
9412pub struct VkVertexInputAttributeDescription {
9413    pub location: u32,
9414    pub binding: u32,
9415    pub format: VkFormat,
9416    pub offset: u32,
9417}
9418
9419#[derive(Debug, Clone, Copy)]
9420#[repr(C)]
9421#[rustfmt::skip]
9422pub struct VkVertexInputBindingDescription {
9423    pub binding: u32,
9424    pub stride: u32,
9425    pub inputRate: VkVertexInputRate,
9426}
9427
9428#[derive(Debug, Clone)]
9429#[repr(C)]
9430#[rustfmt::skip]
9431pub struct VkViewport {
9432    pub x: core::ffi::c_float,
9433    pub y: core::ffi::c_float,
9434    pub width: core::ffi::c_float,
9435    pub height: core::ffi::c_float,
9436    pub minDepth: core::ffi::c_float,
9437    pub maxDepth: core::ffi::c_float,
9438}
9439
9440#[cfg(all(feature = "VK_KHR_wayland_surface"))]
9441#[derive(Debug, Clone)]
9442#[repr(C)]
9443#[rustfmt::skip]
9444pub struct VkWaylandSurfaceCreateInfoKHR {
9445    pub sType: VkStructureType,
9446    pub pNext: *const core::ffi::c_void,
9447    pub flags: VkWaylandSurfaceCreateFlagsKHR,
9448    pub display: *mut core::ffi::c_void,
9449    pub surface: *mut core::ffi::c_void,
9450}
9451#[cfg(all(feature = "VK_KHR_wayland_surface"))]
9452#[rustfmt::skip]
9453pub const VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000006000;
9454#[cfg(all(feature = "VK_KHR_wayland_surface"))]
9455#[rustfmt::skip]
9456unsafe impl crate::VulkanStructure for VkWaylandSurfaceCreateInfoKHR {
9457    #[inline(always)]
9458    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9459        unsafe { core::mem::transmute(self) }
9460    }
9461
9462    #[inline(always)]
9463    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9464        unsafe { core::mem::transmute(self) }
9465    }
9466}
9467#[cfg(all(feature = "VK_KHR_wayland_surface"))]
9468#[rustfmt::skip]
9469unsafe impl crate::TypedVulkanStructure for VkWaylandSurfaceCreateInfoKHR {
9470    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR;
9471}
9472
9473#[cfg(all(feature = "VK_KHR_win32_keyed_mutex"))]
9474#[derive(Debug, Clone)]
9475#[repr(C)]
9476#[rustfmt::skip]
9477pub struct VkWin32KeyedMutexAcquireReleaseInfoKHR {
9478    pub sType: VkStructureType,
9479    pub pNext: *const core::ffi::c_void,
9480    pub acquireCount: u32,
9481    pub pAcquireSyncs: *const VkDeviceMemory,
9482    pub pAcquireKeys: *const u64,
9483    pub pAcquireTimeouts: *const u32,
9484    pub releaseCount: u32,
9485    pub pReleaseSyncs: *const VkDeviceMemory,
9486    pub pReleaseKeys: *const u64,
9487}
9488#[cfg(all(feature = "VK_KHR_win32_keyed_mutex"))]
9489#[rustfmt::skip]
9490pub const VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: VkStructureType = 1000075000;
9491#[cfg(all(feature = "VK_KHR_win32_keyed_mutex"))]
9492#[rustfmt::skip]
9493unsafe impl crate::VulkanStructure for VkWin32KeyedMutexAcquireReleaseInfoKHR {
9494    #[inline(always)]
9495    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9496        unsafe { core::mem::transmute(self) }
9497    }
9498
9499    #[inline(always)]
9500    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9501        unsafe { core::mem::transmute(self) }
9502    }
9503}
9504#[cfg(all(feature = "VK_KHR_win32_keyed_mutex"))]
9505#[rustfmt::skip]
9506unsafe impl crate::TypedVulkanStructure for VkWin32KeyedMutexAcquireReleaseInfoKHR {
9507    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR;
9508}
9509
9510#[cfg(all(feature = "VK_KHR_win32_surface"))]
9511#[derive(Debug, Clone)]
9512#[repr(C)]
9513#[rustfmt::skip]
9514pub struct VkWin32SurfaceCreateInfoKHR {
9515    pub sType: VkStructureType,
9516    pub pNext: *const core::ffi::c_void,
9517    pub flags: VkWin32SurfaceCreateFlagsKHR,
9518    pub hinstance: windows::Win32::Foundation::HINSTANCE,
9519    pub hwnd: windows::Win32::Foundation::HWND,
9520}
9521#[cfg(all(feature = "VK_KHR_win32_surface"))]
9522#[rustfmt::skip]
9523pub const VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000009000;
9524#[cfg(all(feature = "VK_KHR_win32_surface"))]
9525#[rustfmt::skip]
9526unsafe impl crate::VulkanStructure for VkWin32SurfaceCreateInfoKHR {
9527    #[inline(always)]
9528    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9529        unsafe { core::mem::transmute(self) }
9530    }
9531
9532    #[inline(always)]
9533    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9534        unsafe { core::mem::transmute(self) }
9535    }
9536}
9537#[cfg(all(feature = "VK_KHR_win32_surface"))]
9538#[rustfmt::skip]
9539unsafe impl crate::TypedVulkanStructure for VkWin32SurfaceCreateInfoKHR {
9540    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR;
9541}
9542
9543#[derive(Debug, Clone)]
9544#[repr(C)]
9545#[rustfmt::skip]
9546pub struct VkWriteDescriptorSet {
9547    pub sType: VkStructureType,
9548    pub pNext: *const core::ffi::c_void,
9549    pub dstSet: VkDescriptorSet,
9550    pub dstBinding: u32,
9551    pub dstArrayElement: u32,
9552    pub descriptorCount: u32,
9553    pub descriptorType: VkDescriptorType,
9554    pub pImageInfo: *const VkDescriptorImageInfo,
9555    pub pBufferInfo: *const VkDescriptorBufferInfo,
9556    pub pTexelBufferView: *const VkBufferView,
9557}
9558#[rustfmt::skip]
9559pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = 35;
9560#[rustfmt::skip]
9561unsafe impl crate::VulkanStructure for VkWriteDescriptorSet {
9562    #[inline(always)]
9563    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9564        unsafe { core::mem::transmute(self) }
9565    }
9566
9567    #[inline(always)]
9568    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9569        unsafe { core::mem::transmute(self) }
9570    }
9571}
9572#[rustfmt::skip]
9573unsafe impl crate::TypedVulkanStructure for VkWriteDescriptorSet {
9574    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
9575}
9576
9577#[cfg(all(feature = "VK_KHR_xcb_surface"))]
9578#[derive(Debug, Clone)]
9579#[repr(C)]
9580#[rustfmt::skip]
9581pub struct VkXcbSurfaceCreateInfoKHR {
9582    pub sType: VkStructureType,
9583    pub pNext: *const core::ffi::c_void,
9584    pub flags: VkXcbSurfaceCreateFlagsKHR,
9585    pub connection: *mut xcb::ffi::xcb_connection_t,
9586    pub window: xcb::x::Window,
9587}
9588#[cfg(all(feature = "VK_KHR_xcb_surface"))]
9589#[rustfmt::skip]
9590pub const VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000005000;
9591#[cfg(all(feature = "VK_KHR_xcb_surface"))]
9592#[rustfmt::skip]
9593unsafe impl crate::VulkanStructure for VkXcbSurfaceCreateInfoKHR {
9594    #[inline(always)]
9595    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9596        unsafe { core::mem::transmute(self) }
9597    }
9598
9599    #[inline(always)]
9600    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9601        unsafe { core::mem::transmute(self) }
9602    }
9603}
9604#[cfg(all(feature = "VK_KHR_xcb_surface"))]
9605#[rustfmt::skip]
9606unsafe impl crate::TypedVulkanStructure for VkXcbSurfaceCreateInfoKHR {
9607    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR;
9608}
9609
9610#[cfg(all(feature = "VK_KHR_xlib_surface"))]
9611#[derive(Debug, Clone)]
9612#[repr(C)]
9613#[rustfmt::skip]
9614pub struct VkXlibSurfaceCreateInfoKHR {
9615    pub sType: VkStructureType,
9616    pub pNext: *const core::ffi::c_void,
9617    pub flags: VkXlibSurfaceCreateFlagsKHR,
9618    pub dpy: *mut x11::xlib::Display,
9619    pub window: x11::xlib::Window,
9620}
9621#[cfg(all(feature = "VK_KHR_xlib_surface"))]
9622#[rustfmt::skip]
9623pub const VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000004000;
9624#[cfg(all(feature = "VK_KHR_xlib_surface"))]
9625#[rustfmt::skip]
9626unsafe impl crate::VulkanStructure for VkXlibSurfaceCreateInfoKHR {
9627    #[inline(always)]
9628    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9629        unsafe { core::mem::transmute(self) }
9630    }
9631
9632    #[inline(always)]
9633    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9634        unsafe { core::mem::transmute(self) }
9635    }
9636}
9637#[cfg(all(feature = "VK_KHR_xlib_surface"))]
9638#[rustfmt::skip]
9639unsafe impl crate::TypedVulkanStructure for VkXlibSurfaceCreateInfoKHR {
9640    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR;
9641}
9642
9643#[cfg(all(feature = "VK_KHR_synchronization2"))]
9644#[derive(Debug, Clone)]
9645#[repr(C)]
9646#[rustfmt::skip]
9647pub struct VkMemoryBarrier2KHR {
9648    pub sType: VkStructureType,
9649    pub pNext: *const core::ffi::c_void,
9650    pub srcStageMask: VkPipelineStageFlags2KHR,
9651    pub srcAccessMask: VkAccessFlags2KHR,
9652    pub dstStageMask: VkPipelineStageFlags2KHR,
9653    pub dstAccessMask: VkAccessFlags2KHR,
9654}
9655#[cfg(all(feature = "VK_KHR_synchronization2"))]
9656#[rustfmt::skip]
9657pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: VkStructureType = 1000314000;
9658#[cfg(all(feature = "VK_KHR_synchronization2"))]
9659#[rustfmt::skip]
9660unsafe impl crate::VulkanStructure for VkMemoryBarrier2KHR {
9661    #[inline(always)]
9662    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9663        unsafe { core::mem::transmute(self) }
9664    }
9665
9666    #[inline(always)]
9667    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9668        unsafe { core::mem::transmute(self) }
9669    }
9670}
9671#[cfg(all(feature = "VK_KHR_synchronization2"))]
9672#[rustfmt::skip]
9673unsafe impl crate::TypedVulkanStructure for VkMemoryBarrier2KHR {
9674    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR;
9675}
9676#[cfg(feature = "Allow1_3APIs")]
9677#[rustfmt::skip]
9678pub type VkMemoryBarrier2 = VkMemoryBarrier2KHR;
9679#[cfg(feature = "Allow1_3APIs")]
9680#[rustfmt::skip]
9681pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR;
9682
9683#[cfg(all(feature = "VK_KHR_synchronization2"))]
9684#[derive(Debug, Clone)]
9685#[repr(C)]
9686#[rustfmt::skip]
9687pub struct VkBufferMemoryBarrier2KHR {
9688    pub sType: VkStructureType,
9689    pub pNext: *const core::ffi::c_void,
9690    pub srcStageMask: VkPipelineStageFlags2KHR,
9691    pub srcAccessMask: VkAccessFlags2KHR,
9692    pub dstStageMask: VkPipelineStageFlags2KHR,
9693    pub dstAccessMask: VkAccessFlags2KHR,
9694    pub srcQueueFamilyIndex: u32,
9695    pub dstQueueFamilyIndex: u32,
9696    pub buffer: VkBuffer,
9697    pub offset: VkDeviceSize,
9698    pub size: VkDeviceSize,
9699}
9700#[cfg(all(feature = "VK_KHR_synchronization2"))]
9701#[rustfmt::skip]
9702pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR: VkStructureType = 1000314001;
9703#[cfg(all(feature = "VK_KHR_synchronization2"))]
9704#[rustfmt::skip]
9705unsafe impl crate::VulkanStructure for VkBufferMemoryBarrier2KHR {
9706    #[inline(always)]
9707    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9708        unsafe { core::mem::transmute(self) }
9709    }
9710
9711    #[inline(always)]
9712    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9713        unsafe { core::mem::transmute(self) }
9714    }
9715}
9716#[cfg(all(feature = "VK_KHR_synchronization2"))]
9717#[rustfmt::skip]
9718unsafe impl crate::TypedVulkanStructure for VkBufferMemoryBarrier2KHR {
9719    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR;
9720}
9721#[cfg(feature = "Allow1_3APIs")]
9722#[rustfmt::skip]
9723pub type VkBufferMemoryBarrier2 = VkBufferMemoryBarrier2KHR;
9724#[cfg(feature = "Allow1_3APIs")]
9725#[rustfmt::skip]
9726pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR;
9727
9728#[cfg(all(feature = "VK_KHR_synchronization2"))]
9729#[derive(Debug, Clone)]
9730#[repr(C)]
9731#[rustfmt::skip]
9732pub struct VkImageMemoryBarrier2KHR {
9733    pub sType: VkStructureType,
9734    pub pNext: *const core::ffi::c_void,
9735    pub srcStageMask: VkPipelineStageFlags2KHR,
9736    pub srcAccessMask: VkAccessFlags2KHR,
9737    pub dstStageMask: VkPipelineStageFlags2KHR,
9738    pub dstAccessMask: VkAccessFlags2KHR,
9739    pub oldLayout: VkImageLayout,
9740    pub newLayout: VkImageLayout,
9741    pub srcQueueFamilyIndex: u32,
9742    pub dstQueueFamilyIndex: u32,
9743    pub image: VkImage,
9744    pub subresourceRange: VkImageSubresourceRange,
9745}
9746#[cfg(all(feature = "VK_KHR_synchronization2"))]
9747#[rustfmt::skip]
9748pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR: VkStructureType = 1000314002;
9749#[cfg(all(feature = "VK_KHR_synchronization2"))]
9750#[rustfmt::skip]
9751unsafe impl crate::VulkanStructure for VkImageMemoryBarrier2KHR {
9752    #[inline(always)]
9753    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9754        unsafe { core::mem::transmute(self) }
9755    }
9756
9757    #[inline(always)]
9758    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9759        unsafe { core::mem::transmute(self) }
9760    }
9761}
9762#[cfg(all(feature = "VK_KHR_synchronization2"))]
9763#[rustfmt::skip]
9764unsafe impl crate::TypedVulkanStructure for VkImageMemoryBarrier2KHR {
9765    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR;
9766}
9767#[cfg(feature = "Allow1_3APIs")]
9768#[rustfmt::skip]
9769pub type VkImageMemoryBarrier2 = VkImageMemoryBarrier2KHR;
9770#[cfg(feature = "Allow1_3APIs")]
9771#[rustfmt::skip]
9772pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR;
9773
9774#[cfg(all(feature = "VK_KHR_synchronization2"))]
9775#[derive(Debug, Clone)]
9776#[repr(C)]
9777#[rustfmt::skip]
9778pub struct VkDependencyInfoKHR {
9779    pub sType: VkStructureType,
9780    pub pNext: *const core::ffi::c_void,
9781    pub dependencyFlags: VkDependencyFlags,
9782    pub memoryBarrierCount: u32,
9783    pub pMemoryBarriers: *const VkMemoryBarrier2KHR,
9784    pub bufferMemoryBarrierCount: u32,
9785    pub pBufferMemoryBarriers: *const VkBufferMemoryBarrier2KHR,
9786    pub imageMemoryBarrierCount: u32,
9787    pub pImageMemoryBarriers: *const VkImageMemoryBarrier2KHR,
9788}
9789#[cfg(all(feature = "VK_KHR_synchronization2"))]
9790#[rustfmt::skip]
9791pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR: VkStructureType = 1000314003;
9792#[cfg(all(feature = "VK_KHR_synchronization2"))]
9793#[rustfmt::skip]
9794unsafe impl crate::VulkanStructure for VkDependencyInfoKHR {
9795    #[inline(always)]
9796    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9797        unsafe { core::mem::transmute(self) }
9798    }
9799
9800    #[inline(always)]
9801    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9802        unsafe { core::mem::transmute(self) }
9803    }
9804}
9805#[cfg(all(feature = "VK_KHR_synchronization2"))]
9806#[rustfmt::skip]
9807unsafe impl crate::TypedVulkanStructure for VkDependencyInfoKHR {
9808    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR;
9809}
9810#[cfg(feature = "Allow1_3APIs")]
9811#[rustfmt::skip]
9812pub type VkDependencyInfo = VkDependencyInfoKHR;
9813#[cfg(feature = "Allow1_3APIs")]
9814#[rustfmt::skip]
9815pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO: VkStructureType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR;
9816
9817#[cfg(all(feature = "VK_KHR_synchronization2"))]
9818#[derive(Debug, Clone)]
9819#[repr(C)]
9820#[rustfmt::skip]
9821pub struct VkSubmitInfo2KHR {
9822    pub sType: VkStructureType,
9823    pub pNext: *const core::ffi::c_void,
9824    pub flags: VkSubmitFlagsKHR,
9825    pub waitSemaphoreInfoCount: u32,
9826    pub pWaitSemaphoreInfos: *const VkSemaphoreSubmitInfoKHR,
9827    pub commandBufferInfoCount: u32,
9828    pub pCommandBufferInfos: *const VkCommandBufferSubmitInfoKHR,
9829    pub signalSemaphoreInfoCount: u32,
9830    pub pSignalSemaphoreInfos: *const VkSemaphoreSubmitInfoKHR,
9831}
9832#[cfg(all(feature = "VK_KHR_synchronization2"))]
9833#[rustfmt::skip]
9834pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR: VkStructureType = 1000314004;
9835#[cfg(all(feature = "VK_KHR_synchronization2"))]
9836#[rustfmt::skip]
9837unsafe impl crate::VulkanStructure for VkSubmitInfo2KHR {
9838    #[inline(always)]
9839    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9840        unsafe { core::mem::transmute(self) }
9841    }
9842
9843    #[inline(always)]
9844    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9845        unsafe { core::mem::transmute(self) }
9846    }
9847}
9848#[cfg(all(feature = "VK_KHR_synchronization2"))]
9849#[rustfmt::skip]
9850unsafe impl crate::TypedVulkanStructure for VkSubmitInfo2KHR {
9851    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR;
9852}
9853#[cfg(feature = "Allow1_3APIs")]
9854#[rustfmt::skip]
9855pub type VkSubmitInfo2 = VkSubmitInfo2KHR;
9856#[cfg(feature = "Allow1_3APIs")]
9857#[rustfmt::skip]
9858pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR;
9859
9860#[cfg(all(feature = "VK_KHR_synchronization2"))]
9861#[derive(Debug, Clone)]
9862#[repr(C)]
9863#[rustfmt::skip]
9864pub struct VkSemaphoreSubmitInfoKHR {
9865    pub sType: VkStructureType,
9866    pub pNext: *const core::ffi::c_void,
9867    pub semaphore: VkSemaphore,
9868    pub value: u64,
9869    pub stageMask: VkPipelineStageFlags2KHR,
9870    pub deviceIndex: u32,
9871}
9872#[cfg(all(feature = "VK_KHR_synchronization2"))]
9873#[rustfmt::skip]
9874pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = 1000314005;
9875#[cfg(all(feature = "VK_KHR_synchronization2"))]
9876#[rustfmt::skip]
9877unsafe impl crate::VulkanStructure for VkSemaphoreSubmitInfoKHR {
9878    #[inline(always)]
9879    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9880        unsafe { core::mem::transmute(self) }
9881    }
9882
9883    #[inline(always)]
9884    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9885        unsafe { core::mem::transmute(self) }
9886    }
9887}
9888#[cfg(all(feature = "VK_KHR_synchronization2"))]
9889#[rustfmt::skip]
9890unsafe impl crate::TypedVulkanStructure for VkSemaphoreSubmitInfoKHR {
9891    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR;
9892}
9893#[cfg(feature = "Allow1_3APIs")]
9894#[rustfmt::skip]
9895pub type VkSemaphoreSubmitInfo = VkSemaphoreSubmitInfoKHR;
9896#[cfg(feature = "Allow1_3APIs")]
9897#[rustfmt::skip]
9898pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR;
9899
9900#[cfg(all(feature = "VK_KHR_synchronization2"))]
9901#[derive(Debug, Clone)]
9902#[repr(C)]
9903#[rustfmt::skip]
9904pub struct VkCommandBufferSubmitInfoKHR {
9905    pub sType: VkStructureType,
9906    pub pNext: *const core::ffi::c_void,
9907    pub commandBuffer: VkCommandBuffer,
9908    pub deviceMask: u32,
9909}
9910#[cfg(all(feature = "VK_KHR_synchronization2"))]
9911#[rustfmt::skip]
9912pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR: VkStructureType = 1000314006;
9913#[cfg(all(feature = "VK_KHR_synchronization2"))]
9914#[rustfmt::skip]
9915unsafe impl crate::VulkanStructure for VkCommandBufferSubmitInfoKHR {
9916    #[inline(always)]
9917    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9918        unsafe { core::mem::transmute(self) }
9919    }
9920
9921    #[inline(always)]
9922    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9923        unsafe { core::mem::transmute(self) }
9924    }
9925}
9926#[cfg(all(feature = "VK_KHR_synchronization2"))]
9927#[rustfmt::skip]
9928unsafe impl crate::TypedVulkanStructure for VkCommandBufferSubmitInfoKHR {
9929    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR;
9930}
9931#[cfg(feature = "Allow1_3APIs")]
9932#[rustfmt::skip]
9933pub type VkCommandBufferSubmitInfo = VkCommandBufferSubmitInfoKHR;
9934#[cfg(feature = "Allow1_3APIs")]
9935#[rustfmt::skip]
9936pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR;
9937
9938#[cfg(all(feature = "VK_KHR_synchronization2"))]
9939#[derive(Debug, Clone)]
9940#[repr(C)]
9941#[rustfmt::skip]
9942pub struct VkPhysicalDeviceSynchronization2FeaturesKHR {
9943    pub sType: VkStructureType,
9944    pub pNext: *mut core::ffi::c_void,
9945    pub synchronization2: VkBool32,
9946}
9947#[cfg(all(feature = "VK_KHR_synchronization2"))]
9948#[rustfmt::skip]
9949pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: VkStructureType = 1000314007;
9950#[cfg(all(feature = "VK_KHR_synchronization2"))]
9951#[rustfmt::skip]
9952unsafe impl crate::VulkanStructure for VkPhysicalDeviceSynchronization2FeaturesKHR {
9953    #[inline(always)]
9954    fn as_generic(&self) -> &crate::GenericVulkanStructure {
9955        unsafe { core::mem::transmute(self) }
9956    }
9957
9958    #[inline(always)]
9959    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
9960        unsafe { core::mem::transmute(self) }
9961    }
9962}
9963#[cfg(all(feature = "VK_KHR_synchronization2"))]
9964#[rustfmt::skip]
9965unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceSynchronization2FeaturesKHR {
9966    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR;
9967}
9968#[cfg(all(feature = "VK_KHR_synchronization2"))]
9969#[rustfmt::skip]
9970unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceSynchronization2FeaturesKHR {
9971    #[inline(always)]
9972    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
9973        unsafe { core::mem::transmute(self) }
9974    }
9975
9976    #[inline(always)]
9977    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
9978        unsafe { core::mem::transmute(self) }
9979    }
9980}
9981#[cfg(all(feature = "VK_KHR_synchronization2"))]
9982#[rustfmt::skip]
9983unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceSynchronization2FeaturesKHR {
9984    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR;
9985}
9986#[cfg(feature = "Allow1_3APIs")]
9987#[rustfmt::skip]
9988pub type VkPhysicalDeviceSynchronization2Features = VkPhysicalDeviceSynchronization2FeaturesKHR;
9989#[cfg(feature = "Allow1_3APIs")]
9990#[rustfmt::skip]
9991pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR;
9992#[cfg(any(feature = "VK_KHR_external_fence_capabilities", feature = "VK_KHR_external_memory_capabilities", feature = "VK_KHR_external_semaphore_capabilities"))]
9993#[derive(Debug, Clone)]
9994#[repr(C)]
9995#[rustfmt::skip]
9996pub struct VkPhysicalDeviceIDPropertiesKHR {
9997    pub sType: VkStructureType,
9998    pub pNext: *mut core::ffi::c_void,
9999    pub deviceUUID: [u8; VK_UUID_SIZE],
10000    pub driverUUID: [u8; VK_UUID_SIZE],
10001    pub deviceLUID: [u8; VK_LUID_SIZE_KHR],
10002    pub deviceNodeMask: u32,
10003    pub deviceLUIDValid: VkBool32,
10004}
10005#[cfg(any(feature = "VK_KHR_external_fence_capabilities", feature = "VK_KHR_external_memory_capabilities", feature = "VK_KHR_external_semaphore_capabilities"))]
10006#[rustfmt::skip]
10007pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: VkStructureType = 1000071004;
10008#[cfg(any(feature = "VK_KHR_external_fence_capabilities", feature = "VK_KHR_external_memory_capabilities", feature = "VK_KHR_external_semaphore_capabilities"))]
10009#[rustfmt::skip]
10010unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceIDPropertiesKHR {
10011    #[inline(always)]
10012    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
10013        unsafe { core::mem::transmute(self) }
10014    }
10015
10016    #[inline(always)]
10017    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
10018        unsafe { core::mem::transmute(self) }
10019    }
10020}
10021#[cfg(any(feature = "VK_KHR_external_fence_capabilities", feature = "VK_KHR_external_memory_capabilities", feature = "VK_KHR_external_semaphore_capabilities"))]
10022#[rustfmt::skip]
10023unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceIDPropertiesKHR {
10024    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR;
10025}
10026#[cfg(feature = "Allow1_1APIs")]
10027#[rustfmt::skip]
10028pub type VkPhysicalDeviceIDProperties = VkPhysicalDeviceIDPropertiesKHR;
10029#[cfg(feature = "Allow1_1APIs")]
10030#[rustfmt::skip]
10031pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR;
10032#[cfg(feature = "VK_KHR_variable_pointers")]
10033#[rustfmt::skip]
10034pub type VkPhysicalDeviceVariablePointerFeaturesKHR = VkPhysicalDeviceVariablePointersFeaturesKHR;
10035#[cfg(feature = "VK_KHR_variable_pointers")]
10036#[rustfmt::skip]
10037pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
10038
10039#[derive(Clone, Copy)]
10040#[repr(C)]
10041#[rustfmt::skip]
10042pub union VkClearColorValue {
10043    pub float32: [core::ffi::c_float; 4],
10044    pub int32: [i32; 4],
10045    pub uint32: [u32; 4],
10046}
10047
10048#[derive(Clone, Copy)]
10049#[repr(C)]
10050#[rustfmt::skip]
10051pub union VkClearValue {
10052    pub color: VkClearColorValue,
10053    pub depthStencil: VkClearDepthStencilValue,
10054}
10055
10056#[cfg(feature = "Implements")]
10057#[repr(transparent)]
10058#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10059#[rustfmt::skip]
10060pub struct PFN_vkCreateInstance(pub unsafe extern "system" fn(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult);
10061#[cfg(feature = "Implements")]
10062#[rustfmt::skip]
10063unsafe impl crate::resolver::PFN for PFN_vkCreateInstance {
10064    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateInstance";
10065
10066    #[inline(always)]
10067    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10068        unsafe { core::mem::transmute(p) }
10069    }
10070    #[inline(always)]
10071    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10072        unsafe { core::mem::transmute(p) }
10073    }
10074}
10075#[cfg(not(feature = "DynamicLoaded"))]
10076#[cfg(feature = "Implements")]
10077#[rustfmt::skip]
10078impl crate::resolver::StaticCallable for PFN_vkCreateInstance {
10079    const STATIC: Self = Self(vkCreateInstance);
10080}
10081
10082#[cfg(feature = "Implements")]
10083#[repr(transparent)]
10084#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10085#[rustfmt::skip]
10086pub struct PFN_vkDestroyInstance(pub unsafe extern "system" fn(instance: VkInstance, pAllocator: *const VkAllocationCallbacks));
10087#[cfg(feature = "Implements")]
10088#[rustfmt::skip]
10089unsafe impl crate::resolver::PFN for PFN_vkDestroyInstance {
10090    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyInstance";
10091
10092    #[inline(always)]
10093    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10094        unsafe { core::mem::transmute(p) }
10095    }
10096    #[inline(always)]
10097    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10098        unsafe { core::mem::transmute(p) }
10099    }
10100}
10101#[cfg(not(feature = "DynamicLoaded"))]
10102#[cfg(feature = "Implements")]
10103#[rustfmt::skip]
10104impl crate::resolver::StaticCallable for PFN_vkDestroyInstance {
10105    const STATIC: Self = Self(vkDestroyInstance);
10106}
10107
10108#[cfg(feature = "Implements")]
10109#[repr(transparent)]
10110#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10111#[rustfmt::skip]
10112pub struct PFN_vkEnumeratePhysicalDevices(pub unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult);
10113#[cfg(feature = "Implements")]
10114#[rustfmt::skip]
10115unsafe impl crate::resolver::PFN for PFN_vkEnumeratePhysicalDevices {
10116    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumeratePhysicalDevices";
10117
10118    #[inline(always)]
10119    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10120        unsafe { core::mem::transmute(p) }
10121    }
10122    #[inline(always)]
10123    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10124        unsafe { core::mem::transmute(p) }
10125    }
10126}
10127#[cfg(not(feature = "DynamicLoaded"))]
10128#[cfg(feature = "Implements")]
10129#[rustfmt::skip]
10130impl crate::resolver::StaticCallable for PFN_vkEnumeratePhysicalDevices {
10131    const STATIC: Self = Self(vkEnumeratePhysicalDevices);
10132}
10133
10134#[cfg(feature = "Implements")]
10135#[repr(transparent)]
10136#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10137#[rustfmt::skip]
10138pub struct PFN_vkGetPhysicalDeviceFeatures(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures));
10139#[cfg(feature = "Implements")]
10140#[rustfmt::skip]
10141unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceFeatures {
10142    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceFeatures";
10143
10144    #[inline(always)]
10145    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10146        unsafe { core::mem::transmute(p) }
10147    }
10148    #[inline(always)]
10149    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10150        unsafe { core::mem::transmute(p) }
10151    }
10152}
10153#[cfg(not(feature = "DynamicLoaded"))]
10154#[cfg(feature = "Implements")]
10155#[rustfmt::skip]
10156impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceFeatures {
10157    const STATIC: Self = Self(vkGetPhysicalDeviceFeatures);
10158}
10159
10160#[cfg(feature = "Implements")]
10161#[repr(transparent)]
10162#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10163#[rustfmt::skip]
10164pub struct PFN_vkGetPhysicalDeviceFormatProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties));
10165#[cfg(feature = "Implements")]
10166#[rustfmt::skip]
10167unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceFormatProperties {
10168    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceFormatProperties";
10169
10170    #[inline(always)]
10171    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10172        unsafe { core::mem::transmute(p) }
10173    }
10174    #[inline(always)]
10175    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10176        unsafe { core::mem::transmute(p) }
10177    }
10178}
10179#[cfg(not(feature = "DynamicLoaded"))]
10180#[cfg(feature = "Implements")]
10181#[rustfmt::skip]
10182impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceFormatProperties {
10183    const STATIC: Self = Self(vkGetPhysicalDeviceFormatProperties);
10184}
10185
10186#[cfg(feature = "Implements")]
10187#[repr(transparent)]
10188#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10189#[rustfmt::skip]
10190pub struct PFN_vkGetPhysicalDeviceImageFormatProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult);
10191#[cfg(feature = "Implements")]
10192#[rustfmt::skip]
10193unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceImageFormatProperties {
10194    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceImageFormatProperties";
10195
10196    #[inline(always)]
10197    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10198        unsafe { core::mem::transmute(p) }
10199    }
10200    #[inline(always)]
10201    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10202        unsafe { core::mem::transmute(p) }
10203    }
10204}
10205#[cfg(not(feature = "DynamicLoaded"))]
10206#[cfg(feature = "Implements")]
10207#[rustfmt::skip]
10208impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceImageFormatProperties {
10209    const STATIC: Self = Self(vkGetPhysicalDeviceImageFormatProperties);
10210}
10211
10212#[cfg(feature = "Implements")]
10213#[repr(transparent)]
10214#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10215#[rustfmt::skip]
10216pub struct PFN_vkGetPhysicalDeviceProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties));
10217#[cfg(feature = "Implements")]
10218#[rustfmt::skip]
10219unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceProperties {
10220    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceProperties";
10221
10222    #[inline(always)]
10223    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10224        unsafe { core::mem::transmute(p) }
10225    }
10226    #[inline(always)]
10227    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10228        unsafe { core::mem::transmute(p) }
10229    }
10230}
10231#[cfg(not(feature = "DynamicLoaded"))]
10232#[cfg(feature = "Implements")]
10233#[rustfmt::skip]
10234impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceProperties {
10235    const STATIC: Self = Self(vkGetPhysicalDeviceProperties);
10236}
10237
10238#[cfg(feature = "Implements")]
10239#[repr(transparent)]
10240#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10241#[rustfmt::skip]
10242pub struct PFN_vkGetPhysicalDeviceQueueFamilyProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties));
10243#[cfg(feature = "Implements")]
10244#[rustfmt::skip]
10245unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceQueueFamilyProperties {
10246    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceQueueFamilyProperties";
10247
10248    #[inline(always)]
10249    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10250        unsafe { core::mem::transmute(p) }
10251    }
10252    #[inline(always)]
10253    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10254        unsafe { core::mem::transmute(p) }
10255    }
10256}
10257#[cfg(not(feature = "DynamicLoaded"))]
10258#[cfg(feature = "Implements")]
10259#[rustfmt::skip]
10260impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceQueueFamilyProperties {
10261    const STATIC: Self = Self(vkGetPhysicalDeviceQueueFamilyProperties);
10262}
10263
10264#[cfg(feature = "Implements")]
10265#[repr(transparent)]
10266#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10267#[rustfmt::skip]
10268pub struct PFN_vkGetPhysicalDeviceMemoryProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties));
10269#[cfg(feature = "Implements")]
10270#[rustfmt::skip]
10271unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceMemoryProperties {
10272    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceMemoryProperties";
10273
10274    #[inline(always)]
10275    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10276        unsafe { core::mem::transmute(p) }
10277    }
10278    #[inline(always)]
10279    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10280        unsafe { core::mem::transmute(p) }
10281    }
10282}
10283#[cfg(not(feature = "DynamicLoaded"))]
10284#[cfg(feature = "Implements")]
10285#[rustfmt::skip]
10286impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceMemoryProperties {
10287    const STATIC: Self = Self(vkGetPhysicalDeviceMemoryProperties);
10288}
10289
10290#[cfg(feature = "Implements")]
10291#[repr(transparent)]
10292#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10293#[rustfmt::skip]
10294pub struct PFN_vkGetInstanceProcAddr(pub unsafe extern "system" fn(instance: VkInstance, pName: *const core::ffi::c_char) -> Option<PFN_vkVoidFunction>);
10295#[cfg(feature = "Implements")]
10296#[rustfmt::skip]
10297unsafe impl crate::resolver::PFN for PFN_vkGetInstanceProcAddr {
10298    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetInstanceProcAddr";
10299
10300    #[inline(always)]
10301    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10302        unsafe { core::mem::transmute(p) }
10303    }
10304    #[inline(always)]
10305    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10306        unsafe { core::mem::transmute(p) }
10307    }
10308}
10309#[cfg(not(feature = "DynamicLoaded"))]
10310#[cfg(feature = "Implements")]
10311#[rustfmt::skip]
10312impl crate::resolver::StaticCallable for PFN_vkGetInstanceProcAddr {
10313    const STATIC: Self = Self(vkGetInstanceProcAddr);
10314}
10315
10316#[cfg(feature = "Implements")]
10317#[repr(transparent)]
10318#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10319#[rustfmt::skip]
10320pub struct PFN_vkGetDeviceProcAddr(pub unsafe extern "system" fn(device: VkDevice, pName: *const core::ffi::c_char) -> Option<PFN_vkVoidFunction>);
10321#[cfg(feature = "Implements")]
10322#[rustfmt::skip]
10323unsafe impl crate::resolver::PFN for PFN_vkGetDeviceProcAddr {
10324    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceProcAddr";
10325
10326    #[inline(always)]
10327    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10328        unsafe { core::mem::transmute(p) }
10329    }
10330    #[inline(always)]
10331    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10332        unsafe { core::mem::transmute(p) }
10333    }
10334}
10335#[cfg(not(feature = "DynamicLoaded"))]
10336#[cfg(feature = "Implements")]
10337#[rustfmt::skip]
10338impl crate::resolver::StaticCallable for PFN_vkGetDeviceProcAddr {
10339    const STATIC: Self = Self(vkGetDeviceProcAddr);
10340}
10341
10342#[cfg(feature = "Implements")]
10343#[repr(transparent)]
10344#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10345#[rustfmt::skip]
10346pub struct PFN_vkCreateDevice(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult);
10347#[cfg(feature = "Implements")]
10348#[rustfmt::skip]
10349unsafe impl crate::resolver::PFN for PFN_vkCreateDevice {
10350    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDevice";
10351
10352    #[inline(always)]
10353    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10354        unsafe { core::mem::transmute(p) }
10355    }
10356    #[inline(always)]
10357    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10358        unsafe { core::mem::transmute(p) }
10359    }
10360}
10361#[cfg(not(feature = "DynamicLoaded"))]
10362#[cfg(feature = "Implements")]
10363#[rustfmt::skip]
10364impl crate::resolver::StaticCallable for PFN_vkCreateDevice {
10365    const STATIC: Self = Self(vkCreateDevice);
10366}
10367
10368#[cfg(feature = "Implements")]
10369#[repr(transparent)]
10370#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10371#[rustfmt::skip]
10372pub struct PFN_vkDestroyDevice(pub unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks));
10373#[cfg(feature = "Implements")]
10374#[rustfmt::skip]
10375unsafe impl crate::resolver::PFN for PFN_vkDestroyDevice {
10376    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyDevice";
10377
10378    #[inline(always)]
10379    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10380        unsafe { core::mem::transmute(p) }
10381    }
10382    #[inline(always)]
10383    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10384        unsafe { core::mem::transmute(p) }
10385    }
10386}
10387#[cfg(not(feature = "DynamicLoaded"))]
10388#[cfg(feature = "Implements")]
10389#[rustfmt::skip]
10390impl crate::resolver::StaticCallable for PFN_vkDestroyDevice {
10391    const STATIC: Self = Self(vkDestroyDevice);
10392}
10393
10394#[cfg(feature = "Implements")]
10395#[repr(transparent)]
10396#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10397#[rustfmt::skip]
10398pub struct PFN_vkEnumerateInstanceExtensionProperties(pub unsafe extern "system" fn(pLayerName: *const core::ffi::c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult);
10399#[cfg(feature = "Implements")]
10400#[rustfmt::skip]
10401unsafe impl crate::resolver::PFN for PFN_vkEnumerateInstanceExtensionProperties {
10402    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumerateInstanceExtensionProperties";
10403
10404    #[inline(always)]
10405    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10406        unsafe { core::mem::transmute(p) }
10407    }
10408    #[inline(always)]
10409    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10410        unsafe { core::mem::transmute(p) }
10411    }
10412}
10413#[cfg(not(feature = "DynamicLoaded"))]
10414#[cfg(feature = "Implements")]
10415#[rustfmt::skip]
10416impl crate::resolver::StaticCallable for PFN_vkEnumerateInstanceExtensionProperties {
10417    const STATIC: Self = Self(vkEnumerateInstanceExtensionProperties);
10418}
10419
10420#[cfg(feature = "Implements")]
10421#[repr(transparent)]
10422#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10423#[rustfmt::skip]
10424pub struct PFN_vkEnumerateDeviceExtensionProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pLayerName: *const core::ffi::c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult);
10425#[cfg(feature = "Implements")]
10426#[rustfmt::skip]
10427unsafe impl crate::resolver::PFN for PFN_vkEnumerateDeviceExtensionProperties {
10428    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumerateDeviceExtensionProperties";
10429
10430    #[inline(always)]
10431    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10432        unsafe { core::mem::transmute(p) }
10433    }
10434    #[inline(always)]
10435    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10436        unsafe { core::mem::transmute(p) }
10437    }
10438}
10439#[cfg(not(feature = "DynamicLoaded"))]
10440#[cfg(feature = "Implements")]
10441#[rustfmt::skip]
10442impl crate::resolver::StaticCallable for PFN_vkEnumerateDeviceExtensionProperties {
10443    const STATIC: Self = Self(vkEnumerateDeviceExtensionProperties);
10444}
10445
10446#[cfg(feature = "Implements")]
10447#[repr(transparent)]
10448#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10449#[rustfmt::skip]
10450pub struct PFN_vkEnumerateInstanceLayerProperties(pub unsafe extern "system" fn(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult);
10451#[cfg(feature = "Implements")]
10452#[rustfmt::skip]
10453unsafe impl crate::resolver::PFN for PFN_vkEnumerateInstanceLayerProperties {
10454    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumerateInstanceLayerProperties";
10455
10456    #[inline(always)]
10457    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10458        unsafe { core::mem::transmute(p) }
10459    }
10460    #[inline(always)]
10461    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10462        unsafe { core::mem::transmute(p) }
10463    }
10464}
10465#[cfg(not(feature = "DynamicLoaded"))]
10466#[cfg(feature = "Implements")]
10467#[rustfmt::skip]
10468impl crate::resolver::StaticCallable for PFN_vkEnumerateInstanceLayerProperties {
10469    const STATIC: Self = Self(vkEnumerateInstanceLayerProperties);
10470}
10471
10472#[cfg(feature = "Implements")]
10473#[repr(transparent)]
10474#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10475#[rustfmt::skip]
10476pub struct PFN_vkEnumerateDeviceLayerProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult);
10477#[cfg(feature = "Implements")]
10478#[rustfmt::skip]
10479unsafe impl crate::resolver::PFN for PFN_vkEnumerateDeviceLayerProperties {
10480    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumerateDeviceLayerProperties";
10481
10482    #[inline(always)]
10483    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10484        unsafe { core::mem::transmute(p) }
10485    }
10486    #[inline(always)]
10487    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10488        unsafe { core::mem::transmute(p) }
10489    }
10490}
10491#[cfg(not(feature = "DynamicLoaded"))]
10492#[cfg(feature = "Implements")]
10493#[rustfmt::skip]
10494impl crate::resolver::StaticCallable for PFN_vkEnumerateDeviceLayerProperties {
10495    const STATIC: Self = Self(vkEnumerateDeviceLayerProperties);
10496}
10497
10498#[cfg(feature = "Implements")]
10499#[repr(transparent)]
10500#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10501#[rustfmt::skip]
10502pub struct PFN_vkGetDeviceQueue(pub unsafe extern "system" fn(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue));
10503#[cfg(feature = "Implements")]
10504#[rustfmt::skip]
10505unsafe impl crate::resolver::PFN for PFN_vkGetDeviceQueue {
10506    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceQueue";
10507
10508    #[inline(always)]
10509    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10510        unsafe { core::mem::transmute(p) }
10511    }
10512    #[inline(always)]
10513    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10514        unsafe { core::mem::transmute(p) }
10515    }
10516}
10517#[cfg(not(feature = "DynamicLoaded"))]
10518#[cfg(feature = "Implements")]
10519#[rustfmt::skip]
10520impl crate::resolver::StaticCallable for PFN_vkGetDeviceQueue {
10521    const STATIC: Self = Self(vkGetDeviceQueue);
10522}
10523
10524#[cfg(feature = "Implements")]
10525#[repr(transparent)]
10526#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10527#[rustfmt::skip]
10528pub struct PFN_vkQueueSubmit(pub unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult);
10529#[cfg(feature = "Implements")]
10530#[rustfmt::skip]
10531unsafe impl crate::resolver::PFN for PFN_vkQueueSubmit {
10532    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueSubmit";
10533
10534    #[inline(always)]
10535    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10536        unsafe { core::mem::transmute(p) }
10537    }
10538    #[inline(always)]
10539    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10540        unsafe { core::mem::transmute(p) }
10541    }
10542}
10543#[cfg(not(feature = "DynamicLoaded"))]
10544#[cfg(feature = "Implements")]
10545#[rustfmt::skip]
10546impl crate::resolver::StaticCallable for PFN_vkQueueSubmit {
10547    const STATIC: Self = Self(vkQueueSubmit);
10548}
10549
10550#[cfg(feature = "Implements")]
10551#[repr(transparent)]
10552#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10553#[rustfmt::skip]
10554pub struct PFN_vkQueueWaitIdle(pub unsafe extern "system" fn(queue: VkQueue) -> VkResult);
10555#[cfg(feature = "Implements")]
10556#[rustfmt::skip]
10557unsafe impl crate::resolver::PFN for PFN_vkQueueWaitIdle {
10558    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueWaitIdle";
10559
10560    #[inline(always)]
10561    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10562        unsafe { core::mem::transmute(p) }
10563    }
10564    #[inline(always)]
10565    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10566        unsafe { core::mem::transmute(p) }
10567    }
10568}
10569#[cfg(not(feature = "DynamicLoaded"))]
10570#[cfg(feature = "Implements")]
10571#[rustfmt::skip]
10572impl crate::resolver::StaticCallable for PFN_vkQueueWaitIdle {
10573    const STATIC: Self = Self(vkQueueWaitIdle);
10574}
10575
10576#[cfg(feature = "Implements")]
10577#[repr(transparent)]
10578#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10579#[rustfmt::skip]
10580pub struct PFN_vkDeviceWaitIdle(pub unsafe extern "system" fn(device: VkDevice) -> VkResult);
10581#[cfg(feature = "Implements")]
10582#[rustfmt::skip]
10583unsafe impl crate::resolver::PFN for PFN_vkDeviceWaitIdle {
10584    const NAME_CSTR: &'static core::ffi::CStr = c"vkDeviceWaitIdle";
10585
10586    #[inline(always)]
10587    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10588        unsafe { core::mem::transmute(p) }
10589    }
10590    #[inline(always)]
10591    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10592        unsafe { core::mem::transmute(p) }
10593    }
10594}
10595#[cfg(not(feature = "DynamicLoaded"))]
10596#[cfg(feature = "Implements")]
10597#[rustfmt::skip]
10598impl crate::resolver::StaticCallable for PFN_vkDeviceWaitIdle {
10599    const STATIC: Self = Self(vkDeviceWaitIdle);
10600}
10601
10602#[cfg(feature = "Implements")]
10603#[repr(transparent)]
10604#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10605#[rustfmt::skip]
10606pub struct PFN_vkAllocateMemory(pub unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult);
10607#[cfg(feature = "Implements")]
10608#[rustfmt::skip]
10609unsafe impl crate::resolver::PFN for PFN_vkAllocateMemory {
10610    const NAME_CSTR: &'static core::ffi::CStr = c"vkAllocateMemory";
10611
10612    #[inline(always)]
10613    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10614        unsafe { core::mem::transmute(p) }
10615    }
10616    #[inline(always)]
10617    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10618        unsafe { core::mem::transmute(p) }
10619    }
10620}
10621#[cfg(not(feature = "DynamicLoaded"))]
10622#[cfg(feature = "Implements")]
10623#[rustfmt::skip]
10624impl crate::resolver::StaticCallable for PFN_vkAllocateMemory {
10625    const STATIC: Self = Self(vkAllocateMemory);
10626}
10627
10628#[cfg(feature = "Implements")]
10629#[repr(transparent)]
10630#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10631#[rustfmt::skip]
10632pub struct PFN_vkFreeMemory(pub unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks));
10633#[cfg(feature = "Implements")]
10634#[rustfmt::skip]
10635unsafe impl crate::resolver::PFN for PFN_vkFreeMemory {
10636    const NAME_CSTR: &'static core::ffi::CStr = c"vkFreeMemory";
10637
10638    #[inline(always)]
10639    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10640        unsafe { core::mem::transmute(p) }
10641    }
10642    #[inline(always)]
10643    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10644        unsafe { core::mem::transmute(p) }
10645    }
10646}
10647#[cfg(not(feature = "DynamicLoaded"))]
10648#[cfg(feature = "Implements")]
10649#[rustfmt::skip]
10650impl crate::resolver::StaticCallable for PFN_vkFreeMemory {
10651    const STATIC: Self = Self(vkFreeMemory);
10652}
10653
10654#[cfg(feature = "Implements")]
10655#[repr(transparent)]
10656#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10657#[rustfmt::skip]
10658pub struct PFN_vkMapMemory(pub unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut core::ffi::c_void) -> VkResult);
10659#[cfg(feature = "Implements")]
10660#[rustfmt::skip]
10661unsafe impl crate::resolver::PFN for PFN_vkMapMemory {
10662    const NAME_CSTR: &'static core::ffi::CStr = c"vkMapMemory";
10663
10664    #[inline(always)]
10665    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10666        unsafe { core::mem::transmute(p) }
10667    }
10668    #[inline(always)]
10669    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10670        unsafe { core::mem::transmute(p) }
10671    }
10672}
10673#[cfg(not(feature = "DynamicLoaded"))]
10674#[cfg(feature = "Implements")]
10675#[rustfmt::skip]
10676impl crate::resolver::StaticCallable for PFN_vkMapMemory {
10677    const STATIC: Self = Self(vkMapMemory);
10678}
10679
10680#[cfg(feature = "Implements")]
10681#[repr(transparent)]
10682#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10683#[rustfmt::skip]
10684pub struct PFN_vkUnmapMemory(pub unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory));
10685#[cfg(feature = "Implements")]
10686#[rustfmt::skip]
10687unsafe impl crate::resolver::PFN for PFN_vkUnmapMemory {
10688    const NAME_CSTR: &'static core::ffi::CStr = c"vkUnmapMemory";
10689
10690    #[inline(always)]
10691    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10692        unsafe { core::mem::transmute(p) }
10693    }
10694    #[inline(always)]
10695    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10696        unsafe { core::mem::transmute(p) }
10697    }
10698}
10699#[cfg(not(feature = "DynamicLoaded"))]
10700#[cfg(feature = "Implements")]
10701#[rustfmt::skip]
10702impl crate::resolver::StaticCallable for PFN_vkUnmapMemory {
10703    const STATIC: Self = Self(vkUnmapMemory);
10704}
10705
10706#[cfg(feature = "Implements")]
10707#[repr(transparent)]
10708#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10709#[rustfmt::skip]
10710pub struct PFN_vkFlushMappedMemoryRanges(pub unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult);
10711#[cfg(feature = "Implements")]
10712#[rustfmt::skip]
10713unsafe impl crate::resolver::PFN for PFN_vkFlushMappedMemoryRanges {
10714    const NAME_CSTR: &'static core::ffi::CStr = c"vkFlushMappedMemoryRanges";
10715
10716    #[inline(always)]
10717    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10718        unsafe { core::mem::transmute(p) }
10719    }
10720    #[inline(always)]
10721    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10722        unsafe { core::mem::transmute(p) }
10723    }
10724}
10725#[cfg(not(feature = "DynamicLoaded"))]
10726#[cfg(feature = "Implements")]
10727#[rustfmt::skip]
10728impl crate::resolver::StaticCallable for PFN_vkFlushMappedMemoryRanges {
10729    const STATIC: Self = Self(vkFlushMappedMemoryRanges);
10730}
10731
10732#[cfg(feature = "Implements")]
10733#[repr(transparent)]
10734#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10735#[rustfmt::skip]
10736pub struct PFN_vkInvalidateMappedMemoryRanges(pub unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult);
10737#[cfg(feature = "Implements")]
10738#[rustfmt::skip]
10739unsafe impl crate::resolver::PFN for PFN_vkInvalidateMappedMemoryRanges {
10740    const NAME_CSTR: &'static core::ffi::CStr = c"vkInvalidateMappedMemoryRanges";
10741
10742    #[inline(always)]
10743    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10744        unsafe { core::mem::transmute(p) }
10745    }
10746    #[inline(always)]
10747    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10748        unsafe { core::mem::transmute(p) }
10749    }
10750}
10751#[cfg(not(feature = "DynamicLoaded"))]
10752#[cfg(feature = "Implements")]
10753#[rustfmt::skip]
10754impl crate::resolver::StaticCallable for PFN_vkInvalidateMappedMemoryRanges {
10755    const STATIC: Self = Self(vkInvalidateMappedMemoryRanges);
10756}
10757
10758#[cfg(feature = "Implements")]
10759#[repr(transparent)]
10760#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10761#[rustfmt::skip]
10762pub struct PFN_vkGetDeviceMemoryCommitment(pub unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pCommitmentMemoryInBytes: *mut VkDeviceSize));
10763#[cfg(feature = "Implements")]
10764#[rustfmt::skip]
10765unsafe impl crate::resolver::PFN for PFN_vkGetDeviceMemoryCommitment {
10766    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceMemoryCommitment";
10767
10768    #[inline(always)]
10769    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10770        unsafe { core::mem::transmute(p) }
10771    }
10772    #[inline(always)]
10773    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10774        unsafe { core::mem::transmute(p) }
10775    }
10776}
10777#[cfg(not(feature = "DynamicLoaded"))]
10778#[cfg(feature = "Implements")]
10779#[rustfmt::skip]
10780impl crate::resolver::StaticCallable for PFN_vkGetDeviceMemoryCommitment {
10781    const STATIC: Self = Self(vkGetDeviceMemoryCommitment);
10782}
10783
10784#[cfg(feature = "Implements")]
10785#[repr(transparent)]
10786#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10787#[rustfmt::skip]
10788pub struct PFN_vkBindBufferMemory(pub unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult);
10789#[cfg(feature = "Implements")]
10790#[rustfmt::skip]
10791unsafe impl crate::resolver::PFN for PFN_vkBindBufferMemory {
10792    const NAME_CSTR: &'static core::ffi::CStr = c"vkBindBufferMemory";
10793
10794    #[inline(always)]
10795    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10796        unsafe { core::mem::transmute(p) }
10797    }
10798    #[inline(always)]
10799    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10800        unsafe { core::mem::transmute(p) }
10801    }
10802}
10803#[cfg(not(feature = "DynamicLoaded"))]
10804#[cfg(feature = "Implements")]
10805#[rustfmt::skip]
10806impl crate::resolver::StaticCallable for PFN_vkBindBufferMemory {
10807    const STATIC: Self = Self(vkBindBufferMemory);
10808}
10809
10810#[cfg(feature = "Implements")]
10811#[repr(transparent)]
10812#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10813#[rustfmt::skip]
10814pub struct PFN_vkBindImageMemory(pub unsafe extern "system" fn(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult);
10815#[cfg(feature = "Implements")]
10816#[rustfmt::skip]
10817unsafe impl crate::resolver::PFN for PFN_vkBindImageMemory {
10818    const NAME_CSTR: &'static core::ffi::CStr = c"vkBindImageMemory";
10819
10820    #[inline(always)]
10821    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10822        unsafe { core::mem::transmute(p) }
10823    }
10824    #[inline(always)]
10825    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10826        unsafe { core::mem::transmute(p) }
10827    }
10828}
10829#[cfg(not(feature = "DynamicLoaded"))]
10830#[cfg(feature = "Implements")]
10831#[rustfmt::skip]
10832impl crate::resolver::StaticCallable for PFN_vkBindImageMemory {
10833    const STATIC: Self = Self(vkBindImageMemory);
10834}
10835
10836#[cfg(feature = "Implements")]
10837#[repr(transparent)]
10838#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10839#[rustfmt::skip]
10840pub struct PFN_vkGetBufferMemoryRequirements(pub unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements));
10841#[cfg(feature = "Implements")]
10842#[rustfmt::skip]
10843unsafe impl crate::resolver::PFN for PFN_vkGetBufferMemoryRequirements {
10844    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetBufferMemoryRequirements";
10845
10846    #[inline(always)]
10847    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10848        unsafe { core::mem::transmute(p) }
10849    }
10850    #[inline(always)]
10851    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10852        unsafe { core::mem::transmute(p) }
10853    }
10854}
10855#[cfg(not(feature = "DynamicLoaded"))]
10856#[cfg(feature = "Implements")]
10857#[rustfmt::skip]
10858impl crate::resolver::StaticCallable for PFN_vkGetBufferMemoryRequirements {
10859    const STATIC: Self = Self(vkGetBufferMemoryRequirements);
10860}
10861
10862#[cfg(feature = "Implements")]
10863#[repr(transparent)]
10864#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10865#[rustfmt::skip]
10866pub struct PFN_vkGetImageMemoryRequirements(pub unsafe extern "system" fn(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements));
10867#[cfg(feature = "Implements")]
10868#[rustfmt::skip]
10869unsafe impl crate::resolver::PFN for PFN_vkGetImageMemoryRequirements {
10870    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetImageMemoryRequirements";
10871
10872    #[inline(always)]
10873    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10874        unsafe { core::mem::transmute(p) }
10875    }
10876    #[inline(always)]
10877    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10878        unsafe { core::mem::transmute(p) }
10879    }
10880}
10881#[cfg(not(feature = "DynamicLoaded"))]
10882#[cfg(feature = "Implements")]
10883#[rustfmt::skip]
10884impl crate::resolver::StaticCallable for PFN_vkGetImageMemoryRequirements {
10885    const STATIC: Self = Self(vkGetImageMemoryRequirements);
10886}
10887
10888#[cfg(feature = "Implements")]
10889#[repr(transparent)]
10890#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10891#[rustfmt::skip]
10892pub struct PFN_vkGetImageSparseMemoryRequirements(pub unsafe extern "system" fn(device: VkDevice, image: VkImage, pSparseMemoryRequirementsCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements));
10893#[cfg(feature = "Implements")]
10894#[rustfmt::skip]
10895unsafe impl crate::resolver::PFN for PFN_vkGetImageSparseMemoryRequirements {
10896    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetImageSparseMemoryRequirements";
10897
10898    #[inline(always)]
10899    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10900        unsafe { core::mem::transmute(p) }
10901    }
10902    #[inline(always)]
10903    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10904        unsafe { core::mem::transmute(p) }
10905    }
10906}
10907#[cfg(not(feature = "DynamicLoaded"))]
10908#[cfg(feature = "Implements")]
10909#[rustfmt::skip]
10910impl crate::resolver::StaticCallable for PFN_vkGetImageSparseMemoryRequirements {
10911    const STATIC: Self = Self(vkGetImageSparseMemoryRequirements);
10912}
10913
10914#[cfg(feature = "Implements")]
10915#[repr(transparent)]
10916#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10917#[rustfmt::skip]
10918pub struct PFN_vkGetPhysicalDeviceSparseImageFormatProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, samples: VkSampleCountFlags, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties));
10919#[cfg(feature = "Implements")]
10920#[rustfmt::skip]
10921unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSparseImageFormatProperties {
10922    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSparseImageFormatProperties";
10923
10924    #[inline(always)]
10925    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10926        unsafe { core::mem::transmute(p) }
10927    }
10928    #[inline(always)]
10929    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10930        unsafe { core::mem::transmute(p) }
10931    }
10932}
10933#[cfg(not(feature = "DynamicLoaded"))]
10934#[cfg(feature = "Implements")]
10935#[rustfmt::skip]
10936impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceSparseImageFormatProperties {
10937    const STATIC: Self = Self(vkGetPhysicalDeviceSparseImageFormatProperties);
10938}
10939
10940#[cfg(feature = "Implements")]
10941#[repr(transparent)]
10942#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10943#[rustfmt::skip]
10944pub struct PFN_vkQueueBindSparse(pub unsafe extern "system" fn(queue: VkQueue, bindInfoCount: u32, pBindInfos: *const VkBindSparseInfo, fence: VkFence) -> VkResult);
10945#[cfg(feature = "Implements")]
10946#[rustfmt::skip]
10947unsafe impl crate::resolver::PFN for PFN_vkQueueBindSparse {
10948    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueBindSparse";
10949
10950    #[inline(always)]
10951    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10952        unsafe { core::mem::transmute(p) }
10953    }
10954    #[inline(always)]
10955    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10956        unsafe { core::mem::transmute(p) }
10957    }
10958}
10959#[cfg(not(feature = "DynamicLoaded"))]
10960#[cfg(feature = "Implements")]
10961#[rustfmt::skip]
10962impl crate::resolver::StaticCallable for PFN_vkQueueBindSparse {
10963    const STATIC: Self = Self(vkQueueBindSparse);
10964}
10965
10966#[cfg(feature = "Implements")]
10967#[repr(transparent)]
10968#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10969#[rustfmt::skip]
10970pub struct PFN_vkCreateFence(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult);
10971#[cfg(feature = "Implements")]
10972#[rustfmt::skip]
10973unsafe impl crate::resolver::PFN for PFN_vkCreateFence {
10974    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateFence";
10975
10976    #[inline(always)]
10977    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
10978        unsafe { core::mem::transmute(p) }
10979    }
10980    #[inline(always)]
10981    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
10982        unsafe { core::mem::transmute(p) }
10983    }
10984}
10985#[cfg(not(feature = "DynamicLoaded"))]
10986#[cfg(feature = "Implements")]
10987#[rustfmt::skip]
10988impl crate::resolver::StaticCallable for PFN_vkCreateFence {
10989    const STATIC: Self = Self(vkCreateFence);
10990}
10991
10992#[cfg(feature = "Implements")]
10993#[repr(transparent)]
10994#[derive(Debug, Clone, Copy, PartialEq, Eq)]
10995#[rustfmt::skip]
10996pub struct PFN_vkDestroyFence(pub unsafe extern "system" fn(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks));
10997#[cfg(feature = "Implements")]
10998#[rustfmt::skip]
10999unsafe impl crate::resolver::PFN for PFN_vkDestroyFence {
11000    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyFence";
11001
11002    #[inline(always)]
11003    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11004        unsafe { core::mem::transmute(p) }
11005    }
11006    #[inline(always)]
11007    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11008        unsafe { core::mem::transmute(p) }
11009    }
11010}
11011#[cfg(not(feature = "DynamicLoaded"))]
11012#[cfg(feature = "Implements")]
11013#[rustfmt::skip]
11014impl crate::resolver::StaticCallable for PFN_vkDestroyFence {
11015    const STATIC: Self = Self(vkDestroyFence);
11016}
11017
11018#[cfg(feature = "Implements")]
11019#[repr(transparent)]
11020#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11021#[rustfmt::skip]
11022pub struct PFN_vkResetFences(pub unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult);
11023#[cfg(feature = "Implements")]
11024#[rustfmt::skip]
11025unsafe impl crate::resolver::PFN for PFN_vkResetFences {
11026    const NAME_CSTR: &'static core::ffi::CStr = c"vkResetFences";
11027
11028    #[inline(always)]
11029    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11030        unsafe { core::mem::transmute(p) }
11031    }
11032    #[inline(always)]
11033    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11034        unsafe { core::mem::transmute(p) }
11035    }
11036}
11037#[cfg(not(feature = "DynamicLoaded"))]
11038#[cfg(feature = "Implements")]
11039#[rustfmt::skip]
11040impl crate::resolver::StaticCallable for PFN_vkResetFences {
11041    const STATIC: Self = Self(vkResetFences);
11042}
11043
11044#[cfg(feature = "Implements")]
11045#[repr(transparent)]
11046#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11047#[rustfmt::skip]
11048pub struct PFN_vkGetFenceStatus(pub unsafe extern "system" fn(device: VkDevice, fence: VkFence) -> VkResult);
11049#[cfg(feature = "Implements")]
11050#[rustfmt::skip]
11051unsafe impl crate::resolver::PFN for PFN_vkGetFenceStatus {
11052    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetFenceStatus";
11053
11054    #[inline(always)]
11055    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11056        unsafe { core::mem::transmute(p) }
11057    }
11058    #[inline(always)]
11059    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11060        unsafe { core::mem::transmute(p) }
11061    }
11062}
11063#[cfg(not(feature = "DynamicLoaded"))]
11064#[cfg(feature = "Implements")]
11065#[rustfmt::skip]
11066impl crate::resolver::StaticCallable for PFN_vkGetFenceStatus {
11067    const STATIC: Self = Self(vkGetFenceStatus);
11068}
11069
11070#[cfg(feature = "Implements")]
11071#[repr(transparent)]
11072#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11073#[rustfmt::skip]
11074pub struct PFN_vkWaitForFences(pub unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult);
11075#[cfg(feature = "Implements")]
11076#[rustfmt::skip]
11077unsafe impl crate::resolver::PFN for PFN_vkWaitForFences {
11078    const NAME_CSTR: &'static core::ffi::CStr = c"vkWaitForFences";
11079
11080    #[inline(always)]
11081    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11082        unsafe { core::mem::transmute(p) }
11083    }
11084    #[inline(always)]
11085    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11086        unsafe { core::mem::transmute(p) }
11087    }
11088}
11089#[cfg(not(feature = "DynamicLoaded"))]
11090#[cfg(feature = "Implements")]
11091#[rustfmt::skip]
11092impl crate::resolver::StaticCallable for PFN_vkWaitForFences {
11093    const STATIC: Self = Self(vkWaitForFences);
11094}
11095
11096#[cfg(feature = "Implements")]
11097#[repr(transparent)]
11098#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11099#[rustfmt::skip]
11100pub struct PFN_vkCreateSemaphore(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult);
11101#[cfg(feature = "Implements")]
11102#[rustfmt::skip]
11103unsafe impl crate::resolver::PFN for PFN_vkCreateSemaphore {
11104    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateSemaphore";
11105
11106    #[inline(always)]
11107    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11108        unsafe { core::mem::transmute(p) }
11109    }
11110    #[inline(always)]
11111    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11112        unsafe { core::mem::transmute(p) }
11113    }
11114}
11115#[cfg(not(feature = "DynamicLoaded"))]
11116#[cfg(feature = "Implements")]
11117#[rustfmt::skip]
11118impl crate::resolver::StaticCallable for PFN_vkCreateSemaphore {
11119    const STATIC: Self = Self(vkCreateSemaphore);
11120}
11121
11122#[cfg(feature = "Implements")]
11123#[repr(transparent)]
11124#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11125#[rustfmt::skip]
11126pub struct PFN_vkDestroySemaphore(pub unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks));
11127#[cfg(feature = "Implements")]
11128#[rustfmt::skip]
11129unsafe impl crate::resolver::PFN for PFN_vkDestroySemaphore {
11130    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroySemaphore";
11131
11132    #[inline(always)]
11133    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11134        unsafe { core::mem::transmute(p) }
11135    }
11136    #[inline(always)]
11137    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11138        unsafe { core::mem::transmute(p) }
11139    }
11140}
11141#[cfg(not(feature = "DynamicLoaded"))]
11142#[cfg(feature = "Implements")]
11143#[rustfmt::skip]
11144impl crate::resolver::StaticCallable for PFN_vkDestroySemaphore {
11145    const STATIC: Self = Self(vkDestroySemaphore);
11146}
11147
11148#[cfg(feature = "Implements")]
11149#[repr(transparent)]
11150#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11151#[rustfmt::skip]
11152pub struct PFN_vkCreateEvent(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult);
11153#[cfg(feature = "Implements")]
11154#[rustfmt::skip]
11155unsafe impl crate::resolver::PFN for PFN_vkCreateEvent {
11156    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateEvent";
11157
11158    #[inline(always)]
11159    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11160        unsafe { core::mem::transmute(p) }
11161    }
11162    #[inline(always)]
11163    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11164        unsafe { core::mem::transmute(p) }
11165    }
11166}
11167#[cfg(not(feature = "DynamicLoaded"))]
11168#[cfg(feature = "Implements")]
11169#[rustfmt::skip]
11170impl crate::resolver::StaticCallable for PFN_vkCreateEvent {
11171    const STATIC: Self = Self(vkCreateEvent);
11172}
11173
11174#[cfg(feature = "Implements")]
11175#[repr(transparent)]
11176#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11177#[rustfmt::skip]
11178pub struct PFN_vkDestroyEvent(pub unsafe extern "system" fn(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks));
11179#[cfg(feature = "Implements")]
11180#[rustfmt::skip]
11181unsafe impl crate::resolver::PFN for PFN_vkDestroyEvent {
11182    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyEvent";
11183
11184    #[inline(always)]
11185    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11186        unsafe { core::mem::transmute(p) }
11187    }
11188    #[inline(always)]
11189    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11190        unsafe { core::mem::transmute(p) }
11191    }
11192}
11193#[cfg(not(feature = "DynamicLoaded"))]
11194#[cfg(feature = "Implements")]
11195#[rustfmt::skip]
11196impl crate::resolver::StaticCallable for PFN_vkDestroyEvent {
11197    const STATIC: Self = Self(vkDestroyEvent);
11198}
11199
11200#[cfg(feature = "Implements")]
11201#[repr(transparent)]
11202#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11203#[rustfmt::skip]
11204pub struct PFN_vkGetEventStatus(pub unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult);
11205#[cfg(feature = "Implements")]
11206#[rustfmt::skip]
11207unsafe impl crate::resolver::PFN for PFN_vkGetEventStatus {
11208    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetEventStatus";
11209
11210    #[inline(always)]
11211    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11212        unsafe { core::mem::transmute(p) }
11213    }
11214    #[inline(always)]
11215    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11216        unsafe { core::mem::transmute(p) }
11217    }
11218}
11219#[cfg(not(feature = "DynamicLoaded"))]
11220#[cfg(feature = "Implements")]
11221#[rustfmt::skip]
11222impl crate::resolver::StaticCallable for PFN_vkGetEventStatus {
11223    const STATIC: Self = Self(vkGetEventStatus);
11224}
11225
11226#[cfg(feature = "Implements")]
11227#[repr(transparent)]
11228#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11229#[rustfmt::skip]
11230pub struct PFN_vkSetEvent(pub unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult);
11231#[cfg(feature = "Implements")]
11232#[rustfmt::skip]
11233unsafe impl crate::resolver::PFN for PFN_vkSetEvent {
11234    const NAME_CSTR: &'static core::ffi::CStr = c"vkSetEvent";
11235
11236    #[inline(always)]
11237    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11238        unsafe { core::mem::transmute(p) }
11239    }
11240    #[inline(always)]
11241    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11242        unsafe { core::mem::transmute(p) }
11243    }
11244}
11245#[cfg(not(feature = "DynamicLoaded"))]
11246#[cfg(feature = "Implements")]
11247#[rustfmt::skip]
11248impl crate::resolver::StaticCallable for PFN_vkSetEvent {
11249    const STATIC: Self = Self(vkSetEvent);
11250}
11251
11252#[cfg(feature = "Implements")]
11253#[repr(transparent)]
11254#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11255#[rustfmt::skip]
11256pub struct PFN_vkResetEvent(pub unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult);
11257#[cfg(feature = "Implements")]
11258#[rustfmt::skip]
11259unsafe impl crate::resolver::PFN for PFN_vkResetEvent {
11260    const NAME_CSTR: &'static core::ffi::CStr = c"vkResetEvent";
11261
11262    #[inline(always)]
11263    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11264        unsafe { core::mem::transmute(p) }
11265    }
11266    #[inline(always)]
11267    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11268        unsafe { core::mem::transmute(p) }
11269    }
11270}
11271#[cfg(not(feature = "DynamicLoaded"))]
11272#[cfg(feature = "Implements")]
11273#[rustfmt::skip]
11274impl crate::resolver::StaticCallable for PFN_vkResetEvent {
11275    const STATIC: Self = Self(vkResetEvent);
11276}
11277
11278#[cfg(feature = "Implements")]
11279#[repr(transparent)]
11280#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11281#[rustfmt::skip]
11282pub struct PFN_vkCreateQueryPool(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult);
11283#[cfg(feature = "Implements")]
11284#[rustfmt::skip]
11285unsafe impl crate::resolver::PFN for PFN_vkCreateQueryPool {
11286    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateQueryPool";
11287
11288    #[inline(always)]
11289    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11290        unsafe { core::mem::transmute(p) }
11291    }
11292    #[inline(always)]
11293    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11294        unsafe { core::mem::transmute(p) }
11295    }
11296}
11297#[cfg(not(feature = "DynamicLoaded"))]
11298#[cfg(feature = "Implements")]
11299#[rustfmt::skip]
11300impl crate::resolver::StaticCallable for PFN_vkCreateQueryPool {
11301    const STATIC: Self = Self(vkCreateQueryPool);
11302}
11303
11304#[cfg(feature = "Implements")]
11305#[repr(transparent)]
11306#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11307#[rustfmt::skip]
11308pub struct PFN_vkDestroyQueryPool(pub unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks));
11309#[cfg(feature = "Implements")]
11310#[rustfmt::skip]
11311unsafe impl crate::resolver::PFN for PFN_vkDestroyQueryPool {
11312    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyQueryPool";
11313
11314    #[inline(always)]
11315    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11316        unsafe { core::mem::transmute(p) }
11317    }
11318    #[inline(always)]
11319    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11320        unsafe { core::mem::transmute(p) }
11321    }
11322}
11323#[cfg(not(feature = "DynamicLoaded"))]
11324#[cfg(feature = "Implements")]
11325#[rustfmt::skip]
11326impl crate::resolver::StaticCallable for PFN_vkDestroyQueryPool {
11327    const STATIC: Self = Self(vkDestroyQueryPool);
11328}
11329
11330#[cfg(feature = "Implements")]
11331#[repr(transparent)]
11332#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11333#[rustfmt::skip]
11334pub struct PFN_vkGetQueryPoolResults(pub unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *mut core::ffi::c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult);
11335#[cfg(feature = "Implements")]
11336#[rustfmt::skip]
11337unsafe impl crate::resolver::PFN for PFN_vkGetQueryPoolResults {
11338    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetQueryPoolResults";
11339
11340    #[inline(always)]
11341    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11342        unsafe { core::mem::transmute(p) }
11343    }
11344    #[inline(always)]
11345    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11346        unsafe { core::mem::transmute(p) }
11347    }
11348}
11349#[cfg(not(feature = "DynamicLoaded"))]
11350#[cfg(feature = "Implements")]
11351#[rustfmt::skip]
11352impl crate::resolver::StaticCallable for PFN_vkGetQueryPoolResults {
11353    const STATIC: Self = Self(vkGetQueryPoolResults);
11354}
11355
11356#[cfg(feature = "Implements")]
11357#[repr(transparent)]
11358#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11359#[rustfmt::skip]
11360pub struct PFN_vkCreateBuffer(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult);
11361#[cfg(feature = "Implements")]
11362#[rustfmt::skip]
11363unsafe impl crate::resolver::PFN for PFN_vkCreateBuffer {
11364    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateBuffer";
11365
11366    #[inline(always)]
11367    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11368        unsafe { core::mem::transmute(p) }
11369    }
11370    #[inline(always)]
11371    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11372        unsafe { core::mem::transmute(p) }
11373    }
11374}
11375#[cfg(not(feature = "DynamicLoaded"))]
11376#[cfg(feature = "Implements")]
11377#[rustfmt::skip]
11378impl crate::resolver::StaticCallable for PFN_vkCreateBuffer {
11379    const STATIC: Self = Self(vkCreateBuffer);
11380}
11381
11382#[cfg(feature = "Implements")]
11383#[repr(transparent)]
11384#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11385#[rustfmt::skip]
11386pub struct PFN_vkDestroyBuffer(pub unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks));
11387#[cfg(feature = "Implements")]
11388#[rustfmt::skip]
11389unsafe impl crate::resolver::PFN for PFN_vkDestroyBuffer {
11390    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyBuffer";
11391
11392    #[inline(always)]
11393    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11394        unsafe { core::mem::transmute(p) }
11395    }
11396    #[inline(always)]
11397    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11398        unsafe { core::mem::transmute(p) }
11399    }
11400}
11401#[cfg(not(feature = "DynamicLoaded"))]
11402#[cfg(feature = "Implements")]
11403#[rustfmt::skip]
11404impl crate::resolver::StaticCallable for PFN_vkDestroyBuffer {
11405    const STATIC: Self = Self(vkDestroyBuffer);
11406}
11407
11408#[cfg(feature = "Implements")]
11409#[repr(transparent)]
11410#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11411#[rustfmt::skip]
11412pub struct PFN_vkCreateBufferView(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult);
11413#[cfg(feature = "Implements")]
11414#[rustfmt::skip]
11415unsafe impl crate::resolver::PFN for PFN_vkCreateBufferView {
11416    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateBufferView";
11417
11418    #[inline(always)]
11419    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11420        unsafe { core::mem::transmute(p) }
11421    }
11422    #[inline(always)]
11423    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11424        unsafe { core::mem::transmute(p) }
11425    }
11426}
11427#[cfg(not(feature = "DynamicLoaded"))]
11428#[cfg(feature = "Implements")]
11429#[rustfmt::skip]
11430impl crate::resolver::StaticCallable for PFN_vkCreateBufferView {
11431    const STATIC: Self = Self(vkCreateBufferView);
11432}
11433
11434#[cfg(feature = "Implements")]
11435#[repr(transparent)]
11436#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11437#[rustfmt::skip]
11438pub struct PFN_vkDestroyBufferView(pub unsafe extern "system" fn(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks));
11439#[cfg(feature = "Implements")]
11440#[rustfmt::skip]
11441unsafe impl crate::resolver::PFN for PFN_vkDestroyBufferView {
11442    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyBufferView";
11443
11444    #[inline(always)]
11445    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11446        unsafe { core::mem::transmute(p) }
11447    }
11448    #[inline(always)]
11449    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11450        unsafe { core::mem::transmute(p) }
11451    }
11452}
11453#[cfg(not(feature = "DynamicLoaded"))]
11454#[cfg(feature = "Implements")]
11455#[rustfmt::skip]
11456impl crate::resolver::StaticCallable for PFN_vkDestroyBufferView {
11457    const STATIC: Self = Self(vkDestroyBufferView);
11458}
11459
11460#[cfg(feature = "Implements")]
11461#[repr(transparent)]
11462#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11463#[rustfmt::skip]
11464pub struct PFN_vkCreateImage(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult);
11465#[cfg(feature = "Implements")]
11466#[rustfmt::skip]
11467unsafe impl crate::resolver::PFN for PFN_vkCreateImage {
11468    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateImage";
11469
11470    #[inline(always)]
11471    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11472        unsafe { core::mem::transmute(p) }
11473    }
11474    #[inline(always)]
11475    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11476        unsafe { core::mem::transmute(p) }
11477    }
11478}
11479#[cfg(not(feature = "DynamicLoaded"))]
11480#[cfg(feature = "Implements")]
11481#[rustfmt::skip]
11482impl crate::resolver::StaticCallable for PFN_vkCreateImage {
11483    const STATIC: Self = Self(vkCreateImage);
11484}
11485
11486#[cfg(feature = "Implements")]
11487#[repr(transparent)]
11488#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11489#[rustfmt::skip]
11490pub struct PFN_vkDestroyImage(pub unsafe extern "system" fn(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks));
11491#[cfg(feature = "Implements")]
11492#[rustfmt::skip]
11493unsafe impl crate::resolver::PFN for PFN_vkDestroyImage {
11494    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyImage";
11495
11496    #[inline(always)]
11497    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11498        unsafe { core::mem::transmute(p) }
11499    }
11500    #[inline(always)]
11501    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11502        unsafe { core::mem::transmute(p) }
11503    }
11504}
11505#[cfg(not(feature = "DynamicLoaded"))]
11506#[cfg(feature = "Implements")]
11507#[rustfmt::skip]
11508impl crate::resolver::StaticCallable for PFN_vkDestroyImage {
11509    const STATIC: Self = Self(vkDestroyImage);
11510}
11511
11512#[cfg(feature = "Implements")]
11513#[repr(transparent)]
11514#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11515#[rustfmt::skip]
11516pub struct PFN_vkGetImageSubresourceLayout(pub unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout));
11517#[cfg(feature = "Implements")]
11518#[rustfmt::skip]
11519unsafe impl crate::resolver::PFN for PFN_vkGetImageSubresourceLayout {
11520    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetImageSubresourceLayout";
11521
11522    #[inline(always)]
11523    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11524        unsafe { core::mem::transmute(p) }
11525    }
11526    #[inline(always)]
11527    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11528        unsafe { core::mem::transmute(p) }
11529    }
11530}
11531#[cfg(not(feature = "DynamicLoaded"))]
11532#[cfg(feature = "Implements")]
11533#[rustfmt::skip]
11534impl crate::resolver::StaticCallable for PFN_vkGetImageSubresourceLayout {
11535    const STATIC: Self = Self(vkGetImageSubresourceLayout);
11536}
11537
11538#[cfg(feature = "Implements")]
11539#[repr(transparent)]
11540#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11541#[rustfmt::skip]
11542pub struct PFN_vkCreateImageView(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult);
11543#[cfg(feature = "Implements")]
11544#[rustfmt::skip]
11545unsafe impl crate::resolver::PFN for PFN_vkCreateImageView {
11546    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateImageView";
11547
11548    #[inline(always)]
11549    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11550        unsafe { core::mem::transmute(p) }
11551    }
11552    #[inline(always)]
11553    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11554        unsafe { core::mem::transmute(p) }
11555    }
11556}
11557#[cfg(not(feature = "DynamicLoaded"))]
11558#[cfg(feature = "Implements")]
11559#[rustfmt::skip]
11560impl crate::resolver::StaticCallable for PFN_vkCreateImageView {
11561    const STATIC: Self = Self(vkCreateImageView);
11562}
11563
11564#[cfg(feature = "Implements")]
11565#[repr(transparent)]
11566#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11567#[rustfmt::skip]
11568pub struct PFN_vkDestroyImageView(pub unsafe extern "system" fn(device: VkDevice, view: VkImageView, pAllocator: *const VkAllocationCallbacks));
11569#[cfg(feature = "Implements")]
11570#[rustfmt::skip]
11571unsafe impl crate::resolver::PFN for PFN_vkDestroyImageView {
11572    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyImageView";
11573
11574    #[inline(always)]
11575    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11576        unsafe { core::mem::transmute(p) }
11577    }
11578    #[inline(always)]
11579    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11580        unsafe { core::mem::transmute(p) }
11581    }
11582}
11583#[cfg(not(feature = "DynamicLoaded"))]
11584#[cfg(feature = "Implements")]
11585#[rustfmt::skip]
11586impl crate::resolver::StaticCallable for PFN_vkDestroyImageView {
11587    const STATIC: Self = Self(vkDestroyImageView);
11588}
11589
11590#[cfg(feature = "Implements")]
11591#[repr(transparent)]
11592#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11593#[rustfmt::skip]
11594pub struct PFN_vkCreateShaderModule(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkShaderModule) -> VkResult);
11595#[cfg(feature = "Implements")]
11596#[rustfmt::skip]
11597unsafe impl crate::resolver::PFN for PFN_vkCreateShaderModule {
11598    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateShaderModule";
11599
11600    #[inline(always)]
11601    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11602        unsafe { core::mem::transmute(p) }
11603    }
11604    #[inline(always)]
11605    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11606        unsafe { core::mem::transmute(p) }
11607    }
11608}
11609#[cfg(not(feature = "DynamicLoaded"))]
11610#[cfg(feature = "Implements")]
11611#[rustfmt::skip]
11612impl crate::resolver::StaticCallable for PFN_vkCreateShaderModule {
11613    const STATIC: Self = Self(vkCreateShaderModule);
11614}
11615
11616#[cfg(feature = "Implements")]
11617#[repr(transparent)]
11618#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11619#[rustfmt::skip]
11620pub struct PFN_vkDestroyShaderModule(pub unsafe extern "system" fn(device: VkDevice, module: VkShaderModule, pAllocator: *const VkAllocationCallbacks));
11621#[cfg(feature = "Implements")]
11622#[rustfmt::skip]
11623unsafe impl crate::resolver::PFN for PFN_vkDestroyShaderModule {
11624    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyShaderModule";
11625
11626    #[inline(always)]
11627    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11628        unsafe { core::mem::transmute(p) }
11629    }
11630    #[inline(always)]
11631    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11632        unsafe { core::mem::transmute(p) }
11633    }
11634}
11635#[cfg(not(feature = "DynamicLoaded"))]
11636#[cfg(feature = "Implements")]
11637#[rustfmt::skip]
11638impl crate::resolver::StaticCallable for PFN_vkDestroyShaderModule {
11639    const STATIC: Self = Self(vkDestroyShaderModule);
11640}
11641
11642#[cfg(feature = "Implements")]
11643#[repr(transparent)]
11644#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11645#[rustfmt::skip]
11646pub struct PFN_vkCreatePipelineCache(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult);
11647#[cfg(feature = "Implements")]
11648#[rustfmt::skip]
11649unsafe impl crate::resolver::PFN for PFN_vkCreatePipelineCache {
11650    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreatePipelineCache";
11651
11652    #[inline(always)]
11653    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11654        unsafe { core::mem::transmute(p) }
11655    }
11656    #[inline(always)]
11657    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11658        unsafe { core::mem::transmute(p) }
11659    }
11660}
11661#[cfg(not(feature = "DynamicLoaded"))]
11662#[cfg(feature = "Implements")]
11663#[rustfmt::skip]
11664impl crate::resolver::StaticCallable for PFN_vkCreatePipelineCache {
11665    const STATIC: Self = Self(vkCreatePipelineCache);
11666}
11667
11668#[cfg(feature = "Implements")]
11669#[repr(transparent)]
11670#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11671#[rustfmt::skip]
11672pub struct PFN_vkDestroyPipelineCache(pub unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks));
11673#[cfg(feature = "Implements")]
11674#[rustfmt::skip]
11675unsafe impl crate::resolver::PFN for PFN_vkDestroyPipelineCache {
11676    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyPipelineCache";
11677
11678    #[inline(always)]
11679    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11680        unsafe { core::mem::transmute(p) }
11681    }
11682    #[inline(always)]
11683    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11684        unsafe { core::mem::transmute(p) }
11685    }
11686}
11687#[cfg(not(feature = "DynamicLoaded"))]
11688#[cfg(feature = "Implements")]
11689#[rustfmt::skip]
11690impl crate::resolver::StaticCallable for PFN_vkDestroyPipelineCache {
11691    const STATIC: Self = Self(vkDestroyPipelineCache);
11692}
11693
11694#[cfg(feature = "Implements")]
11695#[repr(transparent)]
11696#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11697#[rustfmt::skip]
11698pub struct PFN_vkGetPipelineCacheData(pub unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut core::ffi::c_void) -> VkResult);
11699#[cfg(feature = "Implements")]
11700#[rustfmt::skip]
11701unsafe impl crate::resolver::PFN for PFN_vkGetPipelineCacheData {
11702    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPipelineCacheData";
11703
11704    #[inline(always)]
11705    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11706        unsafe { core::mem::transmute(p) }
11707    }
11708    #[inline(always)]
11709    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11710        unsafe { core::mem::transmute(p) }
11711    }
11712}
11713#[cfg(not(feature = "DynamicLoaded"))]
11714#[cfg(feature = "Implements")]
11715#[rustfmt::skip]
11716impl crate::resolver::StaticCallable for PFN_vkGetPipelineCacheData {
11717    const STATIC: Self = Self(vkGetPipelineCacheData);
11718}
11719
11720#[cfg(feature = "Implements")]
11721#[repr(transparent)]
11722#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11723#[rustfmt::skip]
11724pub struct PFN_vkMergePipelineCaches(pub unsafe extern "system" fn(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult);
11725#[cfg(feature = "Implements")]
11726#[rustfmt::skip]
11727unsafe impl crate::resolver::PFN for PFN_vkMergePipelineCaches {
11728    const NAME_CSTR: &'static core::ffi::CStr = c"vkMergePipelineCaches";
11729
11730    #[inline(always)]
11731    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11732        unsafe { core::mem::transmute(p) }
11733    }
11734    #[inline(always)]
11735    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11736        unsafe { core::mem::transmute(p) }
11737    }
11738}
11739#[cfg(not(feature = "DynamicLoaded"))]
11740#[cfg(feature = "Implements")]
11741#[rustfmt::skip]
11742impl crate::resolver::StaticCallable for PFN_vkMergePipelineCaches {
11743    const STATIC: Self = Self(vkMergePipelineCaches);
11744}
11745
11746#[cfg(feature = "Implements")]
11747#[repr(transparent)]
11748#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11749#[rustfmt::skip]
11750pub struct PFN_vkCreateGraphicsPipelines(pub unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult);
11751#[cfg(feature = "Implements")]
11752#[rustfmt::skip]
11753unsafe impl crate::resolver::PFN for PFN_vkCreateGraphicsPipelines {
11754    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateGraphicsPipelines";
11755
11756    #[inline(always)]
11757    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11758        unsafe { core::mem::transmute(p) }
11759    }
11760    #[inline(always)]
11761    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11762        unsafe { core::mem::transmute(p) }
11763    }
11764}
11765#[cfg(not(feature = "DynamicLoaded"))]
11766#[cfg(feature = "Implements")]
11767#[rustfmt::skip]
11768impl crate::resolver::StaticCallable for PFN_vkCreateGraphicsPipelines {
11769    const STATIC: Self = Self(vkCreateGraphicsPipelines);
11770}
11771
11772#[cfg(feature = "Implements")]
11773#[repr(transparent)]
11774#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11775#[rustfmt::skip]
11776pub struct PFN_vkCreateComputePipelines(pub unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult);
11777#[cfg(feature = "Implements")]
11778#[rustfmt::skip]
11779unsafe impl crate::resolver::PFN for PFN_vkCreateComputePipelines {
11780    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateComputePipelines";
11781
11782    #[inline(always)]
11783    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11784        unsafe { core::mem::transmute(p) }
11785    }
11786    #[inline(always)]
11787    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11788        unsafe { core::mem::transmute(p) }
11789    }
11790}
11791#[cfg(not(feature = "DynamicLoaded"))]
11792#[cfg(feature = "Implements")]
11793#[rustfmt::skip]
11794impl crate::resolver::StaticCallable for PFN_vkCreateComputePipelines {
11795    const STATIC: Self = Self(vkCreateComputePipelines);
11796}
11797
11798#[cfg(feature = "Implements")]
11799#[repr(transparent)]
11800#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11801#[rustfmt::skip]
11802pub struct PFN_vkDestroyPipeline(pub unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks));
11803#[cfg(feature = "Implements")]
11804#[rustfmt::skip]
11805unsafe impl crate::resolver::PFN for PFN_vkDestroyPipeline {
11806    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyPipeline";
11807
11808    #[inline(always)]
11809    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11810        unsafe { core::mem::transmute(p) }
11811    }
11812    #[inline(always)]
11813    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11814        unsafe { core::mem::transmute(p) }
11815    }
11816}
11817#[cfg(not(feature = "DynamicLoaded"))]
11818#[cfg(feature = "Implements")]
11819#[rustfmt::skip]
11820impl crate::resolver::StaticCallable for PFN_vkDestroyPipeline {
11821    const STATIC: Self = Self(vkDestroyPipeline);
11822}
11823
11824#[cfg(feature = "Implements")]
11825#[repr(transparent)]
11826#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11827#[rustfmt::skip]
11828pub struct PFN_vkCreatePipelineLayout(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult);
11829#[cfg(feature = "Implements")]
11830#[rustfmt::skip]
11831unsafe impl crate::resolver::PFN for PFN_vkCreatePipelineLayout {
11832    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreatePipelineLayout";
11833
11834    #[inline(always)]
11835    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11836        unsafe { core::mem::transmute(p) }
11837    }
11838    #[inline(always)]
11839    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11840        unsafe { core::mem::transmute(p) }
11841    }
11842}
11843#[cfg(not(feature = "DynamicLoaded"))]
11844#[cfg(feature = "Implements")]
11845#[rustfmt::skip]
11846impl crate::resolver::StaticCallable for PFN_vkCreatePipelineLayout {
11847    const STATIC: Self = Self(vkCreatePipelineLayout);
11848}
11849
11850#[cfg(feature = "Implements")]
11851#[repr(transparent)]
11852#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11853#[rustfmt::skip]
11854pub struct PFN_vkDestroyPipelineLayout(pub unsafe extern "system" fn(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks));
11855#[cfg(feature = "Implements")]
11856#[rustfmt::skip]
11857unsafe impl crate::resolver::PFN for PFN_vkDestroyPipelineLayout {
11858    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyPipelineLayout";
11859
11860    #[inline(always)]
11861    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11862        unsafe { core::mem::transmute(p) }
11863    }
11864    #[inline(always)]
11865    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11866        unsafe { core::mem::transmute(p) }
11867    }
11868}
11869#[cfg(not(feature = "DynamicLoaded"))]
11870#[cfg(feature = "Implements")]
11871#[rustfmt::skip]
11872impl crate::resolver::StaticCallable for PFN_vkDestroyPipelineLayout {
11873    const STATIC: Self = Self(vkDestroyPipelineLayout);
11874}
11875
11876#[cfg(feature = "Implements")]
11877#[repr(transparent)]
11878#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11879#[rustfmt::skip]
11880pub struct PFN_vkCreateSampler(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult);
11881#[cfg(feature = "Implements")]
11882#[rustfmt::skip]
11883unsafe impl crate::resolver::PFN for PFN_vkCreateSampler {
11884    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateSampler";
11885
11886    #[inline(always)]
11887    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11888        unsafe { core::mem::transmute(p) }
11889    }
11890    #[inline(always)]
11891    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11892        unsafe { core::mem::transmute(p) }
11893    }
11894}
11895#[cfg(not(feature = "DynamicLoaded"))]
11896#[cfg(feature = "Implements")]
11897#[rustfmt::skip]
11898impl crate::resolver::StaticCallable for PFN_vkCreateSampler {
11899    const STATIC: Self = Self(vkCreateSampler);
11900}
11901
11902#[cfg(feature = "Implements")]
11903#[repr(transparent)]
11904#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11905#[rustfmt::skip]
11906pub struct PFN_vkDestroySampler(pub unsafe extern "system" fn(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks));
11907#[cfg(feature = "Implements")]
11908#[rustfmt::skip]
11909unsafe impl crate::resolver::PFN for PFN_vkDestroySampler {
11910    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroySampler";
11911
11912    #[inline(always)]
11913    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11914        unsafe { core::mem::transmute(p) }
11915    }
11916    #[inline(always)]
11917    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11918        unsafe { core::mem::transmute(p) }
11919    }
11920}
11921#[cfg(not(feature = "DynamicLoaded"))]
11922#[cfg(feature = "Implements")]
11923#[rustfmt::skip]
11924impl crate::resolver::StaticCallable for PFN_vkDestroySampler {
11925    const STATIC: Self = Self(vkDestroySampler);
11926}
11927
11928#[cfg(feature = "Implements")]
11929#[repr(transparent)]
11930#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11931#[rustfmt::skip]
11932pub struct PFN_vkCreateDescriptorSetLayout(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult);
11933#[cfg(feature = "Implements")]
11934#[rustfmt::skip]
11935unsafe impl crate::resolver::PFN for PFN_vkCreateDescriptorSetLayout {
11936    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDescriptorSetLayout";
11937
11938    #[inline(always)]
11939    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11940        unsafe { core::mem::transmute(p) }
11941    }
11942    #[inline(always)]
11943    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11944        unsafe { core::mem::transmute(p) }
11945    }
11946}
11947#[cfg(not(feature = "DynamicLoaded"))]
11948#[cfg(feature = "Implements")]
11949#[rustfmt::skip]
11950impl crate::resolver::StaticCallable for PFN_vkCreateDescriptorSetLayout {
11951    const STATIC: Self = Self(vkCreateDescriptorSetLayout);
11952}
11953
11954#[cfg(feature = "Implements")]
11955#[repr(transparent)]
11956#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11957#[rustfmt::skip]
11958pub struct PFN_vkDestroyDescriptorSetLayout(pub unsafe extern "system" fn(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks));
11959#[cfg(feature = "Implements")]
11960#[rustfmt::skip]
11961unsafe impl crate::resolver::PFN for PFN_vkDestroyDescriptorSetLayout {
11962    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyDescriptorSetLayout";
11963
11964    #[inline(always)]
11965    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11966        unsafe { core::mem::transmute(p) }
11967    }
11968    #[inline(always)]
11969    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11970        unsafe { core::mem::transmute(p) }
11971    }
11972}
11973#[cfg(not(feature = "DynamicLoaded"))]
11974#[cfg(feature = "Implements")]
11975#[rustfmt::skip]
11976impl crate::resolver::StaticCallable for PFN_vkDestroyDescriptorSetLayout {
11977    const STATIC: Self = Self(vkDestroyDescriptorSetLayout);
11978}
11979
11980#[cfg(feature = "Implements")]
11981#[repr(transparent)]
11982#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11983#[rustfmt::skip]
11984pub struct PFN_vkCreateDescriptorPool(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pPool: *mut VkDescriptorPool) -> VkResult);
11985#[cfg(feature = "Implements")]
11986#[rustfmt::skip]
11987unsafe impl crate::resolver::PFN for PFN_vkCreateDescriptorPool {
11988    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDescriptorPool";
11989
11990    #[inline(always)]
11991    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
11992        unsafe { core::mem::transmute(p) }
11993    }
11994    #[inline(always)]
11995    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
11996        unsafe { core::mem::transmute(p) }
11997    }
11998}
11999#[cfg(not(feature = "DynamicLoaded"))]
12000#[cfg(feature = "Implements")]
12001#[rustfmt::skip]
12002impl crate::resolver::StaticCallable for PFN_vkCreateDescriptorPool {
12003    const STATIC: Self = Self(vkCreateDescriptorPool);
12004}
12005
12006#[cfg(feature = "Implements")]
12007#[repr(transparent)]
12008#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12009#[rustfmt::skip]
12010pub struct PFN_vkDestroyDescriptorPool(pub unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks));
12011#[cfg(feature = "Implements")]
12012#[rustfmt::skip]
12013unsafe impl crate::resolver::PFN for PFN_vkDestroyDescriptorPool {
12014    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyDescriptorPool";
12015
12016    #[inline(always)]
12017    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12018        unsafe { core::mem::transmute(p) }
12019    }
12020    #[inline(always)]
12021    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12022        unsafe { core::mem::transmute(p) }
12023    }
12024}
12025#[cfg(not(feature = "DynamicLoaded"))]
12026#[cfg(feature = "Implements")]
12027#[rustfmt::skip]
12028impl crate::resolver::StaticCallable for PFN_vkDestroyDescriptorPool {
12029    const STATIC: Self = Self(vkDestroyDescriptorPool);
12030}
12031
12032#[cfg(feature = "Implements")]
12033#[repr(transparent)]
12034#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12035#[rustfmt::skip]
12036pub struct PFN_vkResetDescriptorPool(pub unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult);
12037#[cfg(feature = "Implements")]
12038#[rustfmt::skip]
12039unsafe impl crate::resolver::PFN for PFN_vkResetDescriptorPool {
12040    const NAME_CSTR: &'static core::ffi::CStr = c"vkResetDescriptorPool";
12041
12042    #[inline(always)]
12043    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12044        unsafe { core::mem::transmute(p) }
12045    }
12046    #[inline(always)]
12047    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12048        unsafe { core::mem::transmute(p) }
12049    }
12050}
12051#[cfg(not(feature = "DynamicLoaded"))]
12052#[cfg(feature = "Implements")]
12053#[rustfmt::skip]
12054impl crate::resolver::StaticCallable for PFN_vkResetDescriptorPool {
12055    const STATIC: Self = Self(vkResetDescriptorPool);
12056}
12057
12058#[cfg(feature = "Implements")]
12059#[repr(transparent)]
12060#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12061#[rustfmt::skip]
12062pub struct PFN_vkAllocateDescriptorSets(pub unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult);
12063#[cfg(feature = "Implements")]
12064#[rustfmt::skip]
12065unsafe impl crate::resolver::PFN for PFN_vkAllocateDescriptorSets {
12066    const NAME_CSTR: &'static core::ffi::CStr = c"vkAllocateDescriptorSets";
12067
12068    #[inline(always)]
12069    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12070        unsafe { core::mem::transmute(p) }
12071    }
12072    #[inline(always)]
12073    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12074        unsafe { core::mem::transmute(p) }
12075    }
12076}
12077#[cfg(not(feature = "DynamicLoaded"))]
12078#[cfg(feature = "Implements")]
12079#[rustfmt::skip]
12080impl crate::resolver::StaticCallable for PFN_vkAllocateDescriptorSets {
12081    const STATIC: Self = Self(vkAllocateDescriptorSets);
12082}
12083
12084#[cfg(feature = "Implements")]
12085#[repr(transparent)]
12086#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12087#[rustfmt::skip]
12088pub struct PFN_vkFreeDescriptorSets(pub unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult);
12089#[cfg(feature = "Implements")]
12090#[rustfmt::skip]
12091unsafe impl crate::resolver::PFN for PFN_vkFreeDescriptorSets {
12092    const NAME_CSTR: &'static core::ffi::CStr = c"vkFreeDescriptorSets";
12093
12094    #[inline(always)]
12095    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12096        unsafe { core::mem::transmute(p) }
12097    }
12098    #[inline(always)]
12099    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12100        unsafe { core::mem::transmute(p) }
12101    }
12102}
12103#[cfg(not(feature = "DynamicLoaded"))]
12104#[cfg(feature = "Implements")]
12105#[rustfmt::skip]
12106impl crate::resolver::StaticCallable for PFN_vkFreeDescriptorSets {
12107    const STATIC: Self = Self(vkFreeDescriptorSets);
12108}
12109
12110#[cfg(feature = "Implements")]
12111#[repr(transparent)]
12112#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12113#[rustfmt::skip]
12114pub struct PFN_vkUpdateDescriptorSets(pub unsafe extern "system" fn(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet));
12115#[cfg(feature = "Implements")]
12116#[rustfmt::skip]
12117unsafe impl crate::resolver::PFN for PFN_vkUpdateDescriptorSets {
12118    const NAME_CSTR: &'static core::ffi::CStr = c"vkUpdateDescriptorSets";
12119
12120    #[inline(always)]
12121    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12122        unsafe { core::mem::transmute(p) }
12123    }
12124    #[inline(always)]
12125    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12126        unsafe { core::mem::transmute(p) }
12127    }
12128}
12129#[cfg(not(feature = "DynamicLoaded"))]
12130#[cfg(feature = "Implements")]
12131#[rustfmt::skip]
12132impl crate::resolver::StaticCallable for PFN_vkUpdateDescriptorSets {
12133    const STATIC: Self = Self(vkUpdateDescriptorSets);
12134}
12135
12136#[cfg(feature = "Implements")]
12137#[repr(transparent)]
12138#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12139#[rustfmt::skip]
12140pub struct PFN_vkCreateFramebuffer(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult);
12141#[cfg(feature = "Implements")]
12142#[rustfmt::skip]
12143unsafe impl crate::resolver::PFN for PFN_vkCreateFramebuffer {
12144    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateFramebuffer";
12145
12146    #[inline(always)]
12147    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12148        unsafe { core::mem::transmute(p) }
12149    }
12150    #[inline(always)]
12151    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12152        unsafe { core::mem::transmute(p) }
12153    }
12154}
12155#[cfg(not(feature = "DynamicLoaded"))]
12156#[cfg(feature = "Implements")]
12157#[rustfmt::skip]
12158impl crate::resolver::StaticCallable for PFN_vkCreateFramebuffer {
12159    const STATIC: Self = Self(vkCreateFramebuffer);
12160}
12161
12162#[cfg(feature = "Implements")]
12163#[repr(transparent)]
12164#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12165#[rustfmt::skip]
12166pub struct PFN_vkDestroyFramebuffer(pub unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks));
12167#[cfg(feature = "Implements")]
12168#[rustfmt::skip]
12169unsafe impl crate::resolver::PFN for PFN_vkDestroyFramebuffer {
12170    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyFramebuffer";
12171
12172    #[inline(always)]
12173    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12174        unsafe { core::mem::transmute(p) }
12175    }
12176    #[inline(always)]
12177    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12178        unsafe { core::mem::transmute(p) }
12179    }
12180}
12181#[cfg(not(feature = "DynamicLoaded"))]
12182#[cfg(feature = "Implements")]
12183#[rustfmt::skip]
12184impl crate::resolver::StaticCallable for PFN_vkDestroyFramebuffer {
12185    const STATIC: Self = Self(vkDestroyFramebuffer);
12186}
12187
12188#[cfg(feature = "Implements")]
12189#[repr(transparent)]
12190#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12191#[rustfmt::skip]
12192pub struct PFN_vkCreateRenderPass(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult);
12193#[cfg(feature = "Implements")]
12194#[rustfmt::skip]
12195unsafe impl crate::resolver::PFN for PFN_vkCreateRenderPass {
12196    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateRenderPass";
12197
12198    #[inline(always)]
12199    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12200        unsafe { core::mem::transmute(p) }
12201    }
12202    #[inline(always)]
12203    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12204        unsafe { core::mem::transmute(p) }
12205    }
12206}
12207#[cfg(not(feature = "DynamicLoaded"))]
12208#[cfg(feature = "Implements")]
12209#[rustfmt::skip]
12210impl crate::resolver::StaticCallable for PFN_vkCreateRenderPass {
12211    const STATIC: Self = Self(vkCreateRenderPass);
12212}
12213
12214#[cfg(feature = "Implements")]
12215#[repr(transparent)]
12216#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12217#[rustfmt::skip]
12218pub struct PFN_vkDestroyRenderPass(pub unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks));
12219#[cfg(feature = "Implements")]
12220#[rustfmt::skip]
12221unsafe impl crate::resolver::PFN for PFN_vkDestroyRenderPass {
12222    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyRenderPass";
12223
12224    #[inline(always)]
12225    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12226        unsafe { core::mem::transmute(p) }
12227    }
12228    #[inline(always)]
12229    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12230        unsafe { core::mem::transmute(p) }
12231    }
12232}
12233#[cfg(not(feature = "DynamicLoaded"))]
12234#[cfg(feature = "Implements")]
12235#[rustfmt::skip]
12236impl crate::resolver::StaticCallable for PFN_vkDestroyRenderPass {
12237    const STATIC: Self = Self(vkDestroyRenderPass);
12238}
12239
12240#[cfg(feature = "Implements")]
12241#[repr(transparent)]
12242#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12243#[rustfmt::skip]
12244pub struct PFN_vkGetRenderAreaGranularity(pub unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D));
12245#[cfg(feature = "Implements")]
12246#[rustfmt::skip]
12247unsafe impl crate::resolver::PFN for PFN_vkGetRenderAreaGranularity {
12248    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetRenderAreaGranularity";
12249
12250    #[inline(always)]
12251    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12252        unsafe { core::mem::transmute(p) }
12253    }
12254    #[inline(always)]
12255    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12256        unsafe { core::mem::transmute(p) }
12257    }
12258}
12259#[cfg(not(feature = "DynamicLoaded"))]
12260#[cfg(feature = "Implements")]
12261#[rustfmt::skip]
12262impl crate::resolver::StaticCallable for PFN_vkGetRenderAreaGranularity {
12263    const STATIC: Self = Self(vkGetRenderAreaGranularity);
12264}
12265
12266#[cfg(feature = "Implements")]
12267#[repr(transparent)]
12268#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12269#[rustfmt::skip]
12270pub struct PFN_vkCreateCommandPool(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult);
12271#[cfg(feature = "Implements")]
12272#[rustfmt::skip]
12273unsafe impl crate::resolver::PFN for PFN_vkCreateCommandPool {
12274    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateCommandPool";
12275
12276    #[inline(always)]
12277    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12278        unsafe { core::mem::transmute(p) }
12279    }
12280    #[inline(always)]
12281    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12282        unsafe { core::mem::transmute(p) }
12283    }
12284}
12285#[cfg(not(feature = "DynamicLoaded"))]
12286#[cfg(feature = "Implements")]
12287#[rustfmt::skip]
12288impl crate::resolver::StaticCallable for PFN_vkCreateCommandPool {
12289    const STATIC: Self = Self(vkCreateCommandPool);
12290}
12291
12292#[cfg(feature = "Implements")]
12293#[repr(transparent)]
12294#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12295#[rustfmt::skip]
12296pub struct PFN_vkDestroyCommandPool(pub unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks));
12297#[cfg(feature = "Implements")]
12298#[rustfmt::skip]
12299unsafe impl crate::resolver::PFN for PFN_vkDestroyCommandPool {
12300    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyCommandPool";
12301
12302    #[inline(always)]
12303    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12304        unsafe { core::mem::transmute(p) }
12305    }
12306    #[inline(always)]
12307    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12308        unsafe { core::mem::transmute(p) }
12309    }
12310}
12311#[cfg(not(feature = "DynamicLoaded"))]
12312#[cfg(feature = "Implements")]
12313#[rustfmt::skip]
12314impl crate::resolver::StaticCallable for PFN_vkDestroyCommandPool {
12315    const STATIC: Self = Self(vkDestroyCommandPool);
12316}
12317
12318#[cfg(feature = "Implements")]
12319#[repr(transparent)]
12320#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12321#[rustfmt::skip]
12322pub struct PFN_vkResetCommandPool(pub unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult);
12323#[cfg(feature = "Implements")]
12324#[rustfmt::skip]
12325unsafe impl crate::resolver::PFN for PFN_vkResetCommandPool {
12326    const NAME_CSTR: &'static core::ffi::CStr = c"vkResetCommandPool";
12327
12328    #[inline(always)]
12329    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12330        unsafe { core::mem::transmute(p) }
12331    }
12332    #[inline(always)]
12333    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12334        unsafe { core::mem::transmute(p) }
12335    }
12336}
12337#[cfg(not(feature = "DynamicLoaded"))]
12338#[cfg(feature = "Implements")]
12339#[rustfmt::skip]
12340impl crate::resolver::StaticCallable for PFN_vkResetCommandPool {
12341    const STATIC: Self = Self(vkResetCommandPool);
12342}
12343
12344#[cfg(feature = "Implements")]
12345#[repr(transparent)]
12346#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12347#[rustfmt::skip]
12348pub struct PFN_vkAllocateCommandBuffers(pub unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult);
12349#[cfg(feature = "Implements")]
12350#[rustfmt::skip]
12351unsafe impl crate::resolver::PFN for PFN_vkAllocateCommandBuffers {
12352    const NAME_CSTR: &'static core::ffi::CStr = c"vkAllocateCommandBuffers";
12353
12354    #[inline(always)]
12355    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12356        unsafe { core::mem::transmute(p) }
12357    }
12358    #[inline(always)]
12359    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12360        unsafe { core::mem::transmute(p) }
12361    }
12362}
12363#[cfg(not(feature = "DynamicLoaded"))]
12364#[cfg(feature = "Implements")]
12365#[rustfmt::skip]
12366impl crate::resolver::StaticCallable for PFN_vkAllocateCommandBuffers {
12367    const STATIC: Self = Self(vkAllocateCommandBuffers);
12368}
12369
12370#[cfg(feature = "Implements")]
12371#[repr(transparent)]
12372#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12373#[rustfmt::skip]
12374pub struct PFN_vkFreeCommandBuffers(pub unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer));
12375#[cfg(feature = "Implements")]
12376#[rustfmt::skip]
12377unsafe impl crate::resolver::PFN for PFN_vkFreeCommandBuffers {
12378    const NAME_CSTR: &'static core::ffi::CStr = c"vkFreeCommandBuffers";
12379
12380    #[inline(always)]
12381    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12382        unsafe { core::mem::transmute(p) }
12383    }
12384    #[inline(always)]
12385    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12386        unsafe { core::mem::transmute(p) }
12387    }
12388}
12389#[cfg(not(feature = "DynamicLoaded"))]
12390#[cfg(feature = "Implements")]
12391#[rustfmt::skip]
12392impl crate::resolver::StaticCallable for PFN_vkFreeCommandBuffers {
12393    const STATIC: Self = Self(vkFreeCommandBuffers);
12394}
12395
12396#[cfg(feature = "Implements")]
12397#[repr(transparent)]
12398#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12399#[rustfmt::skip]
12400pub struct PFN_vkBeginCommandBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult);
12401#[cfg(feature = "Implements")]
12402#[rustfmt::skip]
12403unsafe impl crate::resolver::PFN for PFN_vkBeginCommandBuffer {
12404    const NAME_CSTR: &'static core::ffi::CStr = c"vkBeginCommandBuffer";
12405
12406    #[inline(always)]
12407    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12408        unsafe { core::mem::transmute(p) }
12409    }
12410    #[inline(always)]
12411    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12412        unsafe { core::mem::transmute(p) }
12413    }
12414}
12415#[cfg(not(feature = "DynamicLoaded"))]
12416#[cfg(feature = "Implements")]
12417#[rustfmt::skip]
12418impl crate::resolver::StaticCallable for PFN_vkBeginCommandBuffer {
12419    const STATIC: Self = Self(vkBeginCommandBuffer);
12420}
12421
12422#[cfg(feature = "Implements")]
12423#[repr(transparent)]
12424#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12425#[rustfmt::skip]
12426pub struct PFN_vkEndCommandBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> VkResult);
12427#[cfg(feature = "Implements")]
12428#[rustfmt::skip]
12429unsafe impl crate::resolver::PFN for PFN_vkEndCommandBuffer {
12430    const NAME_CSTR: &'static core::ffi::CStr = c"vkEndCommandBuffer";
12431
12432    #[inline(always)]
12433    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12434        unsafe { core::mem::transmute(p) }
12435    }
12436    #[inline(always)]
12437    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12438        unsafe { core::mem::transmute(p) }
12439    }
12440}
12441#[cfg(not(feature = "DynamicLoaded"))]
12442#[cfg(feature = "Implements")]
12443#[rustfmt::skip]
12444impl crate::resolver::StaticCallable for PFN_vkEndCommandBuffer {
12445    const STATIC: Self = Self(vkEndCommandBuffer);
12446}
12447
12448#[cfg(feature = "Implements")]
12449#[repr(transparent)]
12450#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12451#[rustfmt::skip]
12452pub struct PFN_vkResetCommandBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult);
12453#[cfg(feature = "Implements")]
12454#[rustfmt::skip]
12455unsafe impl crate::resolver::PFN for PFN_vkResetCommandBuffer {
12456    const NAME_CSTR: &'static core::ffi::CStr = c"vkResetCommandBuffer";
12457
12458    #[inline(always)]
12459    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12460        unsafe { core::mem::transmute(p) }
12461    }
12462    #[inline(always)]
12463    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12464        unsafe { core::mem::transmute(p) }
12465    }
12466}
12467#[cfg(not(feature = "DynamicLoaded"))]
12468#[cfg(feature = "Implements")]
12469#[rustfmt::skip]
12470impl crate::resolver::StaticCallable for PFN_vkResetCommandBuffer {
12471    const STATIC: Self = Self(vkResetCommandBuffer);
12472}
12473
12474#[cfg(feature = "Implements")]
12475#[cfg(feature = "Allow1_1APIs")]
12476#[repr(transparent)]
12477#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12478#[rustfmt::skip]
12479pub struct PFN_vkEnumerateInstanceVersion(pub unsafe extern "system" fn(pApiVersion: *mut u32) -> VkResult);
12480#[cfg(feature = "Implements")]
12481#[cfg(feature = "Allow1_1APIs")]
12482#[rustfmt::skip]
12483unsafe impl crate::resolver::PFN for PFN_vkEnumerateInstanceVersion {
12484    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumerateInstanceVersion";
12485
12486    #[inline(always)]
12487    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12488        unsafe { core::mem::transmute(p) }
12489    }
12490    #[inline(always)]
12491    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12492        unsafe { core::mem::transmute(p) }
12493    }
12494}
12495#[cfg(not(feature = "DynamicLoaded"))]
12496#[cfg(feature = "Implements")]
12497#[cfg(feature = "Allow1_1APIs")]
12498#[rustfmt::skip]
12499impl crate::resolver::StaticCallable for PFN_vkEnumerateInstanceVersion {
12500    const STATIC: Self = Self(vkEnumerateInstanceVersion);
12501}
12502
12503#[cfg(feature = "Implements")]
12504#[cfg(feature = "VK_KHR_surface")]
12505#[repr(transparent)]
12506#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12507#[rustfmt::skip]
12508pub struct PFN_vkDestroySurfaceKHR(pub unsafe extern "system" fn(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks));
12509#[cfg(feature = "Implements")]
12510#[cfg(feature = "VK_KHR_surface")]
12511#[rustfmt::skip]
12512unsafe impl crate::resolver::PFN for PFN_vkDestroySurfaceKHR {
12513    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroySurfaceKHR";
12514
12515    #[inline(always)]
12516    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12517        unsafe { core::mem::transmute(p) }
12518    }
12519    #[inline(always)]
12520    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12521        unsafe { core::mem::transmute(p) }
12522    }
12523}
12524#[cfg(not(feature = "DynamicLoaded"))]
12525#[cfg(feature = "Implements")]
12526#[cfg(feature = "VK_KHR_surface")]
12527#[rustfmt::skip]
12528impl crate::resolver::StaticCallable for PFN_vkDestroySurfaceKHR {
12529    const STATIC: Self = Self(vkDestroySurfaceKHR);
12530}
12531
12532#[cfg(feature = "Implements")]
12533#[cfg(feature = "VK_KHR_surface")]
12534#[repr(transparent)]
12535#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12536#[rustfmt::skip]
12537pub struct PFN_vkGetPhysicalDeviceSurfaceSupportKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult);
12538#[cfg(feature = "Implements")]
12539#[cfg(feature = "VK_KHR_surface")]
12540#[rustfmt::skip]
12541unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSurfaceSupportKHR {
12542    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSurfaceSupportKHR";
12543
12544    #[inline(always)]
12545    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12546        unsafe { core::mem::transmute(p) }
12547    }
12548    #[inline(always)]
12549    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12550        unsafe { core::mem::transmute(p) }
12551    }
12552}
12553#[cfg(not(feature = "DynamicLoaded"))]
12554#[cfg(feature = "Implements")]
12555#[cfg(feature = "VK_KHR_surface")]
12556#[rustfmt::skip]
12557impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceSurfaceSupportKHR {
12558    const STATIC: Self = Self(vkGetPhysicalDeviceSurfaceSupportKHR);
12559}
12560
12561#[cfg(feature = "Implements")]
12562#[cfg(feature = "VK_KHR_surface")]
12563#[repr(transparent)]
12564#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12565#[rustfmt::skip]
12566pub struct PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult);
12567#[cfg(feature = "Implements")]
12568#[cfg(feature = "VK_KHR_surface")]
12569#[rustfmt::skip]
12570unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR {
12571    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSurfaceCapabilitiesKHR";
12572
12573    #[inline(always)]
12574    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12575        unsafe { core::mem::transmute(p) }
12576    }
12577    #[inline(always)]
12578    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12579        unsafe { core::mem::transmute(p) }
12580    }
12581}
12582#[cfg(not(feature = "DynamicLoaded"))]
12583#[cfg(feature = "Implements")]
12584#[cfg(feature = "VK_KHR_surface")]
12585#[rustfmt::skip]
12586impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR {
12587    const STATIC: Self = Self(vkGetPhysicalDeviceSurfaceCapabilitiesKHR);
12588}
12589
12590#[cfg(feature = "Implements")]
12591#[cfg(feature = "VK_KHR_surface")]
12592#[repr(transparent)]
12593#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12594#[rustfmt::skip]
12595pub struct PFN_vkGetPhysicalDeviceSurfaceFormatsKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatsCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult);
12596#[cfg(feature = "Implements")]
12597#[cfg(feature = "VK_KHR_surface")]
12598#[rustfmt::skip]
12599unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSurfaceFormatsKHR {
12600    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSurfaceFormatsKHR";
12601
12602    #[inline(always)]
12603    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12604        unsafe { core::mem::transmute(p) }
12605    }
12606    #[inline(always)]
12607    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12608        unsafe { core::mem::transmute(p) }
12609    }
12610}
12611#[cfg(not(feature = "DynamicLoaded"))]
12612#[cfg(feature = "Implements")]
12613#[cfg(feature = "VK_KHR_surface")]
12614#[rustfmt::skip]
12615impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceSurfaceFormatsKHR {
12616    const STATIC: Self = Self(vkGetPhysicalDeviceSurfaceFormatsKHR);
12617}
12618
12619#[cfg(feature = "Implements")]
12620#[cfg(feature = "VK_KHR_surface")]
12621#[repr(transparent)]
12622#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12623#[rustfmt::skip]
12624pub struct PFN_vkGetPhysicalDeviceSurfacePresentModesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult);
12625#[cfg(feature = "Implements")]
12626#[cfg(feature = "VK_KHR_surface")]
12627#[rustfmt::skip]
12628unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSurfacePresentModesKHR {
12629    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSurfacePresentModesKHR";
12630
12631    #[inline(always)]
12632    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12633        unsafe { core::mem::transmute(p) }
12634    }
12635    #[inline(always)]
12636    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12637        unsafe { core::mem::transmute(p) }
12638    }
12639}
12640#[cfg(not(feature = "DynamicLoaded"))]
12641#[cfg(feature = "Implements")]
12642#[cfg(feature = "VK_KHR_surface")]
12643#[rustfmt::skip]
12644impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceSurfacePresentModesKHR {
12645    const STATIC: Self = Self(vkGetPhysicalDeviceSurfacePresentModesKHR);
12646}
12647
12648#[cfg(feature = "Implements")]
12649#[cfg(feature = "VK_KHR_swapchain")]
12650#[repr(transparent)]
12651#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12652#[rustfmt::skip]
12653pub struct PFN_vkCreateSwapchainKHR(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult);
12654#[cfg(feature = "Implements")]
12655#[cfg(feature = "VK_KHR_swapchain")]
12656#[rustfmt::skip]
12657unsafe impl crate::resolver::PFN for PFN_vkCreateSwapchainKHR {
12658    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateSwapchainKHR";
12659
12660    #[inline(always)]
12661    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12662        unsafe { core::mem::transmute(p) }
12663    }
12664    #[inline(always)]
12665    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12666        unsafe { core::mem::transmute(p) }
12667    }
12668}
12669#[cfg(not(feature = "DynamicLoaded"))]
12670#[cfg(feature = "Implements")]
12671#[cfg(feature = "VK_KHR_swapchain")]
12672#[rustfmt::skip]
12673impl crate::resolver::StaticCallable for PFN_vkCreateSwapchainKHR {
12674    const STATIC: Self = Self(vkCreateSwapchainKHR);
12675}
12676
12677#[cfg(feature = "Implements")]
12678#[cfg(feature = "VK_KHR_swapchain")]
12679#[repr(transparent)]
12680#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12681#[rustfmt::skip]
12682pub struct PFN_vkDestroySwapchainKHR(pub unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks));
12683#[cfg(feature = "Implements")]
12684#[cfg(feature = "VK_KHR_swapchain")]
12685#[rustfmt::skip]
12686unsafe impl crate::resolver::PFN for PFN_vkDestroySwapchainKHR {
12687    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroySwapchainKHR";
12688
12689    #[inline(always)]
12690    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12691        unsafe { core::mem::transmute(p) }
12692    }
12693    #[inline(always)]
12694    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12695        unsafe { core::mem::transmute(p) }
12696    }
12697}
12698#[cfg(not(feature = "DynamicLoaded"))]
12699#[cfg(feature = "Implements")]
12700#[cfg(feature = "VK_KHR_swapchain")]
12701#[rustfmt::skip]
12702impl crate::resolver::StaticCallable for PFN_vkDestroySwapchainKHR {
12703    const STATIC: Self = Self(vkDestroySwapchainKHR);
12704}
12705
12706#[cfg(feature = "Implements")]
12707#[cfg(feature = "VK_KHR_swapchain")]
12708#[repr(transparent)]
12709#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12710#[rustfmt::skip]
12711pub struct PFN_vkGetSwapchainImagesKHR(pub unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult);
12712#[cfg(feature = "Implements")]
12713#[cfg(feature = "VK_KHR_swapchain")]
12714#[rustfmt::skip]
12715unsafe impl crate::resolver::PFN for PFN_vkGetSwapchainImagesKHR {
12716    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetSwapchainImagesKHR";
12717
12718    #[inline(always)]
12719    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12720        unsafe { core::mem::transmute(p) }
12721    }
12722    #[inline(always)]
12723    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12724        unsafe { core::mem::transmute(p) }
12725    }
12726}
12727#[cfg(not(feature = "DynamicLoaded"))]
12728#[cfg(feature = "Implements")]
12729#[cfg(feature = "VK_KHR_swapchain")]
12730#[rustfmt::skip]
12731impl crate::resolver::StaticCallable for PFN_vkGetSwapchainImagesKHR {
12732    const STATIC: Self = Self(vkGetSwapchainImagesKHR);
12733}
12734
12735#[cfg(feature = "Implements")]
12736#[cfg(feature = "VK_KHR_swapchain")]
12737#[repr(transparent)]
12738#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12739#[rustfmt::skip]
12740pub struct PFN_vkAcquireNextImageKHR(pub unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult);
12741#[cfg(feature = "Implements")]
12742#[cfg(feature = "VK_KHR_swapchain")]
12743#[rustfmt::skip]
12744unsafe impl crate::resolver::PFN for PFN_vkAcquireNextImageKHR {
12745    const NAME_CSTR: &'static core::ffi::CStr = c"vkAcquireNextImageKHR";
12746
12747    #[inline(always)]
12748    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12749        unsafe { core::mem::transmute(p) }
12750    }
12751    #[inline(always)]
12752    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12753        unsafe { core::mem::transmute(p) }
12754    }
12755}
12756#[cfg(not(feature = "DynamicLoaded"))]
12757#[cfg(feature = "Implements")]
12758#[cfg(feature = "VK_KHR_swapchain")]
12759#[rustfmt::skip]
12760impl crate::resolver::StaticCallable for PFN_vkAcquireNextImageKHR {
12761    const STATIC: Self = Self(vkAcquireNextImageKHR);
12762}
12763
12764#[cfg(feature = "Implements")]
12765#[cfg(feature = "VK_KHR_swapchain")]
12766#[repr(transparent)]
12767#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12768#[rustfmt::skip]
12769pub struct PFN_vkQueuePresentKHR(pub unsafe extern "system" fn(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult);
12770#[cfg(feature = "Implements")]
12771#[cfg(feature = "VK_KHR_swapchain")]
12772#[rustfmt::skip]
12773unsafe impl crate::resolver::PFN for PFN_vkQueuePresentKHR {
12774    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueuePresentKHR";
12775
12776    #[inline(always)]
12777    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12778        unsafe { core::mem::transmute(p) }
12779    }
12780    #[inline(always)]
12781    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12782        unsafe { core::mem::transmute(p) }
12783    }
12784}
12785#[cfg(not(feature = "DynamicLoaded"))]
12786#[cfg(feature = "Implements")]
12787#[cfg(feature = "VK_KHR_swapchain")]
12788#[rustfmt::skip]
12789impl crate::resolver::StaticCallable for PFN_vkQueuePresentKHR {
12790    const STATIC: Self = Self(vkQueuePresentKHR);
12791}
12792
12793#[cfg(feature = "Implements")]
12794#[cfg(feature = "VK_KHR_display")]
12795#[repr(transparent)]
12796#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12797#[rustfmt::skip]
12798pub struct PFN_vkGetPhysicalDeviceDisplayPropertiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult);
12799#[cfg(feature = "Implements")]
12800#[cfg(feature = "VK_KHR_display")]
12801#[rustfmt::skip]
12802unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceDisplayPropertiesKHR {
12803    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceDisplayPropertiesKHR";
12804
12805    #[inline(always)]
12806    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12807        unsafe { core::mem::transmute(p) }
12808    }
12809    #[inline(always)]
12810    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12811        unsafe { core::mem::transmute(p) }
12812    }
12813}
12814#[cfg(not(feature = "DynamicLoaded"))]
12815#[cfg(feature = "Implements")]
12816#[cfg(feature = "VK_KHR_display")]
12817#[rustfmt::skip]
12818impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceDisplayPropertiesKHR {
12819    const STATIC: Self = Self(vkGetPhysicalDeviceDisplayPropertiesKHR);
12820}
12821
12822#[cfg(feature = "Implements")]
12823#[cfg(feature = "VK_KHR_display")]
12824#[repr(transparent)]
12825#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12826#[rustfmt::skip]
12827pub struct PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult);
12828#[cfg(feature = "Implements")]
12829#[cfg(feature = "VK_KHR_display")]
12830#[rustfmt::skip]
12831unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR {
12832    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceDisplayPlanePropertiesKHR";
12833
12834    #[inline(always)]
12835    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12836        unsafe { core::mem::transmute(p) }
12837    }
12838    #[inline(always)]
12839    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12840        unsafe { core::mem::transmute(p) }
12841    }
12842}
12843#[cfg(not(feature = "DynamicLoaded"))]
12844#[cfg(feature = "Implements")]
12845#[cfg(feature = "VK_KHR_display")]
12846#[rustfmt::skip]
12847impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR {
12848    const STATIC: Self = Self(vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
12849}
12850
12851#[cfg(feature = "Implements")]
12852#[cfg(feature = "VK_KHR_display")]
12853#[repr(transparent)]
12854#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12855#[rustfmt::skip]
12856pub struct PFN_vkGetDisplayPlaneSupportedDisplaysKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult);
12857#[cfg(feature = "Implements")]
12858#[cfg(feature = "VK_KHR_display")]
12859#[rustfmt::skip]
12860unsafe impl crate::resolver::PFN for PFN_vkGetDisplayPlaneSupportedDisplaysKHR {
12861    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDisplayPlaneSupportedDisplaysKHR";
12862
12863    #[inline(always)]
12864    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12865        unsafe { core::mem::transmute(p) }
12866    }
12867    #[inline(always)]
12868    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12869        unsafe { core::mem::transmute(p) }
12870    }
12871}
12872#[cfg(not(feature = "DynamicLoaded"))]
12873#[cfg(feature = "Implements")]
12874#[cfg(feature = "VK_KHR_display")]
12875#[rustfmt::skip]
12876impl crate::resolver::StaticCallable for PFN_vkGetDisplayPlaneSupportedDisplaysKHR {
12877    const STATIC: Self = Self(vkGetDisplayPlaneSupportedDisplaysKHR);
12878}
12879
12880#[cfg(feature = "Implements")]
12881#[cfg(feature = "VK_KHR_display")]
12882#[repr(transparent)]
12883#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12884#[rustfmt::skip]
12885pub struct PFN_vkGetDisplayModePropertiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult);
12886#[cfg(feature = "Implements")]
12887#[cfg(feature = "VK_KHR_display")]
12888#[rustfmt::skip]
12889unsafe impl crate::resolver::PFN for PFN_vkGetDisplayModePropertiesKHR {
12890    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDisplayModePropertiesKHR";
12891
12892    #[inline(always)]
12893    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12894        unsafe { core::mem::transmute(p) }
12895    }
12896    #[inline(always)]
12897    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12898        unsafe { core::mem::transmute(p) }
12899    }
12900}
12901#[cfg(not(feature = "DynamicLoaded"))]
12902#[cfg(feature = "Implements")]
12903#[cfg(feature = "VK_KHR_display")]
12904#[rustfmt::skip]
12905impl crate::resolver::StaticCallable for PFN_vkGetDisplayModePropertiesKHR {
12906    const STATIC: Self = Self(vkGetDisplayModePropertiesKHR);
12907}
12908
12909#[cfg(feature = "Implements")]
12910#[cfg(feature = "VK_KHR_display")]
12911#[repr(transparent)]
12912#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12913#[rustfmt::skip]
12914pub struct PFN_vkCreateDisplayModeKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult);
12915#[cfg(feature = "Implements")]
12916#[cfg(feature = "VK_KHR_display")]
12917#[rustfmt::skip]
12918unsafe impl crate::resolver::PFN for PFN_vkCreateDisplayModeKHR {
12919    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDisplayModeKHR";
12920
12921    #[inline(always)]
12922    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12923        unsafe { core::mem::transmute(p) }
12924    }
12925    #[inline(always)]
12926    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12927        unsafe { core::mem::transmute(p) }
12928    }
12929}
12930#[cfg(not(feature = "DynamicLoaded"))]
12931#[cfg(feature = "Implements")]
12932#[cfg(feature = "VK_KHR_display")]
12933#[rustfmt::skip]
12934impl crate::resolver::StaticCallable for PFN_vkCreateDisplayModeKHR {
12935    const STATIC: Self = Self(vkCreateDisplayModeKHR);
12936}
12937
12938#[cfg(feature = "Implements")]
12939#[cfg(feature = "VK_KHR_display")]
12940#[repr(transparent)]
12941#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12942#[rustfmt::skip]
12943pub struct PFN_vkGetDisplayPlaneCapabilitiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult);
12944#[cfg(feature = "Implements")]
12945#[cfg(feature = "VK_KHR_display")]
12946#[rustfmt::skip]
12947unsafe impl crate::resolver::PFN for PFN_vkGetDisplayPlaneCapabilitiesKHR {
12948    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDisplayPlaneCapabilitiesKHR";
12949
12950    #[inline(always)]
12951    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12952        unsafe { core::mem::transmute(p) }
12953    }
12954    #[inline(always)]
12955    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12956        unsafe { core::mem::transmute(p) }
12957    }
12958}
12959#[cfg(not(feature = "DynamicLoaded"))]
12960#[cfg(feature = "Implements")]
12961#[cfg(feature = "VK_KHR_display")]
12962#[rustfmt::skip]
12963impl crate::resolver::StaticCallable for PFN_vkGetDisplayPlaneCapabilitiesKHR {
12964    const STATIC: Self = Self(vkGetDisplayPlaneCapabilitiesKHR);
12965}
12966
12967#[cfg(feature = "Implements")]
12968#[cfg(feature = "VK_KHR_display")]
12969#[repr(transparent)]
12970#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12971#[rustfmt::skip]
12972pub struct PFN_vkCreateDisplayPlaneSurfaceKHR(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult);
12973#[cfg(feature = "Implements")]
12974#[cfg(feature = "VK_KHR_display")]
12975#[rustfmt::skip]
12976unsafe impl crate::resolver::PFN for PFN_vkCreateDisplayPlaneSurfaceKHR {
12977    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDisplayPlaneSurfaceKHR";
12978
12979    #[inline(always)]
12980    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
12981        unsafe { core::mem::transmute(p) }
12982    }
12983    #[inline(always)]
12984    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
12985        unsafe { core::mem::transmute(p) }
12986    }
12987}
12988#[cfg(not(feature = "DynamicLoaded"))]
12989#[cfg(feature = "Implements")]
12990#[cfg(feature = "VK_KHR_display")]
12991#[rustfmt::skip]
12992impl crate::resolver::StaticCallable for PFN_vkCreateDisplayPlaneSurfaceKHR {
12993    const STATIC: Self = Self(vkCreateDisplayPlaneSurfaceKHR);
12994}
12995
12996#[cfg(feature = "Implements")]
12997#[cfg(feature = "VK_KHR_display_swapchain")]
12998#[repr(transparent)]
12999#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13000#[rustfmt::skip]
13001pub struct PFN_vkCreateSharedSwapchainKHR(pub unsafe extern "system" fn(device: VkDevice, swapchainCount: u32, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult);
13002#[cfg(feature = "Implements")]
13003#[cfg(feature = "VK_KHR_display_swapchain")]
13004#[rustfmt::skip]
13005unsafe impl crate::resolver::PFN for PFN_vkCreateSharedSwapchainKHR {
13006    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateSharedSwapchainKHR";
13007
13008    #[inline(always)]
13009    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13010        unsafe { core::mem::transmute(p) }
13011    }
13012    #[inline(always)]
13013    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13014        unsafe { core::mem::transmute(p) }
13015    }
13016}
13017
13018#[cfg(feature = "Implements")]
13019#[cfg(feature = "VK_KHR_xlib_surface")]
13020#[repr(transparent)]
13021#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13022#[rustfmt::skip]
13023pub struct PFN_vkCreateXlibSurfaceKHR(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkXlibSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult);
13024#[cfg(feature = "Implements")]
13025#[cfg(feature = "VK_KHR_xlib_surface")]
13026#[rustfmt::skip]
13027unsafe impl crate::resolver::PFN for PFN_vkCreateXlibSurfaceKHR {
13028    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateXlibSurfaceKHR";
13029
13030    #[inline(always)]
13031    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13032        unsafe { core::mem::transmute(p) }
13033    }
13034    #[inline(always)]
13035    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13036        unsafe { core::mem::transmute(p) }
13037    }
13038}
13039#[cfg(not(feature = "DynamicLoaded"))]
13040#[cfg(feature = "Implements")]
13041#[cfg(feature = "VK_KHR_xlib_surface")]
13042#[rustfmt::skip]
13043impl crate::resolver::StaticCallable for PFN_vkCreateXlibSurfaceKHR {
13044    const STATIC: Self = Self(vkCreateXlibSurfaceKHR);
13045}
13046
13047#[cfg(feature = "Implements")]
13048#[cfg(feature = "VK_KHR_xlib_surface")]
13049#[repr(transparent)]
13050#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13051#[rustfmt::skip]
13052pub struct PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, dpy: *mut x11::xlib::Display, visualID: x11::xlib::VisualID) -> VkBool32);
13053#[cfg(feature = "Implements")]
13054#[cfg(feature = "VK_KHR_xlib_surface")]
13055#[rustfmt::skip]
13056unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR {
13057    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceXlibPresentationSupportKHR";
13058
13059    #[inline(always)]
13060    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13061        unsafe { core::mem::transmute(p) }
13062    }
13063    #[inline(always)]
13064    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13065        unsafe { core::mem::transmute(p) }
13066    }
13067}
13068#[cfg(not(feature = "DynamicLoaded"))]
13069#[cfg(feature = "Implements")]
13070#[cfg(feature = "VK_KHR_xlib_surface")]
13071#[rustfmt::skip]
13072impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR {
13073    const STATIC: Self = Self(vkGetPhysicalDeviceXlibPresentationSupportKHR);
13074}
13075
13076#[cfg(feature = "Implements")]
13077#[cfg(feature = "VK_KHR_xcb_surface")]
13078#[repr(transparent)]
13079#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13080#[rustfmt::skip]
13081pub struct PFN_vkCreateXcbSurfaceKHR(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkXcbSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult);
13082#[cfg(feature = "Implements")]
13083#[cfg(feature = "VK_KHR_xcb_surface")]
13084#[rustfmt::skip]
13085unsafe impl crate::resolver::PFN for PFN_vkCreateXcbSurfaceKHR {
13086    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateXcbSurfaceKHR";
13087
13088    #[inline(always)]
13089    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13090        unsafe { core::mem::transmute(p) }
13091    }
13092    #[inline(always)]
13093    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13094        unsafe { core::mem::transmute(p) }
13095    }
13096}
13097#[cfg(not(feature = "DynamicLoaded"))]
13098#[cfg(feature = "Implements")]
13099#[cfg(feature = "VK_KHR_xcb_surface")]
13100#[rustfmt::skip]
13101impl crate::resolver::StaticCallable for PFN_vkCreateXcbSurfaceKHR {
13102    const STATIC: Self = Self(vkCreateXcbSurfaceKHR);
13103}
13104
13105#[cfg(feature = "Implements")]
13106#[cfg(feature = "VK_KHR_xcb_surface")]
13107#[repr(transparent)]
13108#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13109#[rustfmt::skip]
13110pub struct PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, connection: *mut xcb::ffi::xcb_connection_t, visual_id: xcb::x::Visualid) -> VkBool32);
13111#[cfg(feature = "Implements")]
13112#[cfg(feature = "VK_KHR_xcb_surface")]
13113#[rustfmt::skip]
13114unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR {
13115    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceXcbPresentationSupportKHR";
13116
13117    #[inline(always)]
13118    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13119        unsafe { core::mem::transmute(p) }
13120    }
13121    #[inline(always)]
13122    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13123        unsafe { core::mem::transmute(p) }
13124    }
13125}
13126#[cfg(not(feature = "DynamicLoaded"))]
13127#[cfg(feature = "Implements")]
13128#[cfg(feature = "VK_KHR_xcb_surface")]
13129#[rustfmt::skip]
13130impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR {
13131    const STATIC: Self = Self(vkGetPhysicalDeviceXcbPresentationSupportKHR);
13132}
13133
13134#[cfg(feature = "Implements")]
13135#[cfg(feature = "VK_KHR_wayland_surface")]
13136#[repr(transparent)]
13137#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13138#[rustfmt::skip]
13139pub struct PFN_vkCreateWaylandSurfaceKHR(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkWaylandSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult);
13140#[cfg(feature = "Implements")]
13141#[cfg(feature = "VK_KHR_wayland_surface")]
13142#[rustfmt::skip]
13143unsafe impl crate::resolver::PFN for PFN_vkCreateWaylandSurfaceKHR {
13144    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateWaylandSurfaceKHR";
13145
13146    #[inline(always)]
13147    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13148        unsafe { core::mem::transmute(p) }
13149    }
13150    #[inline(always)]
13151    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13152        unsafe { core::mem::transmute(p) }
13153    }
13154}
13155#[cfg(not(feature = "DynamicLoaded"))]
13156#[cfg(feature = "Implements")]
13157#[cfg(feature = "VK_KHR_wayland_surface")]
13158#[rustfmt::skip]
13159impl crate::resolver::StaticCallable for PFN_vkCreateWaylandSurfaceKHR {
13160    const STATIC: Self = Self(vkCreateWaylandSurfaceKHR);
13161}
13162
13163#[cfg(feature = "Implements")]
13164#[cfg(feature = "VK_KHR_wayland_surface")]
13165#[repr(transparent)]
13166#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13167#[rustfmt::skip]
13168pub struct PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, display: *mut core::ffi::c_void) -> VkBool32);
13169#[cfg(feature = "Implements")]
13170#[cfg(feature = "VK_KHR_wayland_surface")]
13171#[rustfmt::skip]
13172unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR {
13173    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceWaylandPresentationSupportKHR";
13174
13175    #[inline(always)]
13176    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13177        unsafe { core::mem::transmute(p) }
13178    }
13179    #[inline(always)]
13180    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13181        unsafe { core::mem::transmute(p) }
13182    }
13183}
13184#[cfg(not(feature = "DynamicLoaded"))]
13185#[cfg(feature = "Implements")]
13186#[cfg(feature = "VK_KHR_wayland_surface")]
13187#[rustfmt::skip]
13188impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR {
13189    const STATIC: Self = Self(vkGetPhysicalDeviceWaylandPresentationSupportKHR);
13190}
13191
13192#[cfg(feature = "Implements")]
13193#[cfg(feature = "VK_KHR_android_surface")]
13194#[repr(transparent)]
13195#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13196#[rustfmt::skip]
13197pub struct PFN_vkCreateAndroidSurfaceKHR(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkAndroidSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult);
13198#[cfg(feature = "Implements")]
13199#[cfg(feature = "VK_KHR_android_surface")]
13200#[rustfmt::skip]
13201unsafe impl crate::resolver::PFN for PFN_vkCreateAndroidSurfaceKHR {
13202    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateAndroidSurfaceKHR";
13203
13204    #[inline(always)]
13205    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13206        unsafe { core::mem::transmute(p) }
13207    }
13208    #[inline(always)]
13209    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13210        unsafe { core::mem::transmute(p) }
13211    }
13212}
13213#[cfg(not(feature = "DynamicLoaded"))]
13214#[cfg(feature = "Implements")]
13215#[cfg(feature = "VK_KHR_android_surface")]
13216#[rustfmt::skip]
13217impl crate::resolver::StaticCallable for PFN_vkCreateAndroidSurfaceKHR {
13218    const STATIC: Self = Self(vkCreateAndroidSurfaceKHR);
13219}
13220
13221#[cfg(feature = "Implements")]
13222#[cfg(feature = "VK_KHR_win32_surface")]
13223#[repr(transparent)]
13224#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13225#[rustfmt::skip]
13226pub struct PFN_vkCreateWin32SurfaceKHR(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkWin32SurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult);
13227#[cfg(feature = "Implements")]
13228#[cfg(feature = "VK_KHR_win32_surface")]
13229#[rustfmt::skip]
13230unsafe impl crate::resolver::PFN for PFN_vkCreateWin32SurfaceKHR {
13231    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateWin32SurfaceKHR";
13232
13233    #[inline(always)]
13234    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13235        unsafe { core::mem::transmute(p) }
13236    }
13237    #[inline(always)]
13238    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13239        unsafe { core::mem::transmute(p) }
13240    }
13241}
13242#[cfg(not(feature = "DynamicLoaded"))]
13243#[cfg(feature = "Implements")]
13244#[cfg(feature = "VK_KHR_win32_surface")]
13245#[rustfmt::skip]
13246impl crate::resolver::StaticCallable for PFN_vkCreateWin32SurfaceKHR {
13247    const STATIC: Self = Self(vkCreateWin32SurfaceKHR);
13248}
13249
13250#[cfg(feature = "Implements")]
13251#[cfg(feature = "VK_KHR_win32_surface")]
13252#[repr(transparent)]
13253#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13254#[rustfmt::skip]
13255pub struct PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32) -> VkBool32);
13256#[cfg(feature = "Implements")]
13257#[cfg(feature = "VK_KHR_win32_surface")]
13258#[rustfmt::skip]
13259unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR {
13260    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceWin32PresentationSupportKHR";
13261
13262    #[inline(always)]
13263    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13264        unsafe { core::mem::transmute(p) }
13265    }
13266    #[inline(always)]
13267    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13268        unsafe { core::mem::transmute(p) }
13269    }
13270}
13271#[cfg(not(feature = "DynamicLoaded"))]
13272#[cfg(feature = "Implements")]
13273#[cfg(feature = "VK_KHR_win32_surface")]
13274#[rustfmt::skip]
13275impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR {
13276    const STATIC: Self = Self(vkGetPhysicalDeviceWin32PresentationSupportKHR);
13277}
13278
13279#[cfg(feature = "Implements")]
13280#[cfg(feature = "VK_EXT_metal_surface")]
13281#[repr(transparent)]
13282#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13283#[rustfmt::skip]
13284pub struct PFN_vkCreateMetalSurfaceEXT(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkMetalSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult);
13285#[cfg(feature = "Implements")]
13286#[cfg(feature = "VK_EXT_metal_surface")]
13287#[rustfmt::skip]
13288unsafe impl crate::resolver::PFN for PFN_vkCreateMetalSurfaceEXT {
13289    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateMetalSurfaceEXT";
13290
13291    #[inline(always)]
13292    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13293        unsafe { core::mem::transmute(p) }
13294    }
13295    #[inline(always)]
13296    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13297        unsafe { core::mem::transmute(p) }
13298    }
13299}
13300#[cfg(not(feature = "DynamicLoaded"))]
13301#[cfg(feature = "Implements")]
13302#[cfg(feature = "VK_EXT_metal_surface")]
13303#[rustfmt::skip]
13304impl crate::resolver::StaticCallable for PFN_vkCreateMetalSurfaceEXT {
13305    const STATIC: Self = Self(vkCreateMetalSurfaceEXT);
13306}
13307
13308#[cfg(feature = "Implements")]
13309#[cfg(feature = "VK_KHR_external_memory_win32")]
13310#[repr(transparent)]
13311#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13312#[rustfmt::skip]
13313pub struct PFN_vkGetMemoryWin32HandleKHR(pub unsafe extern "system" fn(device: VkDevice, pGetWin32HandleInfo: *const VkMemoryGetWin32HandleInfoKHR, pHandle: *mut windows::Win32::Foundation::HANDLE) -> VkResult);
13314#[cfg(feature = "Implements")]
13315#[cfg(feature = "VK_KHR_external_memory_win32")]
13316#[rustfmt::skip]
13317unsafe impl crate::resolver::PFN for PFN_vkGetMemoryWin32HandleKHR {
13318    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetMemoryWin32HandleKHR";
13319
13320    #[inline(always)]
13321    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13322        unsafe { core::mem::transmute(p) }
13323    }
13324    #[inline(always)]
13325    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13326        unsafe { core::mem::transmute(p) }
13327    }
13328}
13329
13330#[cfg(feature = "Implements")]
13331#[cfg(feature = "VK_KHR_external_memory_win32")]
13332#[repr(transparent)]
13333#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13334#[rustfmt::skip]
13335pub struct PFN_vkGetMemoryWin32HandlePropertiesKHR(pub unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagsKHR, handle: windows::Win32::Foundation::HANDLE, pMemoryWin32HandleProperties: *mut VkMemoryWin32HandlePropertiesKHR) -> VkResult);
13336#[cfg(feature = "Implements")]
13337#[cfg(feature = "VK_KHR_external_memory_win32")]
13338#[rustfmt::skip]
13339unsafe impl crate::resolver::PFN for PFN_vkGetMemoryWin32HandlePropertiesKHR {
13340    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetMemoryWin32HandlePropertiesKHR";
13341
13342    #[inline(always)]
13343    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13344        unsafe { core::mem::transmute(p) }
13345    }
13346    #[inline(always)]
13347    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13348        unsafe { core::mem::transmute(p) }
13349    }
13350}
13351
13352#[cfg(feature = "Implements")]
13353#[cfg(feature = "VK_KHR_external_memory_fd")]
13354#[repr(transparent)]
13355#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13356#[rustfmt::skip]
13357pub struct PFN_vkGetMemoryFdKHR(pub unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut core::ffi::c_int) -> VkResult);
13358#[cfg(feature = "Implements")]
13359#[cfg(feature = "VK_KHR_external_memory_fd")]
13360#[rustfmt::skip]
13361unsafe impl crate::resolver::PFN for PFN_vkGetMemoryFdKHR {
13362    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetMemoryFdKHR";
13363
13364    #[inline(always)]
13365    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13366        unsafe { core::mem::transmute(p) }
13367    }
13368    #[inline(always)]
13369    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13370        unsafe { core::mem::transmute(p) }
13371    }
13372}
13373
13374#[cfg(feature = "Implements")]
13375#[cfg(feature = "VK_KHR_external_memory_fd")]
13376#[repr(transparent)]
13377#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13378#[rustfmt::skip]
13379pub struct PFN_vkGetMemoryFdPropertiesKHR(pub unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagsKHR, fd: core::ffi::c_int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult);
13380#[cfg(feature = "Implements")]
13381#[cfg(feature = "VK_KHR_external_memory_fd")]
13382#[rustfmt::skip]
13383unsafe impl crate::resolver::PFN for PFN_vkGetMemoryFdPropertiesKHR {
13384    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetMemoryFdPropertiesKHR";
13385
13386    #[inline(always)]
13387    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13388        unsafe { core::mem::transmute(p) }
13389    }
13390    #[inline(always)]
13391    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13392        unsafe { core::mem::transmute(p) }
13393    }
13394}
13395
13396#[cfg(feature = "Implements")]
13397#[cfg(feature = "VK_KHR_external_semaphore_win32")]
13398#[repr(transparent)]
13399#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13400#[rustfmt::skip]
13401pub struct PFN_vkImportSemaphoreWin32HandleKHR(pub unsafe extern "system" fn(device: VkDevice, pImportSemaphoreWin32HandleInfo: *const VkImportSemaphoreWin32HandleInfoKHR) -> VkResult);
13402#[cfg(feature = "Implements")]
13403#[cfg(feature = "VK_KHR_external_semaphore_win32")]
13404#[rustfmt::skip]
13405unsafe impl crate::resolver::PFN for PFN_vkImportSemaphoreWin32HandleKHR {
13406    const NAME_CSTR: &'static core::ffi::CStr = c"vkImportSemaphoreWin32HandleKHR";
13407
13408    #[inline(always)]
13409    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13410        unsafe { core::mem::transmute(p) }
13411    }
13412    #[inline(always)]
13413    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13414        unsafe { core::mem::transmute(p) }
13415    }
13416}
13417
13418#[cfg(feature = "Implements")]
13419#[cfg(feature = "VK_KHR_external_semaphore_win32")]
13420#[repr(transparent)]
13421#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13422#[rustfmt::skip]
13423pub struct PFN_vkGetSemaphoreWin32HandleKHR(pub unsafe extern "system" fn(device: VkDevice, pGetWin32HandleInfo: *const VkSemaphoreGetWin32HandleInfoKHR, pHandle: *mut windows::Win32::Foundation::HANDLE) -> VkResult);
13424#[cfg(feature = "Implements")]
13425#[cfg(feature = "VK_KHR_external_semaphore_win32")]
13426#[rustfmt::skip]
13427unsafe impl crate::resolver::PFN for PFN_vkGetSemaphoreWin32HandleKHR {
13428    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetSemaphoreWin32HandleKHR";
13429
13430    #[inline(always)]
13431    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13432        unsafe { core::mem::transmute(p) }
13433    }
13434    #[inline(always)]
13435    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13436        unsafe { core::mem::transmute(p) }
13437    }
13438}
13439
13440#[cfg(feature = "Implements")]
13441#[cfg(feature = "VK_KHR_external_semaphore_fd")]
13442#[repr(transparent)]
13443#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13444#[rustfmt::skip]
13445pub struct PFN_vkImportSemaphoreFdKHR(pub unsafe extern "system" fn(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult);
13446#[cfg(feature = "Implements")]
13447#[cfg(feature = "VK_KHR_external_semaphore_fd")]
13448#[rustfmt::skip]
13449unsafe impl crate::resolver::PFN for PFN_vkImportSemaphoreFdKHR {
13450    const NAME_CSTR: &'static core::ffi::CStr = c"vkImportSemaphoreFdKHR";
13451
13452    #[inline(always)]
13453    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13454        unsafe { core::mem::transmute(p) }
13455    }
13456    #[inline(always)]
13457    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13458        unsafe { core::mem::transmute(p) }
13459    }
13460}
13461
13462#[cfg(feature = "Implements")]
13463#[cfg(feature = "VK_KHR_external_semaphore_fd")]
13464#[repr(transparent)]
13465#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13466#[rustfmt::skip]
13467pub struct PFN_vkGetSemaphoreFdKHR(pub unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut core::ffi::c_int) -> VkResult);
13468#[cfg(feature = "Implements")]
13469#[cfg(feature = "VK_KHR_external_semaphore_fd")]
13470#[rustfmt::skip]
13471unsafe impl crate::resolver::PFN for PFN_vkGetSemaphoreFdKHR {
13472    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetSemaphoreFdKHR";
13473
13474    #[inline(always)]
13475    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13476        unsafe { core::mem::transmute(p) }
13477    }
13478    #[inline(always)]
13479    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13480        unsafe { core::mem::transmute(p) }
13481    }
13482}
13483
13484#[cfg(feature = "Implements")]
13485#[cfg(feature = "VK_KHR_external_fence_win32")]
13486#[repr(transparent)]
13487#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13488#[rustfmt::skip]
13489pub struct PFN_vkImportFenceWin32HandleKHR(pub unsafe extern "system" fn(device: VkDevice, pImportFenceWin32HandleInfo: *const VkImportFenceWin32HandleInfoKHR) -> VkResult);
13490#[cfg(feature = "Implements")]
13491#[cfg(feature = "VK_KHR_external_fence_win32")]
13492#[rustfmt::skip]
13493unsafe impl crate::resolver::PFN for PFN_vkImportFenceWin32HandleKHR {
13494    const NAME_CSTR: &'static core::ffi::CStr = c"vkImportFenceWin32HandleKHR";
13495
13496    #[inline(always)]
13497    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13498        unsafe { core::mem::transmute(p) }
13499    }
13500    #[inline(always)]
13501    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13502        unsafe { core::mem::transmute(p) }
13503    }
13504}
13505
13506#[cfg(feature = "Implements")]
13507#[cfg(feature = "VK_KHR_external_fence_win32")]
13508#[repr(transparent)]
13509#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13510#[rustfmt::skip]
13511pub struct PFN_vkGetFenceWin32HandleKHR(pub unsafe extern "system" fn(device: VkDevice, pGetWin32HandleInfo: *const VkFenceGetWin32HandleInfoKHR, pHandle: *mut windows::Win32::Foundation::HANDLE) -> VkResult);
13512#[cfg(feature = "Implements")]
13513#[cfg(feature = "VK_KHR_external_fence_win32")]
13514#[rustfmt::skip]
13515unsafe impl crate::resolver::PFN for PFN_vkGetFenceWin32HandleKHR {
13516    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetFenceWin32HandleKHR";
13517
13518    #[inline(always)]
13519    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13520        unsafe { core::mem::transmute(p) }
13521    }
13522    #[inline(always)]
13523    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13524        unsafe { core::mem::transmute(p) }
13525    }
13526}
13527
13528#[cfg(feature = "Implements")]
13529#[cfg(feature = "VK_KHR_external_fence_fd")]
13530#[repr(transparent)]
13531#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13532#[rustfmt::skip]
13533pub struct PFN_vkImportFenceFdKHR(pub unsafe extern "system" fn(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult);
13534#[cfg(feature = "Implements")]
13535#[cfg(feature = "VK_KHR_external_fence_fd")]
13536#[rustfmt::skip]
13537unsafe impl crate::resolver::PFN for PFN_vkImportFenceFdKHR {
13538    const NAME_CSTR: &'static core::ffi::CStr = c"vkImportFenceFdKHR";
13539
13540    #[inline(always)]
13541    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13542        unsafe { core::mem::transmute(p) }
13543    }
13544    #[inline(always)]
13545    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13546        unsafe { core::mem::transmute(p) }
13547    }
13548}
13549
13550#[cfg(feature = "Implements")]
13551#[cfg(feature = "VK_KHR_external_fence_fd")]
13552#[repr(transparent)]
13553#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13554#[rustfmt::skip]
13555pub struct PFN_vkGetFenceFdKHR(pub unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut core::ffi::c_int) -> VkResult);
13556#[cfg(feature = "Implements")]
13557#[cfg(feature = "VK_KHR_external_fence_fd")]
13558#[rustfmt::skip]
13559unsafe impl crate::resolver::PFN for PFN_vkGetFenceFdKHR {
13560    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetFenceFdKHR";
13561
13562    #[inline(always)]
13563    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13564        unsafe { core::mem::transmute(p) }
13565    }
13566    #[inline(always)]
13567    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13568        unsafe { core::mem::transmute(p) }
13569    }
13570}
13571
13572#[cfg(feature = "Implements")]
13573#[cfg(feature = "VK_KHR_get_surface_capabilities2")]
13574#[repr(transparent)]
13575#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13576#[rustfmt::skip]
13577pub struct PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult);
13578#[cfg(feature = "Implements")]
13579#[cfg(feature = "VK_KHR_get_surface_capabilities2")]
13580#[rustfmt::skip]
13581unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR {
13582    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSurfaceCapabilities2KHR";
13583
13584    #[inline(always)]
13585    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13586        unsafe { core::mem::transmute(p) }
13587    }
13588    #[inline(always)]
13589    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13590        unsafe { core::mem::transmute(p) }
13591    }
13592}
13593
13594#[cfg(feature = "Implements")]
13595#[cfg(feature = "VK_KHR_get_surface_capabilities2")]
13596#[repr(transparent)]
13597#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13598#[rustfmt::skip]
13599pub struct PFN_vkGetPhysicalDeviceSurfaceFormats2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatsCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult);
13600#[cfg(feature = "Implements")]
13601#[cfg(feature = "VK_KHR_get_surface_capabilities2")]
13602#[rustfmt::skip]
13603unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSurfaceFormats2KHR {
13604    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSurfaceFormats2KHR";
13605
13606    #[inline(always)]
13607    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13608        unsafe { core::mem::transmute(p) }
13609    }
13610    #[inline(always)]
13611    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13612        unsafe { core::mem::transmute(p) }
13613    }
13614}
13615
13616#[cfg(feature = "Implements")]
13617#[cfg(feature = "VK_EXT_debug_report")]
13618#[repr(transparent)]
13619#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13620#[rustfmt::skip]
13621pub struct PFN_vkCreateDebugReportCallbackEXT(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult);
13622#[cfg(feature = "Implements")]
13623#[cfg(feature = "VK_EXT_debug_report")]
13624#[rustfmt::skip]
13625unsafe impl crate::resolver::PFN for PFN_vkCreateDebugReportCallbackEXT {
13626    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDebugReportCallbackEXT";
13627
13628    #[inline(always)]
13629    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13630        unsafe { core::mem::transmute(p) }
13631    }
13632    #[inline(always)]
13633    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13634        unsafe { core::mem::transmute(p) }
13635    }
13636}
13637
13638#[cfg(feature = "Implements")]
13639#[cfg(feature = "VK_EXT_debug_report")]
13640#[repr(transparent)]
13641#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13642#[rustfmt::skip]
13643pub struct PFN_vkDestroyDebugReportCallbackEXT(pub unsafe extern "system" fn(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks));
13644#[cfg(feature = "Implements")]
13645#[cfg(feature = "VK_EXT_debug_report")]
13646#[rustfmt::skip]
13647unsafe impl crate::resolver::PFN for PFN_vkDestroyDebugReportCallbackEXT {
13648    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyDebugReportCallbackEXT";
13649
13650    #[inline(always)]
13651    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13652        unsafe { core::mem::transmute(p) }
13653    }
13654    #[inline(always)]
13655    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13656        unsafe { core::mem::transmute(p) }
13657    }
13658}
13659
13660#[cfg(feature = "Implements")]
13661#[cfg(feature = "VK_EXT_debug_report")]
13662#[repr(transparent)]
13663#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13664#[rustfmt::skip]
13665pub struct PFN_vkDebugReportMessageEXT(pub unsafe extern "system" fn(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const core::ffi::c_char, pMessage: *const core::ffi::c_char));
13666#[cfg(feature = "Implements")]
13667#[cfg(feature = "VK_EXT_debug_report")]
13668#[rustfmt::skip]
13669unsafe impl crate::resolver::PFN for PFN_vkDebugReportMessageEXT {
13670    const NAME_CSTR: &'static core::ffi::CStr = c"vkDebugReportMessageEXT";
13671
13672    #[inline(always)]
13673    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13674        unsafe { core::mem::transmute(p) }
13675    }
13676    #[inline(always)]
13677    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13678        unsafe { core::mem::transmute(p) }
13679    }
13680}
13681
13682#[cfg(feature = "Implements")]
13683#[cfg(feature = "VK_EXT_debug_utils")]
13684#[repr(transparent)]
13685#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13686#[rustfmt::skip]
13687pub struct PFN_vkSetDebugUtilsObjectNameEXT(pub unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult);
13688#[cfg(feature = "Implements")]
13689#[cfg(feature = "VK_EXT_debug_utils")]
13690#[rustfmt::skip]
13691unsafe impl crate::resolver::PFN for PFN_vkSetDebugUtilsObjectNameEXT {
13692    const NAME_CSTR: &'static core::ffi::CStr = c"vkSetDebugUtilsObjectNameEXT";
13693
13694    #[inline(always)]
13695    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13696        unsafe { core::mem::transmute(p) }
13697    }
13698    #[inline(always)]
13699    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13700        unsafe { core::mem::transmute(p) }
13701    }
13702}
13703
13704#[cfg(feature = "Implements")]
13705#[cfg(feature = "VK_EXT_debug_utils")]
13706#[repr(transparent)]
13707#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13708#[rustfmt::skip]
13709pub struct PFN_vkSetDebugUtilsObjectTagEXT(pub unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult);
13710#[cfg(feature = "Implements")]
13711#[cfg(feature = "VK_EXT_debug_utils")]
13712#[rustfmt::skip]
13713unsafe impl crate::resolver::PFN for PFN_vkSetDebugUtilsObjectTagEXT {
13714    const NAME_CSTR: &'static core::ffi::CStr = c"vkSetDebugUtilsObjectTagEXT";
13715
13716    #[inline(always)]
13717    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13718        unsafe { core::mem::transmute(p) }
13719    }
13720    #[inline(always)]
13721    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13722        unsafe { core::mem::transmute(p) }
13723    }
13724}
13725
13726#[cfg(feature = "Implements")]
13727#[cfg(feature = "VK_EXT_debug_utils")]
13728#[repr(transparent)]
13729#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13730#[rustfmt::skip]
13731pub struct PFN_vkQueueBeginDebugUtilsLabelEXT(pub unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT));
13732#[cfg(feature = "Implements")]
13733#[cfg(feature = "VK_EXT_debug_utils")]
13734#[rustfmt::skip]
13735unsafe impl crate::resolver::PFN for PFN_vkQueueBeginDebugUtilsLabelEXT {
13736    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueBeginDebugUtilsLabelEXT";
13737
13738    #[inline(always)]
13739    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13740        unsafe { core::mem::transmute(p) }
13741    }
13742    #[inline(always)]
13743    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13744        unsafe { core::mem::transmute(p) }
13745    }
13746}
13747
13748#[cfg(feature = "Implements")]
13749#[cfg(feature = "VK_EXT_debug_utils")]
13750#[repr(transparent)]
13751#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13752#[rustfmt::skip]
13753pub struct PFN_vkQueueEndDebugUtilsLabelEXT(pub unsafe extern "system" fn(queue: VkQueue));
13754#[cfg(feature = "Implements")]
13755#[cfg(feature = "VK_EXT_debug_utils")]
13756#[rustfmt::skip]
13757unsafe impl crate::resolver::PFN for PFN_vkQueueEndDebugUtilsLabelEXT {
13758    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueEndDebugUtilsLabelEXT";
13759
13760    #[inline(always)]
13761    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13762        unsafe { core::mem::transmute(p) }
13763    }
13764    #[inline(always)]
13765    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13766        unsafe { core::mem::transmute(p) }
13767    }
13768}
13769
13770#[cfg(feature = "Implements")]
13771#[cfg(feature = "VK_EXT_debug_utils")]
13772#[repr(transparent)]
13773#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13774#[rustfmt::skip]
13775pub struct PFN_vkQueueInsertDebugUtilsLabelEXT(pub unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT));
13776#[cfg(feature = "Implements")]
13777#[cfg(feature = "VK_EXT_debug_utils")]
13778#[rustfmt::skip]
13779unsafe impl crate::resolver::PFN for PFN_vkQueueInsertDebugUtilsLabelEXT {
13780    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueInsertDebugUtilsLabelEXT";
13781
13782    #[inline(always)]
13783    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13784        unsafe { core::mem::transmute(p) }
13785    }
13786    #[inline(always)]
13787    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13788        unsafe { core::mem::transmute(p) }
13789    }
13790}
13791
13792#[cfg(feature = "Implements")]
13793#[cfg(feature = "VK_EXT_debug_utils")]
13794#[repr(transparent)]
13795#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13796#[rustfmt::skip]
13797pub struct PFN_vkCreateDebugUtilsMessengerEXT(pub unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pDebugUtilsMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult);
13798#[cfg(feature = "Implements")]
13799#[cfg(feature = "VK_EXT_debug_utils")]
13800#[rustfmt::skip]
13801unsafe impl crate::resolver::PFN for PFN_vkCreateDebugUtilsMessengerEXT {
13802    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDebugUtilsMessengerEXT";
13803
13804    #[inline(always)]
13805    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13806        unsafe { core::mem::transmute(p) }
13807    }
13808    #[inline(always)]
13809    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13810        unsafe { core::mem::transmute(p) }
13811    }
13812}
13813
13814#[cfg(feature = "Implements")]
13815#[cfg(feature = "VK_EXT_debug_utils")]
13816#[repr(transparent)]
13817#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13818#[rustfmt::skip]
13819pub struct PFN_vkDestroyDebugUtilsMessengerEXT(pub unsafe extern "system" fn(instance: VkInstance, debugUtilsMessenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks));
13820#[cfg(feature = "Implements")]
13821#[cfg(feature = "VK_EXT_debug_utils")]
13822#[rustfmt::skip]
13823unsafe impl crate::resolver::PFN for PFN_vkDestroyDebugUtilsMessengerEXT {
13824    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyDebugUtilsMessengerEXT";
13825
13826    #[inline(always)]
13827    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13828        unsafe { core::mem::transmute(p) }
13829    }
13830    #[inline(always)]
13831    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13832        unsafe { core::mem::transmute(p) }
13833    }
13834}
13835
13836#[cfg(feature = "Implements")]
13837#[cfg(feature = "VK_EXT_debug_utils")]
13838#[repr(transparent)]
13839#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13840#[rustfmt::skip]
13841pub struct PFN_vkSubmitDebugUtilsMessageEXT(pub unsafe extern "system" fn(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT));
13842#[cfg(feature = "Implements")]
13843#[cfg(feature = "VK_EXT_debug_utils")]
13844#[rustfmt::skip]
13845unsafe impl crate::resolver::PFN for PFN_vkSubmitDebugUtilsMessageEXT {
13846    const NAME_CSTR: &'static core::ffi::CStr = c"vkSubmitDebugUtilsMessageEXT";
13847
13848    #[inline(always)]
13849    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13850        unsafe { core::mem::transmute(p) }
13851    }
13852    #[inline(always)]
13853    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13854        unsafe { core::mem::transmute(p) }
13855    }
13856}
13857
13858#[cfg(feature = "Implements")]
13859#[cfg(feature = "VK_KHR_external_memory_capabilities")]
13860#[repr(transparent)]
13861#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13862#[rustfmt::skip]
13863pub struct PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfoKHR, pExternalBufferProperties: *mut VkExternalBufferPropertiesKHR));
13864#[cfg(feature = "Implements")]
13865#[cfg(feature = "VK_KHR_external_memory_capabilities")]
13866#[rustfmt::skip]
13867unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR {
13868    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceExternalBufferPropertiesKHR";
13869
13870    #[inline(always)]
13871    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13872        unsafe { core::mem::transmute(p) }
13873    }
13874    #[inline(always)]
13875    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13876        unsafe { core::mem::transmute(p) }
13877    }
13878}
13879#[cfg(feature = "Implements")]
13880#[cfg(feature = "Allow1_1APIs")]
13881#[repr(transparent)]
13882#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13883#[rustfmt::skip]
13884pub struct PFN_vkGetPhysicalDeviceExternalBufferProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfoKHR, pExternalBufferProperties: *mut VkExternalBufferPropertiesKHR));
13885#[cfg(feature = "Implements")]
13886#[cfg(feature = "Allow1_1APIs")]
13887#[rustfmt::skip]
13888unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceExternalBufferProperties {
13889    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceExternalBufferProperties";
13890
13891    #[inline(always)]
13892    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13893        unsafe { core::mem::transmute(p) }
13894    }
13895    #[inline(always)]
13896    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13897        unsafe { core::mem::transmute(p) }
13898    }
13899}
13900#[cfg(feature = "Implements")]
13901#[cfg(not(feature = "DynamicLoaded"))]
13902#[cfg(feature = "Allow1_1APIs")]
13903#[rustfmt::skip]
13904impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceExternalBufferProperties {
13905    const STATIC: Self = Self(vkGetPhysicalDeviceExternalBufferProperties);
13906}
13907
13908#[cfg(feature = "Implements")]
13909#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
13910#[repr(transparent)]
13911#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13912#[rustfmt::skip]
13913pub struct PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfoKHR, pExternalSemaphoreProperties: *mut VkExternalSemaphorePropertiesKHR));
13914#[cfg(feature = "Implements")]
13915#[cfg(feature = "VK_KHR_external_semaphore_capabilities")]
13916#[rustfmt::skip]
13917unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR {
13918    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR";
13919
13920    #[inline(always)]
13921    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13922        unsafe { core::mem::transmute(p) }
13923    }
13924    #[inline(always)]
13925    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13926        unsafe { core::mem::transmute(p) }
13927    }
13928}
13929#[cfg(feature = "Implements")]
13930#[cfg(feature = "Allow1_1APIs")]
13931#[repr(transparent)]
13932#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13933#[rustfmt::skip]
13934pub struct PFN_vkGetPhysicalDeviceExternalSemaphoreProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfoKHR, pExternalSemaphoreProperties: *mut VkExternalSemaphorePropertiesKHR));
13935#[cfg(feature = "Implements")]
13936#[cfg(feature = "Allow1_1APIs")]
13937#[rustfmt::skip]
13938unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceExternalSemaphoreProperties {
13939    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceExternalSemaphoreProperties";
13940
13941    #[inline(always)]
13942    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13943        unsafe { core::mem::transmute(p) }
13944    }
13945    #[inline(always)]
13946    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13947        unsafe { core::mem::transmute(p) }
13948    }
13949}
13950#[cfg(feature = "Implements")]
13951#[cfg(not(feature = "DynamicLoaded"))]
13952#[cfg(feature = "Allow1_1APIs")]
13953#[rustfmt::skip]
13954impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceExternalSemaphoreProperties {
13955    const STATIC: Self = Self(vkGetPhysicalDeviceExternalSemaphoreProperties);
13956}
13957
13958#[cfg(feature = "Implements")]
13959#[cfg(feature = "VK_KHR_external_fence_capabilities")]
13960#[repr(transparent)]
13961#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13962#[rustfmt::skip]
13963pub struct PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfoKHR, pExternalFenceProperties: *mut VkExternalFencePropertiesKHR));
13964#[cfg(feature = "Implements")]
13965#[cfg(feature = "VK_KHR_external_fence_capabilities")]
13966#[rustfmt::skip]
13967unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR {
13968    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceExternalFencePropertiesKHR";
13969
13970    #[inline(always)]
13971    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13972        unsafe { core::mem::transmute(p) }
13973    }
13974    #[inline(always)]
13975    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13976        unsafe { core::mem::transmute(p) }
13977    }
13978}
13979#[cfg(feature = "Implements")]
13980#[cfg(feature = "Allow1_1APIs")]
13981#[repr(transparent)]
13982#[derive(Debug, Clone, Copy, PartialEq, Eq)]
13983#[rustfmt::skip]
13984pub struct PFN_vkGetPhysicalDeviceExternalFenceProperties(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfoKHR, pExternalFenceProperties: *mut VkExternalFencePropertiesKHR));
13985#[cfg(feature = "Implements")]
13986#[cfg(feature = "Allow1_1APIs")]
13987#[rustfmt::skip]
13988unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceExternalFenceProperties {
13989    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceExternalFenceProperties";
13990
13991    #[inline(always)]
13992    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
13993        unsafe { core::mem::transmute(p) }
13994    }
13995    #[inline(always)]
13996    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
13997        unsafe { core::mem::transmute(p) }
13998    }
13999}
14000#[cfg(feature = "Implements")]
14001#[cfg(not(feature = "DynamicLoaded"))]
14002#[cfg(feature = "Allow1_1APIs")]
14003#[rustfmt::skip]
14004impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceExternalFenceProperties {
14005    const STATIC: Self = Self(vkGetPhysicalDeviceExternalFenceProperties);
14006}
14007
14008#[cfg(feature = "Implements")]
14009#[cfg(feature = "VK_KHR_device_group")]
14010#[repr(transparent)]
14011#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14012#[rustfmt::skip]
14013pub struct PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR(pub unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags));
14014#[cfg(feature = "Implements")]
14015#[cfg(feature = "VK_KHR_device_group")]
14016#[rustfmt::skip]
14017unsafe impl crate::resolver::PFN for PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR {
14018    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceGroupPeerMemoryFeaturesKHR";
14019
14020    #[inline(always)]
14021    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14022        unsafe { core::mem::transmute(p) }
14023    }
14024    #[inline(always)]
14025    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14026        unsafe { core::mem::transmute(p) }
14027    }
14028}
14029#[cfg(feature = "Implements")]
14030#[cfg(feature = "Allow1_1APIs")]
14031#[repr(transparent)]
14032#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14033#[rustfmt::skip]
14034pub struct PFN_vkGetDeviceGroupPeerMemoryFeatures(pub unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags));
14035#[cfg(feature = "Implements")]
14036#[cfg(feature = "Allow1_1APIs")]
14037#[rustfmt::skip]
14038unsafe impl crate::resolver::PFN for PFN_vkGetDeviceGroupPeerMemoryFeatures {
14039    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceGroupPeerMemoryFeatures";
14040
14041    #[inline(always)]
14042    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14043        unsafe { core::mem::transmute(p) }
14044    }
14045    #[inline(always)]
14046    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14047        unsafe { core::mem::transmute(p) }
14048    }
14049}
14050#[cfg(feature = "Implements")]
14051#[cfg(not(feature = "DynamicLoaded"))]
14052#[cfg(feature = "Allow1_1APIs")]
14053#[rustfmt::skip]
14054impl crate::resolver::StaticCallable for PFN_vkGetDeviceGroupPeerMemoryFeatures {
14055    const STATIC: Self = Self(vkGetDeviceGroupPeerMemoryFeatures);
14056}
14057
14058#[cfg(feature = "Implements")]
14059#[cfg(feature = "VK_KHR_device_group")]
14060#[cfg(feature = "VK_KHR_surface")]
14061#[repr(transparent)]
14062#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14063#[rustfmt::skip]
14064pub struct PFN_vkGetDeviceGroupPresentCapabilitiesKHR(pub unsafe extern "system" fn(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult);
14065#[cfg(feature = "Implements")]
14066#[cfg(feature = "VK_KHR_device_group")]
14067#[cfg(feature = "VK_KHR_surface")]
14068#[rustfmt::skip]
14069unsafe impl crate::resolver::PFN for PFN_vkGetDeviceGroupPresentCapabilitiesKHR {
14070    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceGroupPresentCapabilitiesKHR";
14071
14072    #[inline(always)]
14073    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14074        unsafe { core::mem::transmute(p) }
14075    }
14076    #[inline(always)]
14077    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14078        unsafe { core::mem::transmute(p) }
14079    }
14080}
14081
14082#[cfg(feature = "Implements")]
14083#[cfg(feature = "VK_KHR_device_group")]
14084#[cfg(feature = "VK_KHR_surface")]
14085#[repr(transparent)]
14086#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14087#[rustfmt::skip]
14088pub struct PFN_vkGetDeviceGroupSurfacePresentModesKHR(pub unsafe extern "system" fn(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult);
14089#[cfg(feature = "Implements")]
14090#[cfg(feature = "VK_KHR_device_group")]
14091#[cfg(feature = "VK_KHR_surface")]
14092#[rustfmt::skip]
14093unsafe impl crate::resolver::PFN for PFN_vkGetDeviceGroupSurfacePresentModesKHR {
14094    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceGroupSurfacePresentModesKHR";
14095
14096    #[inline(always)]
14097    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14098        unsafe { core::mem::transmute(p) }
14099    }
14100    #[inline(always)]
14101    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14102        unsafe { core::mem::transmute(p) }
14103    }
14104}
14105
14106#[cfg(feature = "Implements")]
14107#[cfg(feature = "VK_KHR_device_group")]
14108#[cfg(feature = "VK_KHR_surface")]
14109#[repr(transparent)]
14110#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14111#[rustfmt::skip]
14112pub struct PFN_vkGetPhysicalDevicePresentRectanglesKHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut u32, pRects: *mut VkRect2D) -> VkResult);
14113#[cfg(feature = "Implements")]
14114#[cfg(feature = "VK_KHR_device_group")]
14115#[cfg(feature = "VK_KHR_surface")]
14116#[rustfmt::skip]
14117unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDevicePresentRectanglesKHR {
14118    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDevicePresentRectanglesKHR";
14119
14120    #[inline(always)]
14121    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14122        unsafe { core::mem::transmute(p) }
14123    }
14124    #[inline(always)]
14125    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14126        unsafe { core::mem::transmute(p) }
14127    }
14128}
14129
14130#[cfg(feature = "Implements")]
14131#[cfg(feature = "VK_KHR_device_group")]
14132#[cfg(feature = "VK_KHR_swapchain")]
14133#[repr(transparent)]
14134#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14135#[rustfmt::skip]
14136pub struct PFN_vkAcquireNextImage2KHR(pub unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut u32) -> VkResult);
14137#[cfg(feature = "Implements")]
14138#[cfg(feature = "VK_KHR_device_group")]
14139#[cfg(feature = "VK_KHR_swapchain")]
14140#[rustfmt::skip]
14141unsafe impl crate::resolver::PFN for PFN_vkAcquireNextImage2KHR {
14142    const NAME_CSTR: &'static core::ffi::CStr = c"vkAcquireNextImage2KHR";
14143
14144    #[inline(always)]
14145    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14146        unsafe { core::mem::transmute(p) }
14147    }
14148    #[inline(always)]
14149    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14150        unsafe { core::mem::transmute(p) }
14151    }
14152}
14153
14154#[cfg(feature = "Implements")]
14155#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14156#[repr(transparent)]
14157#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14158#[rustfmt::skip]
14159pub struct PFN_vkGetPhysicalDeviceFeatures2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2KHR));
14160#[cfg(feature = "Implements")]
14161#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14162#[rustfmt::skip]
14163unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceFeatures2KHR {
14164    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceFeatures2KHR";
14165
14166    #[inline(always)]
14167    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14168        unsafe { core::mem::transmute(p) }
14169    }
14170    #[inline(always)]
14171    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14172        unsafe { core::mem::transmute(p) }
14173    }
14174}
14175#[cfg(feature = "Implements")]
14176#[cfg(feature = "Allow1_1APIs")]
14177#[repr(transparent)]
14178#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14179#[rustfmt::skip]
14180pub struct PFN_vkGetPhysicalDeviceFeatures2(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2KHR));
14181#[cfg(feature = "Implements")]
14182#[cfg(feature = "Allow1_1APIs")]
14183#[rustfmt::skip]
14184unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceFeatures2 {
14185    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceFeatures2";
14186
14187    #[inline(always)]
14188    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14189        unsafe { core::mem::transmute(p) }
14190    }
14191    #[inline(always)]
14192    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14193        unsafe { core::mem::transmute(p) }
14194    }
14195}
14196#[cfg(feature = "Implements")]
14197#[cfg(not(feature = "DynamicLoaded"))]
14198#[cfg(feature = "Allow1_1APIs")]
14199#[rustfmt::skip]
14200impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceFeatures2 {
14201    const STATIC: Self = Self(vkGetPhysicalDeviceFeatures2);
14202}
14203
14204#[cfg(feature = "Implements")]
14205#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14206#[repr(transparent)]
14207#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14208#[rustfmt::skip]
14209pub struct PFN_vkGetPhysicalDeviceProperties2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2KHR));
14210#[cfg(feature = "Implements")]
14211#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14212#[rustfmt::skip]
14213unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceProperties2KHR {
14214    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceProperties2KHR";
14215
14216    #[inline(always)]
14217    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14218        unsafe { core::mem::transmute(p) }
14219    }
14220    #[inline(always)]
14221    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14222        unsafe { core::mem::transmute(p) }
14223    }
14224}
14225#[cfg(feature = "Implements")]
14226#[cfg(feature = "Allow1_1APIs")]
14227#[repr(transparent)]
14228#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14229#[rustfmt::skip]
14230pub struct PFN_vkGetPhysicalDeviceProperties2(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2KHR));
14231#[cfg(feature = "Implements")]
14232#[cfg(feature = "Allow1_1APIs")]
14233#[rustfmt::skip]
14234unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceProperties2 {
14235    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceProperties2";
14236
14237    #[inline(always)]
14238    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14239        unsafe { core::mem::transmute(p) }
14240    }
14241    #[inline(always)]
14242    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14243        unsafe { core::mem::transmute(p) }
14244    }
14245}
14246#[cfg(feature = "Implements")]
14247#[cfg(not(feature = "DynamicLoaded"))]
14248#[cfg(feature = "Allow1_1APIs")]
14249#[rustfmt::skip]
14250impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceProperties2 {
14251    const STATIC: Self = Self(vkGetPhysicalDeviceProperties2);
14252}
14253
14254#[cfg(feature = "Implements")]
14255#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14256#[repr(transparent)]
14257#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14258#[rustfmt::skip]
14259pub struct PFN_vkGetPhysicalDeviceFormatProperties2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2KHR));
14260#[cfg(feature = "Implements")]
14261#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14262#[rustfmt::skip]
14263unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceFormatProperties2KHR {
14264    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceFormatProperties2KHR";
14265
14266    #[inline(always)]
14267    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14268        unsafe { core::mem::transmute(p) }
14269    }
14270    #[inline(always)]
14271    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14272        unsafe { core::mem::transmute(p) }
14273    }
14274}
14275#[cfg(feature = "Implements")]
14276#[cfg(feature = "Allow1_1APIs")]
14277#[repr(transparent)]
14278#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14279#[rustfmt::skip]
14280pub struct PFN_vkGetPhysicalDeviceFormatProperties2(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2KHR));
14281#[cfg(feature = "Implements")]
14282#[cfg(feature = "Allow1_1APIs")]
14283#[rustfmt::skip]
14284unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceFormatProperties2 {
14285    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceFormatProperties2";
14286
14287    #[inline(always)]
14288    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14289        unsafe { core::mem::transmute(p) }
14290    }
14291    #[inline(always)]
14292    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14293        unsafe { core::mem::transmute(p) }
14294    }
14295}
14296#[cfg(feature = "Implements")]
14297#[cfg(not(feature = "DynamicLoaded"))]
14298#[cfg(feature = "Allow1_1APIs")]
14299#[rustfmt::skip]
14300impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceFormatProperties2 {
14301    const STATIC: Self = Self(vkGetPhysicalDeviceFormatProperties2);
14302}
14303
14304#[cfg(feature = "Implements")]
14305#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14306#[repr(transparent)]
14307#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14308#[rustfmt::skip]
14309pub struct PFN_vkGetPhysicalDeviceImageFormatProperties2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2KHR, pImageFormatProperties: *mut VkImageFormatProperties2KHR) -> VkResult);
14310#[cfg(feature = "Implements")]
14311#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14312#[rustfmt::skip]
14313unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceImageFormatProperties2KHR {
14314    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceImageFormatProperties2KHR";
14315
14316    #[inline(always)]
14317    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14318        unsafe { core::mem::transmute(p) }
14319    }
14320    #[inline(always)]
14321    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14322        unsafe { core::mem::transmute(p) }
14323    }
14324}
14325#[cfg(feature = "Implements")]
14326#[cfg(feature = "Allow1_1APIs")]
14327#[repr(transparent)]
14328#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14329#[rustfmt::skip]
14330pub struct PFN_vkGetPhysicalDeviceImageFormatProperties2(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2KHR, pImageFormatProperties: *mut VkImageFormatProperties2KHR) -> VkResult);
14331#[cfg(feature = "Implements")]
14332#[cfg(feature = "Allow1_1APIs")]
14333#[rustfmt::skip]
14334unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceImageFormatProperties2 {
14335    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceImageFormatProperties2";
14336
14337    #[inline(always)]
14338    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14339        unsafe { core::mem::transmute(p) }
14340    }
14341    #[inline(always)]
14342    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14343        unsafe { core::mem::transmute(p) }
14344    }
14345}
14346#[cfg(feature = "Implements")]
14347#[cfg(not(feature = "DynamicLoaded"))]
14348#[cfg(feature = "Allow1_1APIs")]
14349#[rustfmt::skip]
14350impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceImageFormatProperties2 {
14351    const STATIC: Self = Self(vkGetPhysicalDeviceImageFormatProperties2);
14352}
14353
14354#[cfg(feature = "Implements")]
14355#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14356#[repr(transparent)]
14357#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14358#[rustfmt::skip]
14359pub struct PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2KHR));
14360#[cfg(feature = "Implements")]
14361#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14362#[rustfmt::skip]
14363unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR {
14364    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceQueueFamilyProperties2KHR";
14365
14366    #[inline(always)]
14367    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14368        unsafe { core::mem::transmute(p) }
14369    }
14370    #[inline(always)]
14371    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14372        unsafe { core::mem::transmute(p) }
14373    }
14374}
14375#[cfg(feature = "Implements")]
14376#[cfg(feature = "Allow1_1APIs")]
14377#[repr(transparent)]
14378#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14379#[rustfmt::skip]
14380pub struct PFN_vkGetPhysicalDeviceQueueFamilyProperties2(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2KHR));
14381#[cfg(feature = "Implements")]
14382#[cfg(feature = "Allow1_1APIs")]
14383#[rustfmt::skip]
14384unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceQueueFamilyProperties2 {
14385    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceQueueFamilyProperties2";
14386
14387    #[inline(always)]
14388    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14389        unsafe { core::mem::transmute(p) }
14390    }
14391    #[inline(always)]
14392    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14393        unsafe { core::mem::transmute(p) }
14394    }
14395}
14396#[cfg(feature = "Implements")]
14397#[cfg(not(feature = "DynamicLoaded"))]
14398#[cfg(feature = "Allow1_1APIs")]
14399#[rustfmt::skip]
14400impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceQueueFamilyProperties2 {
14401    const STATIC: Self = Self(vkGetPhysicalDeviceQueueFamilyProperties2);
14402}
14403
14404#[cfg(feature = "Implements")]
14405#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14406#[repr(transparent)]
14407#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14408#[rustfmt::skip]
14409pub struct PFN_vkGetPhysicalDeviceMemoryProperties2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2KHR));
14410#[cfg(feature = "Implements")]
14411#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14412#[rustfmt::skip]
14413unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceMemoryProperties2KHR {
14414    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceMemoryProperties2KHR";
14415
14416    #[inline(always)]
14417    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14418        unsafe { core::mem::transmute(p) }
14419    }
14420    #[inline(always)]
14421    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14422        unsafe { core::mem::transmute(p) }
14423    }
14424}
14425#[cfg(feature = "Implements")]
14426#[cfg(feature = "Allow1_1APIs")]
14427#[repr(transparent)]
14428#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14429#[rustfmt::skip]
14430pub struct PFN_vkGetPhysicalDeviceMemoryProperties2(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2KHR));
14431#[cfg(feature = "Implements")]
14432#[cfg(feature = "Allow1_1APIs")]
14433#[rustfmt::skip]
14434unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceMemoryProperties2 {
14435    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceMemoryProperties2";
14436
14437    #[inline(always)]
14438    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14439        unsafe { core::mem::transmute(p) }
14440    }
14441    #[inline(always)]
14442    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14443        unsafe { core::mem::transmute(p) }
14444    }
14445}
14446#[cfg(feature = "Implements")]
14447#[cfg(not(feature = "DynamicLoaded"))]
14448#[cfg(feature = "Allow1_1APIs")]
14449#[rustfmt::skip]
14450impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceMemoryProperties2 {
14451    const STATIC: Self = Self(vkGetPhysicalDeviceMemoryProperties2);
14452}
14453
14454#[cfg(feature = "Implements")]
14455#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14456#[repr(transparent)]
14457#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14458#[rustfmt::skip]
14459pub struct PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2KHR, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2KHR));
14460#[cfg(feature = "Implements")]
14461#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
14462#[rustfmt::skip]
14463unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR {
14464    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSparseImageFormatProperties2KHR";
14465
14466    #[inline(always)]
14467    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14468        unsafe { core::mem::transmute(p) }
14469    }
14470    #[inline(always)]
14471    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14472        unsafe { core::mem::transmute(p) }
14473    }
14474}
14475#[cfg(feature = "Implements")]
14476#[cfg(feature = "Allow1_1APIs")]
14477#[repr(transparent)]
14478#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14479#[rustfmt::skip]
14480pub struct PFN_vkGetPhysicalDeviceSparseImageFormatProperties2(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2KHR, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2KHR));
14481#[cfg(feature = "Implements")]
14482#[cfg(feature = "Allow1_1APIs")]
14483#[rustfmt::skip]
14484unsafe impl crate::resolver::PFN for PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 {
14485    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetPhysicalDeviceSparseImageFormatProperties2";
14486
14487    #[inline(always)]
14488    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14489        unsafe { core::mem::transmute(p) }
14490    }
14491    #[inline(always)]
14492    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14493        unsafe { core::mem::transmute(p) }
14494    }
14495}
14496#[cfg(feature = "Implements")]
14497#[cfg(not(feature = "DynamicLoaded"))]
14498#[cfg(feature = "Allow1_1APIs")]
14499#[rustfmt::skip]
14500impl crate::resolver::StaticCallable for PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 {
14501    const STATIC: Self = Self(vkGetPhysicalDeviceSparseImageFormatProperties2);
14502}
14503
14504#[cfg(feature = "Implements")]
14505#[cfg(feature = "VK_KHR_device_group_creation")]
14506#[repr(transparent)]
14507#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14508#[rustfmt::skip]
14509pub struct PFN_vkEnumeratePhysicalDeviceGroupKHR(pub unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupPropertiesKHR) -> VkResult);
14510#[cfg(feature = "Implements")]
14511#[cfg(feature = "VK_KHR_device_group_creation")]
14512#[rustfmt::skip]
14513unsafe impl crate::resolver::PFN for PFN_vkEnumeratePhysicalDeviceGroupKHR {
14514    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumeratePhysicalDeviceGroupKHR";
14515
14516    #[inline(always)]
14517    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14518        unsafe { core::mem::transmute(p) }
14519    }
14520    #[inline(always)]
14521    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14522        unsafe { core::mem::transmute(p) }
14523    }
14524}
14525#[cfg(feature = "Implements")]
14526#[cfg(feature = "Allow1_1APIs")]
14527#[repr(transparent)]
14528#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14529#[rustfmt::skip]
14530pub struct PFN_vkEnumeratePhysicalDeviceGroup(pub unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupPropertiesKHR) -> VkResult);
14531#[cfg(feature = "Implements")]
14532#[cfg(feature = "Allow1_1APIs")]
14533#[rustfmt::skip]
14534unsafe impl crate::resolver::PFN for PFN_vkEnumeratePhysicalDeviceGroup {
14535    const NAME_CSTR: &'static core::ffi::CStr = c"vkEnumeratePhysicalDeviceGroup";
14536
14537    #[inline(always)]
14538    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14539        unsafe { core::mem::transmute(p) }
14540    }
14541    #[inline(always)]
14542    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14543        unsafe { core::mem::transmute(p) }
14544    }
14545}
14546#[cfg(feature = "Implements")]
14547#[cfg(not(feature = "DynamicLoaded"))]
14548#[cfg(feature = "Allow1_1APIs")]
14549#[rustfmt::skip]
14550impl crate::resolver::StaticCallable for PFN_vkEnumeratePhysicalDeviceGroup {
14551    const STATIC: Self = Self(vkEnumeratePhysicalDeviceGroup);
14552}
14553
14554#[cfg(feature = "Implements")]
14555#[cfg(feature = "VK_KHR_get_memory_requirements2")]
14556#[repr(transparent)]
14557#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14558#[rustfmt::skip]
14559pub struct PFN_vkGetImageMemoryRequirements2KHR(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2KHR, pMemoryRequirements: *mut VkMemoryRequirements2KHR));
14560#[cfg(feature = "Implements")]
14561#[cfg(feature = "VK_KHR_get_memory_requirements2")]
14562#[rustfmt::skip]
14563unsafe impl crate::resolver::PFN for PFN_vkGetImageMemoryRequirements2KHR {
14564    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetImageMemoryRequirements2KHR";
14565
14566    #[inline(always)]
14567    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14568        unsafe { core::mem::transmute(p) }
14569    }
14570    #[inline(always)]
14571    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14572        unsafe { core::mem::transmute(p) }
14573    }
14574}
14575#[cfg(feature = "Implements")]
14576#[cfg(feature = "Allow1_1APIs")]
14577#[repr(transparent)]
14578#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14579#[rustfmt::skip]
14580pub struct PFN_vkGetImageMemoryRequirements2(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2KHR, pMemoryRequirements: *mut VkMemoryRequirements2KHR));
14581#[cfg(feature = "Implements")]
14582#[cfg(feature = "Allow1_1APIs")]
14583#[rustfmt::skip]
14584unsafe impl crate::resolver::PFN for PFN_vkGetImageMemoryRequirements2 {
14585    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetImageMemoryRequirements2";
14586
14587    #[inline(always)]
14588    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14589        unsafe { core::mem::transmute(p) }
14590    }
14591    #[inline(always)]
14592    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14593        unsafe { core::mem::transmute(p) }
14594    }
14595}
14596#[cfg(feature = "Implements")]
14597#[cfg(not(feature = "DynamicLoaded"))]
14598#[cfg(feature = "Allow1_1APIs")]
14599#[rustfmt::skip]
14600impl crate::resolver::StaticCallable for PFN_vkGetImageMemoryRequirements2 {
14601    const STATIC: Self = Self(vkGetImageMemoryRequirements2);
14602}
14603
14604#[cfg(feature = "Implements")]
14605#[cfg(feature = "VK_KHR_get_memory_requirements2")]
14606#[repr(transparent)]
14607#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14608#[rustfmt::skip]
14609pub struct PFN_vkGetBufferMemoryRequirements2KHR(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2KHR, pMemoryRequirements: *mut VkMemoryRequirements2KHR));
14610#[cfg(feature = "Implements")]
14611#[cfg(feature = "VK_KHR_get_memory_requirements2")]
14612#[rustfmt::skip]
14613unsafe impl crate::resolver::PFN for PFN_vkGetBufferMemoryRequirements2KHR {
14614    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetBufferMemoryRequirements2KHR";
14615
14616    #[inline(always)]
14617    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14618        unsafe { core::mem::transmute(p) }
14619    }
14620    #[inline(always)]
14621    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14622        unsafe { core::mem::transmute(p) }
14623    }
14624}
14625#[cfg(feature = "Implements")]
14626#[cfg(feature = "Allow1_1APIs")]
14627#[repr(transparent)]
14628#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14629#[rustfmt::skip]
14630pub struct PFN_vkGetBufferMemoryRequirements2(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2KHR, pMemoryRequirements: *mut VkMemoryRequirements2KHR));
14631#[cfg(feature = "Implements")]
14632#[cfg(feature = "Allow1_1APIs")]
14633#[rustfmt::skip]
14634unsafe impl crate::resolver::PFN for PFN_vkGetBufferMemoryRequirements2 {
14635    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetBufferMemoryRequirements2";
14636
14637    #[inline(always)]
14638    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14639        unsafe { core::mem::transmute(p) }
14640    }
14641    #[inline(always)]
14642    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14643        unsafe { core::mem::transmute(p) }
14644    }
14645}
14646#[cfg(feature = "Implements")]
14647#[cfg(not(feature = "DynamicLoaded"))]
14648#[cfg(feature = "Allow1_1APIs")]
14649#[rustfmt::skip]
14650impl crate::resolver::StaticCallable for PFN_vkGetBufferMemoryRequirements2 {
14651    const STATIC: Self = Self(vkGetBufferMemoryRequirements2);
14652}
14653
14654#[cfg(feature = "Implements")]
14655#[cfg(feature = "VK_KHR_get_memory_requirements2")]
14656#[repr(transparent)]
14657#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14658#[rustfmt::skip]
14659pub struct PFN_vkGetImageSparseMemoryRequirements2KHR(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2KHR, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2KHR));
14660#[cfg(feature = "Implements")]
14661#[cfg(feature = "VK_KHR_get_memory_requirements2")]
14662#[rustfmt::skip]
14663unsafe impl crate::resolver::PFN for PFN_vkGetImageSparseMemoryRequirements2KHR {
14664    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetImageSparseMemoryRequirements2KHR";
14665
14666    #[inline(always)]
14667    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14668        unsafe { core::mem::transmute(p) }
14669    }
14670    #[inline(always)]
14671    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14672        unsafe { core::mem::transmute(p) }
14673    }
14674}
14675#[cfg(feature = "Implements")]
14676#[cfg(feature = "Allow1_1APIs")]
14677#[repr(transparent)]
14678#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14679#[rustfmt::skip]
14680pub struct PFN_vkGetImageSparseMemoryRequirements2(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2KHR, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2KHR));
14681#[cfg(feature = "Implements")]
14682#[cfg(feature = "Allow1_1APIs")]
14683#[rustfmt::skip]
14684unsafe impl crate::resolver::PFN for PFN_vkGetImageSparseMemoryRequirements2 {
14685    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetImageSparseMemoryRequirements2";
14686
14687    #[inline(always)]
14688    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14689        unsafe { core::mem::transmute(p) }
14690    }
14691    #[inline(always)]
14692    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14693        unsafe { core::mem::transmute(p) }
14694    }
14695}
14696#[cfg(feature = "Implements")]
14697#[cfg(not(feature = "DynamicLoaded"))]
14698#[cfg(feature = "Allow1_1APIs")]
14699#[rustfmt::skip]
14700impl crate::resolver::StaticCallable for PFN_vkGetImageSparseMemoryRequirements2 {
14701    const STATIC: Self = Self(vkGetImageSparseMemoryRequirements2);
14702}
14703
14704#[cfg(feature = "Implements")]
14705#[cfg(feature = "VK_KHR_bind_memory2")]
14706#[repr(transparent)]
14707#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14708#[rustfmt::skip]
14709pub struct PFN_vkBindBufferMemory2KHR(pub unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfoKHR) -> VkResult);
14710#[cfg(feature = "Implements")]
14711#[cfg(feature = "VK_KHR_bind_memory2")]
14712#[rustfmt::skip]
14713unsafe impl crate::resolver::PFN for PFN_vkBindBufferMemory2KHR {
14714    const NAME_CSTR: &'static core::ffi::CStr = c"vkBindBufferMemory2KHR";
14715
14716    #[inline(always)]
14717    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14718        unsafe { core::mem::transmute(p) }
14719    }
14720    #[inline(always)]
14721    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14722        unsafe { core::mem::transmute(p) }
14723    }
14724}
14725#[cfg(feature = "Implements")]
14726#[cfg(feature = "Allow1_1APIs")]
14727#[repr(transparent)]
14728#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14729#[rustfmt::skip]
14730pub struct PFN_vkBindBufferMemory2(pub unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfoKHR) -> VkResult);
14731#[cfg(feature = "Implements")]
14732#[cfg(feature = "Allow1_1APIs")]
14733#[rustfmt::skip]
14734unsafe impl crate::resolver::PFN for PFN_vkBindBufferMemory2 {
14735    const NAME_CSTR: &'static core::ffi::CStr = c"vkBindBufferMemory2";
14736
14737    #[inline(always)]
14738    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14739        unsafe { core::mem::transmute(p) }
14740    }
14741    #[inline(always)]
14742    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14743        unsafe { core::mem::transmute(p) }
14744    }
14745}
14746#[cfg(feature = "Implements")]
14747#[cfg(not(feature = "DynamicLoaded"))]
14748#[cfg(feature = "Allow1_1APIs")]
14749#[rustfmt::skip]
14750impl crate::resolver::StaticCallable for PFN_vkBindBufferMemory2 {
14751    const STATIC: Self = Self(vkBindBufferMemory2);
14752}
14753
14754#[cfg(feature = "Implements")]
14755#[cfg(feature = "VK_KHR_bind_memory2")]
14756#[repr(transparent)]
14757#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14758#[rustfmt::skip]
14759pub struct PFN_vkBindImageMemory2KHR(pub unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfoKHR) -> VkResult);
14760#[cfg(feature = "Implements")]
14761#[cfg(feature = "VK_KHR_bind_memory2")]
14762#[rustfmt::skip]
14763unsafe impl crate::resolver::PFN for PFN_vkBindImageMemory2KHR {
14764    const NAME_CSTR: &'static core::ffi::CStr = c"vkBindImageMemory2KHR";
14765
14766    #[inline(always)]
14767    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14768        unsafe { core::mem::transmute(p) }
14769    }
14770    #[inline(always)]
14771    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14772        unsafe { core::mem::transmute(p) }
14773    }
14774}
14775#[cfg(feature = "Implements")]
14776#[cfg(feature = "Allow1_1APIs")]
14777#[repr(transparent)]
14778#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14779#[rustfmt::skip]
14780pub struct PFN_vkBindImageMemory2(pub unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfoKHR) -> VkResult);
14781#[cfg(feature = "Implements")]
14782#[cfg(feature = "Allow1_1APIs")]
14783#[rustfmt::skip]
14784unsafe impl crate::resolver::PFN for PFN_vkBindImageMemory2 {
14785    const NAME_CSTR: &'static core::ffi::CStr = c"vkBindImageMemory2";
14786
14787    #[inline(always)]
14788    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14789        unsafe { core::mem::transmute(p) }
14790    }
14791    #[inline(always)]
14792    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14793        unsafe { core::mem::transmute(p) }
14794    }
14795}
14796#[cfg(feature = "Implements")]
14797#[cfg(not(feature = "DynamicLoaded"))]
14798#[cfg(feature = "Allow1_1APIs")]
14799#[rustfmt::skip]
14800impl crate::resolver::StaticCallable for PFN_vkBindImageMemory2 {
14801    const STATIC: Self = Self(vkBindImageMemory2);
14802}
14803
14804#[cfg(feature = "Implements")]
14805#[cfg(feature = "VK_KHR_descriptor_update_template")]
14806#[repr(transparent)]
14807#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14808#[rustfmt::skip]
14809pub struct PFN_vkCreateDescriptorUpdateTemplateKHR(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplateKHR) -> VkResult);
14810#[cfg(feature = "Implements")]
14811#[cfg(feature = "VK_KHR_descriptor_update_template")]
14812#[rustfmt::skip]
14813unsafe impl crate::resolver::PFN for PFN_vkCreateDescriptorUpdateTemplateKHR {
14814    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDescriptorUpdateTemplateKHR";
14815
14816    #[inline(always)]
14817    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14818        unsafe { core::mem::transmute(p) }
14819    }
14820    #[inline(always)]
14821    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14822        unsafe { core::mem::transmute(p) }
14823    }
14824}
14825#[cfg(feature = "Implements")]
14826#[cfg(feature = "Allow1_1APIs")]
14827#[repr(transparent)]
14828#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14829#[rustfmt::skip]
14830pub struct PFN_vkCreateDescriptorUpdateTemplate(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplateKHR) -> VkResult);
14831#[cfg(feature = "Implements")]
14832#[cfg(feature = "Allow1_1APIs")]
14833#[rustfmt::skip]
14834unsafe impl crate::resolver::PFN for PFN_vkCreateDescriptorUpdateTemplate {
14835    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateDescriptorUpdateTemplate";
14836
14837    #[inline(always)]
14838    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14839        unsafe { core::mem::transmute(p) }
14840    }
14841    #[inline(always)]
14842    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14843        unsafe { core::mem::transmute(p) }
14844    }
14845}
14846#[cfg(feature = "Implements")]
14847#[cfg(not(feature = "DynamicLoaded"))]
14848#[cfg(feature = "Allow1_1APIs")]
14849#[rustfmt::skip]
14850impl crate::resolver::StaticCallable for PFN_vkCreateDescriptorUpdateTemplate {
14851    const STATIC: Self = Self(vkCreateDescriptorUpdateTemplate);
14852}
14853
14854#[cfg(feature = "Implements")]
14855#[cfg(feature = "VK_KHR_descriptor_update_template")]
14856#[repr(transparent)]
14857#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14858#[rustfmt::skip]
14859pub struct PFN_vkDestroyDescriptorUpdateTemplateKHR(pub unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplateKHR, pAllocator: *const VkAllocationCallbacks));
14860#[cfg(feature = "Implements")]
14861#[cfg(feature = "VK_KHR_descriptor_update_template")]
14862#[rustfmt::skip]
14863unsafe impl crate::resolver::PFN for PFN_vkDestroyDescriptorUpdateTemplateKHR {
14864    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyDescriptorUpdateTemplateKHR";
14865
14866    #[inline(always)]
14867    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14868        unsafe { core::mem::transmute(p) }
14869    }
14870    #[inline(always)]
14871    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14872        unsafe { core::mem::transmute(p) }
14873    }
14874}
14875#[cfg(feature = "Implements")]
14876#[cfg(feature = "Allow1_1APIs")]
14877#[repr(transparent)]
14878#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14879#[rustfmt::skip]
14880pub struct PFN_vkDestroyDescriptorUpdateTemplate(pub unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplateKHR, pAllocator: *const VkAllocationCallbacks));
14881#[cfg(feature = "Implements")]
14882#[cfg(feature = "Allow1_1APIs")]
14883#[rustfmt::skip]
14884unsafe impl crate::resolver::PFN for PFN_vkDestroyDescriptorUpdateTemplate {
14885    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroyDescriptorUpdateTemplate";
14886
14887    #[inline(always)]
14888    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14889        unsafe { core::mem::transmute(p) }
14890    }
14891    #[inline(always)]
14892    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14893        unsafe { core::mem::transmute(p) }
14894    }
14895}
14896#[cfg(feature = "Implements")]
14897#[cfg(not(feature = "DynamicLoaded"))]
14898#[cfg(feature = "Allow1_1APIs")]
14899#[rustfmt::skip]
14900impl crate::resolver::StaticCallable for PFN_vkDestroyDescriptorUpdateTemplate {
14901    const STATIC: Self = Self(vkDestroyDescriptorUpdateTemplate);
14902}
14903
14904#[cfg(feature = "Implements")]
14905#[cfg(feature = "VK_KHR_descriptor_update_template")]
14906#[repr(transparent)]
14907#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14908#[rustfmt::skip]
14909pub struct PFN_vkUpdateDescriptorSetWithTemplateKHR(pub unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplateKHR, pData: *const core::ffi::c_void));
14910#[cfg(feature = "Implements")]
14911#[cfg(feature = "VK_KHR_descriptor_update_template")]
14912#[rustfmt::skip]
14913unsafe impl crate::resolver::PFN for PFN_vkUpdateDescriptorSetWithTemplateKHR {
14914    const NAME_CSTR: &'static core::ffi::CStr = c"vkUpdateDescriptorSetWithTemplateKHR";
14915
14916    #[inline(always)]
14917    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14918        unsafe { core::mem::transmute(p) }
14919    }
14920    #[inline(always)]
14921    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14922        unsafe { core::mem::transmute(p) }
14923    }
14924}
14925#[cfg(feature = "Implements")]
14926#[cfg(feature = "Allow1_1APIs")]
14927#[repr(transparent)]
14928#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14929#[rustfmt::skip]
14930pub struct PFN_vkUpdateDescriptorSetWithTemplate(pub unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplateKHR, pData: *const core::ffi::c_void));
14931#[cfg(feature = "Implements")]
14932#[cfg(feature = "Allow1_1APIs")]
14933#[rustfmt::skip]
14934unsafe impl crate::resolver::PFN for PFN_vkUpdateDescriptorSetWithTemplate {
14935    const NAME_CSTR: &'static core::ffi::CStr = c"vkUpdateDescriptorSetWithTemplate";
14936
14937    #[inline(always)]
14938    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14939        unsafe { core::mem::transmute(p) }
14940    }
14941    #[inline(always)]
14942    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14943        unsafe { core::mem::transmute(p) }
14944    }
14945}
14946#[cfg(feature = "Implements")]
14947#[cfg(not(feature = "DynamicLoaded"))]
14948#[cfg(feature = "Allow1_1APIs")]
14949#[rustfmt::skip]
14950impl crate::resolver::StaticCallable for PFN_vkUpdateDescriptorSetWithTemplate {
14951    const STATIC: Self = Self(vkUpdateDescriptorSetWithTemplate);
14952}
14953
14954#[cfg(feature = "Implements")]
14955#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
14956#[repr(transparent)]
14957#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14958#[rustfmt::skip]
14959pub struct PFN_vkCreateSamplerYcbcrConversionKHR(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: VkSamplerYcbcrConversionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversionKHR) -> VkResult);
14960#[cfg(feature = "Implements")]
14961#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
14962#[rustfmt::skip]
14963unsafe impl crate::resolver::PFN for PFN_vkCreateSamplerYcbcrConversionKHR {
14964    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateSamplerYcbcrConversionKHR";
14965
14966    #[inline(always)]
14967    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14968        unsafe { core::mem::transmute(p) }
14969    }
14970    #[inline(always)]
14971    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14972        unsafe { core::mem::transmute(p) }
14973    }
14974}
14975#[cfg(feature = "Implements")]
14976#[cfg(feature = "Allow1_1APIs")]
14977#[repr(transparent)]
14978#[derive(Debug, Clone, Copy, PartialEq, Eq)]
14979#[rustfmt::skip]
14980pub struct PFN_vkCreateSamplerYcbcrConversion(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: VkSamplerYcbcrConversionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversionKHR) -> VkResult);
14981#[cfg(feature = "Implements")]
14982#[cfg(feature = "Allow1_1APIs")]
14983#[rustfmt::skip]
14984unsafe impl crate::resolver::PFN for PFN_vkCreateSamplerYcbcrConversion {
14985    const NAME_CSTR: &'static core::ffi::CStr = c"vkCreateSamplerYcbcrConversion";
14986
14987    #[inline(always)]
14988    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
14989        unsafe { core::mem::transmute(p) }
14990    }
14991    #[inline(always)]
14992    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
14993        unsafe { core::mem::transmute(p) }
14994    }
14995}
14996#[cfg(feature = "Implements")]
14997#[cfg(not(feature = "DynamicLoaded"))]
14998#[cfg(feature = "Allow1_1APIs")]
14999#[rustfmt::skip]
15000impl crate::resolver::StaticCallable for PFN_vkCreateSamplerYcbcrConversion {
15001    const STATIC: Self = Self(vkCreateSamplerYcbcrConversion);
15002}
15003
15004#[cfg(feature = "Implements")]
15005#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
15006#[repr(transparent)]
15007#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15008#[rustfmt::skip]
15009pub struct PFN_vkDestroySamplerYcbcrConversionKHR(pub unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversionKHR, pAllocator: *const VkAllocationCallbacks));
15010#[cfg(feature = "Implements")]
15011#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
15012#[rustfmt::skip]
15013unsafe impl crate::resolver::PFN for PFN_vkDestroySamplerYcbcrConversionKHR {
15014    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroySamplerYcbcrConversionKHR";
15015
15016    #[inline(always)]
15017    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15018        unsafe { core::mem::transmute(p) }
15019    }
15020    #[inline(always)]
15021    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15022        unsafe { core::mem::transmute(p) }
15023    }
15024}
15025#[cfg(feature = "Implements")]
15026#[cfg(feature = "Allow1_1APIs")]
15027#[repr(transparent)]
15028#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15029#[rustfmt::skip]
15030pub struct PFN_vkDestroySamplerYcbcrConversion(pub unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversionKHR, pAllocator: *const VkAllocationCallbacks));
15031#[cfg(feature = "Implements")]
15032#[cfg(feature = "Allow1_1APIs")]
15033#[rustfmt::skip]
15034unsafe impl crate::resolver::PFN for PFN_vkDestroySamplerYcbcrConversion {
15035    const NAME_CSTR: &'static core::ffi::CStr = c"vkDestroySamplerYcbcrConversion";
15036
15037    #[inline(always)]
15038    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15039        unsafe { core::mem::transmute(p) }
15040    }
15041    #[inline(always)]
15042    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15043        unsafe { core::mem::transmute(p) }
15044    }
15045}
15046#[cfg(feature = "Implements")]
15047#[cfg(not(feature = "DynamicLoaded"))]
15048#[cfg(feature = "Allow1_1APIs")]
15049#[rustfmt::skip]
15050impl crate::resolver::StaticCallable for PFN_vkDestroySamplerYcbcrConversion {
15051    const STATIC: Self = Self(vkDestroySamplerYcbcrConversion);
15052}
15053
15054#[cfg(feature = "Implements")]
15055#[cfg(feature = "VK_KHR_maintenance1")]
15056#[repr(transparent)]
15057#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15058#[rustfmt::skip]
15059pub struct PFN_vkTrimCommandPoolKHR(pub unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlagsKHR));
15060#[cfg(feature = "Implements")]
15061#[cfg(feature = "VK_KHR_maintenance1")]
15062#[rustfmt::skip]
15063unsafe impl crate::resolver::PFN for PFN_vkTrimCommandPoolKHR {
15064    const NAME_CSTR: &'static core::ffi::CStr = c"vkTrimCommandPoolKHR";
15065
15066    #[inline(always)]
15067    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15068        unsafe { core::mem::transmute(p) }
15069    }
15070    #[inline(always)]
15071    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15072        unsafe { core::mem::transmute(p) }
15073    }
15074}
15075#[cfg(feature = "Implements")]
15076#[cfg(feature = "Allow1_1APIs")]
15077#[repr(transparent)]
15078#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15079#[rustfmt::skip]
15080pub struct PFN_vkTrimCommandPool(pub unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlagsKHR));
15081#[cfg(feature = "Implements")]
15082#[cfg(feature = "Allow1_1APIs")]
15083#[rustfmt::skip]
15084unsafe impl crate::resolver::PFN for PFN_vkTrimCommandPool {
15085    const NAME_CSTR: &'static core::ffi::CStr = c"vkTrimCommandPool";
15086
15087    #[inline(always)]
15088    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15089        unsafe { core::mem::transmute(p) }
15090    }
15091    #[inline(always)]
15092    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15093        unsafe { core::mem::transmute(p) }
15094    }
15095}
15096#[cfg(feature = "Implements")]
15097#[cfg(not(feature = "DynamicLoaded"))]
15098#[cfg(feature = "Allow1_1APIs")]
15099#[rustfmt::skip]
15100impl crate::resolver::StaticCallable for PFN_vkTrimCommandPool {
15101    const STATIC: Self = Self(vkTrimCommandPool);
15102}
15103
15104#[cfg(feature = "Implements")]
15105#[cfg(feature = "VK_KHR_maintenance3")]
15106#[repr(transparent)]
15107#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15108#[rustfmt::skip]
15109pub struct PFN_vkGetDescriptorSetLayoutSupportKHR(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport));
15110#[cfg(feature = "Implements")]
15111#[cfg(feature = "VK_KHR_maintenance3")]
15112#[rustfmt::skip]
15113unsafe impl crate::resolver::PFN for PFN_vkGetDescriptorSetLayoutSupportKHR {
15114    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDescriptorSetLayoutSupportKHR";
15115
15116    #[inline(always)]
15117    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15118        unsafe { core::mem::transmute(p) }
15119    }
15120    #[inline(always)]
15121    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15122        unsafe { core::mem::transmute(p) }
15123    }
15124}
15125#[cfg(feature = "Implements")]
15126#[cfg(feature = "Allow1_1APIs")]
15127#[repr(transparent)]
15128#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15129#[rustfmt::skip]
15130pub struct PFN_vkGetDescriptorSetLayoutSupport(pub unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport));
15131#[cfg(feature = "Implements")]
15132#[cfg(feature = "Allow1_1APIs")]
15133#[rustfmt::skip]
15134unsafe impl crate::resolver::PFN for PFN_vkGetDescriptorSetLayoutSupport {
15135    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDescriptorSetLayoutSupport";
15136
15137    #[inline(always)]
15138    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15139        unsafe { core::mem::transmute(p) }
15140    }
15141    #[inline(always)]
15142    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15143        unsafe { core::mem::transmute(p) }
15144    }
15145}
15146#[cfg(feature = "Implements")]
15147#[cfg(not(feature = "DynamicLoaded"))]
15148#[cfg(feature = "Allow1_1APIs")]
15149#[rustfmt::skip]
15150impl crate::resolver::StaticCallable for PFN_vkGetDescriptorSetLayoutSupport {
15151    const STATIC: Self = Self(vkGetDescriptorSetLayoutSupport);
15152}
15153
15154#[cfg(feature = "Implements")]
15155#[cfg(feature = "VK_KHR_synchronization2")]
15156#[repr(transparent)]
15157#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15158#[rustfmt::skip]
15159pub struct PFN_vkQueueSubmit2KHR(pub unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2KHR, fence: VkFence) -> VkResult);
15160#[cfg(feature = "Implements")]
15161#[cfg(feature = "VK_KHR_synchronization2")]
15162#[rustfmt::skip]
15163unsafe impl crate::resolver::PFN for PFN_vkQueueSubmit2KHR {
15164    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueSubmit2KHR";
15165
15166    #[inline(always)]
15167    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15168        unsafe { core::mem::transmute(p) }
15169    }
15170    #[inline(always)]
15171    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15172        unsafe { core::mem::transmute(p) }
15173    }
15174}
15175#[cfg(feature = "Implements")]
15176#[cfg(feature = "Allow1_3APIs")]
15177#[repr(transparent)]
15178#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15179#[rustfmt::skip]
15180pub struct PFN_vkQueueSubmit2(pub unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2KHR, fence: VkFence) -> VkResult);
15181#[cfg(feature = "Implements")]
15182#[cfg(feature = "Allow1_3APIs")]
15183#[rustfmt::skip]
15184unsafe impl crate::resolver::PFN for PFN_vkQueueSubmit2 {
15185    const NAME_CSTR: &'static core::ffi::CStr = c"vkQueueSubmit2";
15186
15187    #[inline(always)]
15188    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15189        unsafe { core::mem::transmute(p) }
15190    }
15191    #[inline(always)]
15192    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15193        unsafe { core::mem::transmute(p) }
15194    }
15195}
15196#[cfg(feature = "Implements")]
15197#[cfg(not(feature = "DynamicLoaded"))]
15198#[cfg(feature = "Allow1_3APIs")]
15199#[rustfmt::skip]
15200impl crate::resolver::StaticCallable for PFN_vkQueueSubmit2 {
15201    const STATIC: Self = Self(vkQueueSubmit2);
15202}
15203
15204#[cfg(feature = "Implements")]
15205#[repr(transparent)]
15206#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15207#[rustfmt::skip]
15208pub struct PFN_vkCmdBindPipeline(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline));
15209#[cfg(feature = "Implements")]
15210#[rustfmt::skip]
15211unsafe impl crate::resolver::PFN for PFN_vkCmdBindPipeline {
15212    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBindPipeline";
15213
15214    #[inline(always)]
15215    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15216        unsafe { core::mem::transmute(p) }
15217    }
15218    #[inline(always)]
15219    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15220        unsafe { core::mem::transmute(p) }
15221    }
15222}
15223#[cfg(not(feature = "DynamicLoaded"))]
15224#[cfg(feature = "Implements")]
15225#[rustfmt::skip]
15226impl crate::resolver::StaticCallable for PFN_vkCmdBindPipeline {
15227    const STATIC: Self = Self(vkCmdBindPipeline);
15228}
15229
15230#[cfg(feature = "Implements")]
15231#[repr(transparent)]
15232#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15233#[rustfmt::skip]
15234pub struct PFN_vkCmdSetViewport(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport));
15235#[cfg(feature = "Implements")]
15236#[rustfmt::skip]
15237unsafe impl crate::resolver::PFN for PFN_vkCmdSetViewport {
15238    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetViewport";
15239
15240    #[inline(always)]
15241    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15242        unsafe { core::mem::transmute(p) }
15243    }
15244    #[inline(always)]
15245    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15246        unsafe { core::mem::transmute(p) }
15247    }
15248}
15249#[cfg(not(feature = "DynamicLoaded"))]
15250#[cfg(feature = "Implements")]
15251#[rustfmt::skip]
15252impl crate::resolver::StaticCallable for PFN_vkCmdSetViewport {
15253    const STATIC: Self = Self(vkCmdSetViewport);
15254}
15255
15256#[cfg(feature = "Implements")]
15257#[repr(transparent)]
15258#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15259#[rustfmt::skip]
15260pub struct PFN_vkCmdSetScissor(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D));
15261#[cfg(feature = "Implements")]
15262#[rustfmt::skip]
15263unsafe impl crate::resolver::PFN for PFN_vkCmdSetScissor {
15264    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetScissor";
15265
15266    #[inline(always)]
15267    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15268        unsafe { core::mem::transmute(p) }
15269    }
15270    #[inline(always)]
15271    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15272        unsafe { core::mem::transmute(p) }
15273    }
15274}
15275#[cfg(not(feature = "DynamicLoaded"))]
15276#[cfg(feature = "Implements")]
15277#[rustfmt::skip]
15278impl crate::resolver::StaticCallable for PFN_vkCmdSetScissor {
15279    const STATIC: Self = Self(vkCmdSetScissor);
15280}
15281
15282#[cfg(feature = "Implements")]
15283#[repr(transparent)]
15284#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15285#[rustfmt::skip]
15286pub struct PFN_vkCmdSetLineWidth(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineWidth: core::ffi::c_float));
15287#[cfg(feature = "Implements")]
15288#[rustfmt::skip]
15289unsafe impl crate::resolver::PFN for PFN_vkCmdSetLineWidth {
15290    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetLineWidth";
15291
15292    #[inline(always)]
15293    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15294        unsafe { core::mem::transmute(p) }
15295    }
15296    #[inline(always)]
15297    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15298        unsafe { core::mem::transmute(p) }
15299    }
15300}
15301#[cfg(not(feature = "DynamicLoaded"))]
15302#[cfg(feature = "Implements")]
15303#[rustfmt::skip]
15304impl crate::resolver::StaticCallable for PFN_vkCmdSetLineWidth {
15305    const STATIC: Self = Self(vkCmdSetLineWidth);
15306}
15307
15308#[cfg(feature = "Implements")]
15309#[repr(transparent)]
15310#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15311#[rustfmt::skip]
15312pub struct PFN_vkCmdSetDepthBias(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: core::ffi::c_float, depthBiasClamp: core::ffi::c_float, depthBiasSlopeFactor: core::ffi::c_float));
15313#[cfg(feature = "Implements")]
15314#[rustfmt::skip]
15315unsafe impl crate::resolver::PFN for PFN_vkCmdSetDepthBias {
15316    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetDepthBias";
15317
15318    #[inline(always)]
15319    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15320        unsafe { core::mem::transmute(p) }
15321    }
15322    #[inline(always)]
15323    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15324        unsafe { core::mem::transmute(p) }
15325    }
15326}
15327#[cfg(not(feature = "DynamicLoaded"))]
15328#[cfg(feature = "Implements")]
15329#[rustfmt::skip]
15330impl crate::resolver::StaticCallable for PFN_vkCmdSetDepthBias {
15331    const STATIC: Self = Self(vkCmdSetDepthBias);
15332}
15333
15334#[cfg(feature = "Implements")]
15335#[repr(transparent)]
15336#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15337#[rustfmt::skip]
15338pub struct PFN_vkCmdSetBlendConstants(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, blendConstants: *const core::ffi::c_float));
15339#[cfg(feature = "Implements")]
15340#[rustfmt::skip]
15341unsafe impl crate::resolver::PFN for PFN_vkCmdSetBlendConstants {
15342    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetBlendConstants";
15343
15344    #[inline(always)]
15345    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15346        unsafe { core::mem::transmute(p) }
15347    }
15348    #[inline(always)]
15349    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15350        unsafe { core::mem::transmute(p) }
15351    }
15352}
15353#[cfg(not(feature = "DynamicLoaded"))]
15354#[cfg(feature = "Implements")]
15355#[rustfmt::skip]
15356impl crate::resolver::StaticCallable for PFN_vkCmdSetBlendConstants {
15357    const STATIC: Self = Self(vkCmdSetBlendConstants);
15358}
15359
15360#[cfg(feature = "Implements")]
15361#[repr(transparent)]
15362#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15363#[rustfmt::skip]
15364pub struct PFN_vkCmdSetDepthBounds(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, minDepthBounds: core::ffi::c_float, maxDepthBounds: core::ffi::c_float));
15365#[cfg(feature = "Implements")]
15366#[rustfmt::skip]
15367unsafe impl crate::resolver::PFN for PFN_vkCmdSetDepthBounds {
15368    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetDepthBounds";
15369
15370    #[inline(always)]
15371    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15372        unsafe { core::mem::transmute(p) }
15373    }
15374    #[inline(always)]
15375    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15376        unsafe { core::mem::transmute(p) }
15377    }
15378}
15379#[cfg(not(feature = "DynamicLoaded"))]
15380#[cfg(feature = "Implements")]
15381#[rustfmt::skip]
15382impl crate::resolver::StaticCallable for PFN_vkCmdSetDepthBounds {
15383    const STATIC: Self = Self(vkCmdSetDepthBounds);
15384}
15385
15386#[cfg(feature = "Implements")]
15387#[repr(transparent)]
15388#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15389#[rustfmt::skip]
15390pub struct PFN_vkCmdSetStencilCompareMask(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32));
15391#[cfg(feature = "Implements")]
15392#[rustfmt::skip]
15393unsafe impl crate::resolver::PFN for PFN_vkCmdSetStencilCompareMask {
15394    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetStencilCompareMask";
15395
15396    #[inline(always)]
15397    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15398        unsafe { core::mem::transmute(p) }
15399    }
15400    #[inline(always)]
15401    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15402        unsafe { core::mem::transmute(p) }
15403    }
15404}
15405#[cfg(not(feature = "DynamicLoaded"))]
15406#[cfg(feature = "Implements")]
15407#[rustfmt::skip]
15408impl crate::resolver::StaticCallable for PFN_vkCmdSetStencilCompareMask {
15409    const STATIC: Self = Self(vkCmdSetStencilCompareMask);
15410}
15411
15412#[cfg(feature = "Implements")]
15413#[repr(transparent)]
15414#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15415#[rustfmt::skip]
15416pub struct PFN_vkCmdSetStencilWriteMask(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32));
15417#[cfg(feature = "Implements")]
15418#[rustfmt::skip]
15419unsafe impl crate::resolver::PFN for PFN_vkCmdSetStencilWriteMask {
15420    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetStencilWriteMask";
15421
15422    #[inline(always)]
15423    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15424        unsafe { core::mem::transmute(p) }
15425    }
15426    #[inline(always)]
15427    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15428        unsafe { core::mem::transmute(p) }
15429    }
15430}
15431#[cfg(not(feature = "DynamicLoaded"))]
15432#[cfg(feature = "Implements")]
15433#[rustfmt::skip]
15434impl crate::resolver::StaticCallable for PFN_vkCmdSetStencilWriteMask {
15435    const STATIC: Self = Self(vkCmdSetStencilWriteMask);
15436}
15437
15438#[cfg(feature = "Implements")]
15439#[repr(transparent)]
15440#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15441#[rustfmt::skip]
15442pub struct PFN_vkCmdSetStencilReference(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32));
15443#[cfg(feature = "Implements")]
15444#[rustfmt::skip]
15445unsafe impl crate::resolver::PFN for PFN_vkCmdSetStencilReference {
15446    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetStencilReference";
15447
15448    #[inline(always)]
15449    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15450        unsafe { core::mem::transmute(p) }
15451    }
15452    #[inline(always)]
15453    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15454        unsafe { core::mem::transmute(p) }
15455    }
15456}
15457#[cfg(not(feature = "DynamicLoaded"))]
15458#[cfg(feature = "Implements")]
15459#[rustfmt::skip]
15460impl crate::resolver::StaticCallable for PFN_vkCmdSetStencilReference {
15461    const STATIC: Self = Self(vkCmdSetStencilReference);
15462}
15463
15464#[cfg(feature = "Implements")]
15465#[repr(transparent)]
15466#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15467#[rustfmt::skip]
15468pub struct PFN_vkCmdBindDescriptorSets(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: *const u32));
15469#[cfg(feature = "Implements")]
15470#[rustfmt::skip]
15471unsafe impl crate::resolver::PFN for PFN_vkCmdBindDescriptorSets {
15472    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBindDescriptorSets";
15473
15474    #[inline(always)]
15475    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15476        unsafe { core::mem::transmute(p) }
15477    }
15478    #[inline(always)]
15479    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15480        unsafe { core::mem::transmute(p) }
15481    }
15482}
15483#[cfg(not(feature = "DynamicLoaded"))]
15484#[cfg(feature = "Implements")]
15485#[rustfmt::skip]
15486impl crate::resolver::StaticCallable for PFN_vkCmdBindDescriptorSets {
15487    const STATIC: Self = Self(vkCmdBindDescriptorSets);
15488}
15489
15490#[cfg(feature = "Implements")]
15491#[repr(transparent)]
15492#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15493#[rustfmt::skip]
15494pub struct PFN_vkCmdBindIndexBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType));
15495#[cfg(feature = "Implements")]
15496#[rustfmt::skip]
15497unsafe impl crate::resolver::PFN for PFN_vkCmdBindIndexBuffer {
15498    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBindIndexBuffer";
15499
15500    #[inline(always)]
15501    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15502        unsafe { core::mem::transmute(p) }
15503    }
15504    #[inline(always)]
15505    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15506        unsafe { core::mem::transmute(p) }
15507    }
15508}
15509#[cfg(not(feature = "DynamicLoaded"))]
15510#[cfg(feature = "Implements")]
15511#[rustfmt::skip]
15512impl crate::resolver::StaticCallable for PFN_vkCmdBindIndexBuffer {
15513    const STATIC: Self = Self(vkCmdBindIndexBuffer);
15514}
15515
15516#[cfg(feature = "Implements")]
15517#[repr(transparent)]
15518#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15519#[rustfmt::skip]
15520pub struct PFN_vkCmdBindVertexBuffers(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize));
15521#[cfg(feature = "Implements")]
15522#[rustfmt::skip]
15523unsafe impl crate::resolver::PFN for PFN_vkCmdBindVertexBuffers {
15524    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBindVertexBuffers";
15525
15526    #[inline(always)]
15527    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15528        unsafe { core::mem::transmute(p) }
15529    }
15530    #[inline(always)]
15531    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15532        unsafe { core::mem::transmute(p) }
15533    }
15534}
15535#[cfg(not(feature = "DynamicLoaded"))]
15536#[cfg(feature = "Implements")]
15537#[rustfmt::skip]
15538impl crate::resolver::StaticCallable for PFN_vkCmdBindVertexBuffers {
15539    const STATIC: Self = Self(vkCmdBindVertexBuffers);
15540}
15541
15542#[cfg(feature = "Implements")]
15543#[repr(transparent)]
15544#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15545#[rustfmt::skip]
15546pub struct PFN_vkCmdDraw(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32));
15547#[cfg(feature = "Implements")]
15548#[rustfmt::skip]
15549unsafe impl crate::resolver::PFN for PFN_vkCmdDraw {
15550    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDraw";
15551
15552    #[inline(always)]
15553    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15554        unsafe { core::mem::transmute(p) }
15555    }
15556    #[inline(always)]
15557    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15558        unsafe { core::mem::transmute(p) }
15559    }
15560}
15561#[cfg(not(feature = "DynamicLoaded"))]
15562#[cfg(feature = "Implements")]
15563#[rustfmt::skip]
15564impl crate::resolver::StaticCallable for PFN_vkCmdDraw {
15565    const STATIC: Self = Self(vkCmdDraw);
15566}
15567
15568#[cfg(feature = "Implements")]
15569#[repr(transparent)]
15570#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15571#[rustfmt::skip]
15572pub struct PFN_vkCmdDrawIndexed(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32));
15573#[cfg(feature = "Implements")]
15574#[rustfmt::skip]
15575unsafe impl crate::resolver::PFN for PFN_vkCmdDrawIndexed {
15576    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDrawIndexed";
15577
15578    #[inline(always)]
15579    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15580        unsafe { core::mem::transmute(p) }
15581    }
15582    #[inline(always)]
15583    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15584        unsafe { core::mem::transmute(p) }
15585    }
15586}
15587#[cfg(not(feature = "DynamicLoaded"))]
15588#[cfg(feature = "Implements")]
15589#[rustfmt::skip]
15590impl crate::resolver::StaticCallable for PFN_vkCmdDrawIndexed {
15591    const STATIC: Self = Self(vkCmdDrawIndexed);
15592}
15593
15594#[cfg(feature = "Implements")]
15595#[repr(transparent)]
15596#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15597#[rustfmt::skip]
15598pub struct PFN_vkCmdDrawIndirect(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32));
15599#[cfg(feature = "Implements")]
15600#[rustfmt::skip]
15601unsafe impl crate::resolver::PFN for PFN_vkCmdDrawIndirect {
15602    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDrawIndirect";
15603
15604    #[inline(always)]
15605    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15606        unsafe { core::mem::transmute(p) }
15607    }
15608    #[inline(always)]
15609    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15610        unsafe { core::mem::transmute(p) }
15611    }
15612}
15613#[cfg(not(feature = "DynamicLoaded"))]
15614#[cfg(feature = "Implements")]
15615#[rustfmt::skip]
15616impl crate::resolver::StaticCallable for PFN_vkCmdDrawIndirect {
15617    const STATIC: Self = Self(vkCmdDrawIndirect);
15618}
15619
15620#[cfg(feature = "Implements")]
15621#[repr(transparent)]
15622#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15623#[rustfmt::skip]
15624pub struct PFN_vkCmdDrawIndexedIndirect(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32));
15625#[cfg(feature = "Implements")]
15626#[rustfmt::skip]
15627unsafe impl crate::resolver::PFN for PFN_vkCmdDrawIndexedIndirect {
15628    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDrawIndexedIndirect";
15629
15630    #[inline(always)]
15631    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15632        unsafe { core::mem::transmute(p) }
15633    }
15634    #[inline(always)]
15635    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15636        unsafe { core::mem::transmute(p) }
15637    }
15638}
15639#[cfg(not(feature = "DynamicLoaded"))]
15640#[cfg(feature = "Implements")]
15641#[rustfmt::skip]
15642impl crate::resolver::StaticCallable for PFN_vkCmdDrawIndexedIndirect {
15643    const STATIC: Self = Self(vkCmdDrawIndexedIndirect);
15644}
15645
15646#[cfg(feature = "Implements")]
15647#[repr(transparent)]
15648#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15649#[rustfmt::skip]
15650pub struct PFN_vkCmdDispatch(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32));
15651#[cfg(feature = "Implements")]
15652#[rustfmt::skip]
15653unsafe impl crate::resolver::PFN for PFN_vkCmdDispatch {
15654    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDispatch";
15655
15656    #[inline(always)]
15657    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15658        unsafe { core::mem::transmute(p) }
15659    }
15660    #[inline(always)]
15661    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15662        unsafe { core::mem::transmute(p) }
15663    }
15664}
15665#[cfg(not(feature = "DynamicLoaded"))]
15666#[cfg(feature = "Implements")]
15667#[rustfmt::skip]
15668impl crate::resolver::StaticCallable for PFN_vkCmdDispatch {
15669    const STATIC: Self = Self(vkCmdDispatch);
15670}
15671
15672#[cfg(feature = "Implements")]
15673#[repr(transparent)]
15674#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15675#[rustfmt::skip]
15676pub struct PFN_vkCmdDispatchIndirect(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize));
15677#[cfg(feature = "Implements")]
15678#[rustfmt::skip]
15679unsafe impl crate::resolver::PFN for PFN_vkCmdDispatchIndirect {
15680    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDispatchIndirect";
15681
15682    #[inline(always)]
15683    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15684        unsafe { core::mem::transmute(p) }
15685    }
15686    #[inline(always)]
15687    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15688        unsafe { core::mem::transmute(p) }
15689    }
15690}
15691#[cfg(not(feature = "DynamicLoaded"))]
15692#[cfg(feature = "Implements")]
15693#[rustfmt::skip]
15694impl crate::resolver::StaticCallable for PFN_vkCmdDispatchIndirect {
15695    const STATIC: Self = Self(vkCmdDispatchIndirect);
15696}
15697
15698#[cfg(feature = "Implements")]
15699#[repr(transparent)]
15700#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15701#[rustfmt::skip]
15702pub struct PFN_vkCmdCopyBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy));
15703#[cfg(feature = "Implements")]
15704#[rustfmt::skip]
15705unsafe impl crate::resolver::PFN for PFN_vkCmdCopyBuffer {
15706    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdCopyBuffer";
15707
15708    #[inline(always)]
15709    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15710        unsafe { core::mem::transmute(p) }
15711    }
15712    #[inline(always)]
15713    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15714        unsafe { core::mem::transmute(p) }
15715    }
15716}
15717#[cfg(not(feature = "DynamicLoaded"))]
15718#[cfg(feature = "Implements")]
15719#[rustfmt::skip]
15720impl crate::resolver::StaticCallable for PFN_vkCmdCopyBuffer {
15721    const STATIC: Self = Self(vkCmdCopyBuffer);
15722}
15723
15724#[cfg(feature = "Implements")]
15725#[repr(transparent)]
15726#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15727#[rustfmt::skip]
15728pub struct PFN_vkCmdCopyImage(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy));
15729#[cfg(feature = "Implements")]
15730#[rustfmt::skip]
15731unsafe impl crate::resolver::PFN for PFN_vkCmdCopyImage {
15732    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdCopyImage";
15733
15734    #[inline(always)]
15735    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15736        unsafe { core::mem::transmute(p) }
15737    }
15738    #[inline(always)]
15739    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15740        unsafe { core::mem::transmute(p) }
15741    }
15742}
15743#[cfg(not(feature = "DynamicLoaded"))]
15744#[cfg(feature = "Implements")]
15745#[rustfmt::skip]
15746impl crate::resolver::StaticCallable for PFN_vkCmdCopyImage {
15747    const STATIC: Self = Self(vkCmdCopyImage);
15748}
15749
15750#[cfg(feature = "Implements")]
15751#[repr(transparent)]
15752#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15753#[rustfmt::skip]
15754pub struct PFN_vkCmdBlitImage(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filters: VkFilter));
15755#[cfg(feature = "Implements")]
15756#[rustfmt::skip]
15757unsafe impl crate::resolver::PFN for PFN_vkCmdBlitImage {
15758    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBlitImage";
15759
15760    #[inline(always)]
15761    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15762        unsafe { core::mem::transmute(p) }
15763    }
15764    #[inline(always)]
15765    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15766        unsafe { core::mem::transmute(p) }
15767    }
15768}
15769#[cfg(not(feature = "DynamicLoaded"))]
15770#[cfg(feature = "Implements")]
15771#[rustfmt::skip]
15772impl crate::resolver::StaticCallable for PFN_vkCmdBlitImage {
15773    const STATIC: Self = Self(vkCmdBlitImage);
15774}
15775
15776#[cfg(feature = "Implements")]
15777#[repr(transparent)]
15778#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15779#[rustfmt::skip]
15780pub struct PFN_vkCmdCopyBufferToImage(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy));
15781#[cfg(feature = "Implements")]
15782#[rustfmt::skip]
15783unsafe impl crate::resolver::PFN for PFN_vkCmdCopyBufferToImage {
15784    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdCopyBufferToImage";
15785
15786    #[inline(always)]
15787    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15788        unsafe { core::mem::transmute(p) }
15789    }
15790    #[inline(always)]
15791    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15792        unsafe { core::mem::transmute(p) }
15793    }
15794}
15795#[cfg(not(feature = "DynamicLoaded"))]
15796#[cfg(feature = "Implements")]
15797#[rustfmt::skip]
15798impl crate::resolver::StaticCallable for PFN_vkCmdCopyBufferToImage {
15799    const STATIC: Self = Self(vkCmdCopyBufferToImage);
15800}
15801
15802#[cfg(feature = "Implements")]
15803#[repr(transparent)]
15804#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15805#[rustfmt::skip]
15806pub struct PFN_vkCmdCopyImageToBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy));
15807#[cfg(feature = "Implements")]
15808#[rustfmt::skip]
15809unsafe impl crate::resolver::PFN for PFN_vkCmdCopyImageToBuffer {
15810    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdCopyImageToBuffer";
15811
15812    #[inline(always)]
15813    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15814        unsafe { core::mem::transmute(p) }
15815    }
15816    #[inline(always)]
15817    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15818        unsafe { core::mem::transmute(p) }
15819    }
15820}
15821#[cfg(not(feature = "DynamicLoaded"))]
15822#[cfg(feature = "Implements")]
15823#[rustfmt::skip]
15824impl crate::resolver::StaticCallable for PFN_vkCmdCopyImageToBuffer {
15825    const STATIC: Self = Self(vkCmdCopyImageToBuffer);
15826}
15827
15828#[cfg(feature = "Implements")]
15829#[repr(transparent)]
15830#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15831#[rustfmt::skip]
15832pub struct PFN_vkCmdUpdateBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const core::ffi::c_void));
15833#[cfg(feature = "Implements")]
15834#[rustfmt::skip]
15835unsafe impl crate::resolver::PFN for PFN_vkCmdUpdateBuffer {
15836    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdUpdateBuffer";
15837
15838    #[inline(always)]
15839    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15840        unsafe { core::mem::transmute(p) }
15841    }
15842    #[inline(always)]
15843    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15844        unsafe { core::mem::transmute(p) }
15845    }
15846}
15847#[cfg(not(feature = "DynamicLoaded"))]
15848#[cfg(feature = "Implements")]
15849#[rustfmt::skip]
15850impl crate::resolver::StaticCallable for PFN_vkCmdUpdateBuffer {
15851    const STATIC: Self = Self(vkCmdUpdateBuffer);
15852}
15853
15854#[cfg(feature = "Implements")]
15855#[repr(transparent)]
15856#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15857#[rustfmt::skip]
15858pub struct PFN_vkCmdFillBuffer(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, data: u32));
15859#[cfg(feature = "Implements")]
15860#[rustfmt::skip]
15861unsafe impl crate::resolver::PFN for PFN_vkCmdFillBuffer {
15862    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdFillBuffer";
15863
15864    #[inline(always)]
15865    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15866        unsafe { core::mem::transmute(p) }
15867    }
15868    #[inline(always)]
15869    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15870        unsafe { core::mem::transmute(p) }
15871    }
15872}
15873#[cfg(not(feature = "DynamicLoaded"))]
15874#[cfg(feature = "Implements")]
15875#[rustfmt::skip]
15876impl crate::resolver::StaticCallable for PFN_vkCmdFillBuffer {
15877    const STATIC: Self = Self(vkCmdFillBuffer);
15878}
15879
15880#[cfg(feature = "Implements")]
15881#[repr(transparent)]
15882#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15883#[rustfmt::skip]
15884pub struct PFN_vkCmdClearColorImage(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange));
15885#[cfg(feature = "Implements")]
15886#[rustfmt::skip]
15887unsafe impl crate::resolver::PFN for PFN_vkCmdClearColorImage {
15888    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdClearColorImage";
15889
15890    #[inline(always)]
15891    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15892        unsafe { core::mem::transmute(p) }
15893    }
15894    #[inline(always)]
15895    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15896        unsafe { core::mem::transmute(p) }
15897    }
15898}
15899#[cfg(not(feature = "DynamicLoaded"))]
15900#[cfg(feature = "Implements")]
15901#[rustfmt::skip]
15902impl crate::resolver::StaticCallable for PFN_vkCmdClearColorImage {
15903    const STATIC: Self = Self(vkCmdClearColorImage);
15904}
15905
15906#[cfg(feature = "Implements")]
15907#[repr(transparent)]
15908#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15909#[rustfmt::skip]
15910pub struct PFN_vkCmdClearDepthStencilImage(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange));
15911#[cfg(feature = "Implements")]
15912#[rustfmt::skip]
15913unsafe impl crate::resolver::PFN for PFN_vkCmdClearDepthStencilImage {
15914    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdClearDepthStencilImage";
15915
15916    #[inline(always)]
15917    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15918        unsafe { core::mem::transmute(p) }
15919    }
15920    #[inline(always)]
15921    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15922        unsafe { core::mem::transmute(p) }
15923    }
15924}
15925#[cfg(not(feature = "DynamicLoaded"))]
15926#[cfg(feature = "Implements")]
15927#[rustfmt::skip]
15928impl crate::resolver::StaticCallable for PFN_vkCmdClearDepthStencilImage {
15929    const STATIC: Self = Self(vkCmdClearDepthStencilImage);
15930}
15931
15932#[cfg(feature = "Implements")]
15933#[repr(transparent)]
15934#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15935#[rustfmt::skip]
15936pub struct PFN_vkCmdClearAttachments(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect));
15937#[cfg(feature = "Implements")]
15938#[rustfmt::skip]
15939unsafe impl crate::resolver::PFN for PFN_vkCmdClearAttachments {
15940    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdClearAttachments";
15941
15942    #[inline(always)]
15943    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15944        unsafe { core::mem::transmute(p) }
15945    }
15946    #[inline(always)]
15947    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15948        unsafe { core::mem::transmute(p) }
15949    }
15950}
15951#[cfg(not(feature = "DynamicLoaded"))]
15952#[cfg(feature = "Implements")]
15953#[rustfmt::skip]
15954impl crate::resolver::StaticCallable for PFN_vkCmdClearAttachments {
15955    const STATIC: Self = Self(vkCmdClearAttachments);
15956}
15957
15958#[cfg(feature = "Implements")]
15959#[repr(transparent)]
15960#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15961#[rustfmt::skip]
15962pub struct PFN_vkCmdResolveImage(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve));
15963#[cfg(feature = "Implements")]
15964#[rustfmt::skip]
15965unsafe impl crate::resolver::PFN for PFN_vkCmdResolveImage {
15966    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdResolveImage";
15967
15968    #[inline(always)]
15969    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15970        unsafe { core::mem::transmute(p) }
15971    }
15972    #[inline(always)]
15973    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
15974        unsafe { core::mem::transmute(p) }
15975    }
15976}
15977#[cfg(not(feature = "DynamicLoaded"))]
15978#[cfg(feature = "Implements")]
15979#[rustfmt::skip]
15980impl crate::resolver::StaticCallable for PFN_vkCmdResolveImage {
15981    const STATIC: Self = Self(vkCmdResolveImage);
15982}
15983
15984#[cfg(feature = "Implements")]
15985#[repr(transparent)]
15986#[derive(Debug, Clone, Copy, PartialEq, Eq)]
15987#[rustfmt::skip]
15988pub struct PFN_vkCmdSetEvent(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags));
15989#[cfg(feature = "Implements")]
15990#[rustfmt::skip]
15991unsafe impl crate::resolver::PFN for PFN_vkCmdSetEvent {
15992    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetEvent";
15993
15994    #[inline(always)]
15995    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
15996        unsafe { core::mem::transmute(p) }
15997    }
15998    #[inline(always)]
15999    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16000        unsafe { core::mem::transmute(p) }
16001    }
16002}
16003#[cfg(not(feature = "DynamicLoaded"))]
16004#[cfg(feature = "Implements")]
16005#[rustfmt::skip]
16006impl crate::resolver::StaticCallable for PFN_vkCmdSetEvent {
16007    const STATIC: Self = Self(vkCmdSetEvent);
16008}
16009
16010#[cfg(feature = "Implements")]
16011#[repr(transparent)]
16012#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16013#[rustfmt::skip]
16014pub struct PFN_vkCmdResetEvent(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags));
16015#[cfg(feature = "Implements")]
16016#[rustfmt::skip]
16017unsafe impl crate::resolver::PFN for PFN_vkCmdResetEvent {
16018    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdResetEvent";
16019
16020    #[inline(always)]
16021    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16022        unsafe { core::mem::transmute(p) }
16023    }
16024    #[inline(always)]
16025    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16026        unsafe { core::mem::transmute(p) }
16027    }
16028}
16029#[cfg(not(feature = "DynamicLoaded"))]
16030#[cfg(feature = "Implements")]
16031#[rustfmt::skip]
16032impl crate::resolver::StaticCallable for PFN_vkCmdResetEvent {
16033    const STATIC: Self = Self(vkCmdResetEvent);
16034}
16035
16036#[cfg(feature = "Implements")]
16037#[repr(transparent)]
16038#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16039#[rustfmt::skip]
16040pub struct PFN_vkCmdWaitEvents(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier));
16041#[cfg(feature = "Implements")]
16042#[rustfmt::skip]
16043unsafe impl crate::resolver::PFN for PFN_vkCmdWaitEvents {
16044    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdWaitEvents";
16045
16046    #[inline(always)]
16047    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16048        unsafe { core::mem::transmute(p) }
16049    }
16050    #[inline(always)]
16051    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16052        unsafe { core::mem::transmute(p) }
16053    }
16054}
16055#[cfg(not(feature = "DynamicLoaded"))]
16056#[cfg(feature = "Implements")]
16057#[rustfmt::skip]
16058impl crate::resolver::StaticCallable for PFN_vkCmdWaitEvents {
16059    const STATIC: Self = Self(vkCmdWaitEvents);
16060}
16061
16062#[cfg(feature = "Implements")]
16063#[repr(transparent)]
16064#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16065#[rustfmt::skip]
16066pub struct PFN_vkCmdPipelineBarrier(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier));
16067#[cfg(feature = "Implements")]
16068#[rustfmt::skip]
16069unsafe impl crate::resolver::PFN for PFN_vkCmdPipelineBarrier {
16070    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdPipelineBarrier";
16071
16072    #[inline(always)]
16073    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16074        unsafe { core::mem::transmute(p) }
16075    }
16076    #[inline(always)]
16077    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16078        unsafe { core::mem::transmute(p) }
16079    }
16080}
16081#[cfg(not(feature = "DynamicLoaded"))]
16082#[cfg(feature = "Implements")]
16083#[rustfmt::skip]
16084impl crate::resolver::StaticCallable for PFN_vkCmdPipelineBarrier {
16085    const STATIC: Self = Self(vkCmdPipelineBarrier);
16086}
16087
16088#[cfg(feature = "Implements")]
16089#[repr(transparent)]
16090#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16091#[rustfmt::skip]
16092pub struct PFN_vkCmdBeginQuery(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags));
16093#[cfg(feature = "Implements")]
16094#[rustfmt::skip]
16095unsafe impl crate::resolver::PFN for PFN_vkCmdBeginQuery {
16096    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBeginQuery";
16097
16098    #[inline(always)]
16099    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16100        unsafe { core::mem::transmute(p) }
16101    }
16102    #[inline(always)]
16103    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16104        unsafe { core::mem::transmute(p) }
16105    }
16106}
16107#[cfg(not(feature = "DynamicLoaded"))]
16108#[cfg(feature = "Implements")]
16109#[rustfmt::skip]
16110impl crate::resolver::StaticCallable for PFN_vkCmdBeginQuery {
16111    const STATIC: Self = Self(vkCmdBeginQuery);
16112}
16113
16114#[cfg(feature = "Implements")]
16115#[repr(transparent)]
16116#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16117#[rustfmt::skip]
16118pub struct PFN_vkCmdEndQuery(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32));
16119#[cfg(feature = "Implements")]
16120#[rustfmt::skip]
16121unsafe impl crate::resolver::PFN for PFN_vkCmdEndQuery {
16122    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdEndQuery";
16123
16124    #[inline(always)]
16125    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16126        unsafe { core::mem::transmute(p) }
16127    }
16128    #[inline(always)]
16129    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16130        unsafe { core::mem::transmute(p) }
16131    }
16132}
16133#[cfg(not(feature = "DynamicLoaded"))]
16134#[cfg(feature = "Implements")]
16135#[rustfmt::skip]
16136impl crate::resolver::StaticCallable for PFN_vkCmdEndQuery {
16137    const STATIC: Self = Self(vkCmdEndQuery);
16138}
16139
16140#[cfg(feature = "Implements")]
16141#[repr(transparent)]
16142#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16143#[rustfmt::skip]
16144pub struct PFN_vkCmdResetQueryPool(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32));
16145#[cfg(feature = "Implements")]
16146#[rustfmt::skip]
16147unsafe impl crate::resolver::PFN for PFN_vkCmdResetQueryPool {
16148    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdResetQueryPool";
16149
16150    #[inline(always)]
16151    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16152        unsafe { core::mem::transmute(p) }
16153    }
16154    #[inline(always)]
16155    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16156        unsafe { core::mem::transmute(p) }
16157    }
16158}
16159#[cfg(not(feature = "DynamicLoaded"))]
16160#[cfg(feature = "Implements")]
16161#[rustfmt::skip]
16162impl crate::resolver::StaticCallable for PFN_vkCmdResetQueryPool {
16163    const STATIC: Self = Self(vkCmdResetQueryPool);
16164}
16165
16166#[cfg(feature = "Implements")]
16167#[repr(transparent)]
16168#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16169#[rustfmt::skip]
16170pub struct PFN_vkCmdWriteTimestamp(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, queryPool: VkQueryPool, query: u32));
16171#[cfg(feature = "Implements")]
16172#[rustfmt::skip]
16173unsafe impl crate::resolver::PFN for PFN_vkCmdWriteTimestamp {
16174    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdWriteTimestamp";
16175
16176    #[inline(always)]
16177    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16178        unsafe { core::mem::transmute(p) }
16179    }
16180    #[inline(always)]
16181    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16182        unsafe { core::mem::transmute(p) }
16183    }
16184}
16185#[cfg(not(feature = "DynamicLoaded"))]
16186#[cfg(feature = "Implements")]
16187#[rustfmt::skip]
16188impl crate::resolver::StaticCallable for PFN_vkCmdWriteTimestamp {
16189    const STATIC: Self = Self(vkCmdWriteTimestamp);
16190}
16191
16192#[cfg(feature = "Implements")]
16193#[repr(transparent)]
16194#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16195#[rustfmt::skip]
16196pub struct PFN_vkCmdCopyQueryPoolResults(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags));
16197#[cfg(feature = "Implements")]
16198#[rustfmt::skip]
16199unsafe impl crate::resolver::PFN for PFN_vkCmdCopyQueryPoolResults {
16200    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdCopyQueryPoolResults";
16201
16202    #[inline(always)]
16203    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16204        unsafe { core::mem::transmute(p) }
16205    }
16206    #[inline(always)]
16207    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16208        unsafe { core::mem::transmute(p) }
16209    }
16210}
16211#[cfg(not(feature = "DynamicLoaded"))]
16212#[cfg(feature = "Implements")]
16213#[rustfmt::skip]
16214impl crate::resolver::StaticCallable for PFN_vkCmdCopyQueryPoolResults {
16215    const STATIC: Self = Self(vkCmdCopyQueryPoolResults);
16216}
16217
16218#[cfg(feature = "Implements")]
16219#[repr(transparent)]
16220#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16221#[rustfmt::skip]
16222pub struct PFN_vkCmdPushConstants(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineLayout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const core::ffi::c_void));
16223#[cfg(feature = "Implements")]
16224#[rustfmt::skip]
16225unsafe impl crate::resolver::PFN for PFN_vkCmdPushConstants {
16226    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdPushConstants";
16227
16228    #[inline(always)]
16229    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16230        unsafe { core::mem::transmute(p) }
16231    }
16232    #[inline(always)]
16233    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16234        unsafe { core::mem::transmute(p) }
16235    }
16236}
16237#[cfg(not(feature = "DynamicLoaded"))]
16238#[cfg(feature = "Implements")]
16239#[rustfmt::skip]
16240impl crate::resolver::StaticCallable for PFN_vkCmdPushConstants {
16241    const STATIC: Self = Self(vkCmdPushConstants);
16242}
16243
16244#[cfg(feature = "Implements")]
16245#[repr(transparent)]
16246#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16247#[rustfmt::skip]
16248pub struct PFN_vkCmdBeginRenderPass(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents));
16249#[cfg(feature = "Implements")]
16250#[rustfmt::skip]
16251unsafe impl crate::resolver::PFN for PFN_vkCmdBeginRenderPass {
16252    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBeginRenderPass";
16253
16254    #[inline(always)]
16255    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16256        unsafe { core::mem::transmute(p) }
16257    }
16258    #[inline(always)]
16259    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16260        unsafe { core::mem::transmute(p) }
16261    }
16262}
16263#[cfg(not(feature = "DynamicLoaded"))]
16264#[cfg(feature = "Implements")]
16265#[rustfmt::skip]
16266impl crate::resolver::StaticCallable for PFN_vkCmdBeginRenderPass {
16267    const STATIC: Self = Self(vkCmdBeginRenderPass);
16268}
16269
16270#[cfg(feature = "Implements")]
16271#[repr(transparent)]
16272#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16273#[rustfmt::skip]
16274pub struct PFN_vkCmdNextSubpass(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, contents: VkSubpassContents));
16275#[cfg(feature = "Implements")]
16276#[rustfmt::skip]
16277unsafe impl crate::resolver::PFN for PFN_vkCmdNextSubpass {
16278    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdNextSubpass";
16279
16280    #[inline(always)]
16281    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16282        unsafe { core::mem::transmute(p) }
16283    }
16284    #[inline(always)]
16285    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16286        unsafe { core::mem::transmute(p) }
16287    }
16288}
16289#[cfg(not(feature = "DynamicLoaded"))]
16290#[cfg(feature = "Implements")]
16291#[rustfmt::skip]
16292impl crate::resolver::StaticCallable for PFN_vkCmdNextSubpass {
16293    const STATIC: Self = Self(vkCmdNextSubpass);
16294}
16295
16296#[cfg(feature = "Implements")]
16297#[repr(transparent)]
16298#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16299#[rustfmt::skip]
16300pub struct PFN_vkCmdEndRenderPass(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer));
16301#[cfg(feature = "Implements")]
16302#[rustfmt::skip]
16303unsafe impl crate::resolver::PFN for PFN_vkCmdEndRenderPass {
16304    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdEndRenderPass";
16305
16306    #[inline(always)]
16307    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16308        unsafe { core::mem::transmute(p) }
16309    }
16310    #[inline(always)]
16311    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16312        unsafe { core::mem::transmute(p) }
16313    }
16314}
16315#[cfg(not(feature = "DynamicLoaded"))]
16316#[cfg(feature = "Implements")]
16317#[rustfmt::skip]
16318impl crate::resolver::StaticCallable for PFN_vkCmdEndRenderPass {
16319    const STATIC: Self = Self(vkCmdEndRenderPass);
16320}
16321
16322#[cfg(feature = "Implements")]
16323#[repr(transparent)]
16324#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16325#[rustfmt::skip]
16326pub struct PFN_vkCmdExecuteCommands(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer));
16327#[cfg(feature = "Implements")]
16328#[rustfmt::skip]
16329unsafe impl crate::resolver::PFN for PFN_vkCmdExecuteCommands {
16330    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdExecuteCommands";
16331
16332    #[inline(always)]
16333    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16334        unsafe { core::mem::transmute(p) }
16335    }
16336    #[inline(always)]
16337    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16338        unsafe { core::mem::transmute(p) }
16339    }
16340}
16341#[cfg(not(feature = "DynamicLoaded"))]
16342#[cfg(feature = "Implements")]
16343#[rustfmt::skip]
16344impl crate::resolver::StaticCallable for PFN_vkCmdExecuteCommands {
16345    const STATIC: Self = Self(vkCmdExecuteCommands);
16346}
16347
16348#[cfg(feature = "Implements")]
16349#[cfg(feature = "VK_EXT_debug_utils")]
16350#[repr(transparent)]
16351#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16352#[rustfmt::skip]
16353pub struct PFN_vkCmdBeginDebugUtilsLabelEXT(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT));
16354#[cfg(feature = "Implements")]
16355#[cfg(feature = "VK_EXT_debug_utils")]
16356#[rustfmt::skip]
16357unsafe impl crate::resolver::PFN for PFN_vkCmdBeginDebugUtilsLabelEXT {
16358    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdBeginDebugUtilsLabelEXT";
16359
16360    #[inline(always)]
16361    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16362        unsafe { core::mem::transmute(p) }
16363    }
16364    #[inline(always)]
16365    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16366        unsafe { core::mem::transmute(p) }
16367    }
16368}
16369
16370#[cfg(feature = "Implements")]
16371#[cfg(feature = "VK_EXT_debug_utils")]
16372#[repr(transparent)]
16373#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16374#[rustfmt::skip]
16375pub struct PFN_vkCmdEndDebugUtilsLabelEXT(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer));
16376#[cfg(feature = "Implements")]
16377#[cfg(feature = "VK_EXT_debug_utils")]
16378#[rustfmt::skip]
16379unsafe impl crate::resolver::PFN for PFN_vkCmdEndDebugUtilsLabelEXT {
16380    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdEndDebugUtilsLabelEXT";
16381
16382    #[inline(always)]
16383    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16384        unsafe { core::mem::transmute(p) }
16385    }
16386    #[inline(always)]
16387    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16388        unsafe { core::mem::transmute(p) }
16389    }
16390}
16391
16392#[cfg(feature = "Implements")]
16393#[cfg(feature = "VK_EXT_debug_utils")]
16394#[repr(transparent)]
16395#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16396#[rustfmt::skip]
16397pub struct PFN_vkCmdInsertDebugUtilsLabelEXT(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT));
16398#[cfg(feature = "Implements")]
16399#[cfg(feature = "VK_EXT_debug_utils")]
16400#[rustfmt::skip]
16401unsafe impl crate::resolver::PFN for PFN_vkCmdInsertDebugUtilsLabelEXT {
16402    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdInsertDebugUtilsLabelEXT";
16403
16404    #[inline(always)]
16405    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16406        unsafe { core::mem::transmute(p) }
16407    }
16408    #[inline(always)]
16409    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16410        unsafe { core::mem::transmute(p) }
16411    }
16412}
16413
16414#[cfg(feature = "Implements")]
16415#[cfg(feature = "VK_KHR_device_group")]
16416#[repr(transparent)]
16417#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16418#[rustfmt::skip]
16419pub struct PFN_vkCmdSetDeviceMaskKHR(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32));
16420#[cfg(feature = "Implements")]
16421#[cfg(feature = "VK_KHR_device_group")]
16422#[rustfmt::skip]
16423unsafe impl crate::resolver::PFN for PFN_vkCmdSetDeviceMaskKHR {
16424    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetDeviceMaskKHR";
16425
16426    #[inline(always)]
16427    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16428        unsafe { core::mem::transmute(p) }
16429    }
16430    #[inline(always)]
16431    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16432        unsafe { core::mem::transmute(p) }
16433    }
16434}
16435#[cfg(feature = "Implements")]
16436#[cfg(feature = "Allow1_1APIs")]
16437#[repr(transparent)]
16438#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16439#[rustfmt::skip]
16440pub struct PFN_vkCmdSetDeviceMask(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32));
16441#[cfg(feature = "Implements")]
16442#[cfg(feature = "Allow1_1APIs")]
16443#[rustfmt::skip]
16444unsafe impl crate::resolver::PFN for PFN_vkCmdSetDeviceMask {
16445    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetDeviceMask";
16446
16447    #[inline(always)]
16448    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16449        unsafe { core::mem::transmute(p) }
16450    }
16451    #[inline(always)]
16452    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16453        unsafe { core::mem::transmute(p) }
16454    }
16455}
16456#[cfg(feature = "Implements")]
16457#[cfg(not(feature = "DynamicLoaded"))]
16458#[cfg(feature = "Allow1_1APIs")]
16459#[rustfmt::skip]
16460impl crate::resolver::StaticCallable for PFN_vkCmdSetDeviceMask {
16461    const STATIC: Self = Self(vkCmdSetDeviceMask);
16462}
16463
16464#[cfg(feature = "Implements")]
16465#[cfg(feature = "VK_KHR_device_group")]
16466#[repr(transparent)]
16467#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16468#[rustfmt::skip]
16469pub struct PFN_vkCmdDispatchBaseKHR(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32));
16470#[cfg(feature = "Implements")]
16471#[cfg(feature = "VK_KHR_device_group")]
16472#[rustfmt::skip]
16473unsafe impl crate::resolver::PFN for PFN_vkCmdDispatchBaseKHR {
16474    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDispatchBaseKHR";
16475
16476    #[inline(always)]
16477    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16478        unsafe { core::mem::transmute(p) }
16479    }
16480    #[inline(always)]
16481    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16482        unsafe { core::mem::transmute(p) }
16483    }
16484}
16485#[cfg(feature = "Implements")]
16486#[cfg(feature = "Allow1_1APIs")]
16487#[repr(transparent)]
16488#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16489#[rustfmt::skip]
16490pub struct PFN_vkCmdDispatchBase(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32));
16491#[cfg(feature = "Implements")]
16492#[cfg(feature = "Allow1_1APIs")]
16493#[rustfmt::skip]
16494unsafe impl crate::resolver::PFN for PFN_vkCmdDispatchBase {
16495    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdDispatchBase";
16496
16497    #[inline(always)]
16498    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16499        unsafe { core::mem::transmute(p) }
16500    }
16501    #[inline(always)]
16502    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16503        unsafe { core::mem::transmute(p) }
16504    }
16505}
16506#[cfg(feature = "Implements")]
16507#[cfg(not(feature = "DynamicLoaded"))]
16508#[cfg(feature = "Allow1_1APIs")]
16509#[rustfmt::skip]
16510impl crate::resolver::StaticCallable for PFN_vkCmdDispatchBase {
16511    const STATIC: Self = Self(vkCmdDispatchBase);
16512}
16513
16514#[cfg(feature = "Implements")]
16515#[cfg(feature = "VK_KHR_synchronization2")]
16516#[repr(transparent)]
16517#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16518#[rustfmt::skip]
16519pub struct PFN_vkCmdSetEvent2KHR(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfoKHR));
16520#[cfg(feature = "Implements")]
16521#[cfg(feature = "VK_KHR_synchronization2")]
16522#[rustfmt::skip]
16523unsafe impl crate::resolver::PFN for PFN_vkCmdSetEvent2KHR {
16524    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetEvent2KHR";
16525
16526    #[inline(always)]
16527    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16528        unsafe { core::mem::transmute(p) }
16529    }
16530    #[inline(always)]
16531    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16532        unsafe { core::mem::transmute(p) }
16533    }
16534}
16535#[cfg(feature = "Implements")]
16536#[cfg(feature = "Allow1_3APIs")]
16537#[repr(transparent)]
16538#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16539#[rustfmt::skip]
16540pub struct PFN_vkCmdSetEvent2(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfoKHR));
16541#[cfg(feature = "Implements")]
16542#[cfg(feature = "Allow1_3APIs")]
16543#[rustfmt::skip]
16544unsafe impl crate::resolver::PFN for PFN_vkCmdSetEvent2 {
16545    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdSetEvent2";
16546
16547    #[inline(always)]
16548    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16549        unsafe { core::mem::transmute(p) }
16550    }
16551    #[inline(always)]
16552    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16553        unsafe { core::mem::transmute(p) }
16554    }
16555}
16556#[cfg(feature = "Implements")]
16557#[cfg(not(feature = "DynamicLoaded"))]
16558#[cfg(feature = "Allow1_3APIs")]
16559#[rustfmt::skip]
16560impl crate::resolver::StaticCallable for PFN_vkCmdSetEvent2 {
16561    const STATIC: Self = Self(vkCmdSetEvent2);
16562}
16563
16564#[cfg(feature = "Implements")]
16565#[cfg(feature = "VK_KHR_synchronization2")]
16566#[repr(transparent)]
16567#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16568#[rustfmt::skip]
16569pub struct PFN_vkCmdResetEvent2KHR(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2KHR));
16570#[cfg(feature = "Implements")]
16571#[cfg(feature = "VK_KHR_synchronization2")]
16572#[rustfmt::skip]
16573unsafe impl crate::resolver::PFN for PFN_vkCmdResetEvent2KHR {
16574    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdResetEvent2KHR";
16575
16576    #[inline(always)]
16577    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16578        unsafe { core::mem::transmute(p) }
16579    }
16580    #[inline(always)]
16581    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16582        unsafe { core::mem::transmute(p) }
16583    }
16584}
16585#[cfg(feature = "Implements")]
16586#[cfg(feature = "Allow1_3APIs")]
16587#[repr(transparent)]
16588#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16589#[rustfmt::skip]
16590pub struct PFN_vkCmdResetEvent2(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2KHR));
16591#[cfg(feature = "Implements")]
16592#[cfg(feature = "Allow1_3APIs")]
16593#[rustfmt::skip]
16594unsafe impl crate::resolver::PFN for PFN_vkCmdResetEvent2 {
16595    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdResetEvent2";
16596
16597    #[inline(always)]
16598    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16599        unsafe { core::mem::transmute(p) }
16600    }
16601    #[inline(always)]
16602    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16603        unsafe { core::mem::transmute(p) }
16604    }
16605}
16606#[cfg(feature = "Implements")]
16607#[cfg(not(feature = "DynamicLoaded"))]
16608#[cfg(feature = "Allow1_3APIs")]
16609#[rustfmt::skip]
16610impl crate::resolver::StaticCallable for PFN_vkCmdResetEvent2 {
16611    const STATIC: Self = Self(vkCmdResetEvent2);
16612}
16613
16614#[cfg(feature = "Implements")]
16615#[cfg(feature = "VK_KHR_synchronization2")]
16616#[repr(transparent)]
16617#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16618#[rustfmt::skip]
16619pub struct PFN_vkCmdWaitEvents2KHR(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfoKHR));
16620#[cfg(feature = "Implements")]
16621#[cfg(feature = "VK_KHR_synchronization2")]
16622#[rustfmt::skip]
16623unsafe impl crate::resolver::PFN for PFN_vkCmdWaitEvents2KHR {
16624    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdWaitEvents2KHR";
16625
16626    #[inline(always)]
16627    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16628        unsafe { core::mem::transmute(p) }
16629    }
16630    #[inline(always)]
16631    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16632        unsafe { core::mem::transmute(p) }
16633    }
16634}
16635#[cfg(feature = "Implements")]
16636#[cfg(feature = "Allow1_3APIs")]
16637#[repr(transparent)]
16638#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16639#[rustfmt::skip]
16640pub struct PFN_vkCmdWaitEvents2(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfoKHR));
16641#[cfg(feature = "Implements")]
16642#[cfg(feature = "Allow1_3APIs")]
16643#[rustfmt::skip]
16644unsafe impl crate::resolver::PFN for PFN_vkCmdWaitEvents2 {
16645    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdWaitEvents2";
16646
16647    #[inline(always)]
16648    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16649        unsafe { core::mem::transmute(p) }
16650    }
16651    #[inline(always)]
16652    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16653        unsafe { core::mem::transmute(p) }
16654    }
16655}
16656#[cfg(feature = "Implements")]
16657#[cfg(not(feature = "DynamicLoaded"))]
16658#[cfg(feature = "Allow1_3APIs")]
16659#[rustfmt::skip]
16660impl crate::resolver::StaticCallable for PFN_vkCmdWaitEvents2 {
16661    const STATIC: Self = Self(vkCmdWaitEvents2);
16662}
16663
16664#[cfg(feature = "Implements")]
16665#[cfg(feature = "VK_KHR_synchronization2")]
16666#[repr(transparent)]
16667#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16668#[rustfmt::skip]
16669pub struct PFN_vkCmdPipelineBarrier2KHR(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfoKHR));
16670#[cfg(feature = "Implements")]
16671#[cfg(feature = "VK_KHR_synchronization2")]
16672#[rustfmt::skip]
16673unsafe impl crate::resolver::PFN for PFN_vkCmdPipelineBarrier2KHR {
16674    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdPipelineBarrier2KHR";
16675
16676    #[inline(always)]
16677    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16678        unsafe { core::mem::transmute(p) }
16679    }
16680    #[inline(always)]
16681    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16682        unsafe { core::mem::transmute(p) }
16683    }
16684}
16685#[cfg(feature = "Implements")]
16686#[cfg(feature = "Allow1_3APIs")]
16687#[repr(transparent)]
16688#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16689#[rustfmt::skip]
16690pub struct PFN_vkCmdPipelineBarrier2(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfoKHR));
16691#[cfg(feature = "Implements")]
16692#[cfg(feature = "Allow1_3APIs")]
16693#[rustfmt::skip]
16694unsafe impl crate::resolver::PFN for PFN_vkCmdPipelineBarrier2 {
16695    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdPipelineBarrier2";
16696
16697    #[inline(always)]
16698    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16699        unsafe { core::mem::transmute(p) }
16700    }
16701    #[inline(always)]
16702    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16703        unsafe { core::mem::transmute(p) }
16704    }
16705}
16706#[cfg(feature = "Implements")]
16707#[cfg(not(feature = "DynamicLoaded"))]
16708#[cfg(feature = "Allow1_3APIs")]
16709#[rustfmt::skip]
16710impl crate::resolver::StaticCallable for PFN_vkCmdPipelineBarrier2 {
16711    const STATIC: Self = Self(vkCmdPipelineBarrier2);
16712}
16713
16714#[cfg(feature = "Implements")]
16715#[cfg(feature = "VK_KHR_synchronization2")]
16716#[repr(transparent)]
16717#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16718#[rustfmt::skip]
16719pub struct PFN_vkCmdWriteTimestamp2KHR(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2KHR, queryPool: VkQueryPool, query: u32));
16720#[cfg(feature = "Implements")]
16721#[cfg(feature = "VK_KHR_synchronization2")]
16722#[rustfmt::skip]
16723unsafe impl crate::resolver::PFN for PFN_vkCmdWriteTimestamp2KHR {
16724    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdWriteTimestamp2KHR";
16725
16726    #[inline(always)]
16727    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16728        unsafe { core::mem::transmute(p) }
16729    }
16730    #[inline(always)]
16731    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16732        unsafe { core::mem::transmute(p) }
16733    }
16734}
16735#[cfg(feature = "Implements")]
16736#[cfg(feature = "Allow1_3APIs")]
16737#[repr(transparent)]
16738#[derive(Debug, Clone, Copy, PartialEq, Eq)]
16739#[rustfmt::skip]
16740pub struct PFN_vkCmdWriteTimestamp2(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2KHR, queryPool: VkQueryPool, query: u32));
16741#[cfg(feature = "Implements")]
16742#[cfg(feature = "Allow1_3APIs")]
16743#[rustfmt::skip]
16744unsafe impl crate::resolver::PFN for PFN_vkCmdWriteTimestamp2 {
16745    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdWriteTimestamp2";
16746
16747    #[inline(always)]
16748    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
16749        unsafe { core::mem::transmute(p) }
16750    }
16751    #[inline(always)]
16752    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
16753        unsafe { core::mem::transmute(p) }
16754    }
16755}
16756#[cfg(feature = "Implements")]
16757#[cfg(not(feature = "DynamicLoaded"))]
16758#[cfg(feature = "Allow1_3APIs")]
16759#[rustfmt::skip]
16760impl crate::resolver::StaticCallable for PFN_vkCmdWriteTimestamp2 {
16761    const STATIC: Self = Self(vkCmdWriteTimestamp2);
16762}
16763
16764#[cfg(feature = "VK_KHR_surface")]
16765#[rustfmt::skip]
16766pub const VK_KHR_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_surface";
16767#[cfg(feature = "VK_KHR_surface")]
16768#[rustfmt::skip]
16769pub const VK_KHR_SURFACE_SPEC_VERSION: usize = 25;
16770
16771#[cfg(feature = "VK_KHR_swapchain")]
16772#[rustfmt::skip]
16773pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME: &'static str = "VK_KHR_swapchain";
16774#[cfg(feature = "VK_KHR_swapchain")]
16775#[rustfmt::skip]
16776pub const VK_KHR_SWAPCHAIN_SPEC_VERSION: usize = 68;
16777
16778#[cfg(feature = "VK_KHR_display")]
16779#[rustfmt::skip]
16780pub const VK_KHR_DISPLAY_EXTENSION_NAME: &'static str = "VK_KHR_display";
16781#[cfg(feature = "VK_KHR_display")]
16782#[rustfmt::skip]
16783pub const VK_KHR_DISPLAY_SPEC_VERSION: usize = 21;
16784
16785#[cfg(feature = "VK_KHR_display_swapchain")]
16786#[rustfmt::skip]
16787pub const VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME: &'static str = "VK_KHR_display_swapchain";
16788#[cfg(feature = "VK_KHR_display_swapchain")]
16789#[rustfmt::skip]
16790pub const VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION: usize = 1;
16791
16792#[cfg(feature = "VK_KHR_xlib_surface")]
16793#[rustfmt::skip]
16794pub const VK_KHR_XLIB_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_xlib_surface";
16795#[cfg(feature = "VK_KHR_xlib_surface")]
16796#[rustfmt::skip]
16797pub const VK_KHR_XLIB_SURFACE_SPEC_VERSION: usize = 6;
16798
16799#[cfg(feature = "VK_KHR_xcb_surface")]
16800#[rustfmt::skip]
16801pub const VK_KHR_XCB_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_xcb_surface";
16802#[cfg(feature = "VK_KHR_xcb_surface")]
16803#[rustfmt::skip]
16804pub const VK_KHR_XCB_SURFACE_SPEC_VERSION: usize = 6;
16805
16806#[cfg(feature = "VK_KHR_wayland_surface")]
16807#[rustfmt::skip]
16808pub const VK_KHR_WAYLAND_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_wayland_surface";
16809#[cfg(feature = "VK_KHR_wayland_surface")]
16810#[rustfmt::skip]
16811pub const VK_KHR_WAYLAND_SURFACE_SPEC_VERSION: usize = 6;
16812
16813#[cfg(feature = "VK_KHR_android_surface")]
16814#[rustfmt::skip]
16815pub const VK_KHR_ANDROID_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_android_surface";
16816#[cfg(feature = "VK_KHR_android_surface")]
16817#[rustfmt::skip]
16818pub const VK_KHR_ANDROID_SURFACE_SPEC_VERSION: usize = 6;
16819
16820#[cfg(feature = "VK_KHR_win32_surface")]
16821#[rustfmt::skip]
16822pub const VK_KHR_WIN32_SURFACE_EXTENSION_NAME: &'static str = "VK_KHR_win32_surface";
16823#[cfg(feature = "VK_KHR_win32_surface")]
16824#[rustfmt::skip]
16825pub const VK_KHR_WIN32_SURFACE_SPEC_VERSION: usize = 6;
16826
16827#[cfg(feature = "VK_EXT_metal_surface")]
16828#[rustfmt::skip]
16829pub const VK_EXT_METAL_SURFACE_EXTENSION_NAME: &'static str = "VK_EXT_metal_surface";
16830#[cfg(feature = "VK_EXT_metal_surface")]
16831#[rustfmt::skip]
16832pub const VK_EXT_METAL_SURFACE_SPEC_VERSION: usize = 1;
16833
16834#[cfg(feature = "VK_KHR_sampler_mirror_clamp_to_edge")]
16835#[rustfmt::skip]
16836pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME: &'static str = "VK_KHR_sampler_mirror_clamp_to_edge";
16837#[cfg(feature = "VK_KHR_sampler_mirror_clamp_to_edge")]
16838#[rustfmt::skip]
16839pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION: usize = 1;
16840
16841#[cfg(feature = "VK_KHR_win32_keyed_mutex")]
16842#[rustfmt::skip]
16843pub const VK_KHR_WIN32_KEYED_MUTEX_EXTENSION_NAME: &'static str = "VK_KHR_win32_keyed_mutex";
16844#[cfg(feature = "VK_KHR_win32_keyed_mutex")]
16845#[rustfmt::skip]
16846pub const VK_KHR_WIN32_KEYED_MUTEX_SPEC_VERSION: usize = 1;
16847
16848#[cfg(feature = "VK_KHR_external_memory")]
16849#[rustfmt::skip]
16850pub const VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME: &'static str = "VK_KHR_external_memory";
16851#[cfg(feature = "VK_KHR_external_memory")]
16852#[rustfmt::skip]
16853pub const VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION: usize = 1;
16854
16855#[cfg(feature = "VK_KHR_external_memory_capabilities")]
16856#[rustfmt::skip]
16857pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: &'static str = "VK_KHR_external_memory_capabilities";
16858#[cfg(feature = "VK_KHR_external_memory_capabilities")]
16859#[rustfmt::skip]
16860pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: usize = 1;
16861
16862#[cfg(feature = "VK_KHR_external_memory_win32")]
16863#[rustfmt::skip]
16864pub const VK_KHR_EXTERNAL_MEMORY_WIN32_EXTENSION_NAME: &'static str = "VK_KHR_external_memory_win32";
16865#[cfg(feature = "VK_KHR_external_memory_win32")]
16866#[rustfmt::skip]
16867pub const VK_KHR_EXTERNAL_MEMORY_WIN32_SPEC_VERSION: usize = 1;
16868
16869#[cfg(feature = "VK_KHR_external_memory_fd")]
16870#[rustfmt::skip]
16871pub const VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME: &'static str = "VK_KHR_external_memory_fd";
16872#[cfg(feature = "VK_KHR_external_memory_fd")]
16873#[rustfmt::skip]
16874pub const VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION: usize = 1;
16875
16876#[cfg(feature = "VK_KHR_external_semaphore")]
16877#[rustfmt::skip]
16878pub const VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME: &'static str = "VK_KHR_external_semaphore";
16879#[cfg(feature = "VK_KHR_external_semaphore")]
16880#[rustfmt::skip]
16881pub const VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION: usize = 1;
16882
16883#[cfg(feature = "VK_KHR_external_semaphore_win32")]
16884#[rustfmt::skip]
16885pub const VK_KHR_EXTERNAL_SEMAPHORE_WIN32_EXTENSION_NAME: &'static str = "VK_KHR_external_semaphore_win32";
16886#[cfg(feature = "VK_KHR_external_semaphore_win32")]
16887#[rustfmt::skip]
16888pub const VK_KHR_EXTERNAL_SEMAPHORE_WIN32_SPEC_VERSION: usize = 1;
16889
16890#[cfg(feature = "VK_KHR_external_semaphore_fd")]
16891#[rustfmt::skip]
16892pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME: &'static str = "VK_KHR_external_semaphore_fd";
16893#[cfg(feature = "VK_KHR_external_semaphore_fd")]
16894#[rustfmt::skip]
16895pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION: usize = 1;
16896
16897#[cfg(feature = "VK_KHR_external_fence_win32")]
16898#[rustfmt::skip]
16899pub const VK_KHR_EXTERNAL_FENCE_WIN32_EXTENSION_NAME: &'static str = "VK_KHR_external_fence_win32";
16900#[cfg(feature = "VK_KHR_external_fence_win32")]
16901#[rustfmt::skip]
16902pub const VK_KHR_EXTERNAL_FENCE_WIN32_SPEC_VERSION: usize = 1;
16903
16904#[cfg(feature = "VK_KHR_external_fence_fd")]
16905#[rustfmt::skip]
16906pub const VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME: &'static str = "VK_KHR_external_fence_fd";
16907#[cfg(feature = "VK_KHR_external_fence_fd")]
16908#[rustfmt::skip]
16909pub const VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION: usize = 1;
16910
16911#[cfg(feature = "VK_KHR_get_surface_capabilities2")]
16912#[rustfmt::skip]
16913pub const VK_KHR_GET_SURFACE_CAPABILITIES2_EXTENSION_NAME: &'static str = "VK_KHR_get_surface_capabilities2";
16914#[cfg(feature = "VK_KHR_get_surface_capabilities2")]
16915#[rustfmt::skip]
16916pub const VK_KHR_GET_SURFACE_CAPABILITIES2_SPEC_VERSION: usize = 1;
16917
16918#[cfg(feature = "VK_EXT_debug_report")]
16919#[rustfmt::skip]
16920pub const VK_EXT_DEBUG_REPORT_EXTENSION_NAME: &'static str = "VK_EXT_debug_report";
16921#[cfg(feature = "VK_EXT_debug_report")]
16922#[rustfmt::skip]
16923pub const VK_EXT_DEBUG_REPORT_SPEC_VERSION: usize = 8;
16924
16925#[cfg(feature = "VK_EXT_debug_utils")]
16926#[rustfmt::skip]
16927pub const VK_EXT_DEBUG_UTILS_EXTENSION_NAME: &'static str = "VK_EXT_debug_utils";
16928#[cfg(feature = "VK_EXT_debug_utils")]
16929#[rustfmt::skip]
16930pub const VK_EXT_DEBUG_UTILS_SPEC_VERSION: usize = 2;
16931
16932#[cfg(feature = "VK_KHR_device_group")]
16933#[rustfmt::skip]
16934pub const VK_KHR_DEVICE_GROUP_EXTENSION_NAME: &'static str = "VK_KHR_device_group";
16935#[cfg(feature = "VK_KHR_device_group")]
16936#[rustfmt::skip]
16937pub const VK_KHR_DEVICE_GROUP_SPEC_VERSION: usize = 4;
16938
16939#[cfg(feature = "VK_KHR_device_group_creation")]
16940#[rustfmt::skip]
16941pub const VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME: &'static str = "VK_KHR_device_group_creation";
16942#[cfg(feature = "VK_KHR_device_group_creation")]
16943#[rustfmt::skip]
16944pub const VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION: usize = 1;
16945
16946#[cfg(feature = "VK_KHR_multiview")]
16947#[rustfmt::skip]
16948pub const VK_KHR_MULTIVIEW_EXTENSION_NAME: &'static str = "VK_KHR_multiview";
16949#[cfg(feature = "VK_KHR_multiview")]
16950#[rustfmt::skip]
16951pub const VK_KHR_MULTIVIEW_SPEC_VERSION: usize = 1;
16952
16953#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
16954#[rustfmt::skip]
16955pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_EXTENSION_NAME: &'static str = "VK_KHR_get_physical_device_properties2";
16956#[cfg(feature = "VK_KHR_get_physical_device_properties2")]
16957#[rustfmt::skip]
16958pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_SPEC_VERSION: usize = 1;
16959
16960#[cfg(feature = "VK_KHR_shader_draw_parameters")]
16961#[rustfmt::skip]
16962pub const VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME: &'static str = "VK_KHR_shader_draw_parameters";
16963#[cfg(feature = "VK_KHR_shader_draw_parameters")]
16964#[rustfmt::skip]
16965pub const VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION: usize = 1;
16966
16967#[cfg(feature = "VK_KHR_portability_enumeration")]
16968#[rustfmt::skip]
16969pub const VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME: &'static str = "VK_KHR_portability_enumeration";
16970#[cfg(feature = "VK_KHR_portability_enumeration")]
16971#[rustfmt::skip]
16972pub const VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION: usize = 1;
16973
16974#[cfg(feature = "VK_KHR_get_memory_requirements2")]
16975#[rustfmt::skip]
16976pub const VK_KHR_GET_MEMORY_REQUIREMENTS2_EXTENSION_NAME: &'static str = "VK_KHR_get_memory_requirements2";
16977#[cfg(feature = "VK_KHR_get_memory_requirements2")]
16978#[rustfmt::skip]
16979pub const VK_KHR_GET_MEMORY_REQUIREMENTS2_SPEC_VERSION: usize = 1;
16980
16981#[cfg(feature = "VK_KHR_relaxed_block_layout")]
16982#[rustfmt::skip]
16983pub const VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME: &'static str = "VK_KHR_relaxed_block_layout";
16984#[cfg(feature = "VK_KHR_relaxed_block_layout")]
16985#[rustfmt::skip]
16986pub const VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION: usize = 1;
16987
16988#[cfg(feature = "VK_KHR_storage_buffer_storage_class")]
16989#[rustfmt::skip]
16990pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME: &'static str = "VK_KHR_storage_buffer_storage_class";
16991#[cfg(feature = "VK_KHR_storage_buffer_storage_class")]
16992#[rustfmt::skip]
16993pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION: usize = 1;
16994
16995#[cfg(feature = "VK_KHR_bind_memory2")]
16996#[rustfmt::skip]
16997pub const VK_KHR_BIND_MEMORY2_EXTENSION_NAME: &'static str = "VK_KHR_bind_memory2";
16998#[cfg(feature = "VK_KHR_bind_memory2")]
16999#[rustfmt::skip]
17000pub const VK_KHR_BIND_MEMORY2_SPEC_VERSION: usize = 1;
17001
17002#[cfg(feature = "VK_KHR_variable_pointers")]
17003#[rustfmt::skip]
17004pub const VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME: &'static str = "VK_KHR_variable_pointers";
17005#[cfg(feature = "VK_KHR_variable_pointers")]
17006#[rustfmt::skip]
17007pub const VK_KHR_VARIABLE_POINTERS_SPEC_VERSION: usize = 1;
17008
17009#[cfg(feature = "VK_KHR_dedicated_allocation")]
17010#[rustfmt::skip]
17011pub const VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME: &'static str = "VK_KHR_dedicated_allocation";
17012#[cfg(feature = "VK_KHR_dedicated_allocation")]
17013#[rustfmt::skip]
17014pub const VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION: usize = 3;
17015
17016#[cfg(feature = "VK_KHR_16bit_storage")]
17017#[rustfmt::skip]
17018pub const VK_KHR_16BIT_STORAGE_EXTENSION_NAME: &'static str = "VK_KHR_16bit_storage";
17019#[cfg(feature = "VK_KHR_16bit_storage")]
17020#[rustfmt::skip]
17021pub const VK_KHR_16BIT_STORAGE_SPEC_VERSION: usize = 1;
17022
17023#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
17024#[rustfmt::skip]
17025pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME: &'static str = "VK_KHR_sampler_ycbcr_conversion";
17026#[cfg(feature = "VK_KHR_sampler_ycbcr_conversion")]
17027#[rustfmt::skip]
17028pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION: usize = 14;
17029
17030#[cfg(feature = "VK_KHR_maintenance1")]
17031#[rustfmt::skip]
17032pub const VK_KHR_MAINTENANCE1_EXTENSION_NAME: &'static str = "VK_KHR_maintenance1";
17033#[cfg(feature = "VK_KHR_maintenance1")]
17034#[rustfmt::skip]
17035pub const VK_KHR_MAINTENANCE1_SPEC_VERSION: usize = 2;
17036
17037#[cfg(feature = "VK_KHR_maintenance2")]
17038#[rustfmt::skip]
17039pub const VK_KHR_MAINTENANCE2_EXTENSION_NAME: &'static str = "VK_KHR_maintenance2";
17040#[cfg(feature = "VK_KHR_maintenance2")]
17041#[rustfmt::skip]
17042pub const VK_KHR_MAINTENANCE2_SPEC_VERSION: usize = 1;
17043
17044#[cfg(feature = "VK_KHR_maintenance3")]
17045#[rustfmt::skip]
17046pub const VK_KHR_MAINTENANCE3_EXTENSION_NAME: &'static str = "VK_KHR_maintenance3";
17047#[cfg(feature = "VK_KHR_maintenance3")]
17048#[rustfmt::skip]
17049pub const VK_KHR_MAINTENANCE3_SPEC_VERSION: usize = 1;
17050
17051#[cfg(feature = "VK_KHR_synchronization2")]
17052#[rustfmt::skip]
17053pub const VK_KHR_SYNCHRONIZATION2_EXTENSION_NAME: &'static str = "VK_KHR_synchronization2";
17054#[cfg(feature = "VK_KHR_synchronization2")]
17055#[rustfmt::skip]
17056pub const VK_KHR_SYNCHRONIZATION2_SPEC_VERSION: usize = 1;
17057
17058#[cfg(feature = "VK_KHR_buffer_device_address")]
17059#[rustfmt::skip]
17060pub const VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME: &'static str = "VK_KHR_buffer_device_address";
17061#[cfg(feature = "VK_KHR_buffer_device_address")]
17062#[rustfmt::skip]
17063pub const VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION: usize = 1;
17064
17065#[cfg(feature = "VK_KHR_timeline_semaphore")]
17066#[rustfmt::skip]
17067pub const VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME: &'static str = "VK_KHR_timeline_semaphore";
17068#[cfg(feature = "VK_KHR_timeline_semaphore")]
17069#[rustfmt::skip]
17070pub const VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION: usize = 2;
17071
17072#[cfg(feature = "VK_KHR_buffer_device_address")]
17073#[rustfmt::skip]
17074pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: VkResult = VkResult(-1000257000);
17075#[cfg(feature = "Allow1_2APIs")]
17076#[rustfmt::skip]
17077pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: VkResult = VkResult(-1000257000);
17078
17079#[cfg(feature = "VK_KHR_timeline_semaphore")]
17080#[rustfmt::skip]
17081pub type VkSemaphoreTypeKHR = i32;
17082#[cfg(feature = "Allow1_2APIs")]
17083#[rustfmt::skip]
17084#[rustfmt::skip]
17085pub type VkSemaphoreType = i32;
17086#[cfg(feature = "VK_KHR_timeline_semaphore")]
17087#[rustfmt::skip]
17088pub const VK_SEMAPHORE_TYPE_BINARY_KHR: VkSemaphoreTypeKHR = 0;
17089#[cfg(feature = "VK_KHR_timeline_semaphore")]
17090#[cfg(feature = "Allow1_2APIs")]
17091#[rustfmt::skip]
17092pub const VK_SEMAPHORE_TYPE_BINARY: VkSemaphoreTypeKHR = 0;
17093#[cfg(feature = "VK_KHR_timeline_semaphore")]
17094#[rustfmt::skip]
17095pub const VK_SEMAPHORE_TYPE_TIMELINE_KHR: VkSemaphoreTypeKHR = 1;
17096#[cfg(feature = "VK_KHR_timeline_semaphore")]
17097#[cfg(feature = "Allow1_2APIs")]
17098#[rustfmt::skip]
17099pub const VK_SEMAPHORE_TYPE_TIMELINE: VkSemaphoreTypeKHR = 1;
17100
17101#[cfg(feature = "VK_KHR_buffer_device_address")]
17102#[rustfmt::skip]
17103pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkBufferCreateFlagBits = 0x00000010;
17104#[cfg(feature = "Allow1_2APIs")]
17105#[rustfmt::skip]
17106pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkBufferCreateFlagBits = 0x00000010;
17107
17108#[cfg(feature = "VK_KHR_buffer_device_address")]
17109#[rustfmt::skip]
17110pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlagBits = 0x00020000;
17111#[cfg(feature = "Allow1_2APIs")]
17112#[rustfmt::skip]
17113pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlagBits = 0x00020000;
17114
17115#[cfg(feature = "VK_KHR_buffer_device_address")]
17116#[rustfmt::skip]
17117pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR: VkMemoryAllocateFlagBits = 0x00000002;
17118#[cfg(feature = "Allow1_2APIs")]
17119#[rustfmt::skip]
17120pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT: VkMemoryAllocateFlagBits = 0x00000002;
17121#[cfg(feature = "VK_KHR_buffer_device_address")]
17122#[rustfmt::skip]
17123pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkMemoryAllocateFlagBits = 0x00000004;
17124#[cfg(feature = "Allow1_2APIs")]
17125#[rustfmt::skip]
17126pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkMemoryAllocateFlagBits = 0x00000004;
17127
17128#[cfg(feature = "VK_KHR_timeline_semaphore")]
17129#[rustfmt::skip]
17130pub type VkSemaphoreWaitFlagsKHR = VkFlags;
17131#[cfg(feature = "Allow1_2APIs")]
17132#[rustfmt::skip]
17133pub type VkSemaphoreWaitFlags = VkSemaphoreWaitFlagsKHR;
17134#[cfg(feature = "VK_KHR_timeline_semaphore")]
17135#[rustfmt::skip]
17136pub type VkSemaphoreWaitFlagBitsKHR = VkFlags;
17137#[cfg(feature = "Allow1_2APIs")]
17138#[rustfmt::skip]
17139pub type VkSemaphoreWaitFlagBits = VkSemaphoreWaitFlagBitsKHR;
17140#[cfg(feature = "VK_KHR_timeline_semaphore")]
17141#[rustfmt::skip]
17142pub const VK_SEMAPHORE_WAIT_ANY_BIT_KHR: VkSemaphoreWaitFlagBitsKHR = 0x00000001;
17143#[cfg(feature = "Allow1_2APIs")]
17144#[rustfmt::skip]
17145pub const VK_SEMAPHORE_WAIT_ANY_BIT: VkSemaphoreWaitFlagBitsKHR = 0x00000001;
17146
17147#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17148#[derive(Debug, Clone)]
17149#[repr(C)]
17150#[rustfmt::skip]
17151pub struct VkBufferDeviceAddressInfoKHR {
17152    pub sType: VkStructureType,
17153    pub pNext: *const core::ffi::c_void,
17154    pub buffer: VkBuffer,
17155}
17156#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17157#[rustfmt::skip]
17158pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR: VkStructureType = 1000244001;
17159#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17160#[rustfmt::skip]
17161unsafe impl crate::VulkanStructure for VkBufferDeviceAddressInfoKHR {
17162    #[inline(always)]
17163    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17164        unsafe { core::mem::transmute(self) }
17165    }
17166
17167    #[inline(always)]
17168    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17169        unsafe { core::mem::transmute(self) }
17170    }
17171}
17172#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17173#[rustfmt::skip]
17174unsafe impl crate::TypedVulkanStructure for VkBufferDeviceAddressInfoKHR {
17175    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR;
17176}
17177#[cfg(feature = "Allow1_2APIs")]
17178#[rustfmt::skip]
17179pub type VkBufferDeviceAddressInfo = VkBufferDeviceAddressInfoKHR;
17180#[cfg(feature = "Allow1_2APIs")]
17181#[rustfmt::skip]
17182pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR;
17183
17184#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17185#[derive(Debug, Clone)]
17186#[repr(C)]
17187#[rustfmt::skip]
17188pub struct VkBufferOpaqueCaptureAddressCreateInfoKHR {
17189    pub sType: VkStructureType,
17190    pub pNext: *const core::ffi::c_void,
17191    pub opaqueCaptureAddress: u64,
17192}
17193#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17194#[rustfmt::skip]
17195pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: VkStructureType = 1000257002;
17196#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17197#[rustfmt::skip]
17198unsafe impl crate::VulkanStructure for VkBufferOpaqueCaptureAddressCreateInfoKHR {
17199    #[inline(always)]
17200    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17201        unsafe { core::mem::transmute(self) }
17202    }
17203
17204    #[inline(always)]
17205    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17206        unsafe { core::mem::transmute(self) }
17207    }
17208}
17209#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17210#[rustfmt::skip]
17211unsafe impl crate::TypedVulkanStructure for VkBufferOpaqueCaptureAddressCreateInfoKHR {
17212    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR;
17213}
17214#[cfg(feature = "Allow1_2APIs")]
17215#[rustfmt::skip]
17216pub type VkBufferOpaqueCaptureAddressCreateInfo = VkBufferOpaqueCaptureAddressCreateInfoKHR;
17217#[cfg(feature = "Allow1_2APIs")]
17218#[rustfmt::skip]
17219pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR;
17220
17221#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17222#[derive(Debug, Clone)]
17223#[repr(C)]
17224#[rustfmt::skip]
17225pub struct VkDeviceMemoryOpaqueCaptureAddressInfoKHR {
17226    pub sType: VkStructureType,
17227    pub pNext: *const core::ffi::c_void,
17228    pub memory: VkDeviceMemory,
17229}
17230#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17231#[rustfmt::skip]
17232pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: VkStructureType = 1000257004;
17233#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17234#[rustfmt::skip]
17235unsafe impl crate::VulkanStructure for VkDeviceMemoryOpaqueCaptureAddressInfoKHR {
17236    #[inline(always)]
17237    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17238        unsafe { core::mem::transmute(self) }
17239    }
17240
17241    #[inline(always)]
17242    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17243        unsafe { core::mem::transmute(self) }
17244    }
17245}
17246#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17247#[rustfmt::skip]
17248unsafe impl crate::TypedVulkanStructure for VkDeviceMemoryOpaqueCaptureAddressInfoKHR {
17249    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR;
17250}
17251#[cfg(feature = "Allow1_2APIs")]
17252#[rustfmt::skip]
17253pub type VkDeviceMemoryOpaqueCaptureAddressInfo = VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
17254#[cfg(feature = "Allow1_2APIs")]
17255#[rustfmt::skip]
17256pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR;
17257
17258#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17259#[derive(Debug, Clone)]
17260#[repr(C)]
17261#[rustfmt::skip]
17262pub struct VkMemoryOpaqueCaptureAddressAllocateInfoKHR {
17263    pub sType: VkStructureType,
17264    pub pNext: *const core::ffi::c_void,
17265    pub opaqueCaptureAddress: u64,
17266}
17267#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17268#[rustfmt::skip]
17269pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: VkStructureType = 1000257003;
17270#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17271#[rustfmt::skip]
17272unsafe impl crate::VulkanStructure for VkMemoryOpaqueCaptureAddressAllocateInfoKHR {
17273    #[inline(always)]
17274    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17275        unsafe { core::mem::transmute(self) }
17276    }
17277
17278    #[inline(always)]
17279    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17280        unsafe { core::mem::transmute(self) }
17281    }
17282}
17283#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17284#[rustfmt::skip]
17285unsafe impl crate::TypedVulkanStructure for VkMemoryOpaqueCaptureAddressAllocateInfoKHR {
17286    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR;
17287}
17288#[cfg(feature = "Allow1_2APIs")]
17289#[rustfmt::skip]
17290pub type VkMemoryOpaqueCaptureAddressAllocateInfo = VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
17291#[cfg(feature = "Allow1_2APIs")]
17292#[rustfmt::skip]
17293pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR;
17294
17295#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17296#[derive(Debug, Clone)]
17297#[repr(C)]
17298#[rustfmt::skip]
17299pub struct VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
17300    pub sType: VkStructureType,
17301    pub pNext: *mut core::ffi::c_void,
17302    pub bufferDeviceAddress: VkBool32,
17303    pub bufferDeviceAddressCaptureReplay: VkBool32,
17304    pub bufferDeviceAddressMultiDevice: VkBool32,
17305}
17306#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17307#[rustfmt::skip]
17308pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: VkStructureType = 1000257000;
17309#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17310#[rustfmt::skip]
17311unsafe impl crate::VulkanStructure for VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
17312    #[inline(always)]
17313    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17314        unsafe { core::mem::transmute(self) }
17315    }
17316
17317    #[inline(always)]
17318    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17319        unsafe { core::mem::transmute(self) }
17320    }
17321}
17322#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17323#[rustfmt::skip]
17324unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
17325    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
17326}
17327#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17328#[rustfmt::skip]
17329unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
17330    #[inline(always)]
17331    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
17332        unsafe { core::mem::transmute(self) }
17333    }
17334
17335    #[inline(always)]
17336    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
17337        unsafe { core::mem::transmute(self) }
17338    }
17339}
17340#[cfg(all(feature = "VK_KHR_buffer_device_address"))]
17341#[rustfmt::skip]
17342unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceBufferDeviceAddressFeaturesKHR {
17343    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
17344}
17345#[cfg(feature = "Allow1_2APIs")]
17346#[rustfmt::skip]
17347pub type VkPhysicalDeviceBufferDeviceAddressFeatures = VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
17348#[cfg(feature = "Allow1_2APIs")]
17349#[rustfmt::skip]
17350pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR;
17351
17352#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17353#[derive(Debug, Clone)]
17354#[repr(C)]
17355#[rustfmt::skip]
17356pub struct VkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
17357    pub sType: VkStructureType,
17358    pub pNext: *mut core::ffi::c_void,
17359    pub timelineSemaphore: VkBool32,
17360}
17361#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17362#[rustfmt::skip]
17363pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: VkStructureType = 1000207000;
17364#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17365#[rustfmt::skip]
17366unsafe impl crate::VulkanStructure for VkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
17367    #[inline(always)]
17368    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17369        unsafe { core::mem::transmute(self) }
17370    }
17371
17372    #[inline(always)]
17373    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17374        unsafe { core::mem::transmute(self) }
17375    }
17376}
17377#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17378#[rustfmt::skip]
17379unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
17380    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR;
17381}
17382#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17383#[rustfmt::skip]
17384unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
17385    #[inline(always)]
17386    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
17387        unsafe { core::mem::transmute(self) }
17388    }
17389
17390    #[inline(always)]
17391    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
17392        unsafe { core::mem::transmute(self) }
17393    }
17394}
17395#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17396#[rustfmt::skip]
17397unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceTimelineSemaphoreFeaturesKHR {
17398    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR;
17399}
17400#[cfg(feature = "Allow1_2APIs")]
17401#[rustfmt::skip]
17402pub type VkPhysicalDeviceTimelineSemaphoreFeatures = VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
17403#[cfg(feature = "Allow1_2APIs")]
17404#[rustfmt::skip]
17405pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR;
17406
17407#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17408#[derive(Debug, Clone)]
17409#[repr(C)]
17410#[rustfmt::skip]
17411pub struct VkPhysicalDeviceTimelineSemaphorePropertiesKHR {
17412    pub sType: VkStructureType,
17413    pub pNext: *mut core::ffi::c_void,
17414    pub maxTimelineSemaphoreValueDifference: u64,
17415}
17416#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17417#[rustfmt::skip]
17418pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: VkStructureType = 1000207001;
17419#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17420#[rustfmt::skip]
17421unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceTimelineSemaphorePropertiesKHR {
17422    #[inline(always)]
17423    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
17424        unsafe { core::mem::transmute(self) }
17425    }
17426
17427    #[inline(always)]
17428    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
17429        unsafe { core::mem::transmute(self) }
17430    }
17431}
17432#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17433#[rustfmt::skip]
17434unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceTimelineSemaphorePropertiesKHR {
17435    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR;
17436}
17437#[cfg(feature = "Allow1_2APIs")]
17438#[rustfmt::skip]
17439pub type VkPhysicalDeviceTimelineSemaphoreProperties = VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
17440#[cfg(feature = "Allow1_2APIs")]
17441#[rustfmt::skip]
17442pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR;
17443
17444#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17445#[derive(Debug, Clone)]
17446#[repr(C)]
17447#[rustfmt::skip]
17448pub struct VkSemaphoreSignalInfoKHR {
17449    pub sType: VkStructureType,
17450    pub pNext: *const core::ffi::c_void,
17451    pub semaphore: VkSemaphore,
17452    pub value: u64,
17453}
17454#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17455#[rustfmt::skip]
17456pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR: VkStructureType = 1000207005;
17457#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17458#[rustfmt::skip]
17459unsafe impl crate::VulkanStructure for VkSemaphoreSignalInfoKHR {
17460    #[inline(always)]
17461    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17462        unsafe { core::mem::transmute(self) }
17463    }
17464
17465    #[inline(always)]
17466    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17467        unsafe { core::mem::transmute(self) }
17468    }
17469}
17470#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17471#[rustfmt::skip]
17472unsafe impl crate::TypedVulkanStructure for VkSemaphoreSignalInfoKHR {
17473    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR;
17474}
17475#[cfg(feature = "Allow1_2APIs")]
17476#[rustfmt::skip]
17477pub type VkSemaphoreSignalInfo = VkSemaphoreSignalInfoKHR;
17478#[cfg(feature = "Allow1_2APIs")]
17479#[rustfmt::skip]
17480pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR;
17481
17482#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17483#[derive(Debug, Clone)]
17484#[repr(C)]
17485#[rustfmt::skip]
17486pub struct VkSemaphoreTypeCreateInfoKHR {
17487    pub sType: VkStructureType,
17488    pub pNext: *const core::ffi::c_void,
17489    pub semaphoreType: VkSemaphoreTypeKHR,
17490    pub initialValue: u64,
17491}
17492#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17493#[rustfmt::skip]
17494pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR: VkStructureType = 1000207002;
17495#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17496#[rustfmt::skip]
17497unsafe impl crate::VulkanStructure for VkSemaphoreTypeCreateInfoKHR {
17498    #[inline(always)]
17499    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17500        unsafe { core::mem::transmute(self) }
17501    }
17502
17503    #[inline(always)]
17504    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17505        unsafe { core::mem::transmute(self) }
17506    }
17507}
17508#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17509#[rustfmt::skip]
17510unsafe impl crate::TypedVulkanStructure for VkSemaphoreTypeCreateInfoKHR {
17511    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR;
17512}
17513#[cfg(feature = "Allow1_2APIs")]
17514#[rustfmt::skip]
17515pub type VkSemaphoreTypeCreateInfo = VkSemaphoreTypeCreateInfoKHR;
17516#[cfg(feature = "Allow1_2APIs")]
17517#[rustfmt::skip]
17518pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR;
17519
17520#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17521#[derive(Debug, Clone)]
17522#[repr(C)]
17523#[rustfmt::skip]
17524pub struct VkSemaphoreWaitInfoKHR {
17525    pub sType: VkStructureType,
17526    pub pNext: *const core::ffi::c_void,
17527    pub flags: VkSemaphoreWaitFlagsKHR,
17528    pub semaphoreCount: u32,
17529    pub pSemaphores: *const VkSemaphore,
17530    pub pValues: *const u64,
17531}
17532#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17533#[rustfmt::skip]
17534pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR: VkStructureType = 1000207004;
17535#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17536#[rustfmt::skip]
17537unsafe impl crate::VulkanStructure for VkSemaphoreWaitInfoKHR {
17538    #[inline(always)]
17539    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17540        unsafe { core::mem::transmute(self) }
17541    }
17542
17543    #[inline(always)]
17544    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17545        unsafe { core::mem::transmute(self) }
17546    }
17547}
17548#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17549#[rustfmt::skip]
17550unsafe impl crate::TypedVulkanStructure for VkSemaphoreWaitInfoKHR {
17551    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR;
17552}
17553#[cfg(feature = "Allow1_2APIs")]
17554#[rustfmt::skip]
17555pub type VkSemaphoreWaitInfo = VkSemaphoreWaitInfoKHR;
17556#[cfg(feature = "Allow1_2APIs")]
17557#[rustfmt::skip]
17558pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR;
17559
17560#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17561#[derive(Debug, Clone)]
17562#[repr(C)]
17563#[rustfmt::skip]
17564pub struct VkTimelineSemaphoreSubmitInfoKHR {
17565    pub sType: VkStructureType,
17566    pub pNext: *const core::ffi::c_void,
17567    pub waitSemaphoreValueCount: u32,
17568    pub pWaitSemaphoreValues: *const u64,
17569    pub signalSemaphoreValueCount: u32,
17570    pub pSignalSemaphoreValues: *const u64,
17571}
17572#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17573#[rustfmt::skip]
17574pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = 1000207003;
17575#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17576#[rustfmt::skip]
17577unsafe impl crate::VulkanStructure for VkTimelineSemaphoreSubmitInfoKHR {
17578    #[inline(always)]
17579    fn as_generic(&self) -> &crate::GenericVulkanStructure {
17580        unsafe { core::mem::transmute(self) }
17581    }
17582
17583    #[inline(always)]
17584    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
17585        unsafe { core::mem::transmute(self) }
17586    }
17587}
17588#[cfg(all(feature = "VK_KHR_timeline_semaphore"))]
17589#[rustfmt::skip]
17590unsafe impl crate::TypedVulkanStructure for VkTimelineSemaphoreSubmitInfoKHR {
17591    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR;
17592}
17593#[cfg(feature = "Allow1_2APIs")]
17594#[rustfmt::skip]
17595pub type VkTimelineSemaphoreSubmitInfo = VkTimelineSemaphoreSubmitInfoKHR;
17596#[cfg(feature = "Allow1_2APIs")]
17597#[rustfmt::skip]
17598pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: VkStructureType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR;
17599
17600#[cfg(feature = "Implements")]
17601#[cfg(feature = "VK_KHR_buffer_device_address")]
17602#[repr(transparent)]
17603#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17604#[rustfmt::skip]
17605pub struct PFN_vkGetBufferDeviceAddressKHR(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfoKHR) -> VkDeviceAddress);
17606#[cfg(feature = "Implements")]
17607#[cfg(feature = "VK_KHR_buffer_device_address")]
17608#[rustfmt::skip]
17609unsafe impl crate::resolver::PFN for PFN_vkGetBufferDeviceAddressKHR {
17610    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetBufferDeviceAddressKHR";
17611
17612    #[inline(always)]
17613    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17614        unsafe { core::mem::transmute(p) }
17615    }
17616    #[inline(always)]
17617    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17618        unsafe { core::mem::transmute(p) }
17619    }
17620}
17621#[cfg(feature = "Implements")]
17622#[cfg(feature = "Allow1_2APIs")]
17623#[repr(transparent)]
17624#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17625#[rustfmt::skip]
17626pub struct PFN_vkGetBufferDeviceAddress(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfoKHR) -> VkDeviceAddress);
17627#[cfg(feature = "Implements")]
17628#[cfg(feature = "Allow1_2APIs")]
17629#[rustfmt::skip]
17630unsafe impl crate::resolver::PFN for PFN_vkGetBufferDeviceAddress {
17631    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetBufferDeviceAddress";
17632
17633    #[inline(always)]
17634    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17635        unsafe { core::mem::transmute(p) }
17636    }
17637    #[inline(always)]
17638    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17639        unsafe { core::mem::transmute(p) }
17640    }
17641}
17642#[cfg(feature = "Implements")]
17643#[cfg(not(feature = "DynamicLoaded"))]
17644#[cfg(feature = "Allow1_2APIs")]
17645#[rustfmt::skip]
17646impl crate::resolver::StaticCallable for PFN_vkGetBufferDeviceAddress {
17647    const STATIC: Self = Self(vkGetBufferDeviceAddress);
17648}
17649
17650#[cfg(feature = "Implements")]
17651#[cfg(feature = "VK_KHR_buffer_device_address")]
17652#[repr(transparent)]
17653#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17654#[rustfmt::skip]
17655pub struct PFN_vkGetBufferOpaqueCaptureAddressKHR(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfoKHR) -> u64);
17656#[cfg(feature = "Implements")]
17657#[cfg(feature = "VK_KHR_buffer_device_address")]
17658#[rustfmt::skip]
17659unsafe impl crate::resolver::PFN for PFN_vkGetBufferOpaqueCaptureAddressKHR {
17660    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetBufferOpaqueCaptureAddressKHR";
17661
17662    #[inline(always)]
17663    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17664        unsafe { core::mem::transmute(p) }
17665    }
17666    #[inline(always)]
17667    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17668        unsafe { core::mem::transmute(p) }
17669    }
17670}
17671#[cfg(feature = "Implements")]
17672#[cfg(feature = "Allow1_2APIs")]
17673#[repr(transparent)]
17674#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17675#[rustfmt::skip]
17676pub struct PFN_vkGetBufferOpaqueCaptureAddress(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfoKHR) -> u64);
17677#[cfg(feature = "Implements")]
17678#[cfg(feature = "Allow1_2APIs")]
17679#[rustfmt::skip]
17680unsafe impl crate::resolver::PFN for PFN_vkGetBufferOpaqueCaptureAddress {
17681    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetBufferOpaqueCaptureAddress";
17682
17683    #[inline(always)]
17684    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17685        unsafe { core::mem::transmute(p) }
17686    }
17687    #[inline(always)]
17688    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17689        unsafe { core::mem::transmute(p) }
17690    }
17691}
17692#[cfg(feature = "Implements")]
17693#[cfg(not(feature = "DynamicLoaded"))]
17694#[cfg(feature = "Allow1_2APIs")]
17695#[rustfmt::skip]
17696impl crate::resolver::StaticCallable for PFN_vkGetBufferOpaqueCaptureAddress {
17697    const STATIC: Self = Self(vkGetBufferOpaqueCaptureAddress);
17698}
17699
17700#[cfg(feature = "Implements")]
17701#[cfg(feature = "VK_KHR_buffer_device_address")]
17702#[repr(transparent)]
17703#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17704#[rustfmt::skip]
17705pub struct PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfoKHR) -> u64);
17706#[cfg(feature = "Implements")]
17707#[cfg(feature = "VK_KHR_buffer_device_address")]
17708#[rustfmt::skip]
17709unsafe impl crate::resolver::PFN for PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR {
17710    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceMemoryOpaqueCaptureAddressKHR";
17711
17712    #[inline(always)]
17713    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17714        unsafe { core::mem::transmute(p) }
17715    }
17716    #[inline(always)]
17717    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17718        unsafe { core::mem::transmute(p) }
17719    }
17720}
17721#[cfg(feature = "Implements")]
17722#[cfg(feature = "Allow1_2APIs")]
17723#[repr(transparent)]
17724#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17725#[rustfmt::skip]
17726pub struct PFN_vkGetDeviceMemoryOpaqueCaptureAddress(pub unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfoKHR) -> u64);
17727#[cfg(feature = "Implements")]
17728#[cfg(feature = "Allow1_2APIs")]
17729#[rustfmt::skip]
17730unsafe impl crate::resolver::PFN for PFN_vkGetDeviceMemoryOpaqueCaptureAddress {
17731    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDeviceMemoryOpaqueCaptureAddress";
17732
17733    #[inline(always)]
17734    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17735        unsafe { core::mem::transmute(p) }
17736    }
17737    #[inline(always)]
17738    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17739        unsafe { core::mem::transmute(p) }
17740    }
17741}
17742#[cfg(feature = "Implements")]
17743#[cfg(not(feature = "DynamicLoaded"))]
17744#[cfg(feature = "Allow1_2APIs")]
17745#[rustfmt::skip]
17746impl crate::resolver::StaticCallable for PFN_vkGetDeviceMemoryOpaqueCaptureAddress {
17747    const STATIC: Self = Self(vkGetDeviceMemoryOpaqueCaptureAddress);
17748}
17749
17750#[cfg(feature = "Implements")]
17751#[cfg(feature = "VK_KHR_timeline_semaphore")]
17752#[repr(transparent)]
17753#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17754#[rustfmt::skip]
17755pub struct PFN_vkGetSemaphoreCounterValueKHR(pub unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult);
17756#[cfg(feature = "Implements")]
17757#[cfg(feature = "VK_KHR_timeline_semaphore")]
17758#[rustfmt::skip]
17759unsafe impl crate::resolver::PFN for PFN_vkGetSemaphoreCounterValueKHR {
17760    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetSemaphoreCounterValueKHR";
17761
17762    #[inline(always)]
17763    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17764        unsafe { core::mem::transmute(p) }
17765    }
17766    #[inline(always)]
17767    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17768        unsafe { core::mem::transmute(p) }
17769    }
17770}
17771#[cfg(feature = "Implements")]
17772#[cfg(feature = "Allow1_2APIs")]
17773#[repr(transparent)]
17774#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17775#[rustfmt::skip]
17776pub struct PFN_vkGetSemaphoreCounterValue(pub unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult);
17777#[cfg(feature = "Implements")]
17778#[cfg(feature = "Allow1_2APIs")]
17779#[rustfmt::skip]
17780unsafe impl crate::resolver::PFN for PFN_vkGetSemaphoreCounterValue {
17781    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetSemaphoreCounterValue";
17782
17783    #[inline(always)]
17784    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17785        unsafe { core::mem::transmute(p) }
17786    }
17787    #[inline(always)]
17788    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17789        unsafe { core::mem::transmute(p) }
17790    }
17791}
17792#[cfg(feature = "Implements")]
17793#[cfg(not(feature = "DynamicLoaded"))]
17794#[cfg(feature = "Allow1_2APIs")]
17795#[rustfmt::skip]
17796impl crate::resolver::StaticCallable for PFN_vkGetSemaphoreCounterValue {
17797    const STATIC: Self = Self(vkGetSemaphoreCounterValue);
17798}
17799
17800#[cfg(feature = "Implements")]
17801#[cfg(feature = "VK_KHR_timeline_semaphore")]
17802#[repr(transparent)]
17803#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17804#[rustfmt::skip]
17805pub struct PFN_vkSignalSemaphoreKHR(pub unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfoKHR) -> VkResult);
17806#[cfg(feature = "Implements")]
17807#[cfg(feature = "VK_KHR_timeline_semaphore")]
17808#[rustfmt::skip]
17809unsafe impl crate::resolver::PFN for PFN_vkSignalSemaphoreKHR {
17810    const NAME_CSTR: &'static core::ffi::CStr = c"vkSignalSemaphoreKHR";
17811
17812    #[inline(always)]
17813    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17814        unsafe { core::mem::transmute(p) }
17815    }
17816    #[inline(always)]
17817    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17818        unsafe { core::mem::transmute(p) }
17819    }
17820}
17821#[cfg(feature = "Implements")]
17822#[cfg(feature = "Allow1_2APIs")]
17823#[repr(transparent)]
17824#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17825#[rustfmt::skip]
17826pub struct PFN_vkSignalSemaphore(pub unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfoKHR) -> VkResult);
17827#[cfg(feature = "Implements")]
17828#[cfg(feature = "Allow1_2APIs")]
17829#[rustfmt::skip]
17830unsafe impl crate::resolver::PFN for PFN_vkSignalSemaphore {
17831    const NAME_CSTR: &'static core::ffi::CStr = c"vkSignalSemaphore";
17832
17833    #[inline(always)]
17834    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17835        unsafe { core::mem::transmute(p) }
17836    }
17837    #[inline(always)]
17838    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17839        unsafe { core::mem::transmute(p) }
17840    }
17841}
17842#[cfg(feature = "Implements")]
17843#[cfg(not(feature = "DynamicLoaded"))]
17844#[cfg(feature = "Allow1_2APIs")]
17845#[rustfmt::skip]
17846impl crate::resolver::StaticCallable for PFN_vkSignalSemaphore {
17847    const STATIC: Self = Self(vkSignalSemaphore);
17848}
17849
17850#[cfg(feature = "Implements")]
17851#[cfg(feature = "VK_KHR_timeline_semaphore")]
17852#[repr(transparent)]
17853#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17854#[rustfmt::skip]
17855pub struct PFN_vkWaitSemaphoresKHR(pub unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfoKHR, timeout: u64) -> VkResult);
17856#[cfg(feature = "Implements")]
17857#[cfg(feature = "VK_KHR_timeline_semaphore")]
17858#[rustfmt::skip]
17859unsafe impl crate::resolver::PFN for PFN_vkWaitSemaphoresKHR {
17860    const NAME_CSTR: &'static core::ffi::CStr = c"vkWaitSemaphoresKHR";
17861
17862    #[inline(always)]
17863    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17864        unsafe { core::mem::transmute(p) }
17865    }
17866    #[inline(always)]
17867    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17868        unsafe { core::mem::transmute(p) }
17869    }
17870}
17871#[cfg(feature = "Implements")]
17872#[cfg(feature = "Allow1_2APIs")]
17873#[repr(transparent)]
17874#[derive(Debug, Clone, Copy, PartialEq, Eq)]
17875#[rustfmt::skip]
17876pub struct PFN_vkWaitSemaphores(pub unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfoKHR, timeout: u64) -> VkResult);
17877#[cfg(feature = "Implements")]
17878#[cfg(feature = "Allow1_2APIs")]
17879#[rustfmt::skip]
17880unsafe impl crate::resolver::PFN for PFN_vkWaitSemaphores {
17881    const NAME_CSTR: &'static core::ffi::CStr = c"vkWaitSemaphores";
17882
17883    #[inline(always)]
17884    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
17885        unsafe { core::mem::transmute(p) }
17886    }
17887    #[inline(always)]
17888    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
17889        unsafe { core::mem::transmute(p) }
17890    }
17891}
17892#[cfg(feature = "Implements")]
17893#[cfg(not(feature = "DynamicLoaded"))]
17894#[cfg(feature = "Allow1_2APIs")]
17895#[rustfmt::skip]
17896impl crate::resolver::StaticCallable for PFN_vkWaitSemaphores {
17897    const STATIC: Self = Self(vkWaitSemaphores);
17898}
17899
17900#[cfg(feature = "VK_EXT_acquire_drm_display")]
17901#[rustfmt::skip]
17902pub const VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME: &'static str = "VK_EXT_acquire_drm_display";
17903#[cfg(feature = "VK_EXT_acquire_drm_display")]
17904#[rustfmt::skip]
17905pub const VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION: usize = 1;
17906
17907#[cfg(feature = "VK_EXT_acquire_xlib_display")]
17908#[rustfmt::skip]
17909pub const VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME: &'static str = "VK_EXT_acquire_xlib_display";
17910#[cfg(feature = "VK_EXT_acquire_xlib_display")]
17911#[rustfmt::skip]
17912pub const VK_EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION: usize = 1;
17913
17914#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17915#[rustfmt::skip]
17916pub const VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME: &'static str = "VK_EXT_blend_operation_advanced";
17917#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17918#[rustfmt::skip]
17919pub const VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION: usize = 2;
17920
17921#[cfg(feature = "VK_AMD_buffer_marker")]
17922#[rustfmt::skip]
17923pub const VK_AMD_BUFFER_MARKER_EXTENSION_NAME: &'static str = "VK_AMD_buffer_marker";
17924#[cfg(feature = "VK_AMD_buffer_marker")]
17925#[rustfmt::skip]
17926pub const VK_AMD_BUFFER_MARKER_SPEC_VERSION: usize = 1;
17927
17928#[cfg(feature = "VK_NV_acquire_winrt_display")]
17929#[rustfmt::skip]
17930pub const VK_NV_ACQUIRE_WINRT_DISPLAY_EXTENSION_NAME: &'static str = "VK_NV_acquire_winrt_display";
17931#[cfg(feature = "VK_NV_acquire_winrt_display")]
17932#[rustfmt::skip]
17933pub const VK_NV_ACQUIRE_WINRT_DISPLAY_SPEC_VERSION: usize = 1;
17934
17935#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17936#[rustfmt::skip]
17937pub const VK_BLEND_OP_ZERO_EXT: VkBlendOp = 1000148000;
17938#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17939#[rustfmt::skip]
17940pub const VK_BLEND_OP_SRC_EXT: VkBlendOp = 1000148001;
17941#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17942#[rustfmt::skip]
17943pub const VK_BLEND_OP_DST_EXT: VkBlendOp = 1000148002;
17944#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17945#[rustfmt::skip]
17946pub const VK_BLEND_OP_SRC_OVER_EXT: VkBlendOp = 1000148003;
17947#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17948#[rustfmt::skip]
17949pub const VK_BLEND_OP_DST_OVER_EXT: VkBlendOp = 1000148004;
17950#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17951#[rustfmt::skip]
17952pub const VK_BLEND_OP_SRC_IN_EXT: VkBlendOp = 1000148005;
17953#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17954#[rustfmt::skip]
17955pub const VK_BLEND_OP_DST_IN_EXT: VkBlendOp = 1000148006;
17956#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17957#[rustfmt::skip]
17958pub const VK_BLEND_OP_SRC_OUT_EXT: VkBlendOp = 1000148007;
17959#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17960#[rustfmt::skip]
17961pub const VK_BLEND_OP_DST_OUT_EXT: VkBlendOp = 1000148008;
17962#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17963#[rustfmt::skip]
17964pub const VK_BLEND_OP_SRC_ATOP_EXT: VkBlendOp = 1000148009;
17965#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17966#[rustfmt::skip]
17967pub const VK_BLEND_OP_DST_ATOP_EXT: VkBlendOp = 1000148010;
17968#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17969#[rustfmt::skip]
17970pub const VK_BLEND_OP_XOR_EXT: VkBlendOp = 1000148011;
17971#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17972#[rustfmt::skip]
17973pub const VK_BLEND_OP_MULTIPLY_EXT: VkBlendOp = 1000148012;
17974#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17975#[rustfmt::skip]
17976pub const VK_BLEND_OP_SCREEN_EXT: VkBlendOp = 1000148013;
17977#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17978#[rustfmt::skip]
17979pub const VK_BLEND_OP_OVERLAY_EXT: VkBlendOp = 1000148014;
17980#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17981#[rustfmt::skip]
17982pub const VK_BLEND_OP_DARKEN_EXT: VkBlendOp = 1000148015;
17983#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17984#[rustfmt::skip]
17985pub const VK_BLEND_OP_LIGHTEN_EXT: VkBlendOp = 1000148016;
17986#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17987#[rustfmt::skip]
17988pub const VK_BLEND_OP_COLORDODGE_EXT: VkBlendOp = 1000148017;
17989#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17990#[rustfmt::skip]
17991pub const VK_BLEND_OP_COLORBURN_EXT: VkBlendOp = 1000148018;
17992#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17993#[rustfmt::skip]
17994pub const VK_BLEND_OP_HARDLIGHT_EXT: VkBlendOp = 1000148019;
17995#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17996#[rustfmt::skip]
17997pub const VK_BLEND_OP_SOFTLIGHT_EXT: VkBlendOp = 1000148020;
17998#[cfg(feature = "VK_EXT_blend_operation_advanced")]
17999#[rustfmt::skip]
18000pub const VK_BLEND_OP_DIFFERENCE_EXT: VkBlendOp = 1000148021;
18001#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18002#[rustfmt::skip]
18003pub const VK_BLEND_OP_EXCLUSION_EXT: VkBlendOp = 1000148022;
18004#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18005#[rustfmt::skip]
18006pub const VK_BLEND_OP_INVERT_EXT: VkBlendOp = 1000148023;
18007#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18008#[rustfmt::skip]
18009pub const VK_BLEND_OP_INVERT_RGB_EXT: VkBlendOp = 1000148024;
18010#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18011#[rustfmt::skip]
18012pub const VK_BLEND_OP_LINEARDODGE_EXT: VkBlendOp = 1000148025;
18013#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18014#[rustfmt::skip]
18015pub const VK_BLEND_OP_LINEARBURN_EXT: VkBlendOp = 1000148026;
18016#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18017#[rustfmt::skip]
18018pub const VK_BLEND_OP_VIVIDLIGHT_EXT: VkBlendOp = 1000148027;
18019#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18020#[rustfmt::skip]
18021pub const VK_BLEND_OP_LINEARLIGHT_EXT: VkBlendOp = 1000148028;
18022#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18023#[rustfmt::skip]
18024pub const VK_BLEND_OP_PINLIGHT_EXT: VkBlendOp = 1000148029;
18025#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18026#[rustfmt::skip]
18027pub const VK_BLEND_OP_HARDMIX_EXT: VkBlendOp = 1000148030;
18028#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18029#[rustfmt::skip]
18030pub const VK_BLEND_OP_HSL_HUE_EXT: VkBlendOp = 1000148031;
18031#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18032#[rustfmt::skip]
18033pub const VK_BLEND_OP_HSL_SATURATION_EXT: VkBlendOp = 1000148032;
18034#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18035#[rustfmt::skip]
18036pub const VK_BLEND_OP_HSL_COLOR_EXT: VkBlendOp = 1000148033;
18037#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18038#[rustfmt::skip]
18039pub const VK_BLEND_OP_HSL_LUMINOSITY_EXT: VkBlendOp = 1000148034;
18040#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18041#[rustfmt::skip]
18042pub const VK_BLEND_OP_PLUS_EXT: VkBlendOp = 1000148035;
18043#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18044#[rustfmt::skip]
18045pub const VK_BLEND_OP_PLUS_CLAMPED_EXT: VkBlendOp = 1000148036;
18046#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18047#[rustfmt::skip]
18048pub const VK_BLEND_OP_PLUS_CLAMPED_ALHPA_EXT: VkBlendOp = 1000148037;
18049#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18050#[rustfmt::skip]
18051pub const VK_BLEND_OP_PLUS_DARKER_EXT: VkBlendOp = 1000148038;
18052#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18053#[rustfmt::skip]
18054pub const VK_BLEND_OP_MINUS_EXT: VkBlendOp = 1000148039;
18055#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18056#[rustfmt::skip]
18057pub const VK_BLEND_OP_MINUS_CLAMPED_EXT: VkBlendOp = 1000148040;
18058#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18059#[rustfmt::skip]
18060pub const VK_BLEND_OP_CONTRAST_EXT: VkBlendOp = 1000148041;
18061#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18062#[rustfmt::skip]
18063pub const VK_BLEND_OP_INVERT_OVG_EXT: VkBlendOp = 1000148042;
18064#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18065#[rustfmt::skip]
18066pub const VK_BLEND_OP_RED_EXT: VkBlendOp = 1000148043;
18067#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18068#[rustfmt::skip]
18069pub const VK_BLEND_OP_GREEN_EXT: VkBlendOp = 1000148044;
18070#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18071#[rustfmt::skip]
18072pub const VK_BLEND_OP_BLUE_EXT: VkBlendOp = 1000148045;
18073
18074#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18075#[rustfmt::skip]
18076pub type VkBlendOverlapEXT = i32;
18077#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18078#[rustfmt::skip]
18079pub const VK_BLEND_OVERLAP_UNCORRELATED_EXT: VkBlendOverlapEXT = 0;
18080#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18081#[rustfmt::skip]
18082pub const VK_BLEND_OVERLAP_DISJOINT_EXT: VkBlendOverlapEXT = 1;
18083#[cfg(feature = "VK_EXT_blend_operation_advanced")]
18084#[rustfmt::skip]
18085pub const VK_BLEND_OVERLAP_CONJOINT_EXT: VkBlendOverlapEXT = 2;
18086
18087#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18088#[derive(Debug, Clone)]
18089#[repr(C)]
18090#[rustfmt::skip]
18091pub struct VkPhysicalDeviceBlendOperationAdvanccedFeaturesEXT {
18092    pub sType: VkStructureType,
18093    pub pNext: *mut core::ffi::c_void,
18094    pub advancedBlendCoherentOperations: VkBool32,
18095}
18096#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18097#[rustfmt::skip]
18098pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: VkStructureType = 1000148000;
18099#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18100#[rustfmt::skip]
18101unsafe impl crate::VulkanStructure for VkPhysicalDeviceBlendOperationAdvanccedFeaturesEXT {
18102    #[inline(always)]
18103    fn as_generic(&self) -> &crate::GenericVulkanStructure {
18104        unsafe { core::mem::transmute(self) }
18105    }
18106
18107    #[inline(always)]
18108    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
18109        unsafe { core::mem::transmute(self) }
18110    }
18111}
18112#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18113#[rustfmt::skip]
18114unsafe impl crate::TypedVulkanStructure for VkPhysicalDeviceBlendOperationAdvanccedFeaturesEXT {
18115    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
18116}
18117#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18118#[rustfmt::skip]
18119unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceBlendOperationAdvanccedFeaturesEXT {
18120    #[inline(always)]
18121    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
18122        unsafe { core::mem::transmute(self) }
18123    }
18124
18125    #[inline(always)]
18126    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
18127        unsafe { core::mem::transmute(self) }
18128    }
18129}
18130#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18131#[rustfmt::skip]
18132unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceBlendOperationAdvanccedFeaturesEXT {
18133    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT;
18134}
18135
18136#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18137#[derive(Debug, Clone)]
18138#[repr(C)]
18139#[rustfmt::skip]
18140pub struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
18141    pub sType: VkStructureType,
18142    pub pNext: *mut core::ffi::c_void,
18143    pub advancedBlendMaxColorAttachments: u32,
18144    pub advancedBlendIndependentBlend: VkBool32,
18145    pub advancedBlendNonPremultipliedSrcColor: VkBool32,
18146    pub advancedBlendNonPremultipliedDstColor: VkBool32,
18147    pub advancedBlendCorrelatedOverlap: VkBool32,
18148    pub advancedBlendAllOperations: VkBool32,
18149}
18150#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18151#[rustfmt::skip]
18152pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: VkStructureType = 1000148001;
18153#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18154#[rustfmt::skip]
18155unsafe impl crate::VulkanSinkStructure for VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
18156    #[inline(always)]
18157    fn as_generic(&self) -> &crate::GenericVulkanSinkStructure {
18158        unsafe { core::mem::transmute(self) }
18159    }
18160
18161    #[inline(always)]
18162    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanSinkStructure {
18163        unsafe { core::mem::transmute(self) }
18164    }
18165}
18166#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18167#[rustfmt::skip]
18168unsafe impl crate::TypedVulkanSinkStructure for VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
18169    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT;
18170}
18171
18172#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18173#[derive(Debug, Clone)]
18174#[repr(C)]
18175#[rustfmt::skip]
18176pub struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
18177    pub sType: VkStructureType,
18178    pub pNext: *const core::ffi::c_void,
18179    pub srcPremultiplied: VkBool32,
18180    pub dstPremultiplied: VkBool32,
18181    pub blendOverlap: VkBlendOverlapEXT,
18182}
18183#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18184#[rustfmt::skip]
18185pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: VkStructureType = 1000148002;
18186#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18187#[rustfmt::skip]
18188unsafe impl crate::VulkanStructure for VkPipelineColorBlendAdvancedStateCreateInfoEXT {
18189    #[inline(always)]
18190    fn as_generic(&self) -> &crate::GenericVulkanStructure {
18191        unsafe { core::mem::transmute(self) }
18192    }
18193
18194    #[inline(always)]
18195    fn as_generic_mut(&mut self) -> &mut crate::GenericVulkanStructure {
18196        unsafe { core::mem::transmute(self) }
18197    }
18198}
18199#[cfg(all(feature = "VK_EXT_blend_operation_advanced"))]
18200#[rustfmt::skip]
18201unsafe impl crate::TypedVulkanStructure for VkPipelineColorBlendAdvancedStateCreateInfoEXT {
18202    const TYPE: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT;
18203}
18204
18205#[cfg(feature = "Implements")]
18206#[cfg(feature = "VK_EXT_acquire_drm_display")]
18207#[repr(transparent)]
18208#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18209#[rustfmt::skip]
18210pub struct PFN_vkAcquireDrmDisplayEXT(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, display: VkDisplayKHR) -> VkResult);
18211#[cfg(feature = "Implements")]
18212#[cfg(feature = "VK_EXT_acquire_drm_display")]
18213#[rustfmt::skip]
18214unsafe impl crate::resolver::PFN for PFN_vkAcquireDrmDisplayEXT {
18215    const NAME_CSTR: &'static core::ffi::CStr = c"vkAcquireDrmDisplayEXT";
18216
18217    #[inline(always)]
18218    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
18219        unsafe { core::mem::transmute(p) }
18220    }
18221    #[inline(always)]
18222    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
18223        unsafe { core::mem::transmute(p) }
18224    }
18225}
18226
18227#[cfg(feature = "Implements")]
18228#[cfg(feature = "VK_NV_acquire_winrt_display")]
18229#[repr(transparent)]
18230#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18231#[rustfmt::skip]
18232pub struct PFN_vkAcquireWinrtDisplayNV(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult);
18233#[cfg(feature = "Implements")]
18234#[cfg(feature = "VK_NV_acquire_winrt_display")]
18235#[rustfmt::skip]
18236unsafe impl crate::resolver::PFN for PFN_vkAcquireWinrtDisplayNV {
18237    const NAME_CSTR: &'static core::ffi::CStr = c"vkAcquireWinrtDisplayNV";
18238
18239    #[inline(always)]
18240    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
18241        unsafe { core::mem::transmute(p) }
18242    }
18243    #[inline(always)]
18244    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
18245        unsafe { core::mem::transmute(p) }
18246    }
18247}
18248
18249#[cfg(feature = "Implements")]
18250#[cfg(feature = "VK_EXT_acquire_xlib_display")]
18251#[repr(transparent)]
18252#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18253#[rustfmt::skip]
18254pub struct PFN_vkAcquireXlibDisplayEXT(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, dpy: *mut x11::xlib::Display, display: VkDisplayKHR) -> VkResult);
18255#[cfg(feature = "Implements")]
18256#[cfg(feature = "VK_EXT_acquire_xlib_display")]
18257#[rustfmt::skip]
18258unsafe impl crate::resolver::PFN for PFN_vkAcquireXlibDisplayEXT {
18259    const NAME_CSTR: &'static core::ffi::CStr = c"vkAcquireXlibDisplayEXT";
18260
18261    #[inline(always)]
18262    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
18263        unsafe { core::mem::transmute(p) }
18264    }
18265    #[inline(always)]
18266    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
18267        unsafe { core::mem::transmute(p) }
18268    }
18269}
18270
18271#[cfg(feature = "Implements")]
18272#[cfg(feature = "VK_EXT_acquire_drm_display")]
18273#[repr(transparent)]
18274#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18275#[rustfmt::skip]
18276pub struct PFN_vkGetDrmDisplayEXT(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, connectorId: u32, pDisplay: *mut VkDisplayKHR) -> VkResult);
18277#[cfg(feature = "Implements")]
18278#[cfg(feature = "VK_EXT_acquire_drm_display")]
18279#[rustfmt::skip]
18280unsafe impl crate::resolver::PFN for PFN_vkGetDrmDisplayEXT {
18281    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetDrmDisplayEXT";
18282
18283    #[inline(always)]
18284    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
18285        unsafe { core::mem::transmute(p) }
18286    }
18287    #[inline(always)]
18288    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
18289        unsafe { core::mem::transmute(p) }
18290    }
18291}
18292
18293#[cfg(feature = "Implements")]
18294#[cfg(feature = "VK_EXT_acquire_xlib_display")]
18295#[repr(transparent)]
18296#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18297#[rustfmt::skip]
18298pub struct PFN_vkGetRandROutputDisplayEXT(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, dpy: *mut x11::xlib::Display, rrOutput: x11::xrandr::RROutput, pDisplay: *mut VkDisplayKHR) -> VkResult);
18299#[cfg(feature = "Implements")]
18300#[cfg(feature = "VK_EXT_acquire_xlib_display")]
18301#[rustfmt::skip]
18302unsafe impl crate::resolver::PFN for PFN_vkGetRandROutputDisplayEXT {
18303    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetRandROutputDisplayEXT";
18304
18305    #[inline(always)]
18306    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
18307        unsafe { core::mem::transmute(p) }
18308    }
18309    #[inline(always)]
18310    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
18311        unsafe { core::mem::transmute(p) }
18312    }
18313}
18314
18315#[cfg(feature = "Implements")]
18316#[cfg(feature = "VK_NV_acquire_winrt_display")]
18317#[repr(transparent)]
18318#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18319#[rustfmt::skip]
18320pub struct PFN_vkGetWinrtDisplayNV(pub unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, deviceRelativeId: u32, pDisplay: *mut VkDisplayKHR) -> VkResult);
18321#[cfg(feature = "Implements")]
18322#[cfg(feature = "VK_NV_acquire_winrt_display")]
18323#[rustfmt::skip]
18324unsafe impl crate::resolver::PFN for PFN_vkGetWinrtDisplayNV {
18325    const NAME_CSTR: &'static core::ffi::CStr = c"vkGetWinrtDisplayNV";
18326
18327    #[inline(always)]
18328    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
18329        unsafe { core::mem::transmute(p) }
18330    }
18331    #[inline(always)]
18332    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
18333        unsafe { core::mem::transmute(p) }
18334    }
18335}
18336
18337#[cfg(feature = "Implements")]
18338#[cfg(feature = "VK_AMD_buffer_marker")]
18339#[repr(transparent)]
18340#[derive(Debug, Clone, Copy, PartialEq, Eq)]
18341#[rustfmt::skip]
18342pub struct PFN_vkCmdWriteBufferMarkerAMD(pub unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32));
18343#[cfg(feature = "Implements")]
18344#[cfg(feature = "VK_AMD_buffer_marker")]
18345#[rustfmt::skip]
18346unsafe impl crate::resolver::PFN for PFN_vkCmdWriteBufferMarkerAMD {
18347    const NAME_CSTR: &'static core::ffi::CStr = c"vkCmdWriteBufferMarkerAMD";
18348
18349    #[inline(always)]
18350    unsafe fn from_ptr(p: *const core::ffi::c_void) -> Self {
18351        unsafe { core::mem::transmute(p) }
18352    }
18353    #[inline(always)]
18354    unsafe fn from_void_fn(p: PFN_vkVoidFunction) -> Self {
18355        unsafe { core::mem::transmute(p) }
18356    }
18357}
18358
18359#[cfg(all(feature = "Implements", not(feature = "DynamicLoaded")))]
18360#[cfg_attr(all(not(windows), not(target_os = "macos"), not(feature = "DynamicLoaded")), link(name = "vulkan"))]
18361#[cfg_attr(all(windows, not(feature = "DynamicLoaded"), feature = "Implements"), link(name = "vulkan-1"))]
18362#[rustfmt::skip]
18363unsafe extern "system" {
18364    pub fn vkCreateInstance(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;
18365    pub fn vkDestroyInstance(instance: VkInstance, pAllocator: *const VkAllocationCallbacks);
18366    pub fn vkEnumeratePhysicalDevices(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;
18367    pub fn vkGetPhysicalDeviceFeatures(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures);
18368    pub fn vkGetPhysicalDeviceFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties);
18369    pub fn vkGetPhysicalDeviceImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;
18370    pub fn vkGetPhysicalDeviceProperties(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties);
18371    pub fn vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties);
18372    pub fn vkGetPhysicalDeviceMemoryProperties(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);
18373    pub fn vkGetInstanceProcAddr(instance: VkInstance, pName: *const core::ffi::c_char) -> Option<PFN_vkVoidFunction>;
18374    pub fn vkGetDeviceProcAddr(device: VkDevice, pName: *const core::ffi::c_char) -> Option<PFN_vkVoidFunction>;
18375    pub fn vkCreateDevice(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;
18376    pub fn vkDestroyDevice(device: VkDevice, pAllocator: *const VkAllocationCallbacks);
18377    pub fn vkEnumerateInstanceExtensionProperties(pLayerName: *const core::ffi::c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
18378    pub fn vkEnumerateDeviceExtensionProperties(physicalDevice: VkPhysicalDevice, pLayerName: *const core::ffi::c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
18379    pub fn vkEnumerateInstanceLayerProperties(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
18380    pub fn vkEnumerateDeviceLayerProperties(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
18381    pub fn vkGetDeviceQueue(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue);
18382    pub fn vkQueueSubmit(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;
18383    pub fn vkQueueWaitIdle(queue: VkQueue) -> VkResult;
18384    pub fn vkDeviceWaitIdle(device: VkDevice) -> VkResult;
18385    pub fn vkAllocateMemory(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;
18386    pub fn vkFreeMemory(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks);
18387    pub fn vkMapMemory(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut core::ffi::c_void) -> VkResult;
18388    pub fn vkUnmapMemory(device: VkDevice, memory: VkDeviceMemory);
18389    pub fn vkFlushMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
18390    pub fn vkInvalidateMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
18391    pub fn vkGetDeviceMemoryCommitment(device: VkDevice, memory: VkDeviceMemory, pCommitmentMemoryInBytes: *mut VkDeviceSize);
18392    pub fn vkBindBufferMemory(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
18393    pub fn vkBindImageMemory(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
18394    pub fn vkGetBufferMemoryRequirements(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements);
18395    pub fn vkGetImageMemoryRequirements(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements);
18396    pub fn vkGetImageSparseMemoryRequirements(device: VkDevice, image: VkImage, pSparseMemoryRequirementsCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);
18397    pub fn vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, r#type: VkImageType, samples: VkSampleCountFlags, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties);
18398    pub fn vkQueueBindSparse(queue: VkQueue, bindInfoCount: u32, pBindInfos: *const VkBindSparseInfo, fence: VkFence) -> VkResult;
18399    pub fn vkCreateFence(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
18400    pub fn vkDestroyFence(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks);
18401    pub fn vkResetFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult;
18402    pub fn vkGetFenceStatus(device: VkDevice, fence: VkFence) -> VkResult;
18403    pub fn vkWaitForFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult;
18404    pub fn vkCreateSemaphore(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;
18405    pub fn vkDestroySemaphore(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks);
18406    pub fn vkCreateEvent(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;
18407    pub fn vkDestroyEvent(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks);
18408    pub fn vkGetEventStatus(device: VkDevice, event: VkEvent) -> VkResult;
18409    pub fn vkSetEvent(device: VkDevice, event: VkEvent) -> VkResult;
18410    pub fn vkResetEvent(device: VkDevice, event: VkEvent) -> VkResult;
18411    pub fn vkCreateQueryPool(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;
18412    pub fn vkDestroyQueryPool(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks);
18413    pub fn vkGetQueryPoolResults(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *mut core::ffi::c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult;
18414    pub fn vkCreateBuffer(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;
18415    pub fn vkDestroyBuffer(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks);
18416    pub fn vkCreateBufferView(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;
18417    pub fn vkDestroyBufferView(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks);
18418    pub fn vkCreateImage(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;
18419    pub fn vkDestroyImage(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks);
18420    pub fn vkGetImageSubresourceLayout(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout);
18421    pub fn vkCreateImageView(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;
18422    pub fn vkDestroyImageView(device: VkDevice, view: VkImageView, pAllocator: *const VkAllocationCallbacks);
18423    pub fn vkCreateShaderModule(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkShaderModule) -> VkResult;
18424    pub fn vkDestroyShaderModule(device: VkDevice, module: VkShaderModule, pAllocator: *const VkAllocationCallbacks);
18425    pub fn vkCreatePipelineCache(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;
18426    pub fn vkDestroyPipelineCache(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks);
18427    pub fn vkGetPipelineCacheData(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut core::ffi::c_void) -> VkResult;
18428    pub fn vkMergePipelineCaches(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult;
18429    pub fn vkCreateGraphicsPipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
18430    pub fn vkCreateComputePipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
18431    pub fn vkDestroyPipeline(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks);
18432    pub fn vkCreatePipelineLayout(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;
18433    pub fn vkDestroyPipelineLayout(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks);
18434    pub fn vkCreateSampler(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;
18435    pub fn vkDestroySampler(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks);
18436    pub fn vkCreateDescriptorSetLayout(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;
18437    pub fn vkDestroyDescriptorSetLayout(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks);
18438    pub fn vkCreateDescriptorPool(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pPool: *mut VkDescriptorPool) -> VkResult;
18439    pub fn vkDestroyDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks);
18440    pub fn vkResetDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;
18441    pub fn vkAllocateDescriptorSets(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;
18442    pub fn vkFreeDescriptorSets(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult;
18443    pub fn vkUpdateDescriptorSets(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet);
18444    pub fn vkCreateFramebuffer(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;
18445    pub fn vkDestroyFramebuffer(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks);
18446    pub fn vkCreateRenderPass(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
18447    pub fn vkDestroyRenderPass(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks);
18448    pub fn vkGetRenderAreaGranularity(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D);
18449    pub fn vkCreateCommandPool(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;
18450    pub fn vkDestroyCommandPool(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks);
18451    pub fn vkResetCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;
18452    pub fn vkAllocateCommandBuffers(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;
18453    pub fn vkFreeCommandBuffers(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
18454    pub fn vkBeginCommandBuffer(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;
18455    pub fn vkEndCommandBuffer(commandBuffer: VkCommandBuffer) -> VkResult;
18456    pub fn vkResetCommandBuffer(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;
18457    #[cfg(feature = "Allow1_1APIs")]
18458    pub fn vkEnumerateInstanceVersion(pApiVersion: *mut u32) -> VkResult;
18459    #[cfg(feature = "VK_KHR_surface")]
18460    pub fn vkDestroySurfaceKHR(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks);
18461    #[cfg(feature = "VK_KHR_surface")]
18462    pub fn vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;
18463    #[cfg(feature = "VK_KHR_surface")]
18464    pub fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;
18465    #[cfg(feature = "VK_KHR_surface")]
18466    pub fn vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatsCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;
18467    #[cfg(feature = "VK_KHR_surface")]
18468    pub fn vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult;
18469    #[cfg(feature = "VK_KHR_swapchain")]
18470    pub fn vkCreateSwapchainKHR(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;
18471    #[cfg(feature = "VK_KHR_swapchain")]
18472    pub fn vkDestroySwapchainKHR(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks);
18473    #[cfg(feature = "VK_KHR_swapchain")]
18474    pub fn vkGetSwapchainImagesKHR(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult;
18475    #[cfg(feature = "VK_KHR_swapchain")]
18476    pub fn vkAcquireNextImageKHR(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult;
18477    #[cfg(feature = "VK_KHR_swapchain")]
18478    pub fn vkQueuePresentKHR(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;
18479    #[cfg(feature = "VK_KHR_display")]
18480    pub fn vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;
18481    #[cfg(feature = "VK_KHR_display")]
18482    pub fn vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;
18483    #[cfg(feature = "VK_KHR_display")]
18484    pub fn vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult;
18485    #[cfg(feature = "VK_KHR_display")]
18486    pub fn vkGetDisplayModePropertiesKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;
18487    #[cfg(feature = "VK_KHR_display")]
18488    pub fn vkCreateDisplayModeKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;
18489    #[cfg(feature = "VK_KHR_display")]
18490    pub fn vkGetDisplayPlaneCapabilitiesKHR(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;
18491    #[cfg(feature = "VK_KHR_display")]
18492    pub fn vkCreateDisplayPlaneSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
18493    #[cfg(feature = "VK_KHR_xlib_surface")]
18494    pub fn vkCreateXlibSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkXlibSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
18495    #[cfg(feature = "VK_KHR_xlib_surface")]
18496    pub fn vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, dpy: *mut x11::xlib::Display, visualID: x11::xlib::VisualID) -> VkBool32;
18497    #[cfg(feature = "VK_KHR_xcb_surface")]
18498    pub fn vkCreateXcbSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkXcbSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
18499    #[cfg(feature = "VK_KHR_xcb_surface")]
18500    pub fn vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, connection: *mut xcb::ffi::xcb_connection_t, visual_id: xcb::x::Visualid) -> VkBool32;
18501    #[cfg(feature = "VK_KHR_wayland_surface")]
18502    pub fn vkCreateWaylandSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkWaylandSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
18503    #[cfg(feature = "VK_KHR_wayland_surface")]
18504    pub fn vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, display: *mut core::ffi::c_void) -> VkBool32;
18505    #[cfg(feature = "VK_KHR_android_surface")]
18506    pub fn vkCreateAndroidSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkAndroidSurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
18507    #[cfg(feature = "VK_KHR_win32_surface")]
18508    pub fn vkCreateWin32SurfaceKHR(instance: VkInstance, pCreateInfo: *const VkWin32SurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
18509    #[cfg(feature = "VK_KHR_win32_surface")]
18510    pub fn vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32) -> VkBool32;
18511    #[cfg(feature = "VK_EXT_metal_surface")]
18512    pub fn vkCreateMetalSurfaceEXT(instance: VkInstance, pCreateInfo: *const VkMetalSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
18513    #[cfg(feature = "Allow1_1APIs")]
18514    pub fn vkGetPhysicalDeviceExternalBufferProperties(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfoKHR, pExternalBufferProperties: *mut VkExternalBufferPropertiesKHR);
18515    #[cfg(feature = "Allow1_1APIs")]
18516    pub fn vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfoKHR, pExternalSemaphoreProperties: *mut VkExternalSemaphorePropertiesKHR);
18517    #[cfg(feature = "Allow1_1APIs")]
18518    pub fn vkGetPhysicalDeviceExternalFenceProperties(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfoKHR, pExternalFenceProperties: *mut VkExternalFencePropertiesKHR);
18519    #[cfg(feature = "Allow1_1APIs")]
18520    pub fn vkGetDeviceGroupPeerMemoryFeatures(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
18521    #[cfg(feature = "Allow1_1APIs")]
18522    pub fn vkGetPhysicalDeviceFeatures2(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2KHR);
18523    #[cfg(feature = "Allow1_1APIs")]
18524    pub fn vkGetPhysicalDeviceProperties2(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2KHR);
18525    #[cfg(feature = "Allow1_1APIs")]
18526    pub fn vkGetPhysicalDeviceFormatProperties2(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2KHR);
18527    #[cfg(feature = "Allow1_1APIs")]
18528    pub fn vkGetPhysicalDeviceImageFormatProperties2(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2KHR, pImageFormatProperties: *mut VkImageFormatProperties2KHR) -> VkResult;
18529    #[cfg(feature = "Allow1_1APIs")]
18530    pub fn vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2KHR);
18531    #[cfg(feature = "Allow1_1APIs")]
18532    pub fn vkGetPhysicalDeviceMemoryProperties2(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2KHR);
18533    #[cfg(feature = "Allow1_1APIs")]
18534    pub fn vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2KHR, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2KHR);
18535    #[cfg(feature = "Allow1_1APIs")]
18536    pub fn vkEnumeratePhysicalDeviceGroup(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupPropertiesKHR) -> VkResult;
18537    #[cfg(feature = "Allow1_1APIs")]
18538    pub fn vkGetImageMemoryRequirements2(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2KHR, pMemoryRequirements: *mut VkMemoryRequirements2KHR);
18539    #[cfg(feature = "Allow1_1APIs")]
18540    pub fn vkGetBufferMemoryRequirements2(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2KHR, pMemoryRequirements: *mut VkMemoryRequirements2KHR);
18541    #[cfg(feature = "Allow1_1APIs")]
18542    pub fn vkGetImageSparseMemoryRequirements2(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2KHR, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2KHR);
18543    #[cfg(feature = "Allow1_1APIs")]
18544    pub fn vkBindBufferMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfoKHR) -> VkResult;
18545    #[cfg(feature = "Allow1_1APIs")]
18546    pub fn vkBindImageMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfoKHR) -> VkResult;
18547    #[cfg(feature = "Allow1_1APIs")]
18548    pub fn vkCreateDescriptorUpdateTemplate(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplateKHR) -> VkResult;
18549    #[cfg(feature = "Allow1_1APIs")]
18550    pub fn vkDestroyDescriptorUpdateTemplate(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplateKHR, pAllocator: *const VkAllocationCallbacks);
18551    #[cfg(feature = "Allow1_1APIs")]
18552    pub fn vkUpdateDescriptorSetWithTemplate(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplateKHR, pData: *const core::ffi::c_void);
18553    #[cfg(feature = "Allow1_1APIs")]
18554    pub fn vkCreateSamplerYcbcrConversion(device: VkDevice, pCreateInfo: VkSamplerYcbcrConversionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversionKHR) -> VkResult;
18555    #[cfg(feature = "Allow1_1APIs")]
18556    pub fn vkDestroySamplerYcbcrConversion(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversionKHR, pAllocator: *const VkAllocationCallbacks);
18557    #[cfg(feature = "Allow1_1APIs")]
18558    pub fn vkTrimCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlagsKHR);
18559    #[cfg(feature = "Allow1_1APIs")]
18560    pub fn vkGetDescriptorSetLayoutSupport(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
18561    #[cfg(feature = "Allow1_3APIs")]
18562    pub fn vkQueueSubmit2(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2KHR, fence: VkFence) -> VkResult;
18563    pub fn vkCmdBindPipeline(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
18564    pub fn vkCmdSetViewport(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport);
18565    pub fn vkCmdSetScissor(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D);
18566    pub fn vkCmdSetLineWidth(commandBuffer: VkCommandBuffer, lineWidth: core::ffi::c_float);
18567    pub fn vkCmdSetDepthBias(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: core::ffi::c_float, depthBiasClamp: core::ffi::c_float, depthBiasSlopeFactor: core::ffi::c_float);
18568    pub fn vkCmdSetBlendConstants(commandBuffer: VkCommandBuffer, blendConstants: *const core::ffi::c_float);
18569    pub fn vkCmdSetDepthBounds(commandBuffer: VkCommandBuffer, minDepthBounds: core::ffi::c_float, maxDepthBounds: core::ffi::c_float);
18570    pub fn vkCmdSetStencilCompareMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32);
18571    pub fn vkCmdSetStencilWriteMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32);
18572    pub fn vkCmdSetStencilReference(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32);
18573    pub fn vkCmdBindDescriptorSets(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: *const u32);
18574    pub fn vkCmdBindIndexBuffer(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType);
18575    pub fn vkCmdBindVertexBuffers(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize);
18576    pub fn vkCmdDraw(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
18577    pub fn vkCmdDrawIndexed(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
18578    pub fn vkCmdDrawIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18579    pub fn vkCmdDrawIndexedIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18580    pub fn vkCmdDispatch(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18581    pub fn vkCmdDispatchIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
18582    pub fn vkCmdCopyBuffer(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy);
18583    pub fn vkCmdCopyImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy);
18584    pub fn vkCmdBlitImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filters: VkFilter);
18585    pub fn vkCmdCopyBufferToImage(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy);
18586    pub fn vkCmdCopyImageToBuffer(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy);
18587    pub fn vkCmdUpdateBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const core::ffi::c_void);
18588    pub fn vkCmdFillBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, data: u32);
18589    pub fn vkCmdClearColorImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
18590    pub fn vkCmdClearDepthStencilImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
18591    pub fn vkCmdClearAttachments(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect);
18592    pub fn vkCmdResolveImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve);
18593    pub fn vkCmdSetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
18594    pub fn vkCmdResetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
18595    pub fn vkCmdWaitEvents(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
18596    pub fn vkCmdPipelineBarrier(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
18597    pub fn vkCmdBeginQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags);
18598    pub fn vkCmdEndQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32);
18599    pub fn vkCmdResetQueryPool(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
18600    pub fn vkCmdWriteTimestamp(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlags, queryPool: VkQueryPool, query: u32);
18601    pub fn vkCmdCopyQueryPoolResults(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags);
18602    pub fn vkCmdPushConstants(commandBuffer: VkCommandBuffer, pipelineLayout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const core::ffi::c_void);
18603    pub fn vkCmdBeginRenderPass(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents);
18604    pub fn vkCmdNextSubpass(commandBuffer: VkCommandBuffer, contents: VkSubpassContents);
18605    pub fn vkCmdEndRenderPass(commandBuffer: VkCommandBuffer);
18606    pub fn vkCmdExecuteCommands(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
18607    #[cfg(feature = "Allow1_1APIs")]
18608    pub fn vkCmdSetDeviceMask(commandBuffer: VkCommandBuffer, deviceMask: u32);
18609    #[cfg(feature = "Allow1_1APIs")]
18610    pub fn vkCmdDispatchBase(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18611    #[cfg(feature = "Allow1_3APIs")]
18612    pub fn vkCmdSetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfoKHR);
18613    #[cfg(feature = "Allow1_3APIs")]
18614    pub fn vkCmdResetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2KHR);
18615    #[cfg(feature = "Allow1_3APIs")]
18616    pub fn vkCmdWaitEvents2(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfoKHR);
18617    #[cfg(feature = "Allow1_3APIs")]
18618    pub fn vkCmdPipelineBarrier2(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfoKHR);
18619    #[cfg(feature = "Allow1_3APIs")]
18620    pub fn vkCmdWriteTimestamp2(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2KHR, queryPool: VkQueryPool, query: u32);
18621    #[cfg(feature = "Allow1_2APIs")]
18622    pub fn vkGetBufferDeviceAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfoKHR) -> VkDeviceAddress;
18623    #[cfg(feature = "Allow1_2APIs")]
18624    pub fn vkGetBufferOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfoKHR) -> u64;
18625    #[cfg(feature = "Allow1_2APIs")]
18626    pub fn vkGetDeviceMemoryOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfoKHR) -> u64;
18627    #[cfg(feature = "Allow1_2APIs")]
18628    pub fn vkGetSemaphoreCounterValue(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
18629    #[cfg(feature = "Allow1_2APIs")]
18630    pub fn vkSignalSemaphore(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfoKHR) -> VkResult;
18631    #[cfg(feature = "Allow1_2APIs")]
18632    pub fn vkWaitSemaphores(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfoKHR, timeout: u64) -> VkResult;
18633}
bedrock/vk2.rs

bedrock/
vk2.rs
