1 use crate::vk::bitflags::*;
2 use crate::vk::definitions::*;
3 use crate::vk::enums::*;
4 use std::os::raw::*;
5 #[allow(non_camel_case_types)]
6 pub type PFN_vkGetInstanceProcAddr =
7     extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction;
8 pub struct StaticFn {
9     pub get_instance_proc_addr:
10         extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction,
11 }
12 unsafe impl Send for StaticFn {}
13 unsafe impl Sync for StaticFn {}
14 impl ::std::clone::Clone for StaticFn {
clone(&self) -> Self15     fn clone(&self) -> Self {
16         StaticFn {
17             get_instance_proc_addr: self.get_instance_proc_addr,
18         }
19     }
20 }
21 impl StaticFn {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,22     pub fn load<F>(mut _f: F) -> Self
23     where
24         F: FnMut(&::std::ffi::CStr) -> *const c_void,
25     {
26         StaticFn {
27             get_instance_proc_addr: unsafe {
28                 extern "system" fn get_instance_proc_addr(
29                     _instance: Instance,
30                     _p_name: *const c_char,
31                 ) -> PFN_vkVoidFunction {
32                     panic!(concat!(
33                         "Unable to load ",
34                         stringify!(get_instance_proc_addr)
35                     ))
36                 }
37                 let cname =
38                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetInstanceProcAddr\0");
39                 let val = _f(cname);
40                 if val.is_null() {
41                     get_instance_proc_addr
42                 } else {
43                     ::std::mem::transmute(val)
44                 }
45             },
46         }
47     }
48     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetInstanceProcAddr.html>"]
get_instance_proc_addr( &self, instance: Instance, p_name: *const c_char, ) -> PFN_vkVoidFunction49     pub unsafe fn get_instance_proc_addr(
50         &self,
51         instance: Instance,
52         p_name: *const c_char,
53     ) -> PFN_vkVoidFunction {
54         (self.get_instance_proc_addr)(instance, p_name)
55     }
56 }
57 #[allow(non_camel_case_types)]
58 pub type PFN_vkCreateInstance = extern "system" fn(
59     p_create_info: *const InstanceCreateInfo,
60     p_allocator: *const AllocationCallbacks,
61     p_instance: *mut Instance,
62 ) -> Result;
63 #[allow(non_camel_case_types)]
64 pub type PFN_vkEnumerateInstanceExtensionProperties = extern "system" fn(
65     p_layer_name: *const c_char,
66     p_property_count: *mut u32,
67     p_properties: *mut ExtensionProperties,
68 ) -> Result;
69 #[allow(non_camel_case_types)]
70 pub type PFN_vkEnumerateInstanceLayerProperties =
71     extern "system" fn(p_property_count: *mut u32, p_properties: *mut LayerProperties) -> Result;
72 pub struct EntryFnV1_0 {
73     pub create_instance: extern "system" fn(
74         p_create_info: *const InstanceCreateInfo,
75         p_allocator: *const AllocationCallbacks,
76         p_instance: *mut Instance,
77     ) -> Result,
78     pub enumerate_instance_extension_properties: extern "system" fn(
79         p_layer_name: *const c_char,
80         p_property_count: *mut u32,
81         p_properties: *mut ExtensionProperties,
82     ) -> Result,
83     pub enumerate_instance_layer_properties: extern "system" fn(
84         p_property_count: *mut u32,
85         p_properties: *mut LayerProperties,
86     ) -> Result,
87 }
88 unsafe impl Send for EntryFnV1_0 {}
89 unsafe impl Sync for EntryFnV1_0 {}
90 impl ::std::clone::Clone for EntryFnV1_0 {
clone(&self) -> Self91     fn clone(&self) -> Self {
92         EntryFnV1_0 {
93             create_instance: self.create_instance,
94             enumerate_instance_extension_properties: self.enumerate_instance_extension_properties,
95             enumerate_instance_layer_properties: self.enumerate_instance_layer_properties,
96         }
97     }
98 }
99 impl EntryFnV1_0 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,100     pub fn load<F>(mut _f: F) -> Self
101     where
102         F: FnMut(&::std::ffi::CStr) -> *const c_void,
103     {
104         EntryFnV1_0 {
105             create_instance: unsafe {
106                 extern "system" fn create_instance(
107                     _p_create_info: *const InstanceCreateInfo,
108                     _p_allocator: *const AllocationCallbacks,
109                     _p_instance: *mut Instance,
110                 ) -> Result {
111                     panic!(concat!("Unable to load ", stringify!(create_instance)))
112                 }
113                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateInstance\0");
114                 let val = _f(cname);
115                 if val.is_null() {
116                     create_instance
117                 } else {
118                     ::std::mem::transmute(val)
119                 }
120             },
121             enumerate_instance_extension_properties: unsafe {
122                 extern "system" fn enumerate_instance_extension_properties(
123                     _p_layer_name: *const c_char,
124                     _p_property_count: *mut u32,
125                     _p_properties: *mut ExtensionProperties,
126                 ) -> Result {
127                     panic!(concat!(
128                         "Unable to load ",
129                         stringify!(enumerate_instance_extension_properties)
130                     ))
131                 }
132                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
133                     b"vkEnumerateInstanceExtensionProperties\0",
134                 );
135                 let val = _f(cname);
136                 if val.is_null() {
137                     enumerate_instance_extension_properties
138                 } else {
139                     ::std::mem::transmute(val)
140                 }
141             },
142             enumerate_instance_layer_properties: unsafe {
143                 extern "system" fn enumerate_instance_layer_properties(
144                     _p_property_count: *mut u32,
145                     _p_properties: *mut LayerProperties,
146                 ) -> Result {
147                     panic!(concat!(
148                         "Unable to load ",
149                         stringify!(enumerate_instance_layer_properties)
150                     ))
151                 }
152                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
153                     b"vkEnumerateInstanceLayerProperties\0",
154                 );
155                 let val = _f(cname);
156                 if val.is_null() {
157                     enumerate_instance_layer_properties
158                 } else {
159                     ::std::mem::transmute(val)
160                 }
161             },
162         }
163     }
164     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateInstance.html>"]
create_instance( &self, p_create_info: *const InstanceCreateInfo, p_allocator: *const AllocationCallbacks, p_instance: *mut Instance, ) -> Result165     pub unsafe fn create_instance(
166         &self,
167         p_create_info: *const InstanceCreateInfo,
168         p_allocator: *const AllocationCallbacks,
169         p_instance: *mut Instance,
170     ) -> Result {
171         (self.create_instance)(p_create_info, p_allocator, p_instance)
172     }
173     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html>"]
enumerate_instance_extension_properties( &self, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result174     pub unsafe fn enumerate_instance_extension_properties(
175         &self,
176         p_layer_name: *const c_char,
177         p_property_count: *mut u32,
178         p_properties: *mut ExtensionProperties,
179     ) -> Result {
180         (self.enumerate_instance_extension_properties)(p_layer_name, p_property_count, p_properties)
181     }
182     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceLayerProperties.html>"]
enumerate_instance_layer_properties( &self, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result183     pub unsafe fn enumerate_instance_layer_properties(
184         &self,
185         p_property_count: *mut u32,
186         p_properties: *mut LayerProperties,
187     ) -> Result {
188         (self.enumerate_instance_layer_properties)(p_property_count, p_properties)
189     }
190 }
191 #[allow(non_camel_case_types)]
192 pub type PFN_vkDestroyInstance =
193     extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks);
194 #[allow(non_camel_case_types)]
195 pub type PFN_vkEnumeratePhysicalDevices = extern "system" fn(
196     instance: Instance,
197     p_physical_device_count: *mut u32,
198     p_physical_devices: *mut PhysicalDevice,
199 ) -> Result;
200 #[allow(non_camel_case_types)]
201 pub type PFN_vkGetPhysicalDeviceFeatures =
202     extern "system" fn(physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures);
203 #[allow(non_camel_case_types)]
204 pub type PFN_vkGetPhysicalDeviceFormatProperties = extern "system" fn(
205     physical_device: PhysicalDevice,
206     format: Format,
207     p_format_properties: *mut FormatProperties,
208 );
209 #[allow(non_camel_case_types)]
210 pub type PFN_vkGetPhysicalDeviceImageFormatProperties = extern "system" fn(
211     physical_device: PhysicalDevice,
212     format: Format,
213     ty: ImageType,
214     tiling: ImageTiling,
215     usage: ImageUsageFlags,
216     flags: ImageCreateFlags,
217     p_image_format_properties: *mut ImageFormatProperties,
218 ) -> Result;
219 #[allow(non_camel_case_types)]
220 pub type PFN_vkGetPhysicalDeviceProperties = extern "system" fn(
221     physical_device: PhysicalDevice,
222     p_properties: *mut PhysicalDeviceProperties,
223 );
224 #[allow(non_camel_case_types)]
225 pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = extern "system" fn(
226     physical_device: PhysicalDevice,
227     p_queue_family_property_count: *mut u32,
228     p_queue_family_properties: *mut QueueFamilyProperties,
229 );
230 #[allow(non_camel_case_types)]
231 pub type PFN_vkGetPhysicalDeviceMemoryProperties = extern "system" fn(
232     physical_device: PhysicalDevice,
233     p_memory_properties: *mut PhysicalDeviceMemoryProperties,
234 );
235 #[allow(non_camel_case_types)]
236 pub type PFN_vkGetDeviceProcAddr =
237     extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction;
238 #[allow(non_camel_case_types)]
239 pub type PFN_vkCreateDevice = extern "system" fn(
240     physical_device: PhysicalDevice,
241     p_create_info: *const DeviceCreateInfo,
242     p_allocator: *const AllocationCallbacks,
243     p_device: *mut Device,
244 ) -> Result;
245 #[allow(non_camel_case_types)]
246 pub type PFN_vkEnumerateDeviceExtensionProperties = extern "system" fn(
247     physical_device: PhysicalDevice,
248     p_layer_name: *const c_char,
249     p_property_count: *mut u32,
250     p_properties: *mut ExtensionProperties,
251 ) -> Result;
252 #[allow(non_camel_case_types)]
253 pub type PFN_vkEnumerateDeviceLayerProperties = extern "system" fn(
254     physical_device: PhysicalDevice,
255     p_property_count: *mut u32,
256     p_properties: *mut LayerProperties,
257 ) -> Result;
258 #[allow(non_camel_case_types)]
259 pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = extern "system" fn(
260     physical_device: PhysicalDevice,
261     format: Format,
262     ty: ImageType,
263     samples: SampleCountFlags,
264     usage: ImageUsageFlags,
265     tiling: ImageTiling,
266     p_property_count: *mut u32,
267     p_properties: *mut SparseImageFormatProperties,
268 );
269 pub struct InstanceFnV1_0 {
270     pub destroy_instance:
271         extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks),
272     pub enumerate_physical_devices: extern "system" fn(
273         instance: Instance,
274         p_physical_device_count: *mut u32,
275         p_physical_devices: *mut PhysicalDevice,
276     ) -> Result,
277     pub get_physical_device_features: extern "system" fn(
278         physical_device: PhysicalDevice,
279         p_features: *mut PhysicalDeviceFeatures,
280     ),
281     pub get_physical_device_format_properties: extern "system" fn(
282         physical_device: PhysicalDevice,
283         format: Format,
284         p_format_properties: *mut FormatProperties,
285     ),
286     pub get_physical_device_image_format_properties: extern "system" fn(
287         physical_device: PhysicalDevice,
288         format: Format,
289         ty: ImageType,
290         tiling: ImageTiling,
291         usage: ImageUsageFlags,
292         flags: ImageCreateFlags,
293         p_image_format_properties: *mut ImageFormatProperties,
294     ) -> Result,
295     pub get_physical_device_properties: extern "system" fn(
296         physical_device: PhysicalDevice,
297         p_properties: *mut PhysicalDeviceProperties,
298     ),
299     pub get_physical_device_queue_family_properties: extern "system" fn(
300         physical_device: PhysicalDevice,
301         p_queue_family_property_count: *mut u32,
302         p_queue_family_properties: *mut QueueFamilyProperties,
303     ),
304     pub get_physical_device_memory_properties: extern "system" fn(
305         physical_device: PhysicalDevice,
306         p_memory_properties: *mut PhysicalDeviceMemoryProperties,
307     ),
308     pub get_device_proc_addr:
309         extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction,
310     pub create_device: extern "system" fn(
311         physical_device: PhysicalDevice,
312         p_create_info: *const DeviceCreateInfo,
313         p_allocator: *const AllocationCallbacks,
314         p_device: *mut Device,
315     ) -> Result,
316     pub enumerate_device_extension_properties: extern "system" fn(
317         physical_device: PhysicalDevice,
318         p_layer_name: *const c_char,
319         p_property_count: *mut u32,
320         p_properties: *mut ExtensionProperties,
321     ) -> Result,
322     pub enumerate_device_layer_properties: extern "system" fn(
323         physical_device: PhysicalDevice,
324         p_property_count: *mut u32,
325         p_properties: *mut LayerProperties,
326     ) -> Result,
327     pub get_physical_device_sparse_image_format_properties: extern "system" fn(
328         physical_device: PhysicalDevice,
329         format: Format,
330         ty: ImageType,
331         samples: SampleCountFlags,
332         usage: ImageUsageFlags,
333         tiling: ImageTiling,
334         p_property_count: *mut u32,
335         p_properties: *mut SparseImageFormatProperties,
336     ),
337 }
338 unsafe impl Send for InstanceFnV1_0 {}
339 unsafe impl Sync for InstanceFnV1_0 {}
340 impl ::std::clone::Clone for InstanceFnV1_0 {
clone(&self) -> Self341     fn clone(&self) -> Self {
342         InstanceFnV1_0 {
343             destroy_instance: self.destroy_instance,
344             enumerate_physical_devices: self.enumerate_physical_devices,
345             get_physical_device_features: self.get_physical_device_features,
346             get_physical_device_format_properties: self.get_physical_device_format_properties,
347             get_physical_device_image_format_properties: self
348                 .get_physical_device_image_format_properties,
349             get_physical_device_properties: self.get_physical_device_properties,
350             get_physical_device_queue_family_properties: self
351                 .get_physical_device_queue_family_properties,
352             get_physical_device_memory_properties: self.get_physical_device_memory_properties,
353             get_device_proc_addr: self.get_device_proc_addr,
354             create_device: self.create_device,
355             enumerate_device_extension_properties: self.enumerate_device_extension_properties,
356             enumerate_device_layer_properties: self.enumerate_device_layer_properties,
357             get_physical_device_sparse_image_format_properties: self
358                 .get_physical_device_sparse_image_format_properties,
359         }
360     }
361 }
362 impl InstanceFnV1_0 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,363     pub fn load<F>(mut _f: F) -> Self
364     where
365         F: FnMut(&::std::ffi::CStr) -> *const c_void,
366     {
367         InstanceFnV1_0 {
368             destroy_instance: unsafe {
369                 extern "system" fn destroy_instance(
370                     _instance: Instance,
371                     _p_allocator: *const AllocationCallbacks,
372                 ) {
373                     panic!(concat!("Unable to load ", stringify!(destroy_instance)))
374                 }
375                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyInstance\0");
376                 let val = _f(cname);
377                 if val.is_null() {
378                     destroy_instance
379                 } else {
380                     ::std::mem::transmute(val)
381                 }
382             },
383             enumerate_physical_devices: unsafe {
384                 extern "system" fn enumerate_physical_devices(
385                     _instance: Instance,
386                     _p_physical_device_count: *mut u32,
387                     _p_physical_devices: *mut PhysicalDevice,
388                 ) -> Result {
389                     panic!(concat!(
390                         "Unable to load ",
391                         stringify!(enumerate_physical_devices)
392                     ))
393                 }
394                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
395                     b"vkEnumeratePhysicalDevices\0",
396                 );
397                 let val = _f(cname);
398                 if val.is_null() {
399                     enumerate_physical_devices
400                 } else {
401                     ::std::mem::transmute(val)
402                 }
403             },
404             get_physical_device_features: unsafe {
405                 extern "system" fn get_physical_device_features(
406                     _physical_device: PhysicalDevice,
407                     _p_features: *mut PhysicalDeviceFeatures,
408                 ) {
409                     panic!(concat!(
410                         "Unable to load ",
411                         stringify!(get_physical_device_features)
412                     ))
413                 }
414                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
415                     b"vkGetPhysicalDeviceFeatures\0",
416                 );
417                 let val = _f(cname);
418                 if val.is_null() {
419                     get_physical_device_features
420                 } else {
421                     ::std::mem::transmute(val)
422                 }
423             },
424             get_physical_device_format_properties: unsafe {
425                 extern "system" fn get_physical_device_format_properties(
426                     _physical_device: PhysicalDevice,
427                     _format: Format,
428                     _p_format_properties: *mut FormatProperties,
429                 ) {
430                     panic!(concat!(
431                         "Unable to load ",
432                         stringify!(get_physical_device_format_properties)
433                     ))
434                 }
435                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
436                     b"vkGetPhysicalDeviceFormatProperties\0",
437                 );
438                 let val = _f(cname);
439                 if val.is_null() {
440                     get_physical_device_format_properties
441                 } else {
442                     ::std::mem::transmute(val)
443                 }
444             },
445             get_physical_device_image_format_properties: unsafe {
446                 extern "system" fn get_physical_device_image_format_properties(
447                     _physical_device: PhysicalDevice,
448                     _format: Format,
449                     _ty: ImageType,
450                     _tiling: ImageTiling,
451                     _usage: ImageUsageFlags,
452                     _flags: ImageCreateFlags,
453                     _p_image_format_properties: *mut ImageFormatProperties,
454                 ) -> Result {
455                     panic!(concat!(
456                         "Unable to load ",
457                         stringify!(get_physical_device_image_format_properties)
458                     ))
459                 }
460                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
461                     b"vkGetPhysicalDeviceImageFormatProperties\0",
462                 );
463                 let val = _f(cname);
464                 if val.is_null() {
465                     get_physical_device_image_format_properties
466                 } else {
467                     ::std::mem::transmute(val)
468                 }
469             },
470             get_physical_device_properties: unsafe {
471                 extern "system" fn get_physical_device_properties(
472                     _physical_device: PhysicalDevice,
473                     _p_properties: *mut PhysicalDeviceProperties,
474                 ) {
475                     panic!(concat!(
476                         "Unable to load ",
477                         stringify!(get_physical_device_properties)
478                     ))
479                 }
480                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
481                     b"vkGetPhysicalDeviceProperties\0",
482                 );
483                 let val = _f(cname);
484                 if val.is_null() {
485                     get_physical_device_properties
486                 } else {
487                     ::std::mem::transmute(val)
488                 }
489             },
490             get_physical_device_queue_family_properties: unsafe {
491                 extern "system" fn get_physical_device_queue_family_properties(
492                     _physical_device: PhysicalDevice,
493                     _p_queue_family_property_count: *mut u32,
494                     _p_queue_family_properties: *mut QueueFamilyProperties,
495                 ) {
496                     panic!(concat!(
497                         "Unable to load ",
498                         stringify!(get_physical_device_queue_family_properties)
499                     ))
500                 }
501                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
502                     b"vkGetPhysicalDeviceQueueFamilyProperties\0",
503                 );
504                 let val = _f(cname);
505                 if val.is_null() {
506                     get_physical_device_queue_family_properties
507                 } else {
508                     ::std::mem::transmute(val)
509                 }
510             },
511             get_physical_device_memory_properties: unsafe {
512                 extern "system" fn get_physical_device_memory_properties(
513                     _physical_device: PhysicalDevice,
514                     _p_memory_properties: *mut PhysicalDeviceMemoryProperties,
515                 ) {
516                     panic!(concat!(
517                         "Unable to load ",
518                         stringify!(get_physical_device_memory_properties)
519                     ))
520                 }
521                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
522                     b"vkGetPhysicalDeviceMemoryProperties\0",
523                 );
524                 let val = _f(cname);
525                 if val.is_null() {
526                     get_physical_device_memory_properties
527                 } else {
528                     ::std::mem::transmute(val)
529                 }
530             },
531             get_device_proc_addr: unsafe {
532                 extern "system" fn get_device_proc_addr(
533                     _device: Device,
534                     _p_name: *const c_char,
535                 ) -> PFN_vkVoidFunction {
536                     panic!(concat!("Unable to load ", stringify!(get_device_proc_addr)))
537                 }
538                 let cname =
539                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceProcAddr\0");
540                 let val = _f(cname);
541                 if val.is_null() {
542                     get_device_proc_addr
543                 } else {
544                     ::std::mem::transmute(val)
545                 }
546             },
547             create_device: unsafe {
548                 extern "system" fn create_device(
549                     _physical_device: PhysicalDevice,
550                     _p_create_info: *const DeviceCreateInfo,
551                     _p_allocator: *const AllocationCallbacks,
552                     _p_device: *mut Device,
553                 ) -> Result {
554                     panic!(concat!("Unable to load ", stringify!(create_device)))
555                 }
556                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDevice\0");
557                 let val = _f(cname);
558                 if val.is_null() {
559                     create_device
560                 } else {
561                     ::std::mem::transmute(val)
562                 }
563             },
564             enumerate_device_extension_properties: unsafe {
565                 extern "system" fn enumerate_device_extension_properties(
566                     _physical_device: PhysicalDevice,
567                     _p_layer_name: *const c_char,
568                     _p_property_count: *mut u32,
569                     _p_properties: *mut ExtensionProperties,
570                 ) -> Result {
571                     panic!(concat!(
572                         "Unable to load ",
573                         stringify!(enumerate_device_extension_properties)
574                     ))
575                 }
576                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
577                     b"vkEnumerateDeviceExtensionProperties\0",
578                 );
579                 let val = _f(cname);
580                 if val.is_null() {
581                     enumerate_device_extension_properties
582                 } else {
583                     ::std::mem::transmute(val)
584                 }
585             },
586             enumerate_device_layer_properties: unsafe {
587                 extern "system" fn enumerate_device_layer_properties(
588                     _physical_device: PhysicalDevice,
589                     _p_property_count: *mut u32,
590                     _p_properties: *mut LayerProperties,
591                 ) -> Result {
592                     panic!(concat!(
593                         "Unable to load ",
594                         stringify!(enumerate_device_layer_properties)
595                     ))
596                 }
597                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
598                     b"vkEnumerateDeviceLayerProperties\0",
599                 );
600                 let val = _f(cname);
601                 if val.is_null() {
602                     enumerate_device_layer_properties
603                 } else {
604                     ::std::mem::transmute(val)
605                 }
606             },
607             get_physical_device_sparse_image_format_properties: unsafe {
608                 extern "system" fn get_physical_device_sparse_image_format_properties(
609                     _physical_device: PhysicalDevice,
610                     _format: Format,
611                     _ty: ImageType,
612                     _samples: SampleCountFlags,
613                     _usage: ImageUsageFlags,
614                     _tiling: ImageTiling,
615                     _p_property_count: *mut u32,
616                     _p_properties: *mut SparseImageFormatProperties,
617                 ) {
618                     panic!(concat!(
619                         "Unable to load ",
620                         stringify!(get_physical_device_sparse_image_format_properties)
621                     ))
622                 }
623                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
624                     b"vkGetPhysicalDeviceSparseImageFormatProperties\0",
625                 );
626                 let val = _f(cname);
627                 if val.is_null() {
628                     get_physical_device_sparse_image_format_properties
629                 } else {
630                     ::std::mem::transmute(val)
631                 }
632             },
633         }
634     }
635     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyInstance.html>"]
destroy_instance( &self, instance: Instance, p_allocator: *const AllocationCallbacks, )636     pub unsafe fn destroy_instance(
637         &self,
638         instance: Instance,
639         p_allocator: *const AllocationCallbacks,
640     ) {
641         (self.destroy_instance)(instance, p_allocator)
642     }
643     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDevices.html>"]
enumerate_physical_devices( &self, instance: Instance, p_physical_device_count: *mut u32, p_physical_devices: *mut PhysicalDevice, ) -> Result644     pub unsafe fn enumerate_physical_devices(
645         &self,
646         instance: Instance,
647         p_physical_device_count: *mut u32,
648         p_physical_devices: *mut PhysicalDevice,
649     ) -> Result {
650         (self.enumerate_physical_devices)(instance, p_physical_device_count, p_physical_devices)
651     }
652     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures.html>"]
get_physical_device_features( &self, physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures, )653     pub unsafe fn get_physical_device_features(
654         &self,
655         physical_device: PhysicalDevice,
656         p_features: *mut PhysicalDeviceFeatures,
657     ) {
658         (self.get_physical_device_features)(physical_device, p_features)
659     }
660     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties.html>"]
get_physical_device_format_properties( &self, physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties, )661     pub unsafe fn get_physical_device_format_properties(
662         &self,
663         physical_device: PhysicalDevice,
664         format: Format,
665         p_format_properties: *mut FormatProperties,
666     ) {
667         (self.get_physical_device_format_properties)(physical_device, format, p_format_properties)
668     }
669     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties.html>"]
get_physical_device_image_format_properties( &self, physical_device: PhysicalDevice, format: Format, ty: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, p_image_format_properties: *mut ImageFormatProperties, ) -> Result670     pub unsafe fn get_physical_device_image_format_properties(
671         &self,
672         physical_device: PhysicalDevice,
673         format: Format,
674         ty: ImageType,
675         tiling: ImageTiling,
676         usage: ImageUsageFlags,
677         flags: ImageCreateFlags,
678         p_image_format_properties: *mut ImageFormatProperties,
679     ) -> Result {
680         (self.get_physical_device_image_format_properties)(
681             physical_device,
682             format,
683             ty,
684             tiling,
685             usage,
686             flags,
687             p_image_format_properties,
688         )
689     }
690     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties.html>"]
get_physical_device_properties( &self, physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties, )691     pub unsafe fn get_physical_device_properties(
692         &self,
693         physical_device: PhysicalDevice,
694         p_properties: *mut PhysicalDeviceProperties,
695     ) {
696         (self.get_physical_device_properties)(physical_device, p_properties)
697     }
698     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html>"]
get_physical_device_queue_family_properties( &self, physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties, )699     pub unsafe fn get_physical_device_queue_family_properties(
700         &self,
701         physical_device: PhysicalDevice,
702         p_queue_family_property_count: *mut u32,
703         p_queue_family_properties: *mut QueueFamilyProperties,
704     ) {
705         (self.get_physical_device_queue_family_properties)(
706             physical_device,
707             p_queue_family_property_count,
708             p_queue_family_properties,
709         )
710     }
711     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties.html>"]
get_physical_device_memory_properties( &self, physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties, )712     pub unsafe fn get_physical_device_memory_properties(
713         &self,
714         physical_device: PhysicalDevice,
715         p_memory_properties: *mut PhysicalDeviceMemoryProperties,
716     ) {
717         (self.get_physical_device_memory_properties)(physical_device, p_memory_properties)
718     }
719     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceProcAddr.html>"]
get_device_proc_addr( &self, device: Device, p_name: *const c_char, ) -> PFN_vkVoidFunction720     pub unsafe fn get_device_proc_addr(
721         &self,
722         device: Device,
723         p_name: *const c_char,
724     ) -> PFN_vkVoidFunction {
725         (self.get_device_proc_addr)(device, p_name)
726     }
727     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDevice.html>"]
create_device( &self, physical_device: PhysicalDevice, p_create_info: *const DeviceCreateInfo, p_allocator: *const AllocationCallbacks, p_device: *mut Device, ) -> Result728     pub unsafe fn create_device(
729         &self,
730         physical_device: PhysicalDevice,
731         p_create_info: *const DeviceCreateInfo,
732         p_allocator: *const AllocationCallbacks,
733         p_device: *mut Device,
734     ) -> Result {
735         (self.create_device)(physical_device, p_create_info, p_allocator, p_device)
736     }
737     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceExtensionProperties.html>"]
enumerate_device_extension_properties( &self, physical_device: PhysicalDevice, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result738     pub unsafe fn enumerate_device_extension_properties(
739         &self,
740         physical_device: PhysicalDevice,
741         p_layer_name: *const c_char,
742         p_property_count: *mut u32,
743         p_properties: *mut ExtensionProperties,
744     ) -> Result {
745         (self.enumerate_device_extension_properties)(
746             physical_device,
747             p_layer_name,
748             p_property_count,
749             p_properties,
750         )
751     }
752     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceLayerProperties.html>"]
enumerate_device_layer_properties( &self, physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result753     pub unsafe fn enumerate_device_layer_properties(
754         &self,
755         physical_device: PhysicalDevice,
756         p_property_count: *mut u32,
757         p_properties: *mut LayerProperties,
758     ) -> Result {
759         (self.enumerate_device_layer_properties)(physical_device, p_property_count, p_properties)
760     }
761     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html>"]
get_physical_device_sparse_image_format_properties( &self, physical_device: PhysicalDevice, format: Format, ty: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties, )762     pub unsafe fn get_physical_device_sparse_image_format_properties(
763         &self,
764         physical_device: PhysicalDevice,
765         format: Format,
766         ty: ImageType,
767         samples: SampleCountFlags,
768         usage: ImageUsageFlags,
769         tiling: ImageTiling,
770         p_property_count: *mut u32,
771         p_properties: *mut SparseImageFormatProperties,
772     ) {
773         (self.get_physical_device_sparse_image_format_properties)(
774             physical_device,
775             format,
776             ty,
777             samples,
778             usage,
779             tiling,
780             p_property_count,
781             p_properties,
782         )
783     }
784 }
785 #[allow(non_camel_case_types)]
786 pub type PFN_vkDestroyDevice =
787     extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks);
788 #[allow(non_camel_case_types)]
789 pub type PFN_vkGetDeviceQueue = extern "system" fn(
790     device: Device,
791     queue_family_index: u32,
792     queue_index: u32,
793     p_queue: *mut Queue,
794 );
795 #[allow(non_camel_case_types)]
796 pub type PFN_vkQueueSubmit = extern "system" fn(
797     queue: Queue,
798     submit_count: u32,
799     p_submits: *const SubmitInfo,
800     fence: Fence,
801 ) -> Result;
802 #[allow(non_camel_case_types)]
803 pub type PFN_vkQueueWaitIdle = extern "system" fn(queue: Queue) -> Result;
804 #[allow(non_camel_case_types)]
805 pub type PFN_vkDeviceWaitIdle = extern "system" fn(device: Device) -> Result;
806 #[allow(non_camel_case_types)]
807 pub type PFN_vkAllocateMemory = extern "system" fn(
808     device: Device,
809     p_allocate_info: *const MemoryAllocateInfo,
810     p_allocator: *const AllocationCallbacks,
811     p_memory: *mut DeviceMemory,
812 ) -> Result;
813 #[allow(non_camel_case_types)]
814 pub type PFN_vkFreeMemory = extern "system" fn(
815     device: Device,
816     memory: DeviceMemory,
817     p_allocator: *const AllocationCallbacks,
818 );
819 #[allow(non_camel_case_types)]
820 pub type PFN_vkMapMemory = extern "system" fn(
821     device: Device,
822     memory: DeviceMemory,
823     offset: DeviceSize,
824     size: DeviceSize,
825     flags: MemoryMapFlags,
826     pp_data: *mut *mut c_void,
827 ) -> Result;
828 #[allow(non_camel_case_types)]
829 pub type PFN_vkUnmapMemory = extern "system" fn(device: Device, memory: DeviceMemory);
830 #[allow(non_camel_case_types)]
831 pub type PFN_vkFlushMappedMemoryRanges = extern "system" fn(
832     device: Device,
833     memory_range_count: u32,
834     p_memory_ranges: *const MappedMemoryRange,
835 ) -> Result;
836 #[allow(non_camel_case_types)]
837 pub type PFN_vkInvalidateMappedMemoryRanges = extern "system" fn(
838     device: Device,
839     memory_range_count: u32,
840     p_memory_ranges: *const MappedMemoryRange,
841 ) -> Result;
842 #[allow(non_camel_case_types)]
843 pub type PFN_vkGetDeviceMemoryCommitment = extern "system" fn(
844     device: Device,
845     memory: DeviceMemory,
846     p_committed_memory_in_bytes: *mut DeviceSize,
847 );
848 #[allow(non_camel_case_types)]
849 pub type PFN_vkBindBufferMemory = extern "system" fn(
850     device: Device,
851     buffer: Buffer,
852     memory: DeviceMemory,
853     memory_offset: DeviceSize,
854 ) -> Result;
855 #[allow(non_camel_case_types)]
856 pub type PFN_vkBindImageMemory = extern "system" fn(
857     device: Device,
858     image: Image,
859     memory: DeviceMemory,
860     memory_offset: DeviceSize,
861 ) -> Result;
862 #[allow(non_camel_case_types)]
863 pub type PFN_vkGetBufferMemoryRequirements = extern "system" fn(
864     device: Device,
865     buffer: Buffer,
866     p_memory_requirements: *mut MemoryRequirements,
867 );
868 #[allow(non_camel_case_types)]
869 pub type PFN_vkGetImageMemoryRequirements = extern "system" fn(
870     device: Device,
871     image: Image,
872     p_memory_requirements: *mut MemoryRequirements,
873 );
874 #[allow(non_camel_case_types)]
875 pub type PFN_vkGetImageSparseMemoryRequirements = extern "system" fn(
876     device: Device,
877     image: Image,
878     p_sparse_memory_requirement_count: *mut u32,
879     p_sparse_memory_requirements: *mut SparseImageMemoryRequirements,
880 );
881 #[allow(non_camel_case_types)]
882 pub type PFN_vkQueueBindSparse = extern "system" fn(
883     queue: Queue,
884     bind_info_count: u32,
885     p_bind_info: *const BindSparseInfo,
886     fence: Fence,
887 ) -> Result;
888 #[allow(non_camel_case_types)]
889 pub type PFN_vkCreateFence = extern "system" fn(
890     device: Device,
891     p_create_info: *const FenceCreateInfo,
892     p_allocator: *const AllocationCallbacks,
893     p_fence: *mut Fence,
894 ) -> Result;
895 #[allow(non_camel_case_types)]
896 pub type PFN_vkDestroyFence =
897     extern "system" fn(device: Device, fence: Fence, p_allocator: *const AllocationCallbacks);
898 #[allow(non_camel_case_types)]
899 pub type PFN_vkResetFences =
900     extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result;
901 #[allow(non_camel_case_types)]
902 pub type PFN_vkGetFenceStatus = extern "system" fn(device: Device, fence: Fence) -> Result;
903 #[allow(non_camel_case_types)]
904 pub type PFN_vkWaitForFences = extern "system" fn(
905     device: Device,
906     fence_count: u32,
907     p_fences: *const Fence,
908     wait_all: Bool32,
909     timeout: u64,
910 ) -> Result;
911 #[allow(non_camel_case_types)]
912 pub type PFN_vkCreateSemaphore = extern "system" fn(
913     device: Device,
914     p_create_info: *const SemaphoreCreateInfo,
915     p_allocator: *const AllocationCallbacks,
916     p_semaphore: *mut Semaphore,
917 ) -> Result;
918 #[allow(non_camel_case_types)]
919 pub type PFN_vkDestroySemaphore = extern "system" fn(
920     device: Device,
921     semaphore: Semaphore,
922     p_allocator: *const AllocationCallbacks,
923 );
924 #[allow(non_camel_case_types)]
925 pub type PFN_vkCreateEvent = extern "system" fn(
926     device: Device,
927     p_create_info: *const EventCreateInfo,
928     p_allocator: *const AllocationCallbacks,
929     p_event: *mut Event,
930 ) -> Result;
931 #[allow(non_camel_case_types)]
932 pub type PFN_vkDestroyEvent =
933     extern "system" fn(device: Device, event: Event, p_allocator: *const AllocationCallbacks);
934 #[allow(non_camel_case_types)]
935 pub type PFN_vkGetEventStatus = extern "system" fn(device: Device, event: Event) -> Result;
936 #[allow(non_camel_case_types)]
937 pub type PFN_vkSetEvent = extern "system" fn(device: Device, event: Event) -> Result;
938 #[allow(non_camel_case_types)]
939 pub type PFN_vkResetEvent = extern "system" fn(device: Device, event: Event) -> Result;
940 #[allow(non_camel_case_types)]
941 pub type PFN_vkCreateQueryPool = extern "system" fn(
942     device: Device,
943     p_create_info: *const QueryPoolCreateInfo,
944     p_allocator: *const AllocationCallbacks,
945     p_query_pool: *mut QueryPool,
946 ) -> Result;
947 #[allow(non_camel_case_types)]
948 pub type PFN_vkDestroyQueryPool = extern "system" fn(
949     device: Device,
950     query_pool: QueryPool,
951     p_allocator: *const AllocationCallbacks,
952 );
953 #[allow(non_camel_case_types)]
954 pub type PFN_vkGetQueryPoolResults = extern "system" fn(
955     device: Device,
956     query_pool: QueryPool,
957     first_query: u32,
958     query_count: u32,
959     data_size: usize,
960     p_data: *mut c_void,
961     stride: DeviceSize,
962     flags: QueryResultFlags,
963 ) -> Result;
964 #[allow(non_camel_case_types)]
965 pub type PFN_vkCreateBuffer = extern "system" fn(
966     device: Device,
967     p_create_info: *const BufferCreateInfo,
968     p_allocator: *const AllocationCallbacks,
969     p_buffer: *mut Buffer,
970 ) -> Result;
971 #[allow(non_camel_case_types)]
972 pub type PFN_vkDestroyBuffer =
973     extern "system" fn(device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks);
974 #[allow(non_camel_case_types)]
975 pub type PFN_vkCreateBufferView = extern "system" fn(
976     device: Device,
977     p_create_info: *const BufferViewCreateInfo,
978     p_allocator: *const AllocationCallbacks,
979     p_view: *mut BufferView,
980 ) -> Result;
981 #[allow(non_camel_case_types)]
982 pub type PFN_vkDestroyBufferView = extern "system" fn(
983     device: Device,
984     buffer_view: BufferView,
985     p_allocator: *const AllocationCallbacks,
986 );
987 #[allow(non_camel_case_types)]
988 pub type PFN_vkCreateImage = extern "system" fn(
989     device: Device,
990     p_create_info: *const ImageCreateInfo,
991     p_allocator: *const AllocationCallbacks,
992     p_image: *mut Image,
993 ) -> Result;
994 #[allow(non_camel_case_types)]
995 pub type PFN_vkDestroyImage =
996     extern "system" fn(device: Device, image: Image, p_allocator: *const AllocationCallbacks);
997 #[allow(non_camel_case_types)]
998 pub type PFN_vkGetImageSubresourceLayout = extern "system" fn(
999     device: Device,
1000     image: Image,
1001     p_subresource: *const ImageSubresource,
1002     p_layout: *mut SubresourceLayout,
1003 );
1004 #[allow(non_camel_case_types)]
1005 pub type PFN_vkCreateImageView = extern "system" fn(
1006     device: Device,
1007     p_create_info: *const ImageViewCreateInfo,
1008     p_allocator: *const AllocationCallbacks,
1009     p_view: *mut ImageView,
1010 ) -> Result;
1011 #[allow(non_camel_case_types)]
1012 pub type PFN_vkDestroyImageView = extern "system" fn(
1013     device: Device,
1014     image_view: ImageView,
1015     p_allocator: *const AllocationCallbacks,
1016 );
1017 #[allow(non_camel_case_types)]
1018 pub type PFN_vkCreateShaderModule = extern "system" fn(
1019     device: Device,
1020     p_create_info: *const ShaderModuleCreateInfo,
1021     p_allocator: *const AllocationCallbacks,
1022     p_shader_module: *mut ShaderModule,
1023 ) -> Result;
1024 #[allow(non_camel_case_types)]
1025 pub type PFN_vkDestroyShaderModule = extern "system" fn(
1026     device: Device,
1027     shader_module: ShaderModule,
1028     p_allocator: *const AllocationCallbacks,
1029 );
1030 #[allow(non_camel_case_types)]
1031 pub type PFN_vkCreatePipelineCache = extern "system" fn(
1032     device: Device,
1033     p_create_info: *const PipelineCacheCreateInfo,
1034     p_allocator: *const AllocationCallbacks,
1035     p_pipeline_cache: *mut PipelineCache,
1036 ) -> Result;
1037 #[allow(non_camel_case_types)]
1038 pub type PFN_vkDestroyPipelineCache = extern "system" fn(
1039     device: Device,
1040     pipeline_cache: PipelineCache,
1041     p_allocator: *const AllocationCallbacks,
1042 );
1043 #[allow(non_camel_case_types)]
1044 pub type PFN_vkGetPipelineCacheData = extern "system" fn(
1045     device: Device,
1046     pipeline_cache: PipelineCache,
1047     p_data_size: *mut usize,
1048     p_data: *mut c_void,
1049 ) -> Result;
1050 #[allow(non_camel_case_types)]
1051 pub type PFN_vkMergePipelineCaches = extern "system" fn(
1052     device: Device,
1053     dst_cache: PipelineCache,
1054     src_cache_count: u32,
1055     p_src_caches: *const PipelineCache,
1056 ) -> Result;
1057 #[allow(non_camel_case_types)]
1058 pub type PFN_vkCreateGraphicsPipelines = extern "system" fn(
1059     device: Device,
1060     pipeline_cache: PipelineCache,
1061     create_info_count: u32,
1062     p_create_infos: *const GraphicsPipelineCreateInfo,
1063     p_allocator: *const AllocationCallbacks,
1064     p_pipelines: *mut Pipeline,
1065 ) -> Result;
1066 #[allow(non_camel_case_types)]
1067 pub type PFN_vkCreateComputePipelines = extern "system" fn(
1068     device: Device,
1069     pipeline_cache: PipelineCache,
1070     create_info_count: u32,
1071     p_create_infos: *const ComputePipelineCreateInfo,
1072     p_allocator: *const AllocationCallbacks,
1073     p_pipelines: *mut Pipeline,
1074 ) -> Result;
1075 #[allow(non_camel_case_types)]
1076 pub type PFN_vkDestroyPipeline =
1077     extern "system" fn(device: Device, pipeline: Pipeline, p_allocator: *const AllocationCallbacks);
1078 #[allow(non_camel_case_types)]
1079 pub type PFN_vkCreatePipelineLayout = extern "system" fn(
1080     device: Device,
1081     p_create_info: *const PipelineLayoutCreateInfo,
1082     p_allocator: *const AllocationCallbacks,
1083     p_pipeline_layout: *mut PipelineLayout,
1084 ) -> Result;
1085 #[allow(non_camel_case_types)]
1086 pub type PFN_vkDestroyPipelineLayout = extern "system" fn(
1087     device: Device,
1088     pipeline_layout: PipelineLayout,
1089     p_allocator: *const AllocationCallbacks,
1090 );
1091 #[allow(non_camel_case_types)]
1092 pub type PFN_vkCreateSampler = extern "system" fn(
1093     device: Device,
1094     p_create_info: *const SamplerCreateInfo,
1095     p_allocator: *const AllocationCallbacks,
1096     p_sampler: *mut Sampler,
1097 ) -> Result;
1098 #[allow(non_camel_case_types)]
1099 pub type PFN_vkDestroySampler =
1100     extern "system" fn(device: Device, sampler: Sampler, p_allocator: *const AllocationCallbacks);
1101 #[allow(non_camel_case_types)]
1102 pub type PFN_vkCreateDescriptorSetLayout = extern "system" fn(
1103     device: Device,
1104     p_create_info: *const DescriptorSetLayoutCreateInfo,
1105     p_allocator: *const AllocationCallbacks,
1106     p_set_layout: *mut DescriptorSetLayout,
1107 ) -> Result;
1108 #[allow(non_camel_case_types)]
1109 pub type PFN_vkDestroyDescriptorSetLayout = extern "system" fn(
1110     device: Device,
1111     descriptor_set_layout: DescriptorSetLayout,
1112     p_allocator: *const AllocationCallbacks,
1113 );
1114 #[allow(non_camel_case_types)]
1115 pub type PFN_vkCreateDescriptorPool = extern "system" fn(
1116     device: Device,
1117     p_create_info: *const DescriptorPoolCreateInfo,
1118     p_allocator: *const AllocationCallbacks,
1119     p_descriptor_pool: *mut DescriptorPool,
1120 ) -> Result;
1121 #[allow(non_camel_case_types)]
1122 pub type PFN_vkDestroyDescriptorPool = extern "system" fn(
1123     device: Device,
1124     descriptor_pool: DescriptorPool,
1125     p_allocator: *const AllocationCallbacks,
1126 );
1127 #[allow(non_camel_case_types)]
1128 pub type PFN_vkResetDescriptorPool = extern "system" fn(
1129     device: Device,
1130     descriptor_pool: DescriptorPool,
1131     flags: DescriptorPoolResetFlags,
1132 ) -> Result;
1133 #[allow(non_camel_case_types)]
1134 pub type PFN_vkAllocateDescriptorSets = extern "system" fn(
1135     device: Device,
1136     p_allocate_info: *const DescriptorSetAllocateInfo,
1137     p_descriptor_sets: *mut DescriptorSet,
1138 ) -> Result;
1139 #[allow(non_camel_case_types)]
1140 pub type PFN_vkFreeDescriptorSets = extern "system" fn(
1141     device: Device,
1142     descriptor_pool: DescriptorPool,
1143     descriptor_set_count: u32,
1144     p_descriptor_sets: *const DescriptorSet,
1145 ) -> Result;
1146 #[allow(non_camel_case_types)]
1147 pub type PFN_vkUpdateDescriptorSets = extern "system" fn(
1148     device: Device,
1149     descriptor_write_count: u32,
1150     p_descriptor_writes: *const WriteDescriptorSet,
1151     descriptor_copy_count: u32,
1152     p_descriptor_copies: *const CopyDescriptorSet,
1153 );
1154 #[allow(non_camel_case_types)]
1155 pub type PFN_vkCreateFramebuffer = extern "system" fn(
1156     device: Device,
1157     p_create_info: *const FramebufferCreateInfo,
1158     p_allocator: *const AllocationCallbacks,
1159     p_framebuffer: *mut Framebuffer,
1160 ) -> Result;
1161 #[allow(non_camel_case_types)]
1162 pub type PFN_vkDestroyFramebuffer = extern "system" fn(
1163     device: Device,
1164     framebuffer: Framebuffer,
1165     p_allocator: *const AllocationCallbacks,
1166 );
1167 #[allow(non_camel_case_types)]
1168 pub type PFN_vkCreateRenderPass = extern "system" fn(
1169     device: Device,
1170     p_create_info: *const RenderPassCreateInfo,
1171     p_allocator: *const AllocationCallbacks,
1172     p_render_pass: *mut RenderPass,
1173 ) -> Result;
1174 #[allow(non_camel_case_types)]
1175 pub type PFN_vkDestroyRenderPass = extern "system" fn(
1176     device: Device,
1177     render_pass: RenderPass,
1178     p_allocator: *const AllocationCallbacks,
1179 );
1180 #[allow(non_camel_case_types)]
1181 pub type PFN_vkGetRenderAreaGranularity =
1182     extern "system" fn(device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D);
1183 #[allow(non_camel_case_types)]
1184 pub type PFN_vkCreateCommandPool = extern "system" fn(
1185     device: Device,
1186     p_create_info: *const CommandPoolCreateInfo,
1187     p_allocator: *const AllocationCallbacks,
1188     p_command_pool: *mut CommandPool,
1189 ) -> Result;
1190 #[allow(non_camel_case_types)]
1191 pub type PFN_vkDestroyCommandPool = extern "system" fn(
1192     device: Device,
1193     command_pool: CommandPool,
1194     p_allocator: *const AllocationCallbacks,
1195 );
1196 #[allow(non_camel_case_types)]
1197 pub type PFN_vkResetCommandPool = extern "system" fn(
1198     device: Device,
1199     command_pool: CommandPool,
1200     flags: CommandPoolResetFlags,
1201 ) -> Result;
1202 #[allow(non_camel_case_types)]
1203 pub type PFN_vkAllocateCommandBuffers = extern "system" fn(
1204     device: Device,
1205     p_allocate_info: *const CommandBufferAllocateInfo,
1206     p_command_buffers: *mut CommandBuffer,
1207 ) -> Result;
1208 #[allow(non_camel_case_types)]
1209 pub type PFN_vkFreeCommandBuffers = extern "system" fn(
1210     device: Device,
1211     command_pool: CommandPool,
1212     command_buffer_count: u32,
1213     p_command_buffers: *const CommandBuffer,
1214 );
1215 #[allow(non_camel_case_types)]
1216 pub type PFN_vkBeginCommandBuffer = extern "system" fn(
1217     command_buffer: CommandBuffer,
1218     p_begin_info: *const CommandBufferBeginInfo,
1219 ) -> Result;
1220 #[allow(non_camel_case_types)]
1221 pub type PFN_vkEndCommandBuffer = extern "system" fn(command_buffer: CommandBuffer) -> Result;
1222 #[allow(non_camel_case_types)]
1223 pub type PFN_vkResetCommandBuffer =
1224     extern "system" fn(command_buffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result;
1225 #[allow(non_camel_case_types)]
1226 pub type PFN_vkCmdBindPipeline = extern "system" fn(
1227     command_buffer: CommandBuffer,
1228     pipeline_bind_point: PipelineBindPoint,
1229     pipeline: Pipeline,
1230 );
1231 #[allow(non_camel_case_types)]
1232 pub type PFN_vkCmdSetViewport = extern "system" fn(
1233     command_buffer: CommandBuffer,
1234     first_viewport: u32,
1235     viewport_count: u32,
1236     p_viewports: *const Viewport,
1237 );
1238 #[allow(non_camel_case_types)]
1239 pub type PFN_vkCmdSetScissor = extern "system" fn(
1240     command_buffer: CommandBuffer,
1241     first_scissor: u32,
1242     scissor_count: u32,
1243     p_scissors: *const Rect2D,
1244 );
1245 #[allow(non_camel_case_types)]
1246 pub type PFN_vkCmdSetLineWidth = extern "system" fn(command_buffer: CommandBuffer, line_width: f32);
1247 #[allow(non_camel_case_types)]
1248 pub type PFN_vkCmdSetDepthBias = extern "system" fn(
1249     command_buffer: CommandBuffer,
1250     depth_bias_constant_factor: f32,
1251     depth_bias_clamp: f32,
1252     depth_bias_slope_factor: f32,
1253 );
1254 #[allow(non_camel_case_types)]
1255 pub type PFN_vkCmdSetBlendConstants =
1256     extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4]);
1257 #[allow(non_camel_case_types)]
1258 pub type PFN_vkCmdSetDepthBounds =
1259     extern "system" fn(command_buffer: CommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32);
1260 #[allow(non_camel_case_types)]
1261 pub type PFN_vkCmdSetStencilCompareMask = extern "system" fn(
1262     command_buffer: CommandBuffer,
1263     face_mask: StencilFaceFlags,
1264     compare_mask: u32,
1265 );
1266 #[allow(non_camel_case_types)]
1267 pub type PFN_vkCmdSetStencilWriteMask =
1268     extern "system" fn(command_buffer: CommandBuffer, face_mask: StencilFaceFlags, write_mask: u32);
1269 #[allow(non_camel_case_types)]
1270 pub type PFN_vkCmdSetStencilReference =
1271     extern "system" fn(command_buffer: CommandBuffer, face_mask: StencilFaceFlags, reference: u32);
1272 #[allow(non_camel_case_types)]
1273 pub type PFN_vkCmdBindDescriptorSets = extern "system" fn(
1274     command_buffer: CommandBuffer,
1275     pipeline_bind_point: PipelineBindPoint,
1276     layout: PipelineLayout,
1277     first_set: u32,
1278     descriptor_set_count: u32,
1279     p_descriptor_sets: *const DescriptorSet,
1280     dynamic_offset_count: u32,
1281     p_dynamic_offsets: *const u32,
1282 );
1283 #[allow(non_camel_case_types)]
1284 pub type PFN_vkCmdBindIndexBuffer = extern "system" fn(
1285     command_buffer: CommandBuffer,
1286     buffer: Buffer,
1287     offset: DeviceSize,
1288     index_type: IndexType,
1289 );
1290 #[allow(non_camel_case_types)]
1291 pub type PFN_vkCmdBindVertexBuffers = extern "system" fn(
1292     command_buffer: CommandBuffer,
1293     first_binding: u32,
1294     binding_count: u32,
1295     p_buffers: *const Buffer,
1296     p_offsets: *const DeviceSize,
1297 );
1298 #[allow(non_camel_case_types)]
1299 pub type PFN_vkCmdDraw = extern "system" fn(
1300     command_buffer: CommandBuffer,
1301     vertex_count: u32,
1302     instance_count: u32,
1303     first_vertex: u32,
1304     first_instance: u32,
1305 );
1306 #[allow(non_camel_case_types)]
1307 pub type PFN_vkCmdDrawIndexed = extern "system" fn(
1308     command_buffer: CommandBuffer,
1309     index_count: u32,
1310     instance_count: u32,
1311     first_index: u32,
1312     vertex_offset: i32,
1313     first_instance: u32,
1314 );
1315 #[allow(non_camel_case_types)]
1316 pub type PFN_vkCmdDrawIndirect = extern "system" fn(
1317     command_buffer: CommandBuffer,
1318     buffer: Buffer,
1319     offset: DeviceSize,
1320     draw_count: u32,
1321     stride: u32,
1322 );
1323 #[allow(non_camel_case_types)]
1324 pub type PFN_vkCmdDrawIndexedIndirect = extern "system" fn(
1325     command_buffer: CommandBuffer,
1326     buffer: Buffer,
1327     offset: DeviceSize,
1328     draw_count: u32,
1329     stride: u32,
1330 );
1331 #[allow(non_camel_case_types)]
1332 pub type PFN_vkCmdDispatch = extern "system" fn(
1333     command_buffer: CommandBuffer,
1334     group_count_x: u32,
1335     group_count_y: u32,
1336     group_count_z: u32,
1337 );
1338 #[allow(non_camel_case_types)]
1339 pub type PFN_vkCmdDispatchIndirect =
1340     extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize);
1341 #[allow(non_camel_case_types)]
1342 pub type PFN_vkCmdCopyBuffer = extern "system" fn(
1343     command_buffer: CommandBuffer,
1344     src_buffer: Buffer,
1345     dst_buffer: Buffer,
1346     region_count: u32,
1347     p_regions: *const BufferCopy,
1348 );
1349 #[allow(non_camel_case_types)]
1350 pub type PFN_vkCmdCopyImage = extern "system" fn(
1351     command_buffer: CommandBuffer,
1352     src_image: Image,
1353     src_image_layout: ImageLayout,
1354     dst_image: Image,
1355     dst_image_layout: ImageLayout,
1356     region_count: u32,
1357     p_regions: *const ImageCopy,
1358 );
1359 #[allow(non_camel_case_types)]
1360 pub type PFN_vkCmdBlitImage = extern "system" fn(
1361     command_buffer: CommandBuffer,
1362     src_image: Image,
1363     src_image_layout: ImageLayout,
1364     dst_image: Image,
1365     dst_image_layout: ImageLayout,
1366     region_count: u32,
1367     p_regions: *const ImageBlit,
1368     filter: Filter,
1369 );
1370 #[allow(non_camel_case_types)]
1371 pub type PFN_vkCmdCopyBufferToImage = extern "system" fn(
1372     command_buffer: CommandBuffer,
1373     src_buffer: Buffer,
1374     dst_image: Image,
1375     dst_image_layout: ImageLayout,
1376     region_count: u32,
1377     p_regions: *const BufferImageCopy,
1378 );
1379 #[allow(non_camel_case_types)]
1380 pub type PFN_vkCmdCopyImageToBuffer = extern "system" fn(
1381     command_buffer: CommandBuffer,
1382     src_image: Image,
1383     src_image_layout: ImageLayout,
1384     dst_buffer: Buffer,
1385     region_count: u32,
1386     p_regions: *const BufferImageCopy,
1387 );
1388 #[allow(non_camel_case_types)]
1389 pub type PFN_vkCmdUpdateBuffer = extern "system" fn(
1390     command_buffer: CommandBuffer,
1391     dst_buffer: Buffer,
1392     dst_offset: DeviceSize,
1393     data_size: DeviceSize,
1394     p_data: *const c_void,
1395 );
1396 #[allow(non_camel_case_types)]
1397 pub type PFN_vkCmdFillBuffer = extern "system" fn(
1398     command_buffer: CommandBuffer,
1399     dst_buffer: Buffer,
1400     dst_offset: DeviceSize,
1401     size: DeviceSize,
1402     data: u32,
1403 );
1404 #[allow(non_camel_case_types)]
1405 pub type PFN_vkCmdClearColorImage = extern "system" fn(
1406     command_buffer: CommandBuffer,
1407     image: Image,
1408     image_layout: ImageLayout,
1409     p_color: *const ClearColorValue,
1410     range_count: u32,
1411     p_ranges: *const ImageSubresourceRange,
1412 );
1413 #[allow(non_camel_case_types)]
1414 pub type PFN_vkCmdClearDepthStencilImage = extern "system" fn(
1415     command_buffer: CommandBuffer,
1416     image: Image,
1417     image_layout: ImageLayout,
1418     p_depth_stencil: *const ClearDepthStencilValue,
1419     range_count: u32,
1420     p_ranges: *const ImageSubresourceRange,
1421 );
1422 #[allow(non_camel_case_types)]
1423 pub type PFN_vkCmdClearAttachments = extern "system" fn(
1424     command_buffer: CommandBuffer,
1425     attachment_count: u32,
1426     p_attachments: *const ClearAttachment,
1427     rect_count: u32,
1428     p_rects: *const ClearRect,
1429 );
1430 #[allow(non_camel_case_types)]
1431 pub type PFN_vkCmdResolveImage = extern "system" fn(
1432     command_buffer: CommandBuffer,
1433     src_image: Image,
1434     src_image_layout: ImageLayout,
1435     dst_image: Image,
1436     dst_image_layout: ImageLayout,
1437     region_count: u32,
1438     p_regions: *const ImageResolve,
1439 );
1440 #[allow(non_camel_case_types)]
1441 pub type PFN_vkCmdSetEvent =
1442     extern "system" fn(command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags);
1443 #[allow(non_camel_case_types)]
1444 pub type PFN_vkCmdResetEvent =
1445     extern "system" fn(command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags);
1446 #[allow(non_camel_case_types)]
1447 pub type PFN_vkCmdWaitEvents = extern "system" fn(
1448     command_buffer: CommandBuffer,
1449     event_count: u32,
1450     p_events: *const Event,
1451     src_stage_mask: PipelineStageFlags,
1452     dst_stage_mask: PipelineStageFlags,
1453     memory_barrier_count: u32,
1454     p_memory_barriers: *const MemoryBarrier,
1455     buffer_memory_barrier_count: u32,
1456     p_buffer_memory_barriers: *const BufferMemoryBarrier,
1457     image_memory_barrier_count: u32,
1458     p_image_memory_barriers: *const ImageMemoryBarrier,
1459 );
1460 #[allow(non_camel_case_types)]
1461 pub type PFN_vkCmdPipelineBarrier = extern "system" fn(
1462     command_buffer: CommandBuffer,
1463     src_stage_mask: PipelineStageFlags,
1464     dst_stage_mask: PipelineStageFlags,
1465     dependency_flags: DependencyFlags,
1466     memory_barrier_count: u32,
1467     p_memory_barriers: *const MemoryBarrier,
1468     buffer_memory_barrier_count: u32,
1469     p_buffer_memory_barriers: *const BufferMemoryBarrier,
1470     image_memory_barrier_count: u32,
1471     p_image_memory_barriers: *const ImageMemoryBarrier,
1472 );
1473 #[allow(non_camel_case_types)]
1474 pub type PFN_vkCmdBeginQuery = extern "system" fn(
1475     command_buffer: CommandBuffer,
1476     query_pool: QueryPool,
1477     query: u32,
1478     flags: QueryControlFlags,
1479 );
1480 #[allow(non_camel_case_types)]
1481 pub type PFN_vkCmdEndQuery =
1482     extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32);
1483 #[allow(non_camel_case_types)]
1484 pub type PFN_vkCmdResetQueryPool = extern "system" fn(
1485     command_buffer: CommandBuffer,
1486     query_pool: QueryPool,
1487     first_query: u32,
1488     query_count: u32,
1489 );
1490 #[allow(non_camel_case_types)]
1491 pub type PFN_vkCmdWriteTimestamp = extern "system" fn(
1492     command_buffer: CommandBuffer,
1493     pipeline_stage: PipelineStageFlags,
1494     query_pool: QueryPool,
1495     query: u32,
1496 );
1497 #[allow(non_camel_case_types)]
1498 pub type PFN_vkCmdCopyQueryPoolResults = extern "system" fn(
1499     command_buffer: CommandBuffer,
1500     query_pool: QueryPool,
1501     first_query: u32,
1502     query_count: u32,
1503     dst_buffer: Buffer,
1504     dst_offset: DeviceSize,
1505     stride: DeviceSize,
1506     flags: QueryResultFlags,
1507 );
1508 #[allow(non_camel_case_types)]
1509 pub type PFN_vkCmdPushConstants = extern "system" fn(
1510     command_buffer: CommandBuffer,
1511     layout: PipelineLayout,
1512     stage_flags: ShaderStageFlags,
1513     offset: u32,
1514     size: u32,
1515     p_values: *const c_void,
1516 );
1517 #[allow(non_camel_case_types)]
1518 pub type PFN_vkCmdBeginRenderPass = extern "system" fn(
1519     command_buffer: CommandBuffer,
1520     p_render_pass_begin: *const RenderPassBeginInfo,
1521     contents: SubpassContents,
1522 );
1523 #[allow(non_camel_case_types)]
1524 pub type PFN_vkCmdNextSubpass =
1525     extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents);
1526 #[allow(non_camel_case_types)]
1527 pub type PFN_vkCmdEndRenderPass = extern "system" fn(command_buffer: CommandBuffer);
1528 #[allow(non_camel_case_types)]
1529 pub type PFN_vkCmdExecuteCommands = extern "system" fn(
1530     command_buffer: CommandBuffer,
1531     command_buffer_count: u32,
1532     p_command_buffers: *const CommandBuffer,
1533 );
1534 pub struct DeviceFnV1_0 {
1535     pub destroy_device: extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks),
1536     pub get_device_queue: extern "system" fn(
1537         device: Device,
1538         queue_family_index: u32,
1539         queue_index: u32,
1540         p_queue: *mut Queue,
1541     ),
1542     pub queue_submit: extern "system" fn(
1543         queue: Queue,
1544         submit_count: u32,
1545         p_submits: *const SubmitInfo,
1546         fence: Fence,
1547     ) -> Result,
1548     pub queue_wait_idle: extern "system" fn(queue: Queue) -> Result,
1549     pub device_wait_idle: extern "system" fn(device: Device) -> Result,
1550     pub allocate_memory: extern "system" fn(
1551         device: Device,
1552         p_allocate_info: *const MemoryAllocateInfo,
1553         p_allocator: *const AllocationCallbacks,
1554         p_memory: *mut DeviceMemory,
1555     ) -> Result,
1556     pub free_memory: extern "system" fn(
1557         device: Device,
1558         memory: DeviceMemory,
1559         p_allocator: *const AllocationCallbacks,
1560     ),
1561     pub map_memory: extern "system" fn(
1562         device: Device,
1563         memory: DeviceMemory,
1564         offset: DeviceSize,
1565         size: DeviceSize,
1566         flags: MemoryMapFlags,
1567         pp_data: *mut *mut c_void,
1568     ) -> Result,
1569     pub unmap_memory: extern "system" fn(device: Device, memory: DeviceMemory),
1570     pub flush_mapped_memory_ranges: extern "system" fn(
1571         device: Device,
1572         memory_range_count: u32,
1573         p_memory_ranges: *const MappedMemoryRange,
1574     ) -> Result,
1575     pub invalidate_mapped_memory_ranges: extern "system" fn(
1576         device: Device,
1577         memory_range_count: u32,
1578         p_memory_ranges: *const MappedMemoryRange,
1579     ) -> Result,
1580     pub get_device_memory_commitment: extern "system" fn(
1581         device: Device,
1582         memory: DeviceMemory,
1583         p_committed_memory_in_bytes: *mut DeviceSize,
1584     ),
1585     pub bind_buffer_memory: extern "system" fn(
1586         device: Device,
1587         buffer: Buffer,
1588         memory: DeviceMemory,
1589         memory_offset: DeviceSize,
1590     ) -> Result,
1591     pub bind_image_memory: extern "system" fn(
1592         device: Device,
1593         image: Image,
1594         memory: DeviceMemory,
1595         memory_offset: DeviceSize,
1596     ) -> Result,
1597     pub get_buffer_memory_requirements: extern "system" fn(
1598         device: Device,
1599         buffer: Buffer,
1600         p_memory_requirements: *mut MemoryRequirements,
1601     ),
1602     pub get_image_memory_requirements: extern "system" fn(
1603         device: Device,
1604         image: Image,
1605         p_memory_requirements: *mut MemoryRequirements,
1606     ),
1607     pub get_image_sparse_memory_requirements: extern "system" fn(
1608         device: Device,
1609         image: Image,
1610         p_sparse_memory_requirement_count: *mut u32,
1611         p_sparse_memory_requirements: *mut SparseImageMemoryRequirements,
1612     ),
1613     pub queue_bind_sparse: extern "system" fn(
1614         queue: Queue,
1615         bind_info_count: u32,
1616         p_bind_info: *const BindSparseInfo,
1617         fence: Fence,
1618     ) -> Result,
1619     pub create_fence: extern "system" fn(
1620         device: Device,
1621         p_create_info: *const FenceCreateInfo,
1622         p_allocator: *const AllocationCallbacks,
1623         p_fence: *mut Fence,
1624     ) -> Result,
1625     pub destroy_fence:
1626         extern "system" fn(device: Device, fence: Fence, p_allocator: *const AllocationCallbacks),
1627     pub reset_fences:
1628         extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result,
1629     pub get_fence_status: extern "system" fn(device: Device, fence: Fence) -> Result,
1630     pub wait_for_fences: extern "system" fn(
1631         device: Device,
1632         fence_count: u32,
1633         p_fences: *const Fence,
1634         wait_all: Bool32,
1635         timeout: u64,
1636     ) -> Result,
1637     pub create_semaphore: extern "system" fn(
1638         device: Device,
1639         p_create_info: *const SemaphoreCreateInfo,
1640         p_allocator: *const AllocationCallbacks,
1641         p_semaphore: *mut Semaphore,
1642     ) -> Result,
1643     pub destroy_semaphore: extern "system" fn(
1644         device: Device,
1645         semaphore: Semaphore,
1646         p_allocator: *const AllocationCallbacks,
1647     ),
1648     pub create_event: extern "system" fn(
1649         device: Device,
1650         p_create_info: *const EventCreateInfo,
1651         p_allocator: *const AllocationCallbacks,
1652         p_event: *mut Event,
1653     ) -> Result,
1654     pub destroy_event:
1655         extern "system" fn(device: Device, event: Event, p_allocator: *const AllocationCallbacks),
1656     pub get_event_status: extern "system" fn(device: Device, event: Event) -> Result,
1657     pub set_event: extern "system" fn(device: Device, event: Event) -> Result,
1658     pub reset_event: extern "system" fn(device: Device, event: Event) -> Result,
1659     pub create_query_pool: extern "system" fn(
1660         device: Device,
1661         p_create_info: *const QueryPoolCreateInfo,
1662         p_allocator: *const AllocationCallbacks,
1663         p_query_pool: *mut QueryPool,
1664     ) -> Result,
1665     pub destroy_query_pool: extern "system" fn(
1666         device: Device,
1667         query_pool: QueryPool,
1668         p_allocator: *const AllocationCallbacks,
1669     ),
1670     pub get_query_pool_results: extern "system" fn(
1671         device: Device,
1672         query_pool: QueryPool,
1673         first_query: u32,
1674         query_count: u32,
1675         data_size: usize,
1676         p_data: *mut c_void,
1677         stride: DeviceSize,
1678         flags: QueryResultFlags,
1679     ) -> Result,
1680     pub create_buffer: extern "system" fn(
1681         device: Device,
1682         p_create_info: *const BufferCreateInfo,
1683         p_allocator: *const AllocationCallbacks,
1684         p_buffer: *mut Buffer,
1685     ) -> Result,
1686     pub destroy_buffer:
1687         extern "system" fn(device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks),
1688     pub create_buffer_view: extern "system" fn(
1689         device: Device,
1690         p_create_info: *const BufferViewCreateInfo,
1691         p_allocator: *const AllocationCallbacks,
1692         p_view: *mut BufferView,
1693     ) -> Result,
1694     pub destroy_buffer_view: extern "system" fn(
1695         device: Device,
1696         buffer_view: BufferView,
1697         p_allocator: *const AllocationCallbacks,
1698     ),
1699     pub create_image: extern "system" fn(
1700         device: Device,
1701         p_create_info: *const ImageCreateInfo,
1702         p_allocator: *const AllocationCallbacks,
1703         p_image: *mut Image,
1704     ) -> Result,
1705     pub destroy_image:
1706         extern "system" fn(device: Device, image: Image, p_allocator: *const AllocationCallbacks),
1707     pub get_image_subresource_layout: extern "system" fn(
1708         device: Device,
1709         image: Image,
1710         p_subresource: *const ImageSubresource,
1711         p_layout: *mut SubresourceLayout,
1712     ),
1713     pub create_image_view: extern "system" fn(
1714         device: Device,
1715         p_create_info: *const ImageViewCreateInfo,
1716         p_allocator: *const AllocationCallbacks,
1717         p_view: *mut ImageView,
1718     ) -> Result,
1719     pub destroy_image_view: extern "system" fn(
1720         device: Device,
1721         image_view: ImageView,
1722         p_allocator: *const AllocationCallbacks,
1723     ),
1724     pub create_shader_module: extern "system" fn(
1725         device: Device,
1726         p_create_info: *const ShaderModuleCreateInfo,
1727         p_allocator: *const AllocationCallbacks,
1728         p_shader_module: *mut ShaderModule,
1729     ) -> Result,
1730     pub destroy_shader_module: extern "system" fn(
1731         device: Device,
1732         shader_module: ShaderModule,
1733         p_allocator: *const AllocationCallbacks,
1734     ),
1735     pub create_pipeline_cache: extern "system" fn(
1736         device: Device,
1737         p_create_info: *const PipelineCacheCreateInfo,
1738         p_allocator: *const AllocationCallbacks,
1739         p_pipeline_cache: *mut PipelineCache,
1740     ) -> Result,
1741     pub destroy_pipeline_cache: extern "system" fn(
1742         device: Device,
1743         pipeline_cache: PipelineCache,
1744         p_allocator: *const AllocationCallbacks,
1745     ),
1746     pub get_pipeline_cache_data: extern "system" fn(
1747         device: Device,
1748         pipeline_cache: PipelineCache,
1749         p_data_size: *mut usize,
1750         p_data: *mut c_void,
1751     ) -> Result,
1752     pub merge_pipeline_caches: extern "system" fn(
1753         device: Device,
1754         dst_cache: PipelineCache,
1755         src_cache_count: u32,
1756         p_src_caches: *const PipelineCache,
1757     ) -> Result,
1758     pub create_graphics_pipelines: extern "system" fn(
1759         device: Device,
1760         pipeline_cache: PipelineCache,
1761         create_info_count: u32,
1762         p_create_infos: *const GraphicsPipelineCreateInfo,
1763         p_allocator: *const AllocationCallbacks,
1764         p_pipelines: *mut Pipeline,
1765     ) -> Result,
1766     pub create_compute_pipelines: extern "system" fn(
1767         device: Device,
1768         pipeline_cache: PipelineCache,
1769         create_info_count: u32,
1770         p_create_infos: *const ComputePipelineCreateInfo,
1771         p_allocator: *const AllocationCallbacks,
1772         p_pipelines: *mut Pipeline,
1773     ) -> Result,
1774     pub destroy_pipeline: extern "system" fn(
1775         device: Device,
1776         pipeline: Pipeline,
1777         p_allocator: *const AllocationCallbacks,
1778     ),
1779     pub create_pipeline_layout: extern "system" fn(
1780         device: Device,
1781         p_create_info: *const PipelineLayoutCreateInfo,
1782         p_allocator: *const AllocationCallbacks,
1783         p_pipeline_layout: *mut PipelineLayout,
1784     ) -> Result,
1785     pub destroy_pipeline_layout: extern "system" fn(
1786         device: Device,
1787         pipeline_layout: PipelineLayout,
1788         p_allocator: *const AllocationCallbacks,
1789     ),
1790     pub create_sampler: extern "system" fn(
1791         device: Device,
1792         p_create_info: *const SamplerCreateInfo,
1793         p_allocator: *const AllocationCallbacks,
1794         p_sampler: *mut Sampler,
1795     ) -> Result,
1796     pub destroy_sampler: extern "system" fn(
1797         device: Device,
1798         sampler: Sampler,
1799         p_allocator: *const AllocationCallbacks,
1800     ),
1801     pub create_descriptor_set_layout: extern "system" fn(
1802         device: Device,
1803         p_create_info: *const DescriptorSetLayoutCreateInfo,
1804         p_allocator: *const AllocationCallbacks,
1805         p_set_layout: *mut DescriptorSetLayout,
1806     ) -> Result,
1807     pub destroy_descriptor_set_layout: extern "system" fn(
1808         device: Device,
1809         descriptor_set_layout: DescriptorSetLayout,
1810         p_allocator: *const AllocationCallbacks,
1811     ),
1812     pub create_descriptor_pool: extern "system" fn(
1813         device: Device,
1814         p_create_info: *const DescriptorPoolCreateInfo,
1815         p_allocator: *const AllocationCallbacks,
1816         p_descriptor_pool: *mut DescriptorPool,
1817     ) -> Result,
1818     pub destroy_descriptor_pool: extern "system" fn(
1819         device: Device,
1820         descriptor_pool: DescriptorPool,
1821         p_allocator: *const AllocationCallbacks,
1822     ),
1823     pub reset_descriptor_pool: extern "system" fn(
1824         device: Device,
1825         descriptor_pool: DescriptorPool,
1826         flags: DescriptorPoolResetFlags,
1827     ) -> Result,
1828     pub allocate_descriptor_sets: extern "system" fn(
1829         device: Device,
1830         p_allocate_info: *const DescriptorSetAllocateInfo,
1831         p_descriptor_sets: *mut DescriptorSet,
1832     ) -> Result,
1833     pub free_descriptor_sets: extern "system" fn(
1834         device: Device,
1835         descriptor_pool: DescriptorPool,
1836         descriptor_set_count: u32,
1837         p_descriptor_sets: *const DescriptorSet,
1838     ) -> Result,
1839     pub update_descriptor_sets: extern "system" fn(
1840         device: Device,
1841         descriptor_write_count: u32,
1842         p_descriptor_writes: *const WriteDescriptorSet,
1843         descriptor_copy_count: u32,
1844         p_descriptor_copies: *const CopyDescriptorSet,
1845     ),
1846     pub create_framebuffer: extern "system" fn(
1847         device: Device,
1848         p_create_info: *const FramebufferCreateInfo,
1849         p_allocator: *const AllocationCallbacks,
1850         p_framebuffer: *mut Framebuffer,
1851     ) -> Result,
1852     pub destroy_framebuffer: extern "system" fn(
1853         device: Device,
1854         framebuffer: Framebuffer,
1855         p_allocator: *const AllocationCallbacks,
1856     ),
1857     pub create_render_pass: extern "system" fn(
1858         device: Device,
1859         p_create_info: *const RenderPassCreateInfo,
1860         p_allocator: *const AllocationCallbacks,
1861         p_render_pass: *mut RenderPass,
1862     ) -> Result,
1863     pub destroy_render_pass: extern "system" fn(
1864         device: Device,
1865         render_pass: RenderPass,
1866         p_allocator: *const AllocationCallbacks,
1867     ),
1868     pub get_render_area_granularity:
1869         extern "system" fn(device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D),
1870     pub create_command_pool: extern "system" fn(
1871         device: Device,
1872         p_create_info: *const CommandPoolCreateInfo,
1873         p_allocator: *const AllocationCallbacks,
1874         p_command_pool: *mut CommandPool,
1875     ) -> Result,
1876     pub destroy_command_pool: extern "system" fn(
1877         device: Device,
1878         command_pool: CommandPool,
1879         p_allocator: *const AllocationCallbacks,
1880     ),
1881     pub reset_command_pool: extern "system" fn(
1882         device: Device,
1883         command_pool: CommandPool,
1884         flags: CommandPoolResetFlags,
1885     ) -> Result,
1886     pub allocate_command_buffers: extern "system" fn(
1887         device: Device,
1888         p_allocate_info: *const CommandBufferAllocateInfo,
1889         p_command_buffers: *mut CommandBuffer,
1890     ) -> Result,
1891     pub free_command_buffers: extern "system" fn(
1892         device: Device,
1893         command_pool: CommandPool,
1894         command_buffer_count: u32,
1895         p_command_buffers: *const CommandBuffer,
1896     ),
1897     pub begin_command_buffer: extern "system" fn(
1898         command_buffer: CommandBuffer,
1899         p_begin_info: *const CommandBufferBeginInfo,
1900     ) -> Result,
1901     pub end_command_buffer: extern "system" fn(command_buffer: CommandBuffer) -> Result,
1902     pub reset_command_buffer:
1903         extern "system" fn(command_buffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result,
1904     pub cmd_bind_pipeline: extern "system" fn(
1905         command_buffer: CommandBuffer,
1906         pipeline_bind_point: PipelineBindPoint,
1907         pipeline: Pipeline,
1908     ),
1909     pub cmd_set_viewport: extern "system" fn(
1910         command_buffer: CommandBuffer,
1911         first_viewport: u32,
1912         viewport_count: u32,
1913         p_viewports: *const Viewport,
1914     ),
1915     pub cmd_set_scissor: extern "system" fn(
1916         command_buffer: CommandBuffer,
1917         first_scissor: u32,
1918         scissor_count: u32,
1919         p_scissors: *const Rect2D,
1920     ),
1921     pub cmd_set_line_width: extern "system" fn(command_buffer: CommandBuffer, line_width: f32),
1922     pub cmd_set_depth_bias: extern "system" fn(
1923         command_buffer: CommandBuffer,
1924         depth_bias_constant_factor: f32,
1925         depth_bias_clamp: f32,
1926         depth_bias_slope_factor: f32,
1927     ),
1928     pub cmd_set_blend_constants:
1929         extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4]),
1930     pub cmd_set_depth_bounds: extern "system" fn(
1931         command_buffer: CommandBuffer,
1932         min_depth_bounds: f32,
1933         max_depth_bounds: f32,
1934     ),
1935     pub cmd_set_stencil_compare_mask: extern "system" fn(
1936         command_buffer: CommandBuffer,
1937         face_mask: StencilFaceFlags,
1938         compare_mask: u32,
1939     ),
1940     pub cmd_set_stencil_write_mask: extern "system" fn(
1941         command_buffer: CommandBuffer,
1942         face_mask: StencilFaceFlags,
1943         write_mask: u32,
1944     ),
1945     pub cmd_set_stencil_reference: extern "system" fn(
1946         command_buffer: CommandBuffer,
1947         face_mask: StencilFaceFlags,
1948         reference: u32,
1949     ),
1950     pub cmd_bind_descriptor_sets: extern "system" fn(
1951         command_buffer: CommandBuffer,
1952         pipeline_bind_point: PipelineBindPoint,
1953         layout: PipelineLayout,
1954         first_set: u32,
1955         descriptor_set_count: u32,
1956         p_descriptor_sets: *const DescriptorSet,
1957         dynamic_offset_count: u32,
1958         p_dynamic_offsets: *const u32,
1959     ),
1960     pub cmd_bind_index_buffer: extern "system" fn(
1961         command_buffer: CommandBuffer,
1962         buffer: Buffer,
1963         offset: DeviceSize,
1964         index_type: IndexType,
1965     ),
1966     pub cmd_bind_vertex_buffers: extern "system" fn(
1967         command_buffer: CommandBuffer,
1968         first_binding: u32,
1969         binding_count: u32,
1970         p_buffers: *const Buffer,
1971         p_offsets: *const DeviceSize,
1972     ),
1973     pub cmd_draw: extern "system" fn(
1974         command_buffer: CommandBuffer,
1975         vertex_count: u32,
1976         instance_count: u32,
1977         first_vertex: u32,
1978         first_instance: u32,
1979     ),
1980     pub cmd_draw_indexed: extern "system" fn(
1981         command_buffer: CommandBuffer,
1982         index_count: u32,
1983         instance_count: u32,
1984         first_index: u32,
1985         vertex_offset: i32,
1986         first_instance: u32,
1987     ),
1988     pub cmd_draw_indirect: extern "system" fn(
1989         command_buffer: CommandBuffer,
1990         buffer: Buffer,
1991         offset: DeviceSize,
1992         draw_count: u32,
1993         stride: u32,
1994     ),
1995     pub cmd_draw_indexed_indirect: extern "system" fn(
1996         command_buffer: CommandBuffer,
1997         buffer: Buffer,
1998         offset: DeviceSize,
1999         draw_count: u32,
2000         stride: u32,
2001     ),
2002     pub cmd_dispatch: extern "system" fn(
2003         command_buffer: CommandBuffer,
2004         group_count_x: u32,
2005         group_count_y: u32,
2006         group_count_z: u32,
2007     ),
2008     pub cmd_dispatch_indirect:
2009         extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize),
2010     pub cmd_copy_buffer: extern "system" fn(
2011         command_buffer: CommandBuffer,
2012         src_buffer: Buffer,
2013         dst_buffer: Buffer,
2014         region_count: u32,
2015         p_regions: *const BufferCopy,
2016     ),
2017     pub cmd_copy_image: extern "system" fn(
2018         command_buffer: CommandBuffer,
2019         src_image: Image,
2020         src_image_layout: ImageLayout,
2021         dst_image: Image,
2022         dst_image_layout: ImageLayout,
2023         region_count: u32,
2024         p_regions: *const ImageCopy,
2025     ),
2026     pub cmd_blit_image: extern "system" fn(
2027         command_buffer: CommandBuffer,
2028         src_image: Image,
2029         src_image_layout: ImageLayout,
2030         dst_image: Image,
2031         dst_image_layout: ImageLayout,
2032         region_count: u32,
2033         p_regions: *const ImageBlit,
2034         filter: Filter,
2035     ),
2036     pub cmd_copy_buffer_to_image: extern "system" fn(
2037         command_buffer: CommandBuffer,
2038         src_buffer: Buffer,
2039         dst_image: Image,
2040         dst_image_layout: ImageLayout,
2041         region_count: u32,
2042         p_regions: *const BufferImageCopy,
2043     ),
2044     pub cmd_copy_image_to_buffer: extern "system" fn(
2045         command_buffer: CommandBuffer,
2046         src_image: Image,
2047         src_image_layout: ImageLayout,
2048         dst_buffer: Buffer,
2049         region_count: u32,
2050         p_regions: *const BufferImageCopy,
2051     ),
2052     pub cmd_update_buffer: extern "system" fn(
2053         command_buffer: CommandBuffer,
2054         dst_buffer: Buffer,
2055         dst_offset: DeviceSize,
2056         data_size: DeviceSize,
2057         p_data: *const c_void,
2058     ),
2059     pub cmd_fill_buffer: extern "system" fn(
2060         command_buffer: CommandBuffer,
2061         dst_buffer: Buffer,
2062         dst_offset: DeviceSize,
2063         size: DeviceSize,
2064         data: u32,
2065     ),
2066     pub cmd_clear_color_image: extern "system" fn(
2067         command_buffer: CommandBuffer,
2068         image: Image,
2069         image_layout: ImageLayout,
2070         p_color: *const ClearColorValue,
2071         range_count: u32,
2072         p_ranges: *const ImageSubresourceRange,
2073     ),
2074     pub cmd_clear_depth_stencil_image: extern "system" fn(
2075         command_buffer: CommandBuffer,
2076         image: Image,
2077         image_layout: ImageLayout,
2078         p_depth_stencil: *const ClearDepthStencilValue,
2079         range_count: u32,
2080         p_ranges: *const ImageSubresourceRange,
2081     ),
2082     pub cmd_clear_attachments: extern "system" fn(
2083         command_buffer: CommandBuffer,
2084         attachment_count: u32,
2085         p_attachments: *const ClearAttachment,
2086         rect_count: u32,
2087         p_rects: *const ClearRect,
2088     ),
2089     pub cmd_resolve_image: extern "system" fn(
2090         command_buffer: CommandBuffer,
2091         src_image: Image,
2092         src_image_layout: ImageLayout,
2093         dst_image: Image,
2094         dst_image_layout: ImageLayout,
2095         region_count: u32,
2096         p_regions: *const ImageResolve,
2097     ),
2098     pub cmd_set_event: extern "system" fn(
2099         command_buffer: CommandBuffer,
2100         event: Event,
2101         stage_mask: PipelineStageFlags,
2102     ),
2103     pub cmd_reset_event: extern "system" fn(
2104         command_buffer: CommandBuffer,
2105         event: Event,
2106         stage_mask: PipelineStageFlags,
2107     ),
2108     pub cmd_wait_events: extern "system" fn(
2109         command_buffer: CommandBuffer,
2110         event_count: u32,
2111         p_events: *const Event,
2112         src_stage_mask: PipelineStageFlags,
2113         dst_stage_mask: PipelineStageFlags,
2114         memory_barrier_count: u32,
2115         p_memory_barriers: *const MemoryBarrier,
2116         buffer_memory_barrier_count: u32,
2117         p_buffer_memory_barriers: *const BufferMemoryBarrier,
2118         image_memory_barrier_count: u32,
2119         p_image_memory_barriers: *const ImageMemoryBarrier,
2120     ),
2121     pub cmd_pipeline_barrier: extern "system" fn(
2122         command_buffer: CommandBuffer,
2123         src_stage_mask: PipelineStageFlags,
2124         dst_stage_mask: PipelineStageFlags,
2125         dependency_flags: DependencyFlags,
2126         memory_barrier_count: u32,
2127         p_memory_barriers: *const MemoryBarrier,
2128         buffer_memory_barrier_count: u32,
2129         p_buffer_memory_barriers: *const BufferMemoryBarrier,
2130         image_memory_barrier_count: u32,
2131         p_image_memory_barriers: *const ImageMemoryBarrier,
2132     ),
2133     pub cmd_begin_query: extern "system" fn(
2134         command_buffer: CommandBuffer,
2135         query_pool: QueryPool,
2136         query: u32,
2137         flags: QueryControlFlags,
2138     ),
2139     pub cmd_end_query:
2140         extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32),
2141     pub cmd_reset_query_pool: extern "system" fn(
2142         command_buffer: CommandBuffer,
2143         query_pool: QueryPool,
2144         first_query: u32,
2145         query_count: u32,
2146     ),
2147     pub cmd_write_timestamp: extern "system" fn(
2148         command_buffer: CommandBuffer,
2149         pipeline_stage: PipelineStageFlags,
2150         query_pool: QueryPool,
2151         query: u32,
2152     ),
2153     pub cmd_copy_query_pool_results: extern "system" fn(
2154         command_buffer: CommandBuffer,
2155         query_pool: QueryPool,
2156         first_query: u32,
2157         query_count: u32,
2158         dst_buffer: Buffer,
2159         dst_offset: DeviceSize,
2160         stride: DeviceSize,
2161         flags: QueryResultFlags,
2162     ),
2163     pub cmd_push_constants: extern "system" fn(
2164         command_buffer: CommandBuffer,
2165         layout: PipelineLayout,
2166         stage_flags: ShaderStageFlags,
2167         offset: u32,
2168         size: u32,
2169         p_values: *const c_void,
2170     ),
2171     pub cmd_begin_render_pass: extern "system" fn(
2172         command_buffer: CommandBuffer,
2173         p_render_pass_begin: *const RenderPassBeginInfo,
2174         contents: SubpassContents,
2175     ),
2176     pub cmd_next_subpass:
2177         extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents),
2178     pub cmd_end_render_pass: extern "system" fn(command_buffer: CommandBuffer),
2179     pub cmd_execute_commands: extern "system" fn(
2180         command_buffer: CommandBuffer,
2181         command_buffer_count: u32,
2182         p_command_buffers: *const CommandBuffer,
2183     ),
2184 }
2185 unsafe impl Send for DeviceFnV1_0 {}
2186 unsafe impl Sync for DeviceFnV1_0 {}
2187 impl ::std::clone::Clone for DeviceFnV1_0 {
clone(&self) -> Self2188     fn clone(&self) -> Self {
2189         DeviceFnV1_0 {
2190             destroy_device: self.destroy_device,
2191             get_device_queue: self.get_device_queue,
2192             queue_submit: self.queue_submit,
2193             queue_wait_idle: self.queue_wait_idle,
2194             device_wait_idle: self.device_wait_idle,
2195             allocate_memory: self.allocate_memory,
2196             free_memory: self.free_memory,
2197             map_memory: self.map_memory,
2198             unmap_memory: self.unmap_memory,
2199             flush_mapped_memory_ranges: self.flush_mapped_memory_ranges,
2200             invalidate_mapped_memory_ranges: self.invalidate_mapped_memory_ranges,
2201             get_device_memory_commitment: self.get_device_memory_commitment,
2202             bind_buffer_memory: self.bind_buffer_memory,
2203             bind_image_memory: self.bind_image_memory,
2204             get_buffer_memory_requirements: self.get_buffer_memory_requirements,
2205             get_image_memory_requirements: self.get_image_memory_requirements,
2206             get_image_sparse_memory_requirements: self.get_image_sparse_memory_requirements,
2207             queue_bind_sparse: self.queue_bind_sparse,
2208             create_fence: self.create_fence,
2209             destroy_fence: self.destroy_fence,
2210             reset_fences: self.reset_fences,
2211             get_fence_status: self.get_fence_status,
2212             wait_for_fences: self.wait_for_fences,
2213             create_semaphore: self.create_semaphore,
2214             destroy_semaphore: self.destroy_semaphore,
2215             create_event: self.create_event,
2216             destroy_event: self.destroy_event,
2217             get_event_status: self.get_event_status,
2218             set_event: self.set_event,
2219             reset_event: self.reset_event,
2220             create_query_pool: self.create_query_pool,
2221             destroy_query_pool: self.destroy_query_pool,
2222             get_query_pool_results: self.get_query_pool_results,
2223             create_buffer: self.create_buffer,
2224             destroy_buffer: self.destroy_buffer,
2225             create_buffer_view: self.create_buffer_view,
2226             destroy_buffer_view: self.destroy_buffer_view,
2227             create_image: self.create_image,
2228             destroy_image: self.destroy_image,
2229             get_image_subresource_layout: self.get_image_subresource_layout,
2230             create_image_view: self.create_image_view,
2231             destroy_image_view: self.destroy_image_view,
2232             create_shader_module: self.create_shader_module,
2233             destroy_shader_module: self.destroy_shader_module,
2234             create_pipeline_cache: self.create_pipeline_cache,
2235             destroy_pipeline_cache: self.destroy_pipeline_cache,
2236             get_pipeline_cache_data: self.get_pipeline_cache_data,
2237             merge_pipeline_caches: self.merge_pipeline_caches,
2238             create_graphics_pipelines: self.create_graphics_pipelines,
2239             create_compute_pipelines: self.create_compute_pipelines,
2240             destroy_pipeline: self.destroy_pipeline,
2241             create_pipeline_layout: self.create_pipeline_layout,
2242             destroy_pipeline_layout: self.destroy_pipeline_layout,
2243             create_sampler: self.create_sampler,
2244             destroy_sampler: self.destroy_sampler,
2245             create_descriptor_set_layout: self.create_descriptor_set_layout,
2246             destroy_descriptor_set_layout: self.destroy_descriptor_set_layout,
2247             create_descriptor_pool: self.create_descriptor_pool,
2248             destroy_descriptor_pool: self.destroy_descriptor_pool,
2249             reset_descriptor_pool: self.reset_descriptor_pool,
2250             allocate_descriptor_sets: self.allocate_descriptor_sets,
2251             free_descriptor_sets: self.free_descriptor_sets,
2252             update_descriptor_sets: self.update_descriptor_sets,
2253             create_framebuffer: self.create_framebuffer,
2254             destroy_framebuffer: self.destroy_framebuffer,
2255             create_render_pass: self.create_render_pass,
2256             destroy_render_pass: self.destroy_render_pass,
2257             get_render_area_granularity: self.get_render_area_granularity,
2258             create_command_pool: self.create_command_pool,
2259             destroy_command_pool: self.destroy_command_pool,
2260             reset_command_pool: self.reset_command_pool,
2261             allocate_command_buffers: self.allocate_command_buffers,
2262             free_command_buffers: self.free_command_buffers,
2263             begin_command_buffer: self.begin_command_buffer,
2264             end_command_buffer: self.end_command_buffer,
2265             reset_command_buffer: self.reset_command_buffer,
2266             cmd_bind_pipeline: self.cmd_bind_pipeline,
2267             cmd_set_viewport: self.cmd_set_viewport,
2268             cmd_set_scissor: self.cmd_set_scissor,
2269             cmd_set_line_width: self.cmd_set_line_width,
2270             cmd_set_depth_bias: self.cmd_set_depth_bias,
2271             cmd_set_blend_constants: self.cmd_set_blend_constants,
2272             cmd_set_depth_bounds: self.cmd_set_depth_bounds,
2273             cmd_set_stencil_compare_mask: self.cmd_set_stencil_compare_mask,
2274             cmd_set_stencil_write_mask: self.cmd_set_stencil_write_mask,
2275             cmd_set_stencil_reference: self.cmd_set_stencil_reference,
2276             cmd_bind_descriptor_sets: self.cmd_bind_descriptor_sets,
2277             cmd_bind_index_buffer: self.cmd_bind_index_buffer,
2278             cmd_bind_vertex_buffers: self.cmd_bind_vertex_buffers,
2279             cmd_draw: self.cmd_draw,
2280             cmd_draw_indexed: self.cmd_draw_indexed,
2281             cmd_draw_indirect: self.cmd_draw_indirect,
2282             cmd_draw_indexed_indirect: self.cmd_draw_indexed_indirect,
2283             cmd_dispatch: self.cmd_dispatch,
2284             cmd_dispatch_indirect: self.cmd_dispatch_indirect,
2285             cmd_copy_buffer: self.cmd_copy_buffer,
2286             cmd_copy_image: self.cmd_copy_image,
2287             cmd_blit_image: self.cmd_blit_image,
2288             cmd_copy_buffer_to_image: self.cmd_copy_buffer_to_image,
2289             cmd_copy_image_to_buffer: self.cmd_copy_image_to_buffer,
2290             cmd_update_buffer: self.cmd_update_buffer,
2291             cmd_fill_buffer: self.cmd_fill_buffer,
2292             cmd_clear_color_image: self.cmd_clear_color_image,
2293             cmd_clear_depth_stencil_image: self.cmd_clear_depth_stencil_image,
2294             cmd_clear_attachments: self.cmd_clear_attachments,
2295             cmd_resolve_image: self.cmd_resolve_image,
2296             cmd_set_event: self.cmd_set_event,
2297             cmd_reset_event: self.cmd_reset_event,
2298             cmd_wait_events: self.cmd_wait_events,
2299             cmd_pipeline_barrier: self.cmd_pipeline_barrier,
2300             cmd_begin_query: self.cmd_begin_query,
2301             cmd_end_query: self.cmd_end_query,
2302             cmd_reset_query_pool: self.cmd_reset_query_pool,
2303             cmd_write_timestamp: self.cmd_write_timestamp,
2304             cmd_copy_query_pool_results: self.cmd_copy_query_pool_results,
2305             cmd_push_constants: self.cmd_push_constants,
2306             cmd_begin_render_pass: self.cmd_begin_render_pass,
2307             cmd_next_subpass: self.cmd_next_subpass,
2308             cmd_end_render_pass: self.cmd_end_render_pass,
2309             cmd_execute_commands: self.cmd_execute_commands,
2310         }
2311     }
2312 }
2313 impl DeviceFnV1_0 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,2314     pub fn load<F>(mut _f: F) -> Self
2315     where
2316         F: FnMut(&::std::ffi::CStr) -> *const c_void,
2317     {
2318         DeviceFnV1_0 {
2319             destroy_device: unsafe {
2320                 extern "system" fn destroy_device(
2321                     _device: Device,
2322                     _p_allocator: *const AllocationCallbacks,
2323                 ) {
2324                     panic!(concat!("Unable to load ", stringify!(destroy_device)))
2325                 }
2326                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDevice\0");
2327                 let val = _f(cname);
2328                 if val.is_null() {
2329                     destroy_device
2330                 } else {
2331                     ::std::mem::transmute(val)
2332                 }
2333             },
2334             get_device_queue: unsafe {
2335                 extern "system" fn get_device_queue(
2336                     _device: Device,
2337                     _queue_family_index: u32,
2338                     _queue_index: u32,
2339                     _p_queue: *mut Queue,
2340                 ) {
2341                     panic!(concat!("Unable to load ", stringify!(get_device_queue)))
2342                 }
2343                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue\0");
2344                 let val = _f(cname);
2345                 if val.is_null() {
2346                     get_device_queue
2347                 } else {
2348                     ::std::mem::transmute(val)
2349                 }
2350             },
2351             queue_submit: unsafe {
2352                 extern "system" fn queue_submit(
2353                     _queue: Queue,
2354                     _submit_count: u32,
2355                     _p_submits: *const SubmitInfo,
2356                     _fence: Fence,
2357                 ) -> Result {
2358                     panic!(concat!("Unable to load ", stringify!(queue_submit)))
2359                 }
2360                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit\0");
2361                 let val = _f(cname);
2362                 if val.is_null() {
2363                     queue_submit
2364                 } else {
2365                     ::std::mem::transmute(val)
2366                 }
2367             },
2368             queue_wait_idle: unsafe {
2369                 extern "system" fn queue_wait_idle(_queue: Queue) -> Result {
2370                     panic!(concat!("Unable to load ", stringify!(queue_wait_idle)))
2371                 }
2372                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueWaitIdle\0");
2373                 let val = _f(cname);
2374                 if val.is_null() {
2375                     queue_wait_idle
2376                 } else {
2377                     ::std::mem::transmute(val)
2378                 }
2379             },
2380             device_wait_idle: unsafe {
2381                 extern "system" fn device_wait_idle(_device: Device) -> Result {
2382                     panic!(concat!("Unable to load ", stringify!(device_wait_idle)))
2383                 }
2384                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDeviceWaitIdle\0");
2385                 let val = _f(cname);
2386                 if val.is_null() {
2387                     device_wait_idle
2388                 } else {
2389                     ::std::mem::transmute(val)
2390                 }
2391             },
2392             allocate_memory: unsafe {
2393                 extern "system" fn allocate_memory(
2394                     _device: Device,
2395                     _p_allocate_info: *const MemoryAllocateInfo,
2396                     _p_allocator: *const AllocationCallbacks,
2397                     _p_memory: *mut DeviceMemory,
2398                 ) -> Result {
2399                     panic!(concat!("Unable to load ", stringify!(allocate_memory)))
2400                 }
2401                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateMemory\0");
2402                 let val = _f(cname);
2403                 if val.is_null() {
2404                     allocate_memory
2405                 } else {
2406                     ::std::mem::transmute(val)
2407                 }
2408             },
2409             free_memory: unsafe {
2410                 extern "system" fn free_memory(
2411                     _device: Device,
2412                     _memory: DeviceMemory,
2413                     _p_allocator: *const AllocationCallbacks,
2414                 ) {
2415                     panic!(concat!("Unable to load ", stringify!(free_memory)))
2416                 }
2417                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeMemory\0");
2418                 let val = _f(cname);
2419                 if val.is_null() {
2420                     free_memory
2421                 } else {
2422                     ::std::mem::transmute(val)
2423                 }
2424             },
2425             map_memory: unsafe {
2426                 extern "system" fn map_memory(
2427                     _device: Device,
2428                     _memory: DeviceMemory,
2429                     _offset: DeviceSize,
2430                     _size: DeviceSize,
2431                     _flags: MemoryMapFlags,
2432                     _pp_data: *mut *mut c_void,
2433                 ) -> Result {
2434                     panic!(concat!("Unable to load ", stringify!(map_memory)))
2435                 }
2436                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory\0");
2437                 let val = _f(cname);
2438                 if val.is_null() {
2439                     map_memory
2440                 } else {
2441                     ::std::mem::transmute(val)
2442                 }
2443             },
2444             unmap_memory: unsafe {
2445                 extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) {
2446                     panic!(concat!("Unable to load ", stringify!(unmap_memory)))
2447                 }
2448                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory\0");
2449                 let val = _f(cname);
2450                 if val.is_null() {
2451                     unmap_memory
2452                 } else {
2453                     ::std::mem::transmute(val)
2454                 }
2455             },
2456             flush_mapped_memory_ranges: unsafe {
2457                 extern "system" fn flush_mapped_memory_ranges(
2458                     _device: Device,
2459                     _memory_range_count: u32,
2460                     _p_memory_ranges: *const MappedMemoryRange,
2461                 ) -> Result {
2462                     panic!(concat!(
2463                         "Unable to load ",
2464                         stringify!(flush_mapped_memory_ranges)
2465                     ))
2466                 }
2467                 let cname =
2468                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFlushMappedMemoryRanges\0");
2469                 let val = _f(cname);
2470                 if val.is_null() {
2471                     flush_mapped_memory_ranges
2472                 } else {
2473                     ::std::mem::transmute(val)
2474                 }
2475             },
2476             invalidate_mapped_memory_ranges: unsafe {
2477                 extern "system" fn invalidate_mapped_memory_ranges(
2478                     _device: Device,
2479                     _memory_range_count: u32,
2480                     _p_memory_ranges: *const MappedMemoryRange,
2481                 ) -> Result {
2482                     panic!(concat!(
2483                         "Unable to load ",
2484                         stringify!(invalidate_mapped_memory_ranges)
2485                     ))
2486                 }
2487                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2488                     b"vkInvalidateMappedMemoryRanges\0",
2489                 );
2490                 let val = _f(cname);
2491                 if val.is_null() {
2492                     invalidate_mapped_memory_ranges
2493                 } else {
2494                     ::std::mem::transmute(val)
2495                 }
2496             },
2497             get_device_memory_commitment: unsafe {
2498                 extern "system" fn get_device_memory_commitment(
2499                     _device: Device,
2500                     _memory: DeviceMemory,
2501                     _p_committed_memory_in_bytes: *mut DeviceSize,
2502                 ) {
2503                     panic!(concat!(
2504                         "Unable to load ",
2505                         stringify!(get_device_memory_commitment)
2506                     ))
2507                 }
2508                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2509                     b"vkGetDeviceMemoryCommitment\0",
2510                 );
2511                 let val = _f(cname);
2512                 if val.is_null() {
2513                     get_device_memory_commitment
2514                 } else {
2515                     ::std::mem::transmute(val)
2516                 }
2517             },
2518             bind_buffer_memory: unsafe {
2519                 extern "system" fn bind_buffer_memory(
2520                     _device: Device,
2521                     _buffer: Buffer,
2522                     _memory: DeviceMemory,
2523                     _memory_offset: DeviceSize,
2524                 ) -> Result {
2525                     panic!(concat!("Unable to load ", stringify!(bind_buffer_memory)))
2526                 }
2527                 let cname =
2528                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory\0");
2529                 let val = _f(cname);
2530                 if val.is_null() {
2531                     bind_buffer_memory
2532                 } else {
2533                     ::std::mem::transmute(val)
2534                 }
2535             },
2536             bind_image_memory: unsafe {
2537                 extern "system" fn bind_image_memory(
2538                     _device: Device,
2539                     _image: Image,
2540                     _memory: DeviceMemory,
2541                     _memory_offset: DeviceSize,
2542                 ) -> Result {
2543                     panic!(concat!("Unable to load ", stringify!(bind_image_memory)))
2544                 }
2545                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory\0");
2546                 let val = _f(cname);
2547                 if val.is_null() {
2548                     bind_image_memory
2549                 } else {
2550                     ::std::mem::transmute(val)
2551                 }
2552             },
2553             get_buffer_memory_requirements: unsafe {
2554                 extern "system" fn get_buffer_memory_requirements(
2555                     _device: Device,
2556                     _buffer: Buffer,
2557                     _p_memory_requirements: *mut MemoryRequirements,
2558                 ) {
2559                     panic!(concat!(
2560                         "Unable to load ",
2561                         stringify!(get_buffer_memory_requirements)
2562                     ))
2563                 }
2564                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2565                     b"vkGetBufferMemoryRequirements\0",
2566                 );
2567                 let val = _f(cname);
2568                 if val.is_null() {
2569                     get_buffer_memory_requirements
2570                 } else {
2571                     ::std::mem::transmute(val)
2572                 }
2573             },
2574             get_image_memory_requirements: unsafe {
2575                 extern "system" fn get_image_memory_requirements(
2576                     _device: Device,
2577                     _image: Image,
2578                     _p_memory_requirements: *mut MemoryRequirements,
2579                 ) {
2580                     panic!(concat!(
2581                         "Unable to load ",
2582                         stringify!(get_image_memory_requirements)
2583                     ))
2584                 }
2585                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2586                     b"vkGetImageMemoryRequirements\0",
2587                 );
2588                 let val = _f(cname);
2589                 if val.is_null() {
2590                     get_image_memory_requirements
2591                 } else {
2592                     ::std::mem::transmute(val)
2593                 }
2594             },
2595             get_image_sparse_memory_requirements: unsafe {
2596                 extern "system" fn get_image_sparse_memory_requirements(
2597                     _device: Device,
2598                     _image: Image,
2599                     _p_sparse_memory_requirement_count: *mut u32,
2600                     _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements,
2601                 ) {
2602                     panic!(concat!(
2603                         "Unable to load ",
2604                         stringify!(get_image_sparse_memory_requirements)
2605                     ))
2606                 }
2607                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2608                     b"vkGetImageSparseMemoryRequirements\0",
2609                 );
2610                 let val = _f(cname);
2611                 if val.is_null() {
2612                     get_image_sparse_memory_requirements
2613                 } else {
2614                     ::std::mem::transmute(val)
2615                 }
2616             },
2617             queue_bind_sparse: unsafe {
2618                 extern "system" fn queue_bind_sparse(
2619                     _queue: Queue,
2620                     _bind_info_count: u32,
2621                     _p_bind_info: *const BindSparseInfo,
2622                     _fence: Fence,
2623                 ) -> Result {
2624                     panic!(concat!("Unable to load ", stringify!(queue_bind_sparse)))
2625                 }
2626                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueBindSparse\0");
2627                 let val = _f(cname);
2628                 if val.is_null() {
2629                     queue_bind_sparse
2630                 } else {
2631                     ::std::mem::transmute(val)
2632                 }
2633             },
2634             create_fence: unsafe {
2635                 extern "system" fn create_fence(
2636                     _device: Device,
2637                     _p_create_info: *const FenceCreateInfo,
2638                     _p_allocator: *const AllocationCallbacks,
2639                     _p_fence: *mut Fence,
2640                 ) -> Result {
2641                     panic!(concat!("Unable to load ", stringify!(create_fence)))
2642                 }
2643                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFence\0");
2644                 let val = _f(cname);
2645                 if val.is_null() {
2646                     create_fence
2647                 } else {
2648                     ::std::mem::transmute(val)
2649                 }
2650             },
2651             destroy_fence: unsafe {
2652                 extern "system" fn destroy_fence(
2653                     _device: Device,
2654                     _fence: Fence,
2655                     _p_allocator: *const AllocationCallbacks,
2656                 ) {
2657                     panic!(concat!("Unable to load ", stringify!(destroy_fence)))
2658                 }
2659                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFence\0");
2660                 let val = _f(cname);
2661                 if val.is_null() {
2662                     destroy_fence
2663                 } else {
2664                     ::std::mem::transmute(val)
2665                 }
2666             },
2667             reset_fences: unsafe {
2668                 extern "system" fn reset_fences(
2669                     _device: Device,
2670                     _fence_count: u32,
2671                     _p_fences: *const Fence,
2672                 ) -> Result {
2673                     panic!(concat!("Unable to load ", stringify!(reset_fences)))
2674                 }
2675                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetFences\0");
2676                 let val = _f(cname);
2677                 if val.is_null() {
2678                     reset_fences
2679                 } else {
2680                     ::std::mem::transmute(val)
2681                 }
2682             },
2683             get_fence_status: unsafe {
2684                 extern "system" fn get_fence_status(_device: Device, _fence: Fence) -> Result {
2685                     panic!(concat!("Unable to load ", stringify!(get_fence_status)))
2686                 }
2687                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceStatus\0");
2688                 let val = _f(cname);
2689                 if val.is_null() {
2690                     get_fence_status
2691                 } else {
2692                     ::std::mem::transmute(val)
2693                 }
2694             },
2695             wait_for_fences: unsafe {
2696                 extern "system" fn wait_for_fences(
2697                     _device: Device,
2698                     _fence_count: u32,
2699                     _p_fences: *const Fence,
2700                     _wait_all: Bool32,
2701                     _timeout: u64,
2702                 ) -> Result {
2703                     panic!(concat!("Unable to load ", stringify!(wait_for_fences)))
2704                 }
2705                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForFences\0");
2706                 let val = _f(cname);
2707                 if val.is_null() {
2708                     wait_for_fences
2709                 } else {
2710                     ::std::mem::transmute(val)
2711                 }
2712             },
2713             create_semaphore: unsafe {
2714                 extern "system" fn create_semaphore(
2715                     _device: Device,
2716                     _p_create_info: *const SemaphoreCreateInfo,
2717                     _p_allocator: *const AllocationCallbacks,
2718                     _p_semaphore: *mut Semaphore,
2719                 ) -> Result {
2720                     panic!(concat!("Unable to load ", stringify!(create_semaphore)))
2721                 }
2722                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSemaphore\0");
2723                 let val = _f(cname);
2724                 if val.is_null() {
2725                     create_semaphore
2726                 } else {
2727                     ::std::mem::transmute(val)
2728                 }
2729             },
2730             destroy_semaphore: unsafe {
2731                 extern "system" fn destroy_semaphore(
2732                     _device: Device,
2733                     _semaphore: Semaphore,
2734                     _p_allocator: *const AllocationCallbacks,
2735                 ) {
2736                     panic!(concat!("Unable to load ", stringify!(destroy_semaphore)))
2737                 }
2738                 let cname =
2739                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySemaphore\0");
2740                 let val = _f(cname);
2741                 if val.is_null() {
2742                     destroy_semaphore
2743                 } else {
2744                     ::std::mem::transmute(val)
2745                 }
2746             },
2747             create_event: unsafe {
2748                 extern "system" fn create_event(
2749                     _device: Device,
2750                     _p_create_info: *const EventCreateInfo,
2751                     _p_allocator: *const AllocationCallbacks,
2752                     _p_event: *mut Event,
2753                 ) -> Result {
2754                     panic!(concat!("Unable to load ", stringify!(create_event)))
2755                 }
2756                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateEvent\0");
2757                 let val = _f(cname);
2758                 if val.is_null() {
2759                     create_event
2760                 } else {
2761                     ::std::mem::transmute(val)
2762                 }
2763             },
2764             destroy_event: unsafe {
2765                 extern "system" fn destroy_event(
2766                     _device: Device,
2767                     _event: Event,
2768                     _p_allocator: *const AllocationCallbacks,
2769                 ) {
2770                     panic!(concat!("Unable to load ", stringify!(destroy_event)))
2771                 }
2772                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyEvent\0");
2773                 let val = _f(cname);
2774                 if val.is_null() {
2775                     destroy_event
2776                 } else {
2777                     ::std::mem::transmute(val)
2778                 }
2779             },
2780             get_event_status: unsafe {
2781                 extern "system" fn get_event_status(_device: Device, _event: Event) -> Result {
2782                     panic!(concat!("Unable to load ", stringify!(get_event_status)))
2783                 }
2784                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetEventStatus\0");
2785                 let val = _f(cname);
2786                 if val.is_null() {
2787                     get_event_status
2788                 } else {
2789                     ::std::mem::transmute(val)
2790                 }
2791             },
2792             set_event: unsafe {
2793                 extern "system" fn set_event(_device: Device, _event: Event) -> Result {
2794                     panic!(concat!("Unable to load ", stringify!(set_event)))
2795                 }
2796                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetEvent\0");
2797                 let val = _f(cname);
2798                 if val.is_null() {
2799                     set_event
2800                 } else {
2801                     ::std::mem::transmute(val)
2802                 }
2803             },
2804             reset_event: unsafe {
2805                 extern "system" fn reset_event(_device: Device, _event: Event) -> Result {
2806                     panic!(concat!("Unable to load ", stringify!(reset_event)))
2807                 }
2808                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetEvent\0");
2809                 let val = _f(cname);
2810                 if val.is_null() {
2811                     reset_event
2812                 } else {
2813                     ::std::mem::transmute(val)
2814                 }
2815             },
2816             create_query_pool: unsafe {
2817                 extern "system" fn create_query_pool(
2818                     _device: Device,
2819                     _p_create_info: *const QueryPoolCreateInfo,
2820                     _p_allocator: *const AllocationCallbacks,
2821                     _p_query_pool: *mut QueryPool,
2822                 ) -> Result {
2823                     panic!(concat!("Unable to load ", stringify!(create_query_pool)))
2824                 }
2825                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateQueryPool\0");
2826                 let val = _f(cname);
2827                 if val.is_null() {
2828                     create_query_pool
2829                 } else {
2830                     ::std::mem::transmute(val)
2831                 }
2832             },
2833             destroy_query_pool: unsafe {
2834                 extern "system" fn destroy_query_pool(
2835                     _device: Device,
2836                     _query_pool: QueryPool,
2837                     _p_allocator: *const AllocationCallbacks,
2838                 ) {
2839                     panic!(concat!("Unable to load ", stringify!(destroy_query_pool)))
2840                 }
2841                 let cname =
2842                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyQueryPool\0");
2843                 let val = _f(cname);
2844                 if val.is_null() {
2845                     destroy_query_pool
2846                 } else {
2847                     ::std::mem::transmute(val)
2848                 }
2849             },
2850             get_query_pool_results: unsafe {
2851                 extern "system" fn get_query_pool_results(
2852                     _device: Device,
2853                     _query_pool: QueryPool,
2854                     _first_query: u32,
2855                     _query_count: u32,
2856                     _data_size: usize,
2857                     _p_data: *mut c_void,
2858                     _stride: DeviceSize,
2859                     _flags: QueryResultFlags,
2860                 ) -> Result {
2861                     panic!(concat!(
2862                         "Unable to load ",
2863                         stringify!(get_query_pool_results)
2864                     ))
2865                 }
2866                 let cname =
2867                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetQueryPoolResults\0");
2868                 let val = _f(cname);
2869                 if val.is_null() {
2870                     get_query_pool_results
2871                 } else {
2872                     ::std::mem::transmute(val)
2873                 }
2874             },
2875             create_buffer: unsafe {
2876                 extern "system" fn create_buffer(
2877                     _device: Device,
2878                     _p_create_info: *const BufferCreateInfo,
2879                     _p_allocator: *const AllocationCallbacks,
2880                     _p_buffer: *mut Buffer,
2881                 ) -> Result {
2882                     panic!(concat!("Unable to load ", stringify!(create_buffer)))
2883                 }
2884                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBuffer\0");
2885                 let val = _f(cname);
2886                 if val.is_null() {
2887                     create_buffer
2888                 } else {
2889                     ::std::mem::transmute(val)
2890                 }
2891             },
2892             destroy_buffer: unsafe {
2893                 extern "system" fn destroy_buffer(
2894                     _device: Device,
2895                     _buffer: Buffer,
2896                     _p_allocator: *const AllocationCallbacks,
2897                 ) {
2898                     panic!(concat!("Unable to load ", stringify!(destroy_buffer)))
2899                 }
2900                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBuffer\0");
2901                 let val = _f(cname);
2902                 if val.is_null() {
2903                     destroy_buffer
2904                 } else {
2905                     ::std::mem::transmute(val)
2906                 }
2907             },
2908             create_buffer_view: unsafe {
2909                 extern "system" fn create_buffer_view(
2910                     _device: Device,
2911                     _p_create_info: *const BufferViewCreateInfo,
2912                     _p_allocator: *const AllocationCallbacks,
2913                     _p_view: *mut BufferView,
2914                 ) -> Result {
2915                     panic!(concat!("Unable to load ", stringify!(create_buffer_view)))
2916                 }
2917                 let cname =
2918                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBufferView\0");
2919                 let val = _f(cname);
2920                 if val.is_null() {
2921                     create_buffer_view
2922                 } else {
2923                     ::std::mem::transmute(val)
2924                 }
2925             },
2926             destroy_buffer_view: unsafe {
2927                 extern "system" fn destroy_buffer_view(
2928                     _device: Device,
2929                     _buffer_view: BufferView,
2930                     _p_allocator: *const AllocationCallbacks,
2931                 ) {
2932                     panic!(concat!("Unable to load ", stringify!(destroy_buffer_view)))
2933                 }
2934                 let cname =
2935                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBufferView\0");
2936                 let val = _f(cname);
2937                 if val.is_null() {
2938                     destroy_buffer_view
2939                 } else {
2940                     ::std::mem::transmute(val)
2941                 }
2942             },
2943             create_image: unsafe {
2944                 extern "system" fn create_image(
2945                     _device: Device,
2946                     _p_create_info: *const ImageCreateInfo,
2947                     _p_allocator: *const AllocationCallbacks,
2948                     _p_image: *mut Image,
2949                 ) -> Result {
2950                     panic!(concat!("Unable to load ", stringify!(create_image)))
2951                 }
2952                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImage\0");
2953                 let val = _f(cname);
2954                 if val.is_null() {
2955                     create_image
2956                 } else {
2957                     ::std::mem::transmute(val)
2958                 }
2959             },
2960             destroy_image: unsafe {
2961                 extern "system" fn destroy_image(
2962                     _device: Device,
2963                     _image: Image,
2964                     _p_allocator: *const AllocationCallbacks,
2965                 ) {
2966                     panic!(concat!("Unable to load ", stringify!(destroy_image)))
2967                 }
2968                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImage\0");
2969                 let val = _f(cname);
2970                 if val.is_null() {
2971                     destroy_image
2972                 } else {
2973                     ::std::mem::transmute(val)
2974                 }
2975             },
2976             get_image_subresource_layout: unsafe {
2977                 extern "system" fn get_image_subresource_layout(
2978                     _device: Device,
2979                     _image: Image,
2980                     _p_subresource: *const ImageSubresource,
2981                     _p_layout: *mut SubresourceLayout,
2982                 ) {
2983                     panic!(concat!(
2984                         "Unable to load ",
2985                         stringify!(get_image_subresource_layout)
2986                     ))
2987                 }
2988                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2989                     b"vkGetImageSubresourceLayout\0",
2990                 );
2991                 let val = _f(cname);
2992                 if val.is_null() {
2993                     get_image_subresource_layout
2994                 } else {
2995                     ::std::mem::transmute(val)
2996                 }
2997             },
2998             create_image_view: unsafe {
2999                 extern "system" fn create_image_view(
3000                     _device: Device,
3001                     _p_create_info: *const ImageViewCreateInfo,
3002                     _p_allocator: *const AllocationCallbacks,
3003                     _p_view: *mut ImageView,
3004                 ) -> Result {
3005                     panic!(concat!("Unable to load ", stringify!(create_image_view)))
3006                 }
3007                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImageView\0");
3008                 let val = _f(cname);
3009                 if val.is_null() {
3010                     create_image_view
3011                 } else {
3012                     ::std::mem::transmute(val)
3013                 }
3014             },
3015             destroy_image_view: unsafe {
3016                 extern "system" fn destroy_image_view(
3017                     _device: Device,
3018                     _image_view: ImageView,
3019                     _p_allocator: *const AllocationCallbacks,
3020                 ) {
3021                     panic!(concat!("Unable to load ", stringify!(destroy_image_view)))
3022                 }
3023                 let cname =
3024                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImageView\0");
3025                 let val = _f(cname);
3026                 if val.is_null() {
3027                     destroy_image_view
3028                 } else {
3029                     ::std::mem::transmute(val)
3030                 }
3031             },
3032             create_shader_module: unsafe {
3033                 extern "system" fn create_shader_module(
3034                     _device: Device,
3035                     _p_create_info: *const ShaderModuleCreateInfo,
3036                     _p_allocator: *const AllocationCallbacks,
3037                     _p_shader_module: *mut ShaderModule,
3038                 ) -> Result {
3039                     panic!(concat!("Unable to load ", stringify!(create_shader_module)))
3040                 }
3041                 let cname =
3042                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShaderModule\0");
3043                 let val = _f(cname);
3044                 if val.is_null() {
3045                     create_shader_module
3046                 } else {
3047                     ::std::mem::transmute(val)
3048                 }
3049             },
3050             destroy_shader_module: unsafe {
3051                 extern "system" fn destroy_shader_module(
3052                     _device: Device,
3053                     _shader_module: ShaderModule,
3054                     _p_allocator: *const AllocationCallbacks,
3055                 ) {
3056                     panic!(concat!(
3057                         "Unable to load ",
3058                         stringify!(destroy_shader_module)
3059                     ))
3060                 }
3061                 let cname =
3062                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderModule\0");
3063                 let val = _f(cname);
3064                 if val.is_null() {
3065                     destroy_shader_module
3066                 } else {
3067                     ::std::mem::transmute(val)
3068                 }
3069             },
3070             create_pipeline_cache: unsafe {
3071                 extern "system" fn create_pipeline_cache(
3072                     _device: Device,
3073                     _p_create_info: *const PipelineCacheCreateInfo,
3074                     _p_allocator: *const AllocationCallbacks,
3075                     _p_pipeline_cache: *mut PipelineCache,
3076                 ) -> Result {
3077                     panic!(concat!(
3078                         "Unable to load ",
3079                         stringify!(create_pipeline_cache)
3080                     ))
3081                 }
3082                 let cname =
3083                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineCache\0");
3084                 let val = _f(cname);
3085                 if val.is_null() {
3086                     create_pipeline_cache
3087                 } else {
3088                     ::std::mem::transmute(val)
3089                 }
3090             },
3091             destroy_pipeline_cache: unsafe {
3092                 extern "system" fn destroy_pipeline_cache(
3093                     _device: Device,
3094                     _pipeline_cache: PipelineCache,
3095                     _p_allocator: *const AllocationCallbacks,
3096                 ) {
3097                     panic!(concat!(
3098                         "Unable to load ",
3099                         stringify!(destroy_pipeline_cache)
3100                     ))
3101                 }
3102                 let cname =
3103                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineCache\0");
3104                 let val = _f(cname);
3105                 if val.is_null() {
3106                     destroy_pipeline_cache
3107                 } else {
3108                     ::std::mem::transmute(val)
3109                 }
3110             },
3111             get_pipeline_cache_data: unsafe {
3112                 extern "system" fn get_pipeline_cache_data(
3113                     _device: Device,
3114                     _pipeline_cache: PipelineCache,
3115                     _p_data_size: *mut usize,
3116                     _p_data: *mut c_void,
3117                 ) -> Result {
3118                     panic!(concat!(
3119                         "Unable to load ",
3120                         stringify!(get_pipeline_cache_data)
3121                     ))
3122                 }
3123                 let cname =
3124                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPipelineCacheData\0");
3125                 let val = _f(cname);
3126                 if val.is_null() {
3127                     get_pipeline_cache_data
3128                 } else {
3129                     ::std::mem::transmute(val)
3130                 }
3131             },
3132             merge_pipeline_caches: unsafe {
3133                 extern "system" fn merge_pipeline_caches(
3134                     _device: Device,
3135                     _dst_cache: PipelineCache,
3136                     _src_cache_count: u32,
3137                     _p_src_caches: *const PipelineCache,
3138                 ) -> Result {
3139                     panic!(concat!(
3140                         "Unable to load ",
3141                         stringify!(merge_pipeline_caches)
3142                     ))
3143                 }
3144                 let cname =
3145                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMergePipelineCaches\0");
3146                 let val = _f(cname);
3147                 if val.is_null() {
3148                     merge_pipeline_caches
3149                 } else {
3150                     ::std::mem::transmute(val)
3151                 }
3152             },
3153             create_graphics_pipelines: unsafe {
3154                 extern "system" fn create_graphics_pipelines(
3155                     _device: Device,
3156                     _pipeline_cache: PipelineCache,
3157                     _create_info_count: u32,
3158                     _p_create_infos: *const GraphicsPipelineCreateInfo,
3159                     _p_allocator: *const AllocationCallbacks,
3160                     _p_pipelines: *mut Pipeline,
3161                 ) -> Result {
3162                     panic!(concat!(
3163                         "Unable to load ",
3164                         stringify!(create_graphics_pipelines)
3165                     ))
3166                 }
3167                 let cname =
3168                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGraphicsPipelines\0");
3169                 let val = _f(cname);
3170                 if val.is_null() {
3171                     create_graphics_pipelines
3172                 } else {
3173                     ::std::mem::transmute(val)
3174                 }
3175             },
3176             create_compute_pipelines: unsafe {
3177                 extern "system" fn create_compute_pipelines(
3178                     _device: Device,
3179                     _pipeline_cache: PipelineCache,
3180                     _create_info_count: u32,
3181                     _p_create_infos: *const ComputePipelineCreateInfo,
3182                     _p_allocator: *const AllocationCallbacks,
3183                     _p_pipelines: *mut Pipeline,
3184                 ) -> Result {
3185                     panic!(concat!(
3186                         "Unable to load ",
3187                         stringify!(create_compute_pipelines)
3188                     ))
3189                 }
3190                 let cname =
3191                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateComputePipelines\0");
3192                 let val = _f(cname);
3193                 if val.is_null() {
3194                     create_compute_pipelines
3195                 } else {
3196                     ::std::mem::transmute(val)
3197                 }
3198             },
3199             destroy_pipeline: unsafe {
3200                 extern "system" fn destroy_pipeline(
3201                     _device: Device,
3202                     _pipeline: Pipeline,
3203                     _p_allocator: *const AllocationCallbacks,
3204                 ) {
3205                     panic!(concat!("Unable to load ", stringify!(destroy_pipeline)))
3206                 }
3207                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipeline\0");
3208                 let val = _f(cname);
3209                 if val.is_null() {
3210                     destroy_pipeline
3211                 } else {
3212                     ::std::mem::transmute(val)
3213                 }
3214             },
3215             create_pipeline_layout: unsafe {
3216                 extern "system" fn create_pipeline_layout(
3217                     _device: Device,
3218                     _p_create_info: *const PipelineLayoutCreateInfo,
3219                     _p_allocator: *const AllocationCallbacks,
3220                     _p_pipeline_layout: *mut PipelineLayout,
3221                 ) -> Result {
3222                     panic!(concat!(
3223                         "Unable to load ",
3224                         stringify!(create_pipeline_layout)
3225                     ))
3226                 }
3227                 let cname =
3228                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineLayout\0");
3229                 let val = _f(cname);
3230                 if val.is_null() {
3231                     create_pipeline_layout
3232                 } else {
3233                     ::std::mem::transmute(val)
3234                 }
3235             },
3236             destroy_pipeline_layout: unsafe {
3237                 extern "system" fn destroy_pipeline_layout(
3238                     _device: Device,
3239                     _pipeline_layout: PipelineLayout,
3240                     _p_allocator: *const AllocationCallbacks,
3241                 ) {
3242                     panic!(concat!(
3243                         "Unable to load ",
3244                         stringify!(destroy_pipeline_layout)
3245                     ))
3246                 }
3247                 let cname =
3248                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineLayout\0");
3249                 let val = _f(cname);
3250                 if val.is_null() {
3251                     destroy_pipeline_layout
3252                 } else {
3253                     ::std::mem::transmute(val)
3254                 }
3255             },
3256             create_sampler: unsafe {
3257                 extern "system" fn create_sampler(
3258                     _device: Device,
3259                     _p_create_info: *const SamplerCreateInfo,
3260                     _p_allocator: *const AllocationCallbacks,
3261                     _p_sampler: *mut Sampler,
3262                 ) -> Result {
3263                     panic!(concat!("Unable to load ", stringify!(create_sampler)))
3264                 }
3265                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSampler\0");
3266                 let val = _f(cname);
3267                 if val.is_null() {
3268                     create_sampler
3269                 } else {
3270                     ::std::mem::transmute(val)
3271                 }
3272             },
3273             destroy_sampler: unsafe {
3274                 extern "system" fn destroy_sampler(
3275                     _device: Device,
3276                     _sampler: Sampler,
3277                     _p_allocator: *const AllocationCallbacks,
3278                 ) {
3279                     panic!(concat!("Unable to load ", stringify!(destroy_sampler)))
3280                 }
3281                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySampler\0");
3282                 let val = _f(cname);
3283                 if val.is_null() {
3284                     destroy_sampler
3285                 } else {
3286                     ::std::mem::transmute(val)
3287                 }
3288             },
3289             create_descriptor_set_layout: unsafe {
3290                 extern "system" fn create_descriptor_set_layout(
3291                     _device: Device,
3292                     _p_create_info: *const DescriptorSetLayoutCreateInfo,
3293                     _p_allocator: *const AllocationCallbacks,
3294                     _p_set_layout: *mut DescriptorSetLayout,
3295                 ) -> Result {
3296                     panic!(concat!(
3297                         "Unable to load ",
3298                         stringify!(create_descriptor_set_layout)
3299                     ))
3300                 }
3301                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3302                     b"vkCreateDescriptorSetLayout\0",
3303                 );
3304                 let val = _f(cname);
3305                 if val.is_null() {
3306                     create_descriptor_set_layout
3307                 } else {
3308                     ::std::mem::transmute(val)
3309                 }
3310             },
3311             destroy_descriptor_set_layout: unsafe {
3312                 extern "system" fn destroy_descriptor_set_layout(
3313                     _device: Device,
3314                     _descriptor_set_layout: DescriptorSetLayout,
3315                     _p_allocator: *const AllocationCallbacks,
3316                 ) {
3317                     panic!(concat!(
3318                         "Unable to load ",
3319                         stringify!(destroy_descriptor_set_layout)
3320                     ))
3321                 }
3322                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3323                     b"vkDestroyDescriptorSetLayout\0",
3324                 );
3325                 let val = _f(cname);
3326                 if val.is_null() {
3327                     destroy_descriptor_set_layout
3328                 } else {
3329                     ::std::mem::transmute(val)
3330                 }
3331             },
3332             create_descriptor_pool: unsafe {
3333                 extern "system" fn create_descriptor_pool(
3334                     _device: Device,
3335                     _p_create_info: *const DescriptorPoolCreateInfo,
3336                     _p_allocator: *const AllocationCallbacks,
3337                     _p_descriptor_pool: *mut DescriptorPool,
3338                 ) -> Result {
3339                     panic!(concat!(
3340                         "Unable to load ",
3341                         stringify!(create_descriptor_pool)
3342                     ))
3343                 }
3344                 let cname =
3345                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDescriptorPool\0");
3346                 let val = _f(cname);
3347                 if val.is_null() {
3348                     create_descriptor_pool
3349                 } else {
3350                     ::std::mem::transmute(val)
3351                 }
3352             },
3353             destroy_descriptor_pool: unsafe {
3354                 extern "system" fn destroy_descriptor_pool(
3355                     _device: Device,
3356                     _descriptor_pool: DescriptorPool,
3357                     _p_allocator: *const AllocationCallbacks,
3358                 ) {
3359                     panic!(concat!(
3360                         "Unable to load ",
3361                         stringify!(destroy_descriptor_pool)
3362                     ))
3363                 }
3364                 let cname =
3365                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDescriptorPool\0");
3366                 let val = _f(cname);
3367                 if val.is_null() {
3368                     destroy_descriptor_pool
3369                 } else {
3370                     ::std::mem::transmute(val)
3371                 }
3372             },
3373             reset_descriptor_pool: unsafe {
3374                 extern "system" fn reset_descriptor_pool(
3375                     _device: Device,
3376                     _descriptor_pool: DescriptorPool,
3377                     _flags: DescriptorPoolResetFlags,
3378                 ) -> Result {
3379                     panic!(concat!(
3380                         "Unable to load ",
3381                         stringify!(reset_descriptor_pool)
3382                     ))
3383                 }
3384                 let cname =
3385                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetDescriptorPool\0");
3386                 let val = _f(cname);
3387                 if val.is_null() {
3388                     reset_descriptor_pool
3389                 } else {
3390                     ::std::mem::transmute(val)
3391                 }
3392             },
3393             allocate_descriptor_sets: unsafe {
3394                 extern "system" fn allocate_descriptor_sets(
3395                     _device: Device,
3396                     _p_allocate_info: *const DescriptorSetAllocateInfo,
3397                     _p_descriptor_sets: *mut DescriptorSet,
3398                 ) -> Result {
3399                     panic!(concat!(
3400                         "Unable to load ",
3401                         stringify!(allocate_descriptor_sets)
3402                     ))
3403                 }
3404                 let cname =
3405                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateDescriptorSets\0");
3406                 let val = _f(cname);
3407                 if val.is_null() {
3408                     allocate_descriptor_sets
3409                 } else {
3410                     ::std::mem::transmute(val)
3411                 }
3412             },
3413             free_descriptor_sets: unsafe {
3414                 extern "system" fn free_descriptor_sets(
3415                     _device: Device,
3416                     _descriptor_pool: DescriptorPool,
3417                     _descriptor_set_count: u32,
3418                     _p_descriptor_sets: *const DescriptorSet,
3419                 ) -> Result {
3420                     panic!(concat!("Unable to load ", stringify!(free_descriptor_sets)))
3421                 }
3422                 let cname =
3423                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeDescriptorSets\0");
3424                 let val = _f(cname);
3425                 if val.is_null() {
3426                     free_descriptor_sets
3427                 } else {
3428                     ::std::mem::transmute(val)
3429                 }
3430             },
3431             update_descriptor_sets: unsafe {
3432                 extern "system" fn update_descriptor_sets(
3433                     _device: Device,
3434                     _descriptor_write_count: u32,
3435                     _p_descriptor_writes: *const WriteDescriptorSet,
3436                     _descriptor_copy_count: u32,
3437                     _p_descriptor_copies: *const CopyDescriptorSet,
3438                 ) {
3439                     panic!(concat!(
3440                         "Unable to load ",
3441                         stringify!(update_descriptor_sets)
3442                     ))
3443                 }
3444                 let cname =
3445                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUpdateDescriptorSets\0");
3446                 let val = _f(cname);
3447                 if val.is_null() {
3448                     update_descriptor_sets
3449                 } else {
3450                     ::std::mem::transmute(val)
3451                 }
3452             },
3453             create_framebuffer: unsafe {
3454                 extern "system" fn create_framebuffer(
3455                     _device: Device,
3456                     _p_create_info: *const FramebufferCreateInfo,
3457                     _p_allocator: *const AllocationCallbacks,
3458                     _p_framebuffer: *mut Framebuffer,
3459                 ) -> Result {
3460                     panic!(concat!("Unable to load ", stringify!(create_framebuffer)))
3461                 }
3462                 let cname =
3463                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFramebuffer\0");
3464                 let val = _f(cname);
3465                 if val.is_null() {
3466                     create_framebuffer
3467                 } else {
3468                     ::std::mem::transmute(val)
3469                 }
3470             },
3471             destroy_framebuffer: unsafe {
3472                 extern "system" fn destroy_framebuffer(
3473                     _device: Device,
3474                     _framebuffer: Framebuffer,
3475                     _p_allocator: *const AllocationCallbacks,
3476                 ) {
3477                     panic!(concat!("Unable to load ", stringify!(destroy_framebuffer)))
3478                 }
3479                 let cname =
3480                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFramebuffer\0");
3481                 let val = _f(cname);
3482                 if val.is_null() {
3483                     destroy_framebuffer
3484                 } else {
3485                     ::std::mem::transmute(val)
3486                 }
3487             },
3488             create_render_pass: unsafe {
3489                 extern "system" fn create_render_pass(
3490                     _device: Device,
3491                     _p_create_info: *const RenderPassCreateInfo,
3492                     _p_allocator: *const AllocationCallbacks,
3493                     _p_render_pass: *mut RenderPass,
3494                 ) -> Result {
3495                     panic!(concat!("Unable to load ", stringify!(create_render_pass)))
3496                 }
3497                 let cname =
3498                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass\0");
3499                 let val = _f(cname);
3500                 if val.is_null() {
3501                     create_render_pass
3502                 } else {
3503                     ::std::mem::transmute(val)
3504                 }
3505             },
3506             destroy_render_pass: unsafe {
3507                 extern "system" fn destroy_render_pass(
3508                     _device: Device,
3509                     _render_pass: RenderPass,
3510                     _p_allocator: *const AllocationCallbacks,
3511                 ) {
3512                     panic!(concat!("Unable to load ", stringify!(destroy_render_pass)))
3513                 }
3514                 let cname =
3515                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyRenderPass\0");
3516                 let val = _f(cname);
3517                 if val.is_null() {
3518                     destroy_render_pass
3519                 } else {
3520                     ::std::mem::transmute(val)
3521                 }
3522             },
3523             get_render_area_granularity: unsafe {
3524                 extern "system" fn get_render_area_granularity(
3525                     _device: Device,
3526                     _render_pass: RenderPass,
3527                     _p_granularity: *mut Extent2D,
3528                 ) {
3529                     panic!(concat!(
3530                         "Unable to load ",
3531                         stringify!(get_render_area_granularity)
3532                     ))
3533                 }
3534                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3535                     b"vkGetRenderAreaGranularity\0",
3536                 );
3537                 let val = _f(cname);
3538                 if val.is_null() {
3539                     get_render_area_granularity
3540                 } else {
3541                     ::std::mem::transmute(val)
3542                 }
3543             },
3544             create_command_pool: unsafe {
3545                 extern "system" fn create_command_pool(
3546                     _device: Device,
3547                     _p_create_info: *const CommandPoolCreateInfo,
3548                     _p_allocator: *const AllocationCallbacks,
3549                     _p_command_pool: *mut CommandPool,
3550                 ) -> Result {
3551                     panic!(concat!("Unable to load ", stringify!(create_command_pool)))
3552                 }
3553                 let cname =
3554                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCommandPool\0");
3555                 let val = _f(cname);
3556                 if val.is_null() {
3557                     create_command_pool
3558                 } else {
3559                     ::std::mem::transmute(val)
3560                 }
3561             },
3562             destroy_command_pool: unsafe {
3563                 extern "system" fn destroy_command_pool(
3564                     _device: Device,
3565                     _command_pool: CommandPool,
3566                     _p_allocator: *const AllocationCallbacks,
3567                 ) {
3568                     panic!(concat!("Unable to load ", stringify!(destroy_command_pool)))
3569                 }
3570                 let cname =
3571                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCommandPool\0");
3572                 let val = _f(cname);
3573                 if val.is_null() {
3574                     destroy_command_pool
3575                 } else {
3576                     ::std::mem::transmute(val)
3577                 }
3578             },
3579             reset_command_pool: unsafe {
3580                 extern "system" fn reset_command_pool(
3581                     _device: Device,
3582                     _command_pool: CommandPool,
3583                     _flags: CommandPoolResetFlags,
3584                 ) -> Result {
3585                     panic!(concat!("Unable to load ", stringify!(reset_command_pool)))
3586                 }
3587                 let cname =
3588                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandPool\0");
3589                 let val = _f(cname);
3590                 if val.is_null() {
3591                     reset_command_pool
3592                 } else {
3593                     ::std::mem::transmute(val)
3594                 }
3595             },
3596             allocate_command_buffers: unsafe {
3597                 extern "system" fn allocate_command_buffers(
3598                     _device: Device,
3599                     _p_allocate_info: *const CommandBufferAllocateInfo,
3600                     _p_command_buffers: *mut CommandBuffer,
3601                 ) -> Result {
3602                     panic!(concat!(
3603                         "Unable to load ",
3604                         stringify!(allocate_command_buffers)
3605                     ))
3606                 }
3607                 let cname =
3608                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateCommandBuffers\0");
3609                 let val = _f(cname);
3610                 if val.is_null() {
3611                     allocate_command_buffers
3612                 } else {
3613                     ::std::mem::transmute(val)
3614                 }
3615             },
3616             free_command_buffers: unsafe {
3617                 extern "system" fn free_command_buffers(
3618                     _device: Device,
3619                     _command_pool: CommandPool,
3620                     _command_buffer_count: u32,
3621                     _p_command_buffers: *const CommandBuffer,
3622                 ) {
3623                     panic!(concat!("Unable to load ", stringify!(free_command_buffers)))
3624                 }
3625                 let cname =
3626                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeCommandBuffers\0");
3627                 let val = _f(cname);
3628                 if val.is_null() {
3629                     free_command_buffers
3630                 } else {
3631                     ::std::mem::transmute(val)
3632                 }
3633             },
3634             begin_command_buffer: unsafe {
3635                 extern "system" fn begin_command_buffer(
3636                     _command_buffer: CommandBuffer,
3637                     _p_begin_info: *const CommandBufferBeginInfo,
3638                 ) -> Result {
3639                     panic!(concat!("Unable to load ", stringify!(begin_command_buffer)))
3640                 }
3641                 let cname =
3642                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBeginCommandBuffer\0");
3643                 let val = _f(cname);
3644                 if val.is_null() {
3645                     begin_command_buffer
3646                 } else {
3647                     ::std::mem::transmute(val)
3648                 }
3649             },
3650             end_command_buffer: unsafe {
3651                 extern "system" fn end_command_buffer(_command_buffer: CommandBuffer) -> Result {
3652                     panic!(concat!("Unable to load ", stringify!(end_command_buffer)))
3653                 }
3654                 let cname =
3655                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkEndCommandBuffer\0");
3656                 let val = _f(cname);
3657                 if val.is_null() {
3658                     end_command_buffer
3659                 } else {
3660                     ::std::mem::transmute(val)
3661                 }
3662             },
3663             reset_command_buffer: unsafe {
3664                 extern "system" fn reset_command_buffer(
3665                     _command_buffer: CommandBuffer,
3666                     _flags: CommandBufferResetFlags,
3667                 ) -> Result {
3668                     panic!(concat!("Unable to load ", stringify!(reset_command_buffer)))
3669                 }
3670                 let cname =
3671                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandBuffer\0");
3672                 let val = _f(cname);
3673                 if val.is_null() {
3674                     reset_command_buffer
3675                 } else {
3676                     ::std::mem::transmute(val)
3677                 }
3678             },
3679             cmd_bind_pipeline: unsafe {
3680                 extern "system" fn cmd_bind_pipeline(
3681                     _command_buffer: CommandBuffer,
3682                     _pipeline_bind_point: PipelineBindPoint,
3683                     _pipeline: Pipeline,
3684                 ) {
3685                     panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline)))
3686                 }
3687                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindPipeline\0");
3688                 let val = _f(cname);
3689                 if val.is_null() {
3690                     cmd_bind_pipeline
3691                 } else {
3692                     ::std::mem::transmute(val)
3693                 }
3694             },
3695             cmd_set_viewport: unsafe {
3696                 extern "system" fn cmd_set_viewport(
3697                     _command_buffer: CommandBuffer,
3698                     _first_viewport: u32,
3699                     _viewport_count: u32,
3700                     _p_viewports: *const Viewport,
3701                 ) {
3702                     panic!(concat!("Unable to load ", stringify!(cmd_set_viewport)))
3703                 }
3704                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewport\0");
3705                 let val = _f(cname);
3706                 if val.is_null() {
3707                     cmd_set_viewport
3708                 } else {
3709                     ::std::mem::transmute(val)
3710                 }
3711             },
3712             cmd_set_scissor: unsafe {
3713                 extern "system" fn cmd_set_scissor(
3714                     _command_buffer: CommandBuffer,
3715                     _first_scissor: u32,
3716                     _scissor_count: u32,
3717                     _p_scissors: *const Rect2D,
3718                 ) {
3719                     panic!(concat!("Unable to load ", stringify!(cmd_set_scissor)))
3720                 }
3721                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissor\0");
3722                 let val = _f(cname);
3723                 if val.is_null() {
3724                     cmd_set_scissor
3725                 } else {
3726                     ::std::mem::transmute(val)
3727                 }
3728             },
3729             cmd_set_line_width: unsafe {
3730                 extern "system" fn cmd_set_line_width(
3731                     _command_buffer: CommandBuffer,
3732                     _line_width: f32,
3733                 ) {
3734                     panic!(concat!("Unable to load ", stringify!(cmd_set_line_width)))
3735                 }
3736                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineWidth\0");
3737                 let val = _f(cname);
3738                 if val.is_null() {
3739                     cmd_set_line_width
3740                 } else {
3741                     ::std::mem::transmute(val)
3742                 }
3743             },
3744             cmd_set_depth_bias: unsafe {
3745                 extern "system" fn cmd_set_depth_bias(
3746                     _command_buffer: CommandBuffer,
3747                     _depth_bias_constant_factor: f32,
3748                     _depth_bias_clamp: f32,
3749                     _depth_bias_slope_factor: f32,
3750                 ) {
3751                     panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias)))
3752                 }
3753                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias\0");
3754                 let val = _f(cname);
3755                 if val.is_null() {
3756                     cmd_set_depth_bias
3757                 } else {
3758                     ::std::mem::transmute(val)
3759                 }
3760             },
3761             cmd_set_blend_constants: unsafe {
3762                 extern "system" fn cmd_set_blend_constants(
3763                     _command_buffer: CommandBuffer,
3764                     _blend_constants: *const [f32; 4],
3765                 ) {
3766                     panic!(concat!(
3767                         "Unable to load ",
3768                         stringify!(cmd_set_blend_constants)
3769                     ))
3770                 }
3771                 let cname =
3772                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetBlendConstants\0");
3773                 let val = _f(cname);
3774                 if val.is_null() {
3775                     cmd_set_blend_constants
3776                 } else {
3777                     ::std::mem::transmute(val)
3778                 }
3779             },
3780             cmd_set_depth_bounds: unsafe {
3781                 extern "system" fn cmd_set_depth_bounds(
3782                     _command_buffer: CommandBuffer,
3783                     _min_depth_bounds: f32,
3784                     _max_depth_bounds: f32,
3785                 ) {
3786                     panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds)))
3787                 }
3788                 let cname =
3789                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBounds\0");
3790                 let val = _f(cname);
3791                 if val.is_null() {
3792                     cmd_set_depth_bounds
3793                 } else {
3794                     ::std::mem::transmute(val)
3795                 }
3796             },
3797             cmd_set_stencil_compare_mask: unsafe {
3798                 extern "system" fn cmd_set_stencil_compare_mask(
3799                     _command_buffer: CommandBuffer,
3800                     _face_mask: StencilFaceFlags,
3801                     _compare_mask: u32,
3802                 ) {
3803                     panic!(concat!(
3804                         "Unable to load ",
3805                         stringify!(cmd_set_stencil_compare_mask)
3806                     ))
3807                 }
3808                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3809                     b"vkCmdSetStencilCompareMask\0",
3810                 );
3811                 let val = _f(cname);
3812                 if val.is_null() {
3813                     cmd_set_stencil_compare_mask
3814                 } else {
3815                     ::std::mem::transmute(val)
3816                 }
3817             },
3818             cmd_set_stencil_write_mask: unsafe {
3819                 extern "system" fn cmd_set_stencil_write_mask(
3820                     _command_buffer: CommandBuffer,
3821                     _face_mask: StencilFaceFlags,
3822                     _write_mask: u32,
3823                 ) {
3824                     panic!(concat!(
3825                         "Unable to load ",
3826                         stringify!(cmd_set_stencil_write_mask)
3827                     ))
3828                 }
3829                 let cname =
3830                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilWriteMask\0");
3831                 let val = _f(cname);
3832                 if val.is_null() {
3833                     cmd_set_stencil_write_mask
3834                 } else {
3835                     ::std::mem::transmute(val)
3836                 }
3837             },
3838             cmd_set_stencil_reference: unsafe {
3839                 extern "system" fn cmd_set_stencil_reference(
3840                     _command_buffer: CommandBuffer,
3841                     _face_mask: StencilFaceFlags,
3842                     _reference: u32,
3843                 ) {
3844                     panic!(concat!(
3845                         "Unable to load ",
3846                         stringify!(cmd_set_stencil_reference)
3847                     ))
3848                 }
3849                 let cname =
3850                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilReference\0");
3851                 let val = _f(cname);
3852                 if val.is_null() {
3853                     cmd_set_stencil_reference
3854                 } else {
3855                     ::std::mem::transmute(val)
3856                 }
3857             },
3858             cmd_bind_descriptor_sets: unsafe {
3859                 extern "system" fn cmd_bind_descriptor_sets(
3860                     _command_buffer: CommandBuffer,
3861                     _pipeline_bind_point: PipelineBindPoint,
3862                     _layout: PipelineLayout,
3863                     _first_set: u32,
3864                     _descriptor_set_count: u32,
3865                     _p_descriptor_sets: *const DescriptorSet,
3866                     _dynamic_offset_count: u32,
3867                     _p_dynamic_offsets: *const u32,
3868                 ) {
3869                     panic!(concat!(
3870                         "Unable to load ",
3871                         stringify!(cmd_bind_descriptor_sets)
3872                     ))
3873                 }
3874                 let cname =
3875                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorSets\0");
3876                 let val = _f(cname);
3877                 if val.is_null() {
3878                     cmd_bind_descriptor_sets
3879                 } else {
3880                     ::std::mem::transmute(val)
3881                 }
3882             },
3883             cmd_bind_index_buffer: unsafe {
3884                 extern "system" fn cmd_bind_index_buffer(
3885                     _command_buffer: CommandBuffer,
3886                     _buffer: Buffer,
3887                     _offset: DeviceSize,
3888                     _index_type: IndexType,
3889                 ) {
3890                     panic!(concat!(
3891                         "Unable to load ",
3892                         stringify!(cmd_bind_index_buffer)
3893                     ))
3894                 }
3895                 let cname =
3896                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer\0");
3897                 let val = _f(cname);
3898                 if val.is_null() {
3899                     cmd_bind_index_buffer
3900                 } else {
3901                     ::std::mem::transmute(val)
3902                 }
3903             },
3904             cmd_bind_vertex_buffers: unsafe {
3905                 extern "system" fn cmd_bind_vertex_buffers(
3906                     _command_buffer: CommandBuffer,
3907                     _first_binding: u32,
3908                     _binding_count: u32,
3909                     _p_buffers: *const Buffer,
3910                     _p_offsets: *const DeviceSize,
3911                 ) {
3912                     panic!(concat!(
3913                         "Unable to load ",
3914                         stringify!(cmd_bind_vertex_buffers)
3915                     ))
3916                 }
3917                 let cname =
3918                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers\0");
3919                 let val = _f(cname);
3920                 if val.is_null() {
3921                     cmd_bind_vertex_buffers
3922                 } else {
3923                     ::std::mem::transmute(val)
3924                 }
3925             },
3926             cmd_draw: unsafe {
3927                 extern "system" fn cmd_draw(
3928                     _command_buffer: CommandBuffer,
3929                     _vertex_count: u32,
3930                     _instance_count: u32,
3931                     _first_vertex: u32,
3932                     _first_instance: u32,
3933                 ) {
3934                     panic!(concat!("Unable to load ", stringify!(cmd_draw)))
3935                 }
3936                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDraw\0");
3937                 let val = _f(cname);
3938                 if val.is_null() {
3939                     cmd_draw
3940                 } else {
3941                     ::std::mem::transmute(val)
3942                 }
3943             },
3944             cmd_draw_indexed: unsafe {
3945                 extern "system" fn cmd_draw_indexed(
3946                     _command_buffer: CommandBuffer,
3947                     _index_count: u32,
3948                     _instance_count: u32,
3949                     _first_index: u32,
3950                     _vertex_offset: i32,
3951                     _first_instance: u32,
3952                 ) {
3953                     panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed)))
3954                 }
3955                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexed\0");
3956                 let val = _f(cname);
3957                 if val.is_null() {
3958                     cmd_draw_indexed
3959                 } else {
3960                     ::std::mem::transmute(val)
3961                 }
3962             },
3963             cmd_draw_indirect: unsafe {
3964                 extern "system" fn cmd_draw_indirect(
3965                     _command_buffer: CommandBuffer,
3966                     _buffer: Buffer,
3967                     _offset: DeviceSize,
3968                     _draw_count: u32,
3969                     _stride: u32,
3970                 ) {
3971                     panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect)))
3972                 }
3973                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirect\0");
3974                 let val = _f(cname);
3975                 if val.is_null() {
3976                     cmd_draw_indirect
3977                 } else {
3978                     ::std::mem::transmute(val)
3979                 }
3980             },
3981             cmd_draw_indexed_indirect: unsafe {
3982                 extern "system" fn cmd_draw_indexed_indirect(
3983                     _command_buffer: CommandBuffer,
3984                     _buffer: Buffer,
3985                     _offset: DeviceSize,
3986                     _draw_count: u32,
3987                     _stride: u32,
3988                 ) {
3989                     panic!(concat!(
3990                         "Unable to load ",
3991                         stringify!(cmd_draw_indexed_indirect)
3992                     ))
3993                 }
3994                 let cname =
3995                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexedIndirect\0");
3996                 let val = _f(cname);
3997                 if val.is_null() {
3998                     cmd_draw_indexed_indirect
3999                 } else {
4000                     ::std::mem::transmute(val)
4001                 }
4002             },
4003             cmd_dispatch: unsafe {
4004                 extern "system" fn cmd_dispatch(
4005                     _command_buffer: CommandBuffer,
4006                     _group_count_x: u32,
4007                     _group_count_y: u32,
4008                     _group_count_z: u32,
4009                 ) {
4010                     panic!(concat!("Unable to load ", stringify!(cmd_dispatch)))
4011                 }
4012                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatch\0");
4013                 let val = _f(cname);
4014                 if val.is_null() {
4015                     cmd_dispatch
4016                 } else {
4017                     ::std::mem::transmute(val)
4018                 }
4019             },
4020             cmd_dispatch_indirect: unsafe {
4021                 extern "system" fn cmd_dispatch_indirect(
4022                     _command_buffer: CommandBuffer,
4023                     _buffer: Buffer,
4024                     _offset: DeviceSize,
4025                 ) {
4026                     panic!(concat!(
4027                         "Unable to load ",
4028                         stringify!(cmd_dispatch_indirect)
4029                     ))
4030                 }
4031                 let cname =
4032                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchIndirect\0");
4033                 let val = _f(cname);
4034                 if val.is_null() {
4035                     cmd_dispatch_indirect
4036                 } else {
4037                     ::std::mem::transmute(val)
4038                 }
4039             },
4040             cmd_copy_buffer: unsafe {
4041                 extern "system" fn cmd_copy_buffer(
4042                     _command_buffer: CommandBuffer,
4043                     _src_buffer: Buffer,
4044                     _dst_buffer: Buffer,
4045                     _region_count: u32,
4046                     _p_regions: *const BufferCopy,
4047                 ) {
4048                     panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer)))
4049                 }
4050                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer\0");
4051                 let val = _f(cname);
4052                 if val.is_null() {
4053                     cmd_copy_buffer
4054                 } else {
4055                     ::std::mem::transmute(val)
4056                 }
4057             },
4058             cmd_copy_image: unsafe {
4059                 extern "system" fn cmd_copy_image(
4060                     _command_buffer: CommandBuffer,
4061                     _src_image: Image,
4062                     _src_image_layout: ImageLayout,
4063                     _dst_image: Image,
4064                     _dst_image_layout: ImageLayout,
4065                     _region_count: u32,
4066                     _p_regions: *const ImageCopy,
4067                 ) {
4068                     panic!(concat!("Unable to load ", stringify!(cmd_copy_image)))
4069                 }
4070                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage\0");
4071                 let val = _f(cname);
4072                 if val.is_null() {
4073                     cmd_copy_image
4074                 } else {
4075                     ::std::mem::transmute(val)
4076                 }
4077             },
4078             cmd_blit_image: unsafe {
4079                 extern "system" fn cmd_blit_image(
4080                     _command_buffer: CommandBuffer,
4081                     _src_image: Image,
4082                     _src_image_layout: ImageLayout,
4083                     _dst_image: Image,
4084                     _dst_image_layout: ImageLayout,
4085                     _region_count: u32,
4086                     _p_regions: *const ImageBlit,
4087                     _filter: Filter,
4088                 ) {
4089                     panic!(concat!("Unable to load ", stringify!(cmd_blit_image)))
4090                 }
4091                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage\0");
4092                 let val = _f(cname);
4093                 if val.is_null() {
4094                     cmd_blit_image
4095                 } else {
4096                     ::std::mem::transmute(val)
4097                 }
4098             },
4099             cmd_copy_buffer_to_image: unsafe {
4100                 extern "system" fn cmd_copy_buffer_to_image(
4101                     _command_buffer: CommandBuffer,
4102                     _src_buffer: Buffer,
4103                     _dst_image: Image,
4104                     _dst_image_layout: ImageLayout,
4105                     _region_count: u32,
4106                     _p_regions: *const BufferImageCopy,
4107                 ) {
4108                     panic!(concat!(
4109                         "Unable to load ",
4110                         stringify!(cmd_copy_buffer_to_image)
4111                     ))
4112                 }
4113                 let cname =
4114                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage\0");
4115                 let val = _f(cname);
4116                 if val.is_null() {
4117                     cmd_copy_buffer_to_image
4118                 } else {
4119                     ::std::mem::transmute(val)
4120                 }
4121             },
4122             cmd_copy_image_to_buffer: unsafe {
4123                 extern "system" fn cmd_copy_image_to_buffer(
4124                     _command_buffer: CommandBuffer,
4125                     _src_image: Image,
4126                     _src_image_layout: ImageLayout,
4127                     _dst_buffer: Buffer,
4128                     _region_count: u32,
4129                     _p_regions: *const BufferImageCopy,
4130                 ) {
4131                     panic!(concat!(
4132                         "Unable to load ",
4133                         stringify!(cmd_copy_image_to_buffer)
4134                     ))
4135                 }
4136                 let cname =
4137                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer\0");
4138                 let val = _f(cname);
4139                 if val.is_null() {
4140                     cmd_copy_image_to_buffer
4141                 } else {
4142                     ::std::mem::transmute(val)
4143                 }
4144             },
4145             cmd_update_buffer: unsafe {
4146                 extern "system" fn cmd_update_buffer(
4147                     _command_buffer: CommandBuffer,
4148                     _dst_buffer: Buffer,
4149                     _dst_offset: DeviceSize,
4150                     _data_size: DeviceSize,
4151                     _p_data: *const c_void,
4152                 ) {
4153                     panic!(concat!("Unable to load ", stringify!(cmd_update_buffer)))
4154                 }
4155                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdUpdateBuffer\0");
4156                 let val = _f(cname);
4157                 if val.is_null() {
4158                     cmd_update_buffer
4159                 } else {
4160                     ::std::mem::transmute(val)
4161                 }
4162             },
4163             cmd_fill_buffer: unsafe {
4164                 extern "system" fn cmd_fill_buffer(
4165                     _command_buffer: CommandBuffer,
4166                     _dst_buffer: Buffer,
4167                     _dst_offset: DeviceSize,
4168                     _size: DeviceSize,
4169                     _data: u32,
4170                 ) {
4171                     panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer)))
4172                 }
4173                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdFillBuffer\0");
4174                 let val = _f(cname);
4175                 if val.is_null() {
4176                     cmd_fill_buffer
4177                 } else {
4178                     ::std::mem::transmute(val)
4179                 }
4180             },
4181             cmd_clear_color_image: unsafe {
4182                 extern "system" fn cmd_clear_color_image(
4183                     _command_buffer: CommandBuffer,
4184                     _image: Image,
4185                     _image_layout: ImageLayout,
4186                     _p_color: *const ClearColorValue,
4187                     _range_count: u32,
4188                     _p_ranges: *const ImageSubresourceRange,
4189                 ) {
4190                     panic!(concat!(
4191                         "Unable to load ",
4192                         stringify!(cmd_clear_color_image)
4193                     ))
4194                 }
4195                 let cname =
4196                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearColorImage\0");
4197                 let val = _f(cname);
4198                 if val.is_null() {
4199                     cmd_clear_color_image
4200                 } else {
4201                     ::std::mem::transmute(val)
4202                 }
4203             },
4204             cmd_clear_depth_stencil_image: unsafe {
4205                 extern "system" fn cmd_clear_depth_stencil_image(
4206                     _command_buffer: CommandBuffer,
4207                     _image: Image,
4208                     _image_layout: ImageLayout,
4209                     _p_depth_stencil: *const ClearDepthStencilValue,
4210                     _range_count: u32,
4211                     _p_ranges: *const ImageSubresourceRange,
4212                 ) {
4213                     panic!(concat!(
4214                         "Unable to load ",
4215                         stringify!(cmd_clear_depth_stencil_image)
4216                     ))
4217                 }
4218                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4219                     b"vkCmdClearDepthStencilImage\0",
4220                 );
4221                 let val = _f(cname);
4222                 if val.is_null() {
4223                     cmd_clear_depth_stencil_image
4224                 } else {
4225                     ::std::mem::transmute(val)
4226                 }
4227             },
4228             cmd_clear_attachments: unsafe {
4229                 extern "system" fn cmd_clear_attachments(
4230                     _command_buffer: CommandBuffer,
4231                     _attachment_count: u32,
4232                     _p_attachments: *const ClearAttachment,
4233                     _rect_count: u32,
4234                     _p_rects: *const ClearRect,
4235                 ) {
4236                     panic!(concat!(
4237                         "Unable to load ",
4238                         stringify!(cmd_clear_attachments)
4239                     ))
4240                 }
4241                 let cname =
4242                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearAttachments\0");
4243                 let val = _f(cname);
4244                 if val.is_null() {
4245                     cmd_clear_attachments
4246                 } else {
4247                     ::std::mem::transmute(val)
4248                 }
4249             },
4250             cmd_resolve_image: unsafe {
4251                 extern "system" fn cmd_resolve_image(
4252                     _command_buffer: CommandBuffer,
4253                     _src_image: Image,
4254                     _src_image_layout: ImageLayout,
4255                     _dst_image: Image,
4256                     _dst_image_layout: ImageLayout,
4257                     _region_count: u32,
4258                     _p_regions: *const ImageResolve,
4259                 ) {
4260                     panic!(concat!("Unable to load ", stringify!(cmd_resolve_image)))
4261                 }
4262                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage\0");
4263                 let val = _f(cname);
4264                 if val.is_null() {
4265                     cmd_resolve_image
4266                 } else {
4267                     ::std::mem::transmute(val)
4268                 }
4269             },
4270             cmd_set_event: unsafe {
4271                 extern "system" fn cmd_set_event(
4272                     _command_buffer: CommandBuffer,
4273                     _event: Event,
4274                     _stage_mask: PipelineStageFlags,
4275                 ) {
4276                     panic!(concat!("Unable to load ", stringify!(cmd_set_event)))
4277                 }
4278                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent\0");
4279                 let val = _f(cname);
4280                 if val.is_null() {
4281                     cmd_set_event
4282                 } else {
4283                     ::std::mem::transmute(val)
4284                 }
4285             },
4286             cmd_reset_event: unsafe {
4287                 extern "system" fn cmd_reset_event(
4288                     _command_buffer: CommandBuffer,
4289                     _event: Event,
4290                     _stage_mask: PipelineStageFlags,
4291                 ) {
4292                     panic!(concat!("Unable to load ", stringify!(cmd_reset_event)))
4293                 }
4294                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent\0");
4295                 let val = _f(cname);
4296                 if val.is_null() {
4297                     cmd_reset_event
4298                 } else {
4299                     ::std::mem::transmute(val)
4300                 }
4301             },
4302             cmd_wait_events: unsafe {
4303                 extern "system" fn cmd_wait_events(
4304                     _command_buffer: CommandBuffer,
4305                     _event_count: u32,
4306                     _p_events: *const Event,
4307                     _src_stage_mask: PipelineStageFlags,
4308                     _dst_stage_mask: PipelineStageFlags,
4309                     _memory_barrier_count: u32,
4310                     _p_memory_barriers: *const MemoryBarrier,
4311                     _buffer_memory_barrier_count: u32,
4312                     _p_buffer_memory_barriers: *const BufferMemoryBarrier,
4313                     _image_memory_barrier_count: u32,
4314                     _p_image_memory_barriers: *const ImageMemoryBarrier,
4315                 ) {
4316                     panic!(concat!("Unable to load ", stringify!(cmd_wait_events)))
4317                 }
4318                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents\0");
4319                 let val = _f(cname);
4320                 if val.is_null() {
4321                     cmd_wait_events
4322                 } else {
4323                     ::std::mem::transmute(val)
4324                 }
4325             },
4326             cmd_pipeline_barrier: unsafe {
4327                 extern "system" fn cmd_pipeline_barrier(
4328                     _command_buffer: CommandBuffer,
4329                     _src_stage_mask: PipelineStageFlags,
4330                     _dst_stage_mask: PipelineStageFlags,
4331                     _dependency_flags: DependencyFlags,
4332                     _memory_barrier_count: u32,
4333                     _p_memory_barriers: *const MemoryBarrier,
4334                     _buffer_memory_barrier_count: u32,
4335                     _p_buffer_memory_barriers: *const BufferMemoryBarrier,
4336                     _image_memory_barrier_count: u32,
4337                     _p_image_memory_barriers: *const ImageMemoryBarrier,
4338                 ) {
4339                     panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier)))
4340                 }
4341                 let cname =
4342                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier\0");
4343                 let val = _f(cname);
4344                 if val.is_null() {
4345                     cmd_pipeline_barrier
4346                 } else {
4347                     ::std::mem::transmute(val)
4348                 }
4349             },
4350             cmd_begin_query: unsafe {
4351                 extern "system" fn cmd_begin_query(
4352                     _command_buffer: CommandBuffer,
4353                     _query_pool: QueryPool,
4354                     _query: u32,
4355                     _flags: QueryControlFlags,
4356                 ) {
4357                     panic!(concat!("Unable to load ", stringify!(cmd_begin_query)))
4358                 }
4359                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQuery\0");
4360                 let val = _f(cname);
4361                 if val.is_null() {
4362                     cmd_begin_query
4363                 } else {
4364                     ::std::mem::transmute(val)
4365                 }
4366             },
4367             cmd_end_query: unsafe {
4368                 extern "system" fn cmd_end_query(
4369                     _command_buffer: CommandBuffer,
4370                     _query_pool: QueryPool,
4371                     _query: u32,
4372                 ) {
4373                     panic!(concat!("Unable to load ", stringify!(cmd_end_query)))
4374                 }
4375                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQuery\0");
4376                 let val = _f(cname);
4377                 if val.is_null() {
4378                     cmd_end_query
4379                 } else {
4380                     ::std::mem::transmute(val)
4381                 }
4382             },
4383             cmd_reset_query_pool: unsafe {
4384                 extern "system" fn cmd_reset_query_pool(
4385                     _command_buffer: CommandBuffer,
4386                     _query_pool: QueryPool,
4387                     _first_query: u32,
4388                     _query_count: u32,
4389                 ) {
4390                     panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool)))
4391                 }
4392                 let cname =
4393                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetQueryPool\0");
4394                 let val = _f(cname);
4395                 if val.is_null() {
4396                     cmd_reset_query_pool
4397                 } else {
4398                     ::std::mem::transmute(val)
4399                 }
4400             },
4401             cmd_write_timestamp: unsafe {
4402                 extern "system" fn cmd_write_timestamp(
4403                     _command_buffer: CommandBuffer,
4404                     _pipeline_stage: PipelineStageFlags,
4405                     _query_pool: QueryPool,
4406                     _query: u32,
4407                 ) {
4408                     panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp)))
4409                 }
4410                 let cname =
4411                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp\0");
4412                 let val = _f(cname);
4413                 if val.is_null() {
4414                     cmd_write_timestamp
4415                 } else {
4416                     ::std::mem::transmute(val)
4417                 }
4418             },
4419             cmd_copy_query_pool_results: unsafe {
4420                 extern "system" fn cmd_copy_query_pool_results(
4421                     _command_buffer: CommandBuffer,
4422                     _query_pool: QueryPool,
4423                     _first_query: u32,
4424                     _query_count: u32,
4425                     _dst_buffer: Buffer,
4426                     _dst_offset: DeviceSize,
4427                     _stride: DeviceSize,
4428                     _flags: QueryResultFlags,
4429                 ) {
4430                     panic!(concat!(
4431                         "Unable to load ",
4432                         stringify!(cmd_copy_query_pool_results)
4433                     ))
4434                 }
4435                 let cname =
4436                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyQueryPoolResults\0");
4437                 let val = _f(cname);
4438                 if val.is_null() {
4439                     cmd_copy_query_pool_results
4440                 } else {
4441                     ::std::mem::transmute(val)
4442                 }
4443             },
4444             cmd_push_constants: unsafe {
4445                 extern "system" fn cmd_push_constants(
4446                     _command_buffer: CommandBuffer,
4447                     _layout: PipelineLayout,
4448                     _stage_flags: ShaderStageFlags,
4449                     _offset: u32,
4450                     _size: u32,
4451                     _p_values: *const c_void,
4452                 ) {
4453                     panic!(concat!("Unable to load ", stringify!(cmd_push_constants)))
4454                 }
4455                 let cname =
4456                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushConstants\0");
4457                 let val = _f(cname);
4458                 if val.is_null() {
4459                     cmd_push_constants
4460                 } else {
4461                     ::std::mem::transmute(val)
4462                 }
4463             },
4464             cmd_begin_render_pass: unsafe {
4465                 extern "system" fn cmd_begin_render_pass(
4466                     _command_buffer: CommandBuffer,
4467                     _p_render_pass_begin: *const RenderPassBeginInfo,
4468                     _contents: SubpassContents,
4469                 ) {
4470                     panic!(concat!(
4471                         "Unable to load ",
4472                         stringify!(cmd_begin_render_pass)
4473                     ))
4474                 }
4475                 let cname =
4476                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass\0");
4477                 let val = _f(cname);
4478                 if val.is_null() {
4479                     cmd_begin_render_pass
4480                 } else {
4481                     ::std::mem::transmute(val)
4482                 }
4483             },
4484             cmd_next_subpass: unsafe {
4485                 extern "system" fn cmd_next_subpass(
4486                     _command_buffer: CommandBuffer,
4487                     _contents: SubpassContents,
4488                 ) {
4489                     panic!(concat!("Unable to load ", stringify!(cmd_next_subpass)))
4490                 }
4491                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass\0");
4492                 let val = _f(cname);
4493                 if val.is_null() {
4494                     cmd_next_subpass
4495                 } else {
4496                     ::std::mem::transmute(val)
4497                 }
4498             },
4499             cmd_end_render_pass: unsafe {
4500                 extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) {
4501                     panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass)))
4502                 }
4503                 let cname =
4504                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass\0");
4505                 let val = _f(cname);
4506                 if val.is_null() {
4507                     cmd_end_render_pass
4508                 } else {
4509                     ::std::mem::transmute(val)
4510                 }
4511             },
4512             cmd_execute_commands: unsafe {
4513                 extern "system" fn cmd_execute_commands(
4514                     _command_buffer: CommandBuffer,
4515                     _command_buffer_count: u32,
4516                     _p_command_buffers: *const CommandBuffer,
4517                 ) {
4518                     panic!(concat!("Unable to load ", stringify!(cmd_execute_commands)))
4519                 }
4520                 let cname =
4521                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdExecuteCommands\0");
4522                 let val = _f(cname);
4523                 if val.is_null() {
4524                     cmd_execute_commands
4525                 } else {
4526                     ::std::mem::transmute(val)
4527                 }
4528             },
4529         }
4530     }
4531     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDevice.html>"]
destroy_device(&self, device: Device, p_allocator: *const AllocationCallbacks)4532     pub unsafe fn destroy_device(&self, device: Device, p_allocator: *const AllocationCallbacks) {
4533         (self.destroy_device)(device, p_allocator)
4534     }
4535     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceQueue.html>"]
get_device_queue( &self, device: Device, queue_family_index: u32, queue_index: u32, p_queue: *mut Queue, )4536     pub unsafe fn get_device_queue(
4537         &self,
4538         device: Device,
4539         queue_family_index: u32,
4540         queue_index: u32,
4541         p_queue: *mut Queue,
4542     ) {
4543         (self.get_device_queue)(device, queue_family_index, queue_index, p_queue)
4544     }
4545     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSubmit.html>"]
queue_submit( &self, queue: Queue, submit_count: u32, p_submits: *const SubmitInfo, fence: Fence, ) -> Result4546     pub unsafe fn queue_submit(
4547         &self,
4548         queue: Queue,
4549         submit_count: u32,
4550         p_submits: *const SubmitInfo,
4551         fence: Fence,
4552     ) -> Result {
4553         (self.queue_submit)(queue, submit_count, p_submits, fence)
4554     }
4555     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueWaitIdle.html>"]
queue_wait_idle(&self, queue: Queue) -> Result4556     pub unsafe fn queue_wait_idle(&self, queue: Queue) -> Result {
4557         (self.queue_wait_idle)(queue)
4558     }
4559     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDeviceWaitIdle.html>"]
device_wait_idle(&self, device: Device) -> Result4560     pub unsafe fn device_wait_idle(&self, device: Device) -> Result {
4561         (self.device_wait_idle)(device)
4562     }
4563     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateMemory.html>"]
allocate_memory( &self, device: Device, p_allocate_info: *const MemoryAllocateInfo, p_allocator: *const AllocationCallbacks, p_memory: *mut DeviceMemory, ) -> Result4564     pub unsafe fn allocate_memory(
4565         &self,
4566         device: Device,
4567         p_allocate_info: *const MemoryAllocateInfo,
4568         p_allocator: *const AllocationCallbacks,
4569         p_memory: *mut DeviceMemory,
4570     ) -> Result {
4571         (self.allocate_memory)(device, p_allocate_info, p_allocator, p_memory)
4572     }
4573     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeMemory.html>"]
free_memory( &self, device: Device, memory: DeviceMemory, p_allocator: *const AllocationCallbacks, )4574     pub unsafe fn free_memory(
4575         &self,
4576         device: Device,
4577         memory: DeviceMemory,
4578         p_allocator: *const AllocationCallbacks,
4579     ) {
4580         (self.free_memory)(device, memory, p_allocator)
4581     }
4582     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMapMemory.html>"]
map_memory( &self, device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, pp_data: *mut *mut c_void, ) -> Result4583     pub unsafe fn map_memory(
4584         &self,
4585         device: Device,
4586         memory: DeviceMemory,
4587         offset: DeviceSize,
4588         size: DeviceSize,
4589         flags: MemoryMapFlags,
4590         pp_data: *mut *mut c_void,
4591     ) -> Result {
4592         (self.map_memory)(device, memory, offset, size, flags, pp_data)
4593     }
4594     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUnmapMemory.html>"]
unmap_memory(&self, device: Device, memory: DeviceMemory)4595     pub unsafe fn unmap_memory(&self, device: Device, memory: DeviceMemory) {
4596         (self.unmap_memory)(device, memory)
4597     }
4598     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFlushMappedMemoryRanges.html>"]
flush_mapped_memory_ranges( &self, device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result4599     pub unsafe fn flush_mapped_memory_ranges(
4600         &self,
4601         device: Device,
4602         memory_range_count: u32,
4603         p_memory_ranges: *const MappedMemoryRange,
4604     ) -> Result {
4605         (self.flush_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges)
4606     }
4607     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkInvalidateMappedMemoryRanges.html>"]
invalidate_mapped_memory_ranges( &self, device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result4608     pub unsafe fn invalidate_mapped_memory_ranges(
4609         &self,
4610         device: Device,
4611         memory_range_count: u32,
4612         p_memory_ranges: *const MappedMemoryRange,
4613     ) -> Result {
4614         (self.invalidate_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges)
4615     }
4616     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryCommitment.html>"]
get_device_memory_commitment( &self, device: Device, memory: DeviceMemory, p_committed_memory_in_bytes: *mut DeviceSize, )4617     pub unsafe fn get_device_memory_commitment(
4618         &self,
4619         device: Device,
4620         memory: DeviceMemory,
4621         p_committed_memory_in_bytes: *mut DeviceSize,
4622     ) {
4623         (self.get_device_memory_commitment)(device, memory, p_committed_memory_in_bytes)
4624     }
4625     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory.html>"]
bind_buffer_memory( &self, device: Device, buffer: Buffer, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result4626     pub unsafe fn bind_buffer_memory(
4627         &self,
4628         device: Device,
4629         buffer: Buffer,
4630         memory: DeviceMemory,
4631         memory_offset: DeviceSize,
4632     ) -> Result {
4633         (self.bind_buffer_memory)(device, buffer, memory, memory_offset)
4634     }
4635     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory.html>"]
bind_image_memory( &self, device: Device, image: Image, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result4636     pub unsafe fn bind_image_memory(
4637         &self,
4638         device: Device,
4639         image: Image,
4640         memory: DeviceMemory,
4641         memory_offset: DeviceSize,
4642     ) -> Result {
4643         (self.bind_image_memory)(device, image, memory, memory_offset)
4644     }
4645     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements.html>"]
get_buffer_memory_requirements( &self, device: Device, buffer: Buffer, p_memory_requirements: *mut MemoryRequirements, )4646     pub unsafe fn get_buffer_memory_requirements(
4647         &self,
4648         device: Device,
4649         buffer: Buffer,
4650         p_memory_requirements: *mut MemoryRequirements,
4651     ) {
4652         (self.get_buffer_memory_requirements)(device, buffer, p_memory_requirements)
4653     }
4654     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements.html>"]
get_image_memory_requirements( &self, device: Device, image: Image, p_memory_requirements: *mut MemoryRequirements, )4655     pub unsafe fn get_image_memory_requirements(
4656         &self,
4657         device: Device,
4658         image: Image,
4659         p_memory_requirements: *mut MemoryRequirements,
4660     ) {
4661         (self.get_image_memory_requirements)(device, image, p_memory_requirements)
4662     }
4663     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements.html>"]
get_image_sparse_memory_requirements( &self, device: Device, image: Image, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, )4664     pub unsafe fn get_image_sparse_memory_requirements(
4665         &self,
4666         device: Device,
4667         image: Image,
4668         p_sparse_memory_requirement_count: *mut u32,
4669         p_sparse_memory_requirements: *mut SparseImageMemoryRequirements,
4670     ) {
4671         (self.get_image_sparse_memory_requirements)(
4672             device,
4673             image,
4674             p_sparse_memory_requirement_count,
4675             p_sparse_memory_requirements,
4676         )
4677     }
4678     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueBindSparse.html>"]
queue_bind_sparse( &self, queue: Queue, bind_info_count: u32, p_bind_info: *const BindSparseInfo, fence: Fence, ) -> Result4679     pub unsafe fn queue_bind_sparse(
4680         &self,
4681         queue: Queue,
4682         bind_info_count: u32,
4683         p_bind_info: *const BindSparseInfo,
4684         fence: Fence,
4685     ) -> Result {
4686         (self.queue_bind_sparse)(queue, bind_info_count, p_bind_info, fence)
4687     }
4688     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFence.html>"]
create_fence( &self, device: Device, p_create_info: *const FenceCreateInfo, p_allocator: *const AllocationCallbacks, p_fence: *mut Fence, ) -> Result4689     pub unsafe fn create_fence(
4690         &self,
4691         device: Device,
4692         p_create_info: *const FenceCreateInfo,
4693         p_allocator: *const AllocationCallbacks,
4694         p_fence: *mut Fence,
4695     ) -> Result {
4696         (self.create_fence)(device, p_create_info, p_allocator, p_fence)
4697     }
4698     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFence.html>"]
destroy_fence( &self, device: Device, fence: Fence, p_allocator: *const AllocationCallbacks, )4699     pub unsafe fn destroy_fence(
4700         &self,
4701         device: Device,
4702         fence: Fence,
4703         p_allocator: *const AllocationCallbacks,
4704     ) {
4705         (self.destroy_fence)(device, fence, p_allocator)
4706     }
4707     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetFences.html>"]
reset_fences( &self, device: Device, fence_count: u32, p_fences: *const Fence, ) -> Result4708     pub unsafe fn reset_fences(
4709         &self,
4710         device: Device,
4711         fence_count: u32,
4712         p_fences: *const Fence,
4713     ) -> Result {
4714         (self.reset_fences)(device, fence_count, p_fences)
4715     }
4716     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetFenceStatus.html>"]
get_fence_status(&self, device: Device, fence: Fence) -> Result4717     pub unsafe fn get_fence_status(&self, device: Device, fence: Fence) -> Result {
4718         (self.get_fence_status)(device, fence)
4719     }
4720     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitForFences.html>"]
wait_for_fences( &self, device: Device, fence_count: u32, p_fences: *const Fence, wait_all: Bool32, timeout: u64, ) -> Result4721     pub unsafe fn wait_for_fences(
4722         &self,
4723         device: Device,
4724         fence_count: u32,
4725         p_fences: *const Fence,
4726         wait_all: Bool32,
4727         timeout: u64,
4728     ) -> Result {
4729         (self.wait_for_fences)(device, fence_count, p_fences, wait_all, timeout)
4730     }
4731     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSemaphore.html>"]
create_semaphore( &self, device: Device, p_create_info: *const SemaphoreCreateInfo, p_allocator: *const AllocationCallbacks, p_semaphore: *mut Semaphore, ) -> Result4732     pub unsafe fn create_semaphore(
4733         &self,
4734         device: Device,
4735         p_create_info: *const SemaphoreCreateInfo,
4736         p_allocator: *const AllocationCallbacks,
4737         p_semaphore: *mut Semaphore,
4738     ) -> Result {
4739         (self.create_semaphore)(device, p_create_info, p_allocator, p_semaphore)
4740     }
4741     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySemaphore.html>"]
destroy_semaphore( &self, device: Device, semaphore: Semaphore, p_allocator: *const AllocationCallbacks, )4742     pub unsafe fn destroy_semaphore(
4743         &self,
4744         device: Device,
4745         semaphore: Semaphore,
4746         p_allocator: *const AllocationCallbacks,
4747     ) {
4748         (self.destroy_semaphore)(device, semaphore, p_allocator)
4749     }
4750     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateEvent.html>"]
create_event( &self, device: Device, p_create_info: *const EventCreateInfo, p_allocator: *const AllocationCallbacks, p_event: *mut Event, ) -> Result4751     pub unsafe fn create_event(
4752         &self,
4753         device: Device,
4754         p_create_info: *const EventCreateInfo,
4755         p_allocator: *const AllocationCallbacks,
4756         p_event: *mut Event,
4757     ) -> Result {
4758         (self.create_event)(device, p_create_info, p_allocator, p_event)
4759     }
4760     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyEvent.html>"]
destroy_event( &self, device: Device, event: Event, p_allocator: *const AllocationCallbacks, )4761     pub unsafe fn destroy_event(
4762         &self,
4763         device: Device,
4764         event: Event,
4765         p_allocator: *const AllocationCallbacks,
4766     ) {
4767         (self.destroy_event)(device, event, p_allocator)
4768     }
4769     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetEventStatus.html>"]
get_event_status(&self, device: Device, event: Event) -> Result4770     pub unsafe fn get_event_status(&self, device: Device, event: Event) -> Result {
4771         (self.get_event_status)(device, event)
4772     }
4773     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetEvent.html>"]
set_event(&self, device: Device, event: Event) -> Result4774     pub unsafe fn set_event(&self, device: Device, event: Event) -> Result {
4775         (self.set_event)(device, event)
4776     }
4777     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetEvent.html>"]
reset_event(&self, device: Device, event: Event) -> Result4778     pub unsafe fn reset_event(&self, device: Device, event: Event) -> Result {
4779         (self.reset_event)(device, event)
4780     }
4781     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateQueryPool.html>"]
create_query_pool( &self, device: Device, p_create_info: *const QueryPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_query_pool: *mut QueryPool, ) -> Result4782     pub unsafe fn create_query_pool(
4783         &self,
4784         device: Device,
4785         p_create_info: *const QueryPoolCreateInfo,
4786         p_allocator: *const AllocationCallbacks,
4787         p_query_pool: *mut QueryPool,
4788     ) -> Result {
4789         (self.create_query_pool)(device, p_create_info, p_allocator, p_query_pool)
4790     }
4791     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyQueryPool.html>"]
destroy_query_pool( &self, device: Device, query_pool: QueryPool, p_allocator: *const AllocationCallbacks, )4792     pub unsafe fn destroy_query_pool(
4793         &self,
4794         device: Device,
4795         query_pool: QueryPool,
4796         p_allocator: *const AllocationCallbacks,
4797     ) {
4798         (self.destroy_query_pool)(device, query_pool, p_allocator)
4799     }
4800     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetQueryPoolResults.html>"]
get_query_pool_results( &self, device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, data_size: usize, p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, ) -> Result4801     pub unsafe fn get_query_pool_results(
4802         &self,
4803         device: Device,
4804         query_pool: QueryPool,
4805         first_query: u32,
4806         query_count: u32,
4807         data_size: usize,
4808         p_data: *mut c_void,
4809         stride: DeviceSize,
4810         flags: QueryResultFlags,
4811     ) -> Result {
4812         (self.get_query_pool_results)(
4813             device,
4814             query_pool,
4815             first_query,
4816             query_count,
4817             data_size,
4818             p_data,
4819             stride,
4820             flags,
4821         )
4822     }
4823     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBuffer.html>"]
create_buffer( &self, device: Device, p_create_info: *const BufferCreateInfo, p_allocator: *const AllocationCallbacks, p_buffer: *mut Buffer, ) -> Result4824     pub unsafe fn create_buffer(
4825         &self,
4826         device: Device,
4827         p_create_info: *const BufferCreateInfo,
4828         p_allocator: *const AllocationCallbacks,
4829         p_buffer: *mut Buffer,
4830     ) -> Result {
4831         (self.create_buffer)(device, p_create_info, p_allocator, p_buffer)
4832     }
4833     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBuffer.html>"]
destroy_buffer( &self, device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks, )4834     pub unsafe fn destroy_buffer(
4835         &self,
4836         device: Device,
4837         buffer: Buffer,
4838         p_allocator: *const AllocationCallbacks,
4839     ) {
4840         (self.destroy_buffer)(device, buffer, p_allocator)
4841     }
4842     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBufferView.html>"]
create_buffer_view( &self, device: Device, p_create_info: *const BufferViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut BufferView, ) -> Result4843     pub unsafe fn create_buffer_view(
4844         &self,
4845         device: Device,
4846         p_create_info: *const BufferViewCreateInfo,
4847         p_allocator: *const AllocationCallbacks,
4848         p_view: *mut BufferView,
4849     ) -> Result {
4850         (self.create_buffer_view)(device, p_create_info, p_allocator, p_view)
4851     }
4852     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBufferView.html>"]
destroy_buffer_view( &self, device: Device, buffer_view: BufferView, p_allocator: *const AllocationCallbacks, )4853     pub unsafe fn destroy_buffer_view(
4854         &self,
4855         device: Device,
4856         buffer_view: BufferView,
4857         p_allocator: *const AllocationCallbacks,
4858     ) {
4859         (self.destroy_buffer_view)(device, buffer_view, p_allocator)
4860     }
4861     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImage.html>"]
create_image( &self, device: Device, p_create_info: *const ImageCreateInfo, p_allocator: *const AllocationCallbacks, p_image: *mut Image, ) -> Result4862     pub unsafe fn create_image(
4863         &self,
4864         device: Device,
4865         p_create_info: *const ImageCreateInfo,
4866         p_allocator: *const AllocationCallbacks,
4867         p_image: *mut Image,
4868     ) -> Result {
4869         (self.create_image)(device, p_create_info, p_allocator, p_image)
4870     }
4871     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImage.html>"]
destroy_image( &self, device: Device, image: Image, p_allocator: *const AllocationCallbacks, )4872     pub unsafe fn destroy_image(
4873         &self,
4874         device: Device,
4875         image: Image,
4876         p_allocator: *const AllocationCallbacks,
4877     ) {
4878         (self.destroy_image)(device, image, p_allocator)
4879     }
4880     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSubresourceLayout.html>"]
get_image_subresource_layout( &self, device: Device, image: Image, p_subresource: *const ImageSubresource, p_layout: *mut SubresourceLayout, )4881     pub unsafe fn get_image_subresource_layout(
4882         &self,
4883         device: Device,
4884         image: Image,
4885         p_subresource: *const ImageSubresource,
4886         p_layout: *mut SubresourceLayout,
4887     ) {
4888         (self.get_image_subresource_layout)(device, image, p_subresource, p_layout)
4889     }
4890     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImageView.html>"]
create_image_view( &self, device: Device, p_create_info: *const ImageViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut ImageView, ) -> Result4891     pub unsafe fn create_image_view(
4892         &self,
4893         device: Device,
4894         p_create_info: *const ImageViewCreateInfo,
4895         p_allocator: *const AllocationCallbacks,
4896         p_view: *mut ImageView,
4897     ) -> Result {
4898         (self.create_image_view)(device, p_create_info, p_allocator, p_view)
4899     }
4900     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImageView.html>"]
destroy_image_view( &self, device: Device, image_view: ImageView, p_allocator: *const AllocationCallbacks, )4901     pub unsafe fn destroy_image_view(
4902         &self,
4903         device: Device,
4904         image_view: ImageView,
4905         p_allocator: *const AllocationCallbacks,
4906     ) {
4907         (self.destroy_image_view)(device, image_view, p_allocator)
4908     }
4909     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateShaderModule.html>"]
create_shader_module( &self, device: Device, p_create_info: *const ShaderModuleCreateInfo, p_allocator: *const AllocationCallbacks, p_shader_module: *mut ShaderModule, ) -> Result4910     pub unsafe fn create_shader_module(
4911         &self,
4912         device: Device,
4913         p_create_info: *const ShaderModuleCreateInfo,
4914         p_allocator: *const AllocationCallbacks,
4915         p_shader_module: *mut ShaderModule,
4916     ) -> Result {
4917         (self.create_shader_module)(device, p_create_info, p_allocator, p_shader_module)
4918     }
4919     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyShaderModule.html>"]
destroy_shader_module( &self, device: Device, shader_module: ShaderModule, p_allocator: *const AllocationCallbacks, )4920     pub unsafe fn destroy_shader_module(
4921         &self,
4922         device: Device,
4923         shader_module: ShaderModule,
4924         p_allocator: *const AllocationCallbacks,
4925     ) {
4926         (self.destroy_shader_module)(device, shader_module, p_allocator)
4927     }
4928     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineCache.html>"]
create_pipeline_cache( &self, device: Device, p_create_info: *const PipelineCacheCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_cache: *mut PipelineCache, ) -> Result4929     pub unsafe fn create_pipeline_cache(
4930         &self,
4931         device: Device,
4932         p_create_info: *const PipelineCacheCreateInfo,
4933         p_allocator: *const AllocationCallbacks,
4934         p_pipeline_cache: *mut PipelineCache,
4935     ) -> Result {
4936         (self.create_pipeline_cache)(device, p_create_info, p_allocator, p_pipeline_cache)
4937     }
4938     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineCache.html>"]
destroy_pipeline_cache( &self, device: Device, pipeline_cache: PipelineCache, p_allocator: *const AllocationCallbacks, )4939     pub unsafe fn destroy_pipeline_cache(
4940         &self,
4941         device: Device,
4942         pipeline_cache: PipelineCache,
4943         p_allocator: *const AllocationCallbacks,
4944     ) {
4945         (self.destroy_pipeline_cache)(device, pipeline_cache, p_allocator)
4946     }
4947     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineCacheData.html>"]
get_pipeline_cache_data( &self, device: Device, pipeline_cache: PipelineCache, p_data_size: *mut usize, p_data: *mut c_void, ) -> Result4948     pub unsafe fn get_pipeline_cache_data(
4949         &self,
4950         device: Device,
4951         pipeline_cache: PipelineCache,
4952         p_data_size: *mut usize,
4953         p_data: *mut c_void,
4954     ) -> Result {
4955         (self.get_pipeline_cache_data)(device, pipeline_cache, p_data_size, p_data)
4956     }
4957     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMergePipelineCaches.html>"]
merge_pipeline_caches( &self, device: Device, dst_cache: PipelineCache, src_cache_count: u32, p_src_caches: *const PipelineCache, ) -> Result4958     pub unsafe fn merge_pipeline_caches(
4959         &self,
4960         device: Device,
4961         dst_cache: PipelineCache,
4962         src_cache_count: u32,
4963         p_src_caches: *const PipelineCache,
4964     ) -> Result {
4965         (self.merge_pipeline_caches)(device, dst_cache, src_cache_count, p_src_caches)
4966     }
4967     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateGraphicsPipelines.html>"]
create_graphics_pipelines( &self, device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result4968     pub unsafe fn create_graphics_pipelines(
4969         &self,
4970         device: Device,
4971         pipeline_cache: PipelineCache,
4972         create_info_count: u32,
4973         p_create_infos: *const GraphicsPipelineCreateInfo,
4974         p_allocator: *const AllocationCallbacks,
4975         p_pipelines: *mut Pipeline,
4976     ) -> Result {
4977         (self.create_graphics_pipelines)(
4978             device,
4979             pipeline_cache,
4980             create_info_count,
4981             p_create_infos,
4982             p_allocator,
4983             p_pipelines,
4984         )
4985     }
4986     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateComputePipelines.html>"]
create_compute_pipelines( &self, device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result4987     pub unsafe fn create_compute_pipelines(
4988         &self,
4989         device: Device,
4990         pipeline_cache: PipelineCache,
4991         create_info_count: u32,
4992         p_create_infos: *const ComputePipelineCreateInfo,
4993         p_allocator: *const AllocationCallbacks,
4994         p_pipelines: *mut Pipeline,
4995     ) -> Result {
4996         (self.create_compute_pipelines)(
4997             device,
4998             pipeline_cache,
4999             create_info_count,
5000             p_create_infos,
5001             p_allocator,
5002             p_pipelines,
5003         )
5004     }
5005     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipeline.html>"]
destroy_pipeline( &self, device: Device, pipeline: Pipeline, p_allocator: *const AllocationCallbacks, )5006     pub unsafe fn destroy_pipeline(
5007         &self,
5008         device: Device,
5009         pipeline: Pipeline,
5010         p_allocator: *const AllocationCallbacks,
5011     ) {
5012         (self.destroy_pipeline)(device, pipeline, p_allocator)
5013     }
5014     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineLayout.html>"]
create_pipeline_layout( &self, device: Device, p_create_info: *const PipelineLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_layout: *mut PipelineLayout, ) -> Result5015     pub unsafe fn create_pipeline_layout(
5016         &self,
5017         device: Device,
5018         p_create_info: *const PipelineLayoutCreateInfo,
5019         p_allocator: *const AllocationCallbacks,
5020         p_pipeline_layout: *mut PipelineLayout,
5021     ) -> Result {
5022         (self.create_pipeline_layout)(device, p_create_info, p_allocator, p_pipeline_layout)
5023     }
5024     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineLayout.html>"]
destroy_pipeline_layout( &self, device: Device, pipeline_layout: PipelineLayout, p_allocator: *const AllocationCallbacks, )5025     pub unsafe fn destroy_pipeline_layout(
5026         &self,
5027         device: Device,
5028         pipeline_layout: PipelineLayout,
5029         p_allocator: *const AllocationCallbacks,
5030     ) {
5031         (self.destroy_pipeline_layout)(device, pipeline_layout, p_allocator)
5032     }
5033     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSampler.html>"]
create_sampler( &self, device: Device, p_create_info: *const SamplerCreateInfo, p_allocator: *const AllocationCallbacks, p_sampler: *mut Sampler, ) -> Result5034     pub unsafe fn create_sampler(
5035         &self,
5036         device: Device,
5037         p_create_info: *const SamplerCreateInfo,
5038         p_allocator: *const AllocationCallbacks,
5039         p_sampler: *mut Sampler,
5040     ) -> Result {
5041         (self.create_sampler)(device, p_create_info, p_allocator, p_sampler)
5042     }
5043     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySampler.html>"]
destroy_sampler( &self, device: Device, sampler: Sampler, p_allocator: *const AllocationCallbacks, )5044     pub unsafe fn destroy_sampler(
5045         &self,
5046         device: Device,
5047         sampler: Sampler,
5048         p_allocator: *const AllocationCallbacks,
5049     ) {
5050         (self.destroy_sampler)(device, sampler, p_allocator)
5051     }
5052     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorSetLayout.html>"]
create_descriptor_set_layout( &self, device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_set_layout: *mut DescriptorSetLayout, ) -> Result5053     pub unsafe fn create_descriptor_set_layout(
5054         &self,
5055         device: Device,
5056         p_create_info: *const DescriptorSetLayoutCreateInfo,
5057         p_allocator: *const AllocationCallbacks,
5058         p_set_layout: *mut DescriptorSetLayout,
5059     ) -> Result {
5060         (self.create_descriptor_set_layout)(device, p_create_info, p_allocator, p_set_layout)
5061     }
5062     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorSetLayout.html>"]
destroy_descriptor_set_layout( &self, device: Device, descriptor_set_layout: DescriptorSetLayout, p_allocator: *const AllocationCallbacks, )5063     pub unsafe fn destroy_descriptor_set_layout(
5064         &self,
5065         device: Device,
5066         descriptor_set_layout: DescriptorSetLayout,
5067         p_allocator: *const AllocationCallbacks,
5068     ) {
5069         (self.destroy_descriptor_set_layout)(device, descriptor_set_layout, p_allocator)
5070     }
5071     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorPool.html>"]
create_descriptor_pool( &self, device: Device, p_create_info: *const DescriptorPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_pool: *mut DescriptorPool, ) -> Result5072     pub unsafe fn create_descriptor_pool(
5073         &self,
5074         device: Device,
5075         p_create_info: *const DescriptorPoolCreateInfo,
5076         p_allocator: *const AllocationCallbacks,
5077         p_descriptor_pool: *mut DescriptorPool,
5078     ) -> Result {
5079         (self.create_descriptor_pool)(device, p_create_info, p_allocator, p_descriptor_pool)
5080     }
5081     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorPool.html>"]
destroy_descriptor_pool( &self, device: Device, descriptor_pool: DescriptorPool, p_allocator: *const AllocationCallbacks, )5082     pub unsafe fn destroy_descriptor_pool(
5083         &self,
5084         device: Device,
5085         descriptor_pool: DescriptorPool,
5086         p_allocator: *const AllocationCallbacks,
5087     ) {
5088         (self.destroy_descriptor_pool)(device, descriptor_pool, p_allocator)
5089     }
5090     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetDescriptorPool.html>"]
reset_descriptor_pool( &self, device: Device, descriptor_pool: DescriptorPool, flags: DescriptorPoolResetFlags, ) -> Result5091     pub unsafe fn reset_descriptor_pool(
5092         &self,
5093         device: Device,
5094         descriptor_pool: DescriptorPool,
5095         flags: DescriptorPoolResetFlags,
5096     ) -> Result {
5097         (self.reset_descriptor_pool)(device, descriptor_pool, flags)
5098     }
5099     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateDescriptorSets.html>"]
allocate_descriptor_sets( &self, device: Device, p_allocate_info: *const DescriptorSetAllocateInfo, p_descriptor_sets: *mut DescriptorSet, ) -> Result5100     pub unsafe fn allocate_descriptor_sets(
5101         &self,
5102         device: Device,
5103         p_allocate_info: *const DescriptorSetAllocateInfo,
5104         p_descriptor_sets: *mut DescriptorSet,
5105     ) -> Result {
5106         (self.allocate_descriptor_sets)(device, p_allocate_info, p_descriptor_sets)
5107     }
5108     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeDescriptorSets.html>"]
free_descriptor_sets( &self, device: Device, descriptor_pool: DescriptorPool, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, ) -> Result5109     pub unsafe fn free_descriptor_sets(
5110         &self,
5111         device: Device,
5112         descriptor_pool: DescriptorPool,
5113         descriptor_set_count: u32,
5114         p_descriptor_sets: *const DescriptorSet,
5115     ) -> Result {
5116         (self.free_descriptor_sets)(
5117             device,
5118             descriptor_pool,
5119             descriptor_set_count,
5120             p_descriptor_sets,
5121         )
5122     }
5123     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSets.html>"]
update_descriptor_sets( &self, device: Device, descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, descriptor_copy_count: u32, p_descriptor_copies: *const CopyDescriptorSet, )5124     pub unsafe fn update_descriptor_sets(
5125         &self,
5126         device: Device,
5127         descriptor_write_count: u32,
5128         p_descriptor_writes: *const WriteDescriptorSet,
5129         descriptor_copy_count: u32,
5130         p_descriptor_copies: *const CopyDescriptorSet,
5131     ) {
5132         (self.update_descriptor_sets)(
5133             device,
5134             descriptor_write_count,
5135             p_descriptor_writes,
5136             descriptor_copy_count,
5137             p_descriptor_copies,
5138         )
5139     }
5140     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFramebuffer.html>"]
create_framebuffer( &self, device: Device, p_create_info: *const FramebufferCreateInfo, p_allocator: *const AllocationCallbacks, p_framebuffer: *mut Framebuffer, ) -> Result5141     pub unsafe fn create_framebuffer(
5142         &self,
5143         device: Device,
5144         p_create_info: *const FramebufferCreateInfo,
5145         p_allocator: *const AllocationCallbacks,
5146         p_framebuffer: *mut Framebuffer,
5147     ) -> Result {
5148         (self.create_framebuffer)(device, p_create_info, p_allocator, p_framebuffer)
5149     }
5150     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFramebuffer.html>"]
destroy_framebuffer( &self, device: Device, framebuffer: Framebuffer, p_allocator: *const AllocationCallbacks, )5151     pub unsafe fn destroy_framebuffer(
5152         &self,
5153         device: Device,
5154         framebuffer: Framebuffer,
5155         p_allocator: *const AllocationCallbacks,
5156     ) {
5157         (self.destroy_framebuffer)(device, framebuffer, p_allocator)
5158     }
5159     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass.html>"]
create_render_pass( &self, device: Device, p_create_info: *const RenderPassCreateInfo, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result5160     pub unsafe fn create_render_pass(
5161         &self,
5162         device: Device,
5163         p_create_info: *const RenderPassCreateInfo,
5164         p_allocator: *const AllocationCallbacks,
5165         p_render_pass: *mut RenderPass,
5166     ) -> Result {
5167         (self.create_render_pass)(device, p_create_info, p_allocator, p_render_pass)
5168     }
5169     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyRenderPass.html>"]
destroy_render_pass( &self, device: Device, render_pass: RenderPass, p_allocator: *const AllocationCallbacks, )5170     pub unsafe fn destroy_render_pass(
5171         &self,
5172         device: Device,
5173         render_pass: RenderPass,
5174         p_allocator: *const AllocationCallbacks,
5175     ) {
5176         (self.destroy_render_pass)(device, render_pass, p_allocator)
5177     }
5178     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRenderAreaGranularity.html>"]
get_render_area_granularity( &self, device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D, )5179     pub unsafe fn get_render_area_granularity(
5180         &self,
5181         device: Device,
5182         render_pass: RenderPass,
5183         p_granularity: *mut Extent2D,
5184     ) {
5185         (self.get_render_area_granularity)(device, render_pass, p_granularity)
5186     }
5187     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateCommandPool.html>"]
create_command_pool( &self, device: Device, p_create_info: *const CommandPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_command_pool: *mut CommandPool, ) -> Result5188     pub unsafe fn create_command_pool(
5189         &self,
5190         device: Device,
5191         p_create_info: *const CommandPoolCreateInfo,
5192         p_allocator: *const AllocationCallbacks,
5193         p_command_pool: *mut CommandPool,
5194     ) -> Result {
5195         (self.create_command_pool)(device, p_create_info, p_allocator, p_command_pool)
5196     }
5197     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyCommandPool.html>"]
destroy_command_pool( &self, device: Device, command_pool: CommandPool, p_allocator: *const AllocationCallbacks, )5198     pub unsafe fn destroy_command_pool(
5199         &self,
5200         device: Device,
5201         command_pool: CommandPool,
5202         p_allocator: *const AllocationCallbacks,
5203     ) {
5204         (self.destroy_command_pool)(device, command_pool, p_allocator)
5205     }
5206     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandPool.html>"]
reset_command_pool( &self, device: Device, command_pool: CommandPool, flags: CommandPoolResetFlags, ) -> Result5207     pub unsafe fn reset_command_pool(
5208         &self,
5209         device: Device,
5210         command_pool: CommandPool,
5211         flags: CommandPoolResetFlags,
5212     ) -> Result {
5213         (self.reset_command_pool)(device, command_pool, flags)
5214     }
5215     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateCommandBuffers.html>"]
allocate_command_buffers( &self, device: Device, p_allocate_info: *const CommandBufferAllocateInfo, p_command_buffers: *mut CommandBuffer, ) -> Result5216     pub unsafe fn allocate_command_buffers(
5217         &self,
5218         device: Device,
5219         p_allocate_info: *const CommandBufferAllocateInfo,
5220         p_command_buffers: *mut CommandBuffer,
5221     ) -> Result {
5222         (self.allocate_command_buffers)(device, p_allocate_info, p_command_buffers)
5223     }
5224     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeCommandBuffers.html>"]
free_command_buffers( &self, device: Device, command_pool: CommandPool, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, )5225     pub unsafe fn free_command_buffers(
5226         &self,
5227         device: Device,
5228         command_pool: CommandPool,
5229         command_buffer_count: u32,
5230         p_command_buffers: *const CommandBuffer,
5231     ) {
5232         (self.free_command_buffers)(
5233             device,
5234             command_pool,
5235             command_buffer_count,
5236             p_command_buffers,
5237         )
5238     }
5239     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBeginCommandBuffer.html>"]
begin_command_buffer( &self, command_buffer: CommandBuffer, p_begin_info: *const CommandBufferBeginInfo, ) -> Result5240     pub unsafe fn begin_command_buffer(
5241         &self,
5242         command_buffer: CommandBuffer,
5243         p_begin_info: *const CommandBufferBeginInfo,
5244     ) -> Result {
5245         (self.begin_command_buffer)(command_buffer, p_begin_info)
5246     }
5247     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEndCommandBuffer.html>"]
end_command_buffer(&self, command_buffer: CommandBuffer) -> Result5248     pub unsafe fn end_command_buffer(&self, command_buffer: CommandBuffer) -> Result {
5249         (self.end_command_buffer)(command_buffer)
5250     }
5251     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandBuffer.html>"]
reset_command_buffer( &self, command_buffer: CommandBuffer, flags: CommandBufferResetFlags, ) -> Result5252     pub unsafe fn reset_command_buffer(
5253         &self,
5254         command_buffer: CommandBuffer,
5255         flags: CommandBufferResetFlags,
5256     ) -> Result {
5257         (self.reset_command_buffer)(command_buffer, flags)
5258     }
5259     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindPipeline.html>"]
cmd_bind_pipeline( &self, command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, pipeline: Pipeline, )5260     pub unsafe fn cmd_bind_pipeline(
5261         &self,
5262         command_buffer: CommandBuffer,
5263         pipeline_bind_point: PipelineBindPoint,
5264         pipeline: Pipeline,
5265     ) {
5266         (self.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline)
5267     }
5268     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewport.html>"]
cmd_set_viewport( &self, command_buffer: CommandBuffer, first_viewport: u32, viewport_count: u32, p_viewports: *const Viewport, )5269     pub unsafe fn cmd_set_viewport(
5270         &self,
5271         command_buffer: CommandBuffer,
5272         first_viewport: u32,
5273         viewport_count: u32,
5274         p_viewports: *const Viewport,
5275     ) {
5276         (self.cmd_set_viewport)(command_buffer, first_viewport, viewport_count, p_viewports)
5277     }
5278     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetScissor.html>"]
cmd_set_scissor( &self, command_buffer: CommandBuffer, first_scissor: u32, scissor_count: u32, p_scissors: *const Rect2D, )5279     pub unsafe fn cmd_set_scissor(
5280         &self,
5281         command_buffer: CommandBuffer,
5282         first_scissor: u32,
5283         scissor_count: u32,
5284         p_scissors: *const Rect2D,
5285     ) {
5286         (self.cmd_set_scissor)(command_buffer, first_scissor, scissor_count, p_scissors)
5287     }
5288     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetLineWidth.html>"]
cmd_set_line_width(&self, command_buffer: CommandBuffer, line_width: f32)5289     pub unsafe fn cmd_set_line_width(&self, command_buffer: CommandBuffer, line_width: f32) {
5290         (self.cmd_set_line_width)(command_buffer, line_width)
5291     }
5292     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBias.html>"]
cmd_set_depth_bias( &self, command_buffer: CommandBuffer, depth_bias_constant_factor: f32, depth_bias_clamp: f32, depth_bias_slope_factor: f32, )5293     pub unsafe fn cmd_set_depth_bias(
5294         &self,
5295         command_buffer: CommandBuffer,
5296         depth_bias_constant_factor: f32,
5297         depth_bias_clamp: f32,
5298         depth_bias_slope_factor: f32,
5299     ) {
5300         (self.cmd_set_depth_bias)(
5301             command_buffer,
5302             depth_bias_constant_factor,
5303             depth_bias_clamp,
5304             depth_bias_slope_factor,
5305         )
5306     }
5307     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetBlendConstants.html>"]
cmd_set_blend_constants( &self, command_buffer: CommandBuffer, blend_constants: *const [f32; 4], )5308     pub unsafe fn cmd_set_blend_constants(
5309         &self,
5310         command_buffer: CommandBuffer,
5311         blend_constants: *const [f32; 4],
5312     ) {
5313         (self.cmd_set_blend_constants)(command_buffer, blend_constants)
5314     }
5315     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBounds.html>"]
cmd_set_depth_bounds( &self, command_buffer: CommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32, )5316     pub unsafe fn cmd_set_depth_bounds(
5317         &self,
5318         command_buffer: CommandBuffer,
5319         min_depth_bounds: f32,
5320         max_depth_bounds: f32,
5321     ) {
5322         (self.cmd_set_depth_bounds)(command_buffer, min_depth_bounds, max_depth_bounds)
5323     }
5324     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilCompareMask.html>"]
cmd_set_stencil_compare_mask( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, compare_mask: u32, )5325     pub unsafe fn cmd_set_stencil_compare_mask(
5326         &self,
5327         command_buffer: CommandBuffer,
5328         face_mask: StencilFaceFlags,
5329         compare_mask: u32,
5330     ) {
5331         (self.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask)
5332     }
5333     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilWriteMask.html>"]
cmd_set_stencil_write_mask( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, write_mask: u32, )5334     pub unsafe fn cmd_set_stencil_write_mask(
5335         &self,
5336         command_buffer: CommandBuffer,
5337         face_mask: StencilFaceFlags,
5338         write_mask: u32,
5339     ) {
5340         (self.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask)
5341     }
5342     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilReference.html>"]
cmd_set_stencil_reference( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, reference: u32, )5343     pub unsafe fn cmd_set_stencil_reference(
5344         &self,
5345         command_buffer: CommandBuffer,
5346         face_mask: StencilFaceFlags,
5347         reference: u32,
5348     ) {
5349         (self.cmd_set_stencil_reference)(command_buffer, face_mask, reference)
5350     }
5351     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindDescriptorSets.html>"]
cmd_bind_descriptor_sets( &self, command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, first_set: u32, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, dynamic_offset_count: u32, p_dynamic_offsets: *const u32, )5352     pub unsafe fn cmd_bind_descriptor_sets(
5353         &self,
5354         command_buffer: CommandBuffer,
5355         pipeline_bind_point: PipelineBindPoint,
5356         layout: PipelineLayout,
5357         first_set: u32,
5358         descriptor_set_count: u32,
5359         p_descriptor_sets: *const DescriptorSet,
5360         dynamic_offset_count: u32,
5361         p_dynamic_offsets: *const u32,
5362     ) {
5363         (self.cmd_bind_descriptor_sets)(
5364             command_buffer,
5365             pipeline_bind_point,
5366             layout,
5367             first_set,
5368             descriptor_set_count,
5369             p_descriptor_sets,
5370             dynamic_offset_count,
5371             p_dynamic_offsets,
5372         )
5373     }
5374     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindIndexBuffer.html>"]
cmd_bind_index_buffer( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, index_type: IndexType, )5375     pub unsafe fn cmd_bind_index_buffer(
5376         &self,
5377         command_buffer: CommandBuffer,
5378         buffer: Buffer,
5379         offset: DeviceSize,
5380         index_type: IndexType,
5381     ) {
5382         (self.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type)
5383     }
5384     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindVertexBuffers.html>"]
cmd_bind_vertex_buffers( &self, command_buffer: CommandBuffer, first_binding: u32, binding_count: u32, p_buffers: *const Buffer, p_offsets: *const DeviceSize, )5385     pub unsafe fn cmd_bind_vertex_buffers(
5386         &self,
5387         command_buffer: CommandBuffer,
5388         first_binding: u32,
5389         binding_count: u32,
5390         p_buffers: *const Buffer,
5391         p_offsets: *const DeviceSize,
5392     ) {
5393         (self.cmd_bind_vertex_buffers)(
5394             command_buffer,
5395             first_binding,
5396             binding_count,
5397             p_buffers,
5398             p_offsets,
5399         )
5400     }
5401     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDraw.html>"]
cmd_draw( &self, command_buffer: CommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32, )5402     pub unsafe fn cmd_draw(
5403         &self,
5404         command_buffer: CommandBuffer,
5405         vertex_count: u32,
5406         instance_count: u32,
5407         first_vertex: u32,
5408         first_instance: u32,
5409     ) {
5410         (self.cmd_draw)(
5411             command_buffer,
5412             vertex_count,
5413             instance_count,
5414             first_vertex,
5415             first_instance,
5416         )
5417     }
5418     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexed.html>"]
cmd_draw_indexed( &self, command_buffer: CommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32, )5419     pub unsafe fn cmd_draw_indexed(
5420         &self,
5421         command_buffer: CommandBuffer,
5422         index_count: u32,
5423         instance_count: u32,
5424         first_index: u32,
5425         vertex_offset: i32,
5426         first_instance: u32,
5427     ) {
5428         (self.cmd_draw_indexed)(
5429             command_buffer,
5430             index_count,
5431             instance_count,
5432             first_index,
5433             vertex_offset,
5434             first_instance,
5435         )
5436     }
5437     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirect.html>"]
cmd_draw_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, )5438     pub unsafe fn cmd_draw_indirect(
5439         &self,
5440         command_buffer: CommandBuffer,
5441         buffer: Buffer,
5442         offset: DeviceSize,
5443         draw_count: u32,
5444         stride: u32,
5445     ) {
5446         (self.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride)
5447     }
5448     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirect.html>"]
cmd_draw_indexed_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, )5449     pub unsafe fn cmd_draw_indexed_indirect(
5450         &self,
5451         command_buffer: CommandBuffer,
5452         buffer: Buffer,
5453         offset: DeviceSize,
5454         draw_count: u32,
5455         stride: u32,
5456     ) {
5457         (self.cmd_draw_indexed_indirect)(command_buffer, buffer, offset, draw_count, stride)
5458     }
5459     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatch.html>"]
cmd_dispatch( &self, command_buffer: CommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32, )5460     pub unsafe fn cmd_dispatch(
5461         &self,
5462         command_buffer: CommandBuffer,
5463         group_count_x: u32,
5464         group_count_y: u32,
5465         group_count_z: u32,
5466     ) {
5467         (self.cmd_dispatch)(command_buffer, group_count_x, group_count_y, group_count_z)
5468     }
5469     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchIndirect.html>"]
cmd_dispatch_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, )5470     pub unsafe fn cmd_dispatch_indirect(
5471         &self,
5472         command_buffer: CommandBuffer,
5473         buffer: Buffer,
5474         offset: DeviceSize,
5475     ) {
5476         (self.cmd_dispatch_indirect)(command_buffer, buffer, offset)
5477     }
5478     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBuffer.html>"]
cmd_copy_buffer( &self, command_buffer: CommandBuffer, src_buffer: Buffer, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferCopy, )5479     pub unsafe fn cmd_copy_buffer(
5480         &self,
5481         command_buffer: CommandBuffer,
5482         src_buffer: Buffer,
5483         dst_buffer: Buffer,
5484         region_count: u32,
5485         p_regions: *const BufferCopy,
5486     ) {
5487         (self.cmd_copy_buffer)(
5488             command_buffer,
5489             src_buffer,
5490             dst_buffer,
5491             region_count,
5492             p_regions,
5493         )
5494     }
5495     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImage.html>"]
cmd_copy_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageCopy, )5496     pub unsafe fn cmd_copy_image(
5497         &self,
5498         command_buffer: CommandBuffer,
5499         src_image: Image,
5500         src_image_layout: ImageLayout,
5501         dst_image: Image,
5502         dst_image_layout: ImageLayout,
5503         region_count: u32,
5504         p_regions: *const ImageCopy,
5505     ) {
5506         (self.cmd_copy_image)(
5507             command_buffer,
5508             src_image,
5509             src_image_layout,
5510             dst_image,
5511             dst_image_layout,
5512             region_count,
5513             p_regions,
5514         )
5515     }
5516     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBlitImage.html>"]
cmd_blit_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageBlit, filter: Filter, )5517     pub unsafe fn cmd_blit_image(
5518         &self,
5519         command_buffer: CommandBuffer,
5520         src_image: Image,
5521         src_image_layout: ImageLayout,
5522         dst_image: Image,
5523         dst_image_layout: ImageLayout,
5524         region_count: u32,
5525         p_regions: *const ImageBlit,
5526         filter: Filter,
5527     ) {
5528         (self.cmd_blit_image)(
5529             command_buffer,
5530             src_image,
5531             src_image_layout,
5532             dst_image,
5533             dst_image_layout,
5534             region_count,
5535             p_regions,
5536             filter,
5537         )
5538     }
5539     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBufferToImage.html>"]
cmd_copy_buffer_to_image( &self, command_buffer: CommandBuffer, src_buffer: Buffer, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const BufferImageCopy, )5540     pub unsafe fn cmd_copy_buffer_to_image(
5541         &self,
5542         command_buffer: CommandBuffer,
5543         src_buffer: Buffer,
5544         dst_image: Image,
5545         dst_image_layout: ImageLayout,
5546         region_count: u32,
5547         p_regions: *const BufferImageCopy,
5548     ) {
5549         (self.cmd_copy_buffer_to_image)(
5550             command_buffer,
5551             src_buffer,
5552             dst_image,
5553             dst_image_layout,
5554             region_count,
5555             p_regions,
5556         )
5557     }
5558     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImageToBuffer.html>"]
cmd_copy_image_to_buffer( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferImageCopy, )5559     pub unsafe fn cmd_copy_image_to_buffer(
5560         &self,
5561         command_buffer: CommandBuffer,
5562         src_image: Image,
5563         src_image_layout: ImageLayout,
5564         dst_buffer: Buffer,
5565         region_count: u32,
5566         p_regions: *const BufferImageCopy,
5567     ) {
5568         (self.cmd_copy_image_to_buffer)(
5569             command_buffer,
5570             src_image,
5571             src_image_layout,
5572             dst_buffer,
5573             region_count,
5574             p_regions,
5575         )
5576     }
5577     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdUpdateBuffer.html>"]
cmd_update_buffer( &self, command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, data_size: DeviceSize, p_data: *const c_void, )5578     pub unsafe fn cmd_update_buffer(
5579         &self,
5580         command_buffer: CommandBuffer,
5581         dst_buffer: Buffer,
5582         dst_offset: DeviceSize,
5583         data_size: DeviceSize,
5584         p_data: *const c_void,
5585     ) {
5586         (self.cmd_update_buffer)(command_buffer, dst_buffer, dst_offset, data_size, p_data)
5587     }
5588     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdFillBuffer.html>"]
cmd_fill_buffer( &self, command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, size: DeviceSize, data: u32, )5589     pub unsafe fn cmd_fill_buffer(
5590         &self,
5591         command_buffer: CommandBuffer,
5592         dst_buffer: Buffer,
5593         dst_offset: DeviceSize,
5594         size: DeviceSize,
5595         data: u32,
5596     ) {
5597         (self.cmd_fill_buffer)(command_buffer, dst_buffer, dst_offset, size, data)
5598     }
5599     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearColorImage.html>"]
cmd_clear_color_image( &self, command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_color: *const ClearColorValue, range_count: u32, p_ranges: *const ImageSubresourceRange, )5600     pub unsafe fn cmd_clear_color_image(
5601         &self,
5602         command_buffer: CommandBuffer,
5603         image: Image,
5604         image_layout: ImageLayout,
5605         p_color: *const ClearColorValue,
5606         range_count: u32,
5607         p_ranges: *const ImageSubresourceRange,
5608     ) {
5609         (self.cmd_clear_color_image)(
5610             command_buffer,
5611             image,
5612             image_layout,
5613             p_color,
5614             range_count,
5615             p_ranges,
5616         )
5617     }
5618     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearDepthStencilImage.html>"]
cmd_clear_depth_stencil_image( &self, command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, range_count: u32, p_ranges: *const ImageSubresourceRange, )5619     pub unsafe fn cmd_clear_depth_stencil_image(
5620         &self,
5621         command_buffer: CommandBuffer,
5622         image: Image,
5623         image_layout: ImageLayout,
5624         p_depth_stencil: *const ClearDepthStencilValue,
5625         range_count: u32,
5626         p_ranges: *const ImageSubresourceRange,
5627     ) {
5628         (self.cmd_clear_depth_stencil_image)(
5629             command_buffer,
5630             image,
5631             image_layout,
5632             p_depth_stencil,
5633             range_count,
5634             p_ranges,
5635         )
5636     }
5637     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearAttachments.html>"]
cmd_clear_attachments( &self, command_buffer: CommandBuffer, attachment_count: u32, p_attachments: *const ClearAttachment, rect_count: u32, p_rects: *const ClearRect, )5638     pub unsafe fn cmd_clear_attachments(
5639         &self,
5640         command_buffer: CommandBuffer,
5641         attachment_count: u32,
5642         p_attachments: *const ClearAttachment,
5643         rect_count: u32,
5644         p_rects: *const ClearRect,
5645     ) {
5646         (self.cmd_clear_attachments)(
5647             command_buffer,
5648             attachment_count,
5649             p_attachments,
5650             rect_count,
5651             p_rects,
5652         )
5653     }
5654     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResolveImage.html>"]
cmd_resolve_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageResolve, )5655     pub unsafe fn cmd_resolve_image(
5656         &self,
5657         command_buffer: CommandBuffer,
5658         src_image: Image,
5659         src_image_layout: ImageLayout,
5660         dst_image: Image,
5661         dst_image_layout: ImageLayout,
5662         region_count: u32,
5663         p_regions: *const ImageResolve,
5664     ) {
5665         (self.cmd_resolve_image)(
5666             command_buffer,
5667             src_image,
5668             src_image_layout,
5669             dst_image,
5670             dst_image_layout,
5671             region_count,
5672             p_regions,
5673         )
5674     }
5675     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetEvent.html>"]
cmd_set_event( &self, command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, )5676     pub unsafe fn cmd_set_event(
5677         &self,
5678         command_buffer: CommandBuffer,
5679         event: Event,
5680         stage_mask: PipelineStageFlags,
5681     ) {
5682         (self.cmd_set_event)(command_buffer, event, stage_mask)
5683     }
5684     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetEvent.html>"]
cmd_reset_event( &self, command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, )5685     pub unsafe fn cmd_reset_event(
5686         &self,
5687         command_buffer: CommandBuffer,
5688         event: Event,
5689         stage_mask: PipelineStageFlags,
5690     ) {
5691         (self.cmd_reset_event)(command_buffer, event, stage_mask)
5692     }
5693     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWaitEvents.html>"]
cmd_wait_events( &self, command_buffer: CommandBuffer, event_count: u32, p_events: *const Event, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, )5694     pub unsafe fn cmd_wait_events(
5695         &self,
5696         command_buffer: CommandBuffer,
5697         event_count: u32,
5698         p_events: *const Event,
5699         src_stage_mask: PipelineStageFlags,
5700         dst_stage_mask: PipelineStageFlags,
5701         memory_barrier_count: u32,
5702         p_memory_barriers: *const MemoryBarrier,
5703         buffer_memory_barrier_count: u32,
5704         p_buffer_memory_barriers: *const BufferMemoryBarrier,
5705         image_memory_barrier_count: u32,
5706         p_image_memory_barriers: *const ImageMemoryBarrier,
5707     ) {
5708         (self.cmd_wait_events)(
5709             command_buffer,
5710             event_count,
5711             p_events,
5712             src_stage_mask,
5713             dst_stage_mask,
5714             memory_barrier_count,
5715             p_memory_barriers,
5716             buffer_memory_barrier_count,
5717             p_buffer_memory_barriers,
5718             image_memory_barrier_count,
5719             p_image_memory_barriers,
5720         )
5721     }
5722     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPipelineBarrier.html>"]
cmd_pipeline_barrier( &self, command_buffer: CommandBuffer, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, dependency_flags: DependencyFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, )5723     pub unsafe fn cmd_pipeline_barrier(
5724         &self,
5725         command_buffer: CommandBuffer,
5726         src_stage_mask: PipelineStageFlags,
5727         dst_stage_mask: PipelineStageFlags,
5728         dependency_flags: DependencyFlags,
5729         memory_barrier_count: u32,
5730         p_memory_barriers: *const MemoryBarrier,
5731         buffer_memory_barrier_count: u32,
5732         p_buffer_memory_barriers: *const BufferMemoryBarrier,
5733         image_memory_barrier_count: u32,
5734         p_image_memory_barriers: *const ImageMemoryBarrier,
5735     ) {
5736         (self.cmd_pipeline_barrier)(
5737             command_buffer,
5738             src_stage_mask,
5739             dst_stage_mask,
5740             dependency_flags,
5741             memory_barrier_count,
5742             p_memory_barriers,
5743             buffer_memory_barrier_count,
5744             p_buffer_memory_barriers,
5745             image_memory_barrier_count,
5746             p_image_memory_barriers,
5747         )
5748     }
5749     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginQuery.html>"]
cmd_begin_query( &self, command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, flags: QueryControlFlags, )5750     pub unsafe fn cmd_begin_query(
5751         &self,
5752         command_buffer: CommandBuffer,
5753         query_pool: QueryPool,
5754         query: u32,
5755         flags: QueryControlFlags,
5756     ) {
5757         (self.cmd_begin_query)(command_buffer, query_pool, query, flags)
5758     }
5759     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndQuery.html>"]
cmd_end_query( &self, command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, )5760     pub unsafe fn cmd_end_query(
5761         &self,
5762         command_buffer: CommandBuffer,
5763         query_pool: QueryPool,
5764         query: u32,
5765     ) {
5766         (self.cmd_end_query)(command_buffer, query_pool, query)
5767     }
5768     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetQueryPool.html>"]
cmd_reset_query_pool( &self, command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, )5769     pub unsafe fn cmd_reset_query_pool(
5770         &self,
5771         command_buffer: CommandBuffer,
5772         query_pool: QueryPool,
5773         first_query: u32,
5774         query_count: u32,
5775     ) {
5776         (self.cmd_reset_query_pool)(command_buffer, query_pool, first_query, query_count)
5777     }
5778     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html>"]
cmd_write_timestamp( &self, command_buffer: CommandBuffer, pipeline_stage: PipelineStageFlags, query_pool: QueryPool, query: u32, )5779     pub unsafe fn cmd_write_timestamp(
5780         &self,
5781         command_buffer: CommandBuffer,
5782         pipeline_stage: PipelineStageFlags,
5783         query_pool: QueryPool,
5784         query: u32,
5785     ) {
5786         (self.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query)
5787     }
5788     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyQueryPoolResults.html>"]
cmd_copy_query_pool_results( &self, command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, dst_buffer: Buffer, dst_offset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags, )5789     pub unsafe fn cmd_copy_query_pool_results(
5790         &self,
5791         command_buffer: CommandBuffer,
5792         query_pool: QueryPool,
5793         first_query: u32,
5794         query_count: u32,
5795         dst_buffer: Buffer,
5796         dst_offset: DeviceSize,
5797         stride: DeviceSize,
5798         flags: QueryResultFlags,
5799     ) {
5800         (self.cmd_copy_query_pool_results)(
5801             command_buffer,
5802             query_pool,
5803             first_query,
5804             query_count,
5805             dst_buffer,
5806             dst_offset,
5807             stride,
5808             flags,
5809         )
5810     }
5811     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushConstants.html>"]
cmd_push_constants( &self, command_buffer: CommandBuffer, layout: PipelineLayout, stage_flags: ShaderStageFlags, offset: u32, size: u32, p_values: *const c_void, )5812     pub unsafe fn cmd_push_constants(
5813         &self,
5814         command_buffer: CommandBuffer,
5815         layout: PipelineLayout,
5816         stage_flags: ShaderStageFlags,
5817         offset: u32,
5818         size: u32,
5819         p_values: *const c_void,
5820     ) {
5821         (self.cmd_push_constants)(command_buffer, layout, stage_flags, offset, size, p_values)
5822     }
5823     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass.html>"]
cmd_begin_render_pass( &self, command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, contents: SubpassContents, )5824     pub unsafe fn cmd_begin_render_pass(
5825         &self,
5826         command_buffer: CommandBuffer,
5827         p_render_pass_begin: *const RenderPassBeginInfo,
5828         contents: SubpassContents,
5829     ) {
5830         (self.cmd_begin_render_pass)(command_buffer, p_render_pass_begin, contents)
5831     }
5832     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass.html>"]
cmd_next_subpass( &self, command_buffer: CommandBuffer, contents: SubpassContents, )5833     pub unsafe fn cmd_next_subpass(
5834         &self,
5835         command_buffer: CommandBuffer,
5836         contents: SubpassContents,
5837     ) {
5838         (self.cmd_next_subpass)(command_buffer, contents)
5839     }
5840     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass.html>"]
cmd_end_render_pass(&self, command_buffer: CommandBuffer)5841     pub unsafe fn cmd_end_render_pass(&self, command_buffer: CommandBuffer) {
5842         (self.cmd_end_render_pass)(command_buffer)
5843     }
5844     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdExecuteCommands.html>"]
cmd_execute_commands( &self, command_buffer: CommandBuffer, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, )5845     pub unsafe fn cmd_execute_commands(
5846         &self,
5847         command_buffer: CommandBuffer,
5848         command_buffer_count: u32,
5849         p_command_buffers: *const CommandBuffer,
5850     ) {
5851         (self.cmd_execute_commands)(command_buffer, command_buffer_count, p_command_buffers)
5852     }
5853 }
5854 #[allow(non_camel_case_types)]
5855 pub type PFN_vkEnumerateInstanceVersion = extern "system" fn(p_api_version: *mut u32) -> Result;
5856 pub struct EntryFnV1_1 {
5857     pub enumerate_instance_version: extern "system" fn(p_api_version: *mut u32) -> Result,
5858 }
5859 unsafe impl Send for EntryFnV1_1 {}
5860 unsafe impl Sync for EntryFnV1_1 {}
5861 impl ::std::clone::Clone for EntryFnV1_1 {
clone(&self) -> Self5862     fn clone(&self) -> Self {
5863         EntryFnV1_1 {
5864             enumerate_instance_version: self.enumerate_instance_version,
5865         }
5866     }
5867 }
5868 impl EntryFnV1_1 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,5869     pub fn load<F>(mut _f: F) -> Self
5870     where
5871         F: FnMut(&::std::ffi::CStr) -> *const c_void,
5872     {
5873         EntryFnV1_1 {
5874             enumerate_instance_version: unsafe {
5875                 extern "system" fn enumerate_instance_version(_p_api_version: *mut u32) -> Result {
5876                     panic!(concat!(
5877                         "Unable to load ",
5878                         stringify!(enumerate_instance_version)
5879                     ))
5880                 }
5881                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5882                     b"vkEnumerateInstanceVersion\0",
5883                 );
5884                 let val = _f(cname);
5885                 if val.is_null() {
5886                     enumerate_instance_version
5887                 } else {
5888                     ::std::mem::transmute(val)
5889                 }
5890             },
5891         }
5892     }
5893     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceVersion.html>"]
enumerate_instance_version(&self, p_api_version: *mut u32) -> Result5894     pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut u32) -> Result {
5895         (self.enumerate_instance_version)(p_api_version)
5896     }
5897 }
5898 pub struct InstanceFnV1_1 {
5899     pub enumerate_physical_device_groups: extern "system" fn(
5900         instance: Instance,
5901         p_physical_device_group_count: *mut u32,
5902         p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
5903     ) -> Result,
5904     pub get_physical_device_features2: extern "system" fn(
5905         physical_device: PhysicalDevice,
5906         p_features: *mut PhysicalDeviceFeatures2,
5907     ),
5908     pub get_physical_device_properties2: extern "system" fn(
5909         physical_device: PhysicalDevice,
5910         p_properties: *mut PhysicalDeviceProperties2,
5911     ),
5912     pub get_physical_device_format_properties2: extern "system" fn(
5913         physical_device: PhysicalDevice,
5914         format: Format,
5915         p_format_properties: *mut FormatProperties2,
5916     ),
5917     pub get_physical_device_image_format_properties2: extern "system" fn(
5918         physical_device: PhysicalDevice,
5919         p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
5920         p_image_format_properties: *mut ImageFormatProperties2,
5921     ) -> Result,
5922     pub get_physical_device_queue_family_properties2: extern "system" fn(
5923         physical_device: PhysicalDevice,
5924         p_queue_family_property_count: *mut u32,
5925         p_queue_family_properties: *mut QueueFamilyProperties2,
5926     ),
5927     pub get_physical_device_memory_properties2: extern "system" fn(
5928         physical_device: PhysicalDevice,
5929         p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
5930     ),
5931     pub get_physical_device_sparse_image_format_properties2: extern "system" fn(
5932         physical_device: PhysicalDevice,
5933         p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
5934         p_property_count: *mut u32,
5935         p_properties: *mut SparseImageFormatProperties2,
5936     ),
5937     pub get_physical_device_external_buffer_properties: extern "system" fn(
5938         physical_device: PhysicalDevice,
5939         p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
5940         p_external_buffer_properties: *mut ExternalBufferProperties,
5941     ),
5942     pub get_physical_device_external_fence_properties: extern "system" fn(
5943         physical_device: PhysicalDevice,
5944         p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
5945         p_external_fence_properties: *mut ExternalFenceProperties,
5946     ),
5947     pub get_physical_device_external_semaphore_properties: extern "system" fn(
5948         physical_device: PhysicalDevice,
5949         p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
5950         p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
5951     ),
5952 }
5953 unsafe impl Send for InstanceFnV1_1 {}
5954 unsafe impl Sync for InstanceFnV1_1 {}
5955 impl ::std::clone::Clone for InstanceFnV1_1 {
clone(&self) -> Self5956     fn clone(&self) -> Self {
5957         InstanceFnV1_1 {
5958             enumerate_physical_device_groups: self.enumerate_physical_device_groups,
5959             get_physical_device_features2: self.get_physical_device_features2,
5960             get_physical_device_properties2: self.get_physical_device_properties2,
5961             get_physical_device_format_properties2: self.get_physical_device_format_properties2,
5962             get_physical_device_image_format_properties2: self
5963                 .get_physical_device_image_format_properties2,
5964             get_physical_device_queue_family_properties2: self
5965                 .get_physical_device_queue_family_properties2,
5966             get_physical_device_memory_properties2: self.get_physical_device_memory_properties2,
5967             get_physical_device_sparse_image_format_properties2: self
5968                 .get_physical_device_sparse_image_format_properties2,
5969             get_physical_device_external_buffer_properties: self
5970                 .get_physical_device_external_buffer_properties,
5971             get_physical_device_external_fence_properties: self
5972                 .get_physical_device_external_fence_properties,
5973             get_physical_device_external_semaphore_properties: self
5974                 .get_physical_device_external_semaphore_properties,
5975         }
5976     }
5977 }
5978 impl InstanceFnV1_1 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,5979     pub fn load<F>(mut _f: F) -> Self
5980     where
5981         F: FnMut(&::std::ffi::CStr) -> *const c_void,
5982     {
5983         InstanceFnV1_1 {
5984             enumerate_physical_device_groups: unsafe {
5985                 extern "system" fn enumerate_physical_device_groups(
5986                     _instance: Instance,
5987                     _p_physical_device_group_count: *mut u32,
5988                     _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
5989                 ) -> Result {
5990                     panic!(concat!(
5991                         "Unable to load ",
5992                         stringify!(enumerate_physical_device_groups)
5993                     ))
5994                 }
5995                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5996                     b"vkEnumeratePhysicalDeviceGroups\0",
5997                 );
5998                 let val = _f(cname);
5999                 if val.is_null() {
6000                     enumerate_physical_device_groups
6001                 } else {
6002                     ::std::mem::transmute(val)
6003                 }
6004             },
6005             get_physical_device_features2: unsafe {
6006                 extern "system" fn get_physical_device_features2(
6007                     _physical_device: PhysicalDevice,
6008                     _p_features: *mut PhysicalDeviceFeatures2,
6009                 ) {
6010                     panic!(concat!(
6011                         "Unable to load ",
6012                         stringify!(get_physical_device_features2)
6013                     ))
6014                 }
6015                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6016                     b"vkGetPhysicalDeviceFeatures2\0",
6017                 );
6018                 let val = _f(cname);
6019                 if val.is_null() {
6020                     get_physical_device_features2
6021                 } else {
6022                     ::std::mem::transmute(val)
6023                 }
6024             },
6025             get_physical_device_properties2: unsafe {
6026                 extern "system" fn get_physical_device_properties2(
6027                     _physical_device: PhysicalDevice,
6028                     _p_properties: *mut PhysicalDeviceProperties2,
6029                 ) {
6030                     panic!(concat!(
6031                         "Unable to load ",
6032                         stringify!(get_physical_device_properties2)
6033                     ))
6034                 }
6035                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6036                     b"vkGetPhysicalDeviceProperties2\0",
6037                 );
6038                 let val = _f(cname);
6039                 if val.is_null() {
6040                     get_physical_device_properties2
6041                 } else {
6042                     ::std::mem::transmute(val)
6043                 }
6044             },
6045             get_physical_device_format_properties2: unsafe {
6046                 extern "system" fn get_physical_device_format_properties2(
6047                     _physical_device: PhysicalDevice,
6048                     _format: Format,
6049                     _p_format_properties: *mut FormatProperties2,
6050                 ) {
6051                     panic!(concat!(
6052                         "Unable to load ",
6053                         stringify!(get_physical_device_format_properties2)
6054                     ))
6055                 }
6056                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6057                     b"vkGetPhysicalDeviceFormatProperties2\0",
6058                 );
6059                 let val = _f(cname);
6060                 if val.is_null() {
6061                     get_physical_device_format_properties2
6062                 } else {
6063                     ::std::mem::transmute(val)
6064                 }
6065             },
6066             get_physical_device_image_format_properties2: unsafe {
6067                 extern "system" fn get_physical_device_image_format_properties2(
6068                     _physical_device: PhysicalDevice,
6069                     _p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
6070                     _p_image_format_properties: *mut ImageFormatProperties2,
6071                 ) -> Result {
6072                     panic!(concat!(
6073                         "Unable to load ",
6074                         stringify!(get_physical_device_image_format_properties2)
6075                     ))
6076                 }
6077                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6078                     b"vkGetPhysicalDeviceImageFormatProperties2\0",
6079                 );
6080                 let val = _f(cname);
6081                 if val.is_null() {
6082                     get_physical_device_image_format_properties2
6083                 } else {
6084                     ::std::mem::transmute(val)
6085                 }
6086             },
6087             get_physical_device_queue_family_properties2: unsafe {
6088                 extern "system" fn get_physical_device_queue_family_properties2(
6089                     _physical_device: PhysicalDevice,
6090                     _p_queue_family_property_count: *mut u32,
6091                     _p_queue_family_properties: *mut QueueFamilyProperties2,
6092                 ) {
6093                     panic!(concat!(
6094                         "Unable to load ",
6095                         stringify!(get_physical_device_queue_family_properties2)
6096                     ))
6097                 }
6098                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6099                     b"vkGetPhysicalDeviceQueueFamilyProperties2\0",
6100                 );
6101                 let val = _f(cname);
6102                 if val.is_null() {
6103                     get_physical_device_queue_family_properties2
6104                 } else {
6105                     ::std::mem::transmute(val)
6106                 }
6107             },
6108             get_physical_device_memory_properties2: unsafe {
6109                 extern "system" fn get_physical_device_memory_properties2(
6110                     _physical_device: PhysicalDevice,
6111                     _p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
6112                 ) {
6113                     panic!(concat!(
6114                         "Unable to load ",
6115                         stringify!(get_physical_device_memory_properties2)
6116                     ))
6117                 }
6118                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6119                     b"vkGetPhysicalDeviceMemoryProperties2\0",
6120                 );
6121                 let val = _f(cname);
6122                 if val.is_null() {
6123                     get_physical_device_memory_properties2
6124                 } else {
6125                     ::std::mem::transmute(val)
6126                 }
6127             },
6128             get_physical_device_sparse_image_format_properties2: unsafe {
6129                 extern "system" fn get_physical_device_sparse_image_format_properties2(
6130                     _physical_device: PhysicalDevice,
6131                     _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
6132                     _p_property_count: *mut u32,
6133                     _p_properties: *mut SparseImageFormatProperties2,
6134                 ) {
6135                     panic!(concat!(
6136                         "Unable to load ",
6137                         stringify!(get_physical_device_sparse_image_format_properties2)
6138                     ))
6139                 }
6140                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6141                     b"vkGetPhysicalDeviceSparseImageFormatProperties2\0",
6142                 );
6143                 let val = _f(cname);
6144                 if val.is_null() {
6145                     get_physical_device_sparse_image_format_properties2
6146                 } else {
6147                     ::std::mem::transmute(val)
6148                 }
6149             },
6150             get_physical_device_external_buffer_properties: unsafe {
6151                 extern "system" fn get_physical_device_external_buffer_properties(
6152                     _physical_device: PhysicalDevice,
6153                     _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
6154                     _p_external_buffer_properties: *mut ExternalBufferProperties,
6155                 ) {
6156                     panic!(concat!(
6157                         "Unable to load ",
6158                         stringify!(get_physical_device_external_buffer_properties)
6159                     ))
6160                 }
6161                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6162                     b"vkGetPhysicalDeviceExternalBufferProperties\0",
6163                 );
6164                 let val = _f(cname);
6165                 if val.is_null() {
6166                     get_physical_device_external_buffer_properties
6167                 } else {
6168                     ::std::mem::transmute(val)
6169                 }
6170             },
6171             get_physical_device_external_fence_properties: unsafe {
6172                 extern "system" fn get_physical_device_external_fence_properties(
6173                     _physical_device: PhysicalDevice,
6174                     _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
6175                     _p_external_fence_properties: *mut ExternalFenceProperties,
6176                 ) {
6177                     panic!(concat!(
6178                         "Unable to load ",
6179                         stringify!(get_physical_device_external_fence_properties)
6180                     ))
6181                 }
6182                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6183                     b"vkGetPhysicalDeviceExternalFenceProperties\0",
6184                 );
6185                 let val = _f(cname);
6186                 if val.is_null() {
6187                     get_physical_device_external_fence_properties
6188                 } else {
6189                     ::std::mem::transmute(val)
6190                 }
6191             },
6192             get_physical_device_external_semaphore_properties: unsafe {
6193                 extern "system" fn get_physical_device_external_semaphore_properties(
6194                     _physical_device: PhysicalDevice,
6195                     _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
6196                     _p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
6197                 ) {
6198                     panic!(concat!(
6199                         "Unable to load ",
6200                         stringify!(get_physical_device_external_semaphore_properties)
6201                     ))
6202                 }
6203                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6204                     b"vkGetPhysicalDeviceExternalSemaphoreProperties\0",
6205                 );
6206                 let val = _f(cname);
6207                 if val.is_null() {
6208                     get_physical_device_external_semaphore_properties
6209                 } else {
6210                     ::std::mem::transmute(val)
6211                 }
6212             },
6213         }
6214     }
6215     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDeviceGroups.html>"]
enumerate_physical_device_groups( &self, instance: Instance, p_physical_device_group_count: *mut u32, p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result6216     pub unsafe fn enumerate_physical_device_groups(
6217         &self,
6218         instance: Instance,
6219         p_physical_device_group_count: *mut u32,
6220         p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
6221     ) -> Result {
6222         (self.enumerate_physical_device_groups)(
6223             instance,
6224             p_physical_device_group_count,
6225             p_physical_device_group_properties,
6226         )
6227     }
6228     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures2.html>"]
get_physical_device_features2( &self, physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures2, )6229     pub unsafe fn get_physical_device_features2(
6230         &self,
6231         physical_device: PhysicalDevice,
6232         p_features: *mut PhysicalDeviceFeatures2,
6233     ) {
6234         (self.get_physical_device_features2)(physical_device, p_features)
6235     }
6236     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties2.html>"]
get_physical_device_properties2( &self, physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties2, )6237     pub unsafe fn get_physical_device_properties2(
6238         &self,
6239         physical_device: PhysicalDevice,
6240         p_properties: *mut PhysicalDeviceProperties2,
6241     ) {
6242         (self.get_physical_device_properties2)(physical_device, p_properties)
6243     }
6244     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties2.html>"]
get_physical_device_format_properties2( &self, physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties2, )6245     pub unsafe fn get_physical_device_format_properties2(
6246         &self,
6247         physical_device: PhysicalDevice,
6248         format: Format,
6249         p_format_properties: *mut FormatProperties2,
6250     ) {
6251         (self.get_physical_device_format_properties2)(physical_device, format, p_format_properties)
6252     }
6253     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2.html>"]
get_physical_device_image_format_properties2( &self, physical_device: PhysicalDevice, p_image_format_info: *const PhysicalDeviceImageFormatInfo2, p_image_format_properties: *mut ImageFormatProperties2, ) -> Result6254     pub unsafe fn get_physical_device_image_format_properties2(
6255         &self,
6256         physical_device: PhysicalDevice,
6257         p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
6258         p_image_format_properties: *mut ImageFormatProperties2,
6259     ) -> Result {
6260         (self.get_physical_device_image_format_properties2)(
6261             physical_device,
6262             p_image_format_info,
6263             p_image_format_properties,
6264         )
6265     }
6266     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html>"]
get_physical_device_queue_family_properties2( &self, physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties2, )6267     pub unsafe fn get_physical_device_queue_family_properties2(
6268         &self,
6269         physical_device: PhysicalDevice,
6270         p_queue_family_property_count: *mut u32,
6271         p_queue_family_properties: *mut QueueFamilyProperties2,
6272     ) {
6273         (self.get_physical_device_queue_family_properties2)(
6274             physical_device,
6275             p_queue_family_property_count,
6276             p_queue_family_properties,
6277         )
6278     }
6279     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2.html>"]
get_physical_device_memory_properties2( &self, physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties2, )6280     pub unsafe fn get_physical_device_memory_properties2(
6281         &self,
6282         physical_device: PhysicalDevice,
6283         p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
6284     ) {
6285         (self.get_physical_device_memory_properties2)(physical_device, p_memory_properties)
6286     }
6287     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html>"]
get_physical_device_sparse_image_format_properties2( &self, physical_device: PhysicalDevice, p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties2, )6288     pub unsafe fn get_physical_device_sparse_image_format_properties2(
6289         &self,
6290         physical_device: PhysicalDevice,
6291         p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
6292         p_property_count: *mut u32,
6293         p_properties: *mut SparseImageFormatProperties2,
6294     ) {
6295         (self.get_physical_device_sparse_image_format_properties2)(
6296             physical_device,
6297             p_format_info,
6298             p_property_count,
6299             p_properties,
6300         )
6301     }
6302     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalBufferProperties.html>"]
get_physical_device_external_buffer_properties( &self, physical_device: PhysicalDevice, p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, p_external_buffer_properties: *mut ExternalBufferProperties, )6303     pub unsafe fn get_physical_device_external_buffer_properties(
6304         &self,
6305         physical_device: PhysicalDevice,
6306         p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
6307         p_external_buffer_properties: *mut ExternalBufferProperties,
6308     ) {
6309         (self.get_physical_device_external_buffer_properties)(
6310             physical_device,
6311             p_external_buffer_info,
6312             p_external_buffer_properties,
6313         )
6314     }
6315     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalFenceProperties.html>"]
get_physical_device_external_fence_properties( &self, physical_device: PhysicalDevice, p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, p_external_fence_properties: *mut ExternalFenceProperties, )6316     pub unsafe fn get_physical_device_external_fence_properties(
6317         &self,
6318         physical_device: PhysicalDevice,
6319         p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
6320         p_external_fence_properties: *mut ExternalFenceProperties,
6321     ) {
6322         (self.get_physical_device_external_fence_properties)(
6323             physical_device,
6324             p_external_fence_info,
6325             p_external_fence_properties,
6326         )
6327     }
6328     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html>"]
get_physical_device_external_semaphore_properties( &self, physical_device: PhysicalDevice, p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, p_external_semaphore_properties: *mut ExternalSemaphoreProperties, )6329     pub unsafe fn get_physical_device_external_semaphore_properties(
6330         &self,
6331         physical_device: PhysicalDevice,
6332         p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
6333         p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
6334     ) {
6335         (self.get_physical_device_external_semaphore_properties)(
6336             physical_device,
6337             p_external_semaphore_info,
6338             p_external_semaphore_properties,
6339         )
6340     }
6341 }
6342 #[allow(non_camel_case_types)]
6343 pub type PFN_vkGetDeviceQueue2 = extern "system" fn(
6344     device: Device,
6345     bind_info_count: u32,
6346     p_bind_infos: *const BindBufferMemoryInfo,
6347 ) -> Result;
6348 pub struct DeviceFnV1_1 {
6349     pub bind_buffer_memory2: extern "system" fn(
6350         device: Device,
6351         bind_info_count: u32,
6352         p_bind_infos: *const BindBufferMemoryInfo,
6353     ) -> Result,
6354     pub bind_image_memory2: extern "system" fn(
6355         device: Device,
6356         bind_info_count: u32,
6357         p_bind_infos: *const BindImageMemoryInfo,
6358     ) -> Result,
6359     pub get_device_group_peer_memory_features: extern "system" fn(
6360         device: Device,
6361         heap_index: u32,
6362         local_device_index: u32,
6363         remote_device_index: u32,
6364         p_peer_memory_features: *mut PeerMemoryFeatureFlags,
6365     ),
6366     pub cmd_set_device_mask: extern "system" fn(command_buffer: CommandBuffer, device_mask: u32),
6367     pub cmd_dispatch_base: extern "system" fn(
6368         command_buffer: CommandBuffer,
6369         base_group_x: u32,
6370         base_group_y: u32,
6371         base_group_z: u32,
6372         group_count_x: u32,
6373         group_count_y: u32,
6374         group_count_z: u32,
6375     ),
6376     pub get_image_memory_requirements2: extern "system" fn(
6377         device: Device,
6378         p_info: *const ImageMemoryRequirementsInfo2,
6379         p_memory_requirements: *mut MemoryRequirements2,
6380     ),
6381     pub get_buffer_memory_requirements2: extern "system" fn(
6382         device: Device,
6383         p_info: *const BufferMemoryRequirementsInfo2,
6384         p_memory_requirements: *mut MemoryRequirements2,
6385     ),
6386     pub get_image_sparse_memory_requirements2: extern "system" fn(
6387         device: Device,
6388         p_info: *const ImageSparseMemoryRequirementsInfo2,
6389         p_sparse_memory_requirement_count: *mut u32,
6390         p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
6391     ),
6392     pub trim_command_pool:
6393         extern "system" fn(device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags),
6394     pub get_device_queue2: extern "system" fn(
6395         device: Device,
6396         p_queue_info: *const DeviceQueueInfo2,
6397         p_queue: *mut Queue,
6398     ),
6399     pub create_sampler_ycbcr_conversion: extern "system" fn(
6400         device: Device,
6401         p_create_info: *const SamplerYcbcrConversionCreateInfo,
6402         p_allocator: *const AllocationCallbacks,
6403         p_ycbcr_conversion: *mut SamplerYcbcrConversion,
6404     ) -> Result,
6405     pub destroy_sampler_ycbcr_conversion: extern "system" fn(
6406         device: Device,
6407         ycbcr_conversion: SamplerYcbcrConversion,
6408         p_allocator: *const AllocationCallbacks,
6409     ),
6410     pub create_descriptor_update_template: extern "system" fn(
6411         device: Device,
6412         p_create_info: *const DescriptorUpdateTemplateCreateInfo,
6413         p_allocator: *const AllocationCallbacks,
6414         p_descriptor_update_template: *mut DescriptorUpdateTemplate,
6415     ) -> Result,
6416     pub destroy_descriptor_update_template: extern "system" fn(
6417         device: Device,
6418         descriptor_update_template: DescriptorUpdateTemplate,
6419         p_allocator: *const AllocationCallbacks,
6420     ),
6421     pub update_descriptor_set_with_template: extern "system" fn(
6422         device: Device,
6423         descriptor_set: DescriptorSet,
6424         descriptor_update_template: DescriptorUpdateTemplate,
6425         p_data: *const c_void,
6426     ),
6427     pub get_descriptor_set_layout_support: extern "system" fn(
6428         device: Device,
6429         p_create_info: *const DescriptorSetLayoutCreateInfo,
6430         p_support: *mut DescriptorSetLayoutSupport,
6431     ),
6432 }
6433 unsafe impl Send for DeviceFnV1_1 {}
6434 unsafe impl Sync for DeviceFnV1_1 {}
6435 impl ::std::clone::Clone for DeviceFnV1_1 {
clone(&self) -> Self6436     fn clone(&self) -> Self {
6437         DeviceFnV1_1 {
6438             bind_buffer_memory2: self.bind_buffer_memory2,
6439             bind_image_memory2: self.bind_image_memory2,
6440             get_device_group_peer_memory_features: self.get_device_group_peer_memory_features,
6441             cmd_set_device_mask: self.cmd_set_device_mask,
6442             cmd_dispatch_base: self.cmd_dispatch_base,
6443             get_image_memory_requirements2: self.get_image_memory_requirements2,
6444             get_buffer_memory_requirements2: self.get_buffer_memory_requirements2,
6445             get_image_sparse_memory_requirements2: self.get_image_sparse_memory_requirements2,
6446             trim_command_pool: self.trim_command_pool,
6447             get_device_queue2: self.get_device_queue2,
6448             create_sampler_ycbcr_conversion: self.create_sampler_ycbcr_conversion,
6449             destroy_sampler_ycbcr_conversion: self.destroy_sampler_ycbcr_conversion,
6450             create_descriptor_update_template: self.create_descriptor_update_template,
6451             destroy_descriptor_update_template: self.destroy_descriptor_update_template,
6452             update_descriptor_set_with_template: self.update_descriptor_set_with_template,
6453             get_descriptor_set_layout_support: self.get_descriptor_set_layout_support,
6454         }
6455     }
6456 }
6457 impl DeviceFnV1_1 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,6458     pub fn load<F>(mut _f: F) -> Self
6459     where
6460         F: FnMut(&::std::ffi::CStr) -> *const c_void,
6461     {
6462         DeviceFnV1_1 {
6463             bind_buffer_memory2: unsafe {
6464                 extern "system" fn bind_buffer_memory2(
6465                     _device: Device,
6466                     _bind_info_count: u32,
6467                     _p_bind_infos: *const BindBufferMemoryInfo,
6468                 ) -> Result {
6469                     panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2)))
6470                 }
6471                 let cname =
6472                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2\0");
6473                 let val = _f(cname);
6474                 if val.is_null() {
6475                     bind_buffer_memory2
6476                 } else {
6477                     ::std::mem::transmute(val)
6478                 }
6479             },
6480             bind_image_memory2: unsafe {
6481                 extern "system" fn bind_image_memory2(
6482                     _device: Device,
6483                     _bind_info_count: u32,
6484                     _p_bind_infos: *const BindImageMemoryInfo,
6485                 ) -> Result {
6486                     panic!(concat!("Unable to load ", stringify!(bind_image_memory2)))
6487                 }
6488                 let cname =
6489                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2\0");
6490                 let val = _f(cname);
6491                 if val.is_null() {
6492                     bind_image_memory2
6493                 } else {
6494                     ::std::mem::transmute(val)
6495                 }
6496             },
6497             get_device_group_peer_memory_features: unsafe {
6498                 extern "system" fn get_device_group_peer_memory_features(
6499                     _device: Device,
6500                     _heap_index: u32,
6501                     _local_device_index: u32,
6502                     _remote_device_index: u32,
6503                     _p_peer_memory_features: *mut PeerMemoryFeatureFlags,
6504                 ) {
6505                     panic!(concat!(
6506                         "Unable to load ",
6507                         stringify!(get_device_group_peer_memory_features)
6508                     ))
6509                 }
6510                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6511                     b"vkGetDeviceGroupPeerMemoryFeatures\0",
6512                 );
6513                 let val = _f(cname);
6514                 if val.is_null() {
6515                     get_device_group_peer_memory_features
6516                 } else {
6517                     ::std::mem::transmute(val)
6518                 }
6519             },
6520             cmd_set_device_mask: unsafe {
6521                 extern "system" fn cmd_set_device_mask(
6522                     _command_buffer: CommandBuffer,
6523                     _device_mask: u32,
6524                 ) {
6525                     panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask)))
6526                 }
6527                 let cname =
6528                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMask\0");
6529                 let val = _f(cname);
6530                 if val.is_null() {
6531                     cmd_set_device_mask
6532                 } else {
6533                     ::std::mem::transmute(val)
6534                 }
6535             },
6536             cmd_dispatch_base: unsafe {
6537                 extern "system" fn cmd_dispatch_base(
6538                     _command_buffer: CommandBuffer,
6539                     _base_group_x: u32,
6540                     _base_group_y: u32,
6541                     _base_group_z: u32,
6542                     _group_count_x: u32,
6543                     _group_count_y: u32,
6544                     _group_count_z: u32,
6545                 ) {
6546                     panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base)))
6547                 }
6548                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBase\0");
6549                 let val = _f(cname);
6550                 if val.is_null() {
6551                     cmd_dispatch_base
6552                 } else {
6553                     ::std::mem::transmute(val)
6554                 }
6555             },
6556             get_image_memory_requirements2: unsafe {
6557                 extern "system" fn get_image_memory_requirements2(
6558                     _device: Device,
6559                     _p_info: *const ImageMemoryRequirementsInfo2,
6560                     _p_memory_requirements: *mut MemoryRequirements2,
6561                 ) {
6562                     panic!(concat!(
6563                         "Unable to load ",
6564                         stringify!(get_image_memory_requirements2)
6565                     ))
6566                 }
6567                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6568                     b"vkGetImageMemoryRequirements2\0",
6569                 );
6570                 let val = _f(cname);
6571                 if val.is_null() {
6572                     get_image_memory_requirements2
6573                 } else {
6574                     ::std::mem::transmute(val)
6575                 }
6576             },
6577             get_buffer_memory_requirements2: unsafe {
6578                 extern "system" fn get_buffer_memory_requirements2(
6579                     _device: Device,
6580                     _p_info: *const BufferMemoryRequirementsInfo2,
6581                     _p_memory_requirements: *mut MemoryRequirements2,
6582                 ) {
6583                     panic!(concat!(
6584                         "Unable to load ",
6585                         stringify!(get_buffer_memory_requirements2)
6586                     ))
6587                 }
6588                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6589                     b"vkGetBufferMemoryRequirements2\0",
6590                 );
6591                 let val = _f(cname);
6592                 if val.is_null() {
6593                     get_buffer_memory_requirements2
6594                 } else {
6595                     ::std::mem::transmute(val)
6596                 }
6597             },
6598             get_image_sparse_memory_requirements2: unsafe {
6599                 extern "system" fn get_image_sparse_memory_requirements2(
6600                     _device: Device,
6601                     _p_info: *const ImageSparseMemoryRequirementsInfo2,
6602                     _p_sparse_memory_requirement_count: *mut u32,
6603                     _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
6604                 ) {
6605                     panic!(concat!(
6606                         "Unable to load ",
6607                         stringify!(get_image_sparse_memory_requirements2)
6608                     ))
6609                 }
6610                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6611                     b"vkGetImageSparseMemoryRequirements2\0",
6612                 );
6613                 let val = _f(cname);
6614                 if val.is_null() {
6615                     get_image_sparse_memory_requirements2
6616                 } else {
6617                     ::std::mem::transmute(val)
6618                 }
6619             },
6620             trim_command_pool: unsafe {
6621                 extern "system" fn trim_command_pool(
6622                     _device: Device,
6623                     _command_pool: CommandPool,
6624                     _flags: CommandPoolTrimFlags,
6625                 ) {
6626                     panic!(concat!("Unable to load ", stringify!(trim_command_pool)))
6627                 }
6628                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPool\0");
6629                 let val = _f(cname);
6630                 if val.is_null() {
6631                     trim_command_pool
6632                 } else {
6633                     ::std::mem::transmute(val)
6634                 }
6635             },
6636             get_device_queue2: unsafe {
6637                 extern "system" fn get_device_queue2(
6638                     _device: Device,
6639                     _p_queue_info: *const DeviceQueueInfo2,
6640                     _p_queue: *mut Queue,
6641                 ) {
6642                     panic!(concat!("Unable to load ", stringify!(get_device_queue2)))
6643                 }
6644                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue2\0");
6645                 let val = _f(cname);
6646                 if val.is_null() {
6647                     get_device_queue2
6648                 } else {
6649                     ::std::mem::transmute(val)
6650                 }
6651             },
6652             create_sampler_ycbcr_conversion: unsafe {
6653                 extern "system" fn create_sampler_ycbcr_conversion(
6654                     _device: Device,
6655                     _p_create_info: *const SamplerYcbcrConversionCreateInfo,
6656                     _p_allocator: *const AllocationCallbacks,
6657                     _p_ycbcr_conversion: *mut SamplerYcbcrConversion,
6658                 ) -> Result {
6659                     panic!(concat!(
6660                         "Unable to load ",
6661                         stringify!(create_sampler_ycbcr_conversion)
6662                     ))
6663                 }
6664                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6665                     b"vkCreateSamplerYcbcrConversion\0",
6666                 );
6667                 let val = _f(cname);
6668                 if val.is_null() {
6669                     create_sampler_ycbcr_conversion
6670                 } else {
6671                     ::std::mem::transmute(val)
6672                 }
6673             },
6674             destroy_sampler_ycbcr_conversion: unsafe {
6675                 extern "system" fn destroy_sampler_ycbcr_conversion(
6676                     _device: Device,
6677                     _ycbcr_conversion: SamplerYcbcrConversion,
6678                     _p_allocator: *const AllocationCallbacks,
6679                 ) {
6680                     panic!(concat!(
6681                         "Unable to load ",
6682                         stringify!(destroy_sampler_ycbcr_conversion)
6683                     ))
6684                 }
6685                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6686                     b"vkDestroySamplerYcbcrConversion\0",
6687                 );
6688                 let val = _f(cname);
6689                 if val.is_null() {
6690                     destroy_sampler_ycbcr_conversion
6691                 } else {
6692                     ::std::mem::transmute(val)
6693                 }
6694             },
6695             create_descriptor_update_template: unsafe {
6696                 extern "system" fn create_descriptor_update_template(
6697                     _device: Device,
6698                     _p_create_info: *const DescriptorUpdateTemplateCreateInfo,
6699                     _p_allocator: *const AllocationCallbacks,
6700                     _p_descriptor_update_template: *mut DescriptorUpdateTemplate,
6701                 ) -> Result {
6702                     panic!(concat!(
6703                         "Unable to load ",
6704                         stringify!(create_descriptor_update_template)
6705                     ))
6706                 }
6707                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6708                     b"vkCreateDescriptorUpdateTemplate\0",
6709                 );
6710                 let val = _f(cname);
6711                 if val.is_null() {
6712                     create_descriptor_update_template
6713                 } else {
6714                     ::std::mem::transmute(val)
6715                 }
6716             },
6717             destroy_descriptor_update_template: unsafe {
6718                 extern "system" fn destroy_descriptor_update_template(
6719                     _device: Device,
6720                     _descriptor_update_template: DescriptorUpdateTemplate,
6721                     _p_allocator: *const AllocationCallbacks,
6722                 ) {
6723                     panic!(concat!(
6724                         "Unable to load ",
6725                         stringify!(destroy_descriptor_update_template)
6726                     ))
6727                 }
6728                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6729                     b"vkDestroyDescriptorUpdateTemplate\0",
6730                 );
6731                 let val = _f(cname);
6732                 if val.is_null() {
6733                     destroy_descriptor_update_template
6734                 } else {
6735                     ::std::mem::transmute(val)
6736                 }
6737             },
6738             update_descriptor_set_with_template: unsafe {
6739                 extern "system" fn update_descriptor_set_with_template(
6740                     _device: Device,
6741                     _descriptor_set: DescriptorSet,
6742                     _descriptor_update_template: DescriptorUpdateTemplate,
6743                     _p_data: *const c_void,
6744                 ) {
6745                     panic!(concat!(
6746                         "Unable to load ",
6747                         stringify!(update_descriptor_set_with_template)
6748                     ))
6749                 }
6750                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6751                     b"vkUpdateDescriptorSetWithTemplate\0",
6752                 );
6753                 let val = _f(cname);
6754                 if val.is_null() {
6755                     update_descriptor_set_with_template
6756                 } else {
6757                     ::std::mem::transmute(val)
6758                 }
6759             },
6760             get_descriptor_set_layout_support: unsafe {
6761                 extern "system" fn get_descriptor_set_layout_support(
6762                     _device: Device,
6763                     _p_create_info: *const DescriptorSetLayoutCreateInfo,
6764                     _p_support: *mut DescriptorSetLayoutSupport,
6765                 ) {
6766                     panic!(concat!(
6767                         "Unable to load ",
6768                         stringify!(get_descriptor_set_layout_support)
6769                     ))
6770                 }
6771                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6772                     b"vkGetDescriptorSetLayoutSupport\0",
6773                 );
6774                 let val = _f(cname);
6775                 if val.is_null() {
6776                     get_descriptor_set_layout_support
6777                 } else {
6778                     ::std::mem::transmute(val)
6779                 }
6780             },
6781         }
6782     }
6783     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory2.html>"]
bind_buffer_memory2( &self, device: Device, bind_info_count: u32, p_bind_infos: *const BindBufferMemoryInfo, ) -> Result6784     pub unsafe fn bind_buffer_memory2(
6785         &self,
6786         device: Device,
6787         bind_info_count: u32,
6788         p_bind_infos: *const BindBufferMemoryInfo,
6789     ) -> Result {
6790         (self.bind_buffer_memory2)(device, bind_info_count, p_bind_infos)
6791     }
6792     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory2.html>"]
bind_image_memory2( &self, device: Device, bind_info_count: u32, p_bind_infos: *const BindImageMemoryInfo, ) -> Result6793     pub unsafe fn bind_image_memory2(
6794         &self,
6795         device: Device,
6796         bind_info_count: u32,
6797         p_bind_infos: *const BindImageMemoryInfo,
6798     ) -> Result {
6799         (self.bind_image_memory2)(device, bind_info_count, p_bind_infos)
6800     }
6801     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupPeerMemoryFeatures.html>"]
get_device_group_peer_memory_features( &self, device: Device, heap_index: u32, local_device_index: u32, remote_device_index: u32, p_peer_memory_features: *mut PeerMemoryFeatureFlags, )6802     pub unsafe fn get_device_group_peer_memory_features(
6803         &self,
6804         device: Device,
6805         heap_index: u32,
6806         local_device_index: u32,
6807         remote_device_index: u32,
6808         p_peer_memory_features: *mut PeerMemoryFeatureFlags,
6809     ) {
6810         (self.get_device_group_peer_memory_features)(
6811             device,
6812             heap_index,
6813             local_device_index,
6814             remote_device_index,
6815             p_peer_memory_features,
6816         )
6817     }
6818     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDeviceMask.html>"]
cmd_set_device_mask(&self, command_buffer: CommandBuffer, device_mask: u32)6819     pub unsafe fn cmd_set_device_mask(&self, command_buffer: CommandBuffer, device_mask: u32) {
6820         (self.cmd_set_device_mask)(command_buffer, device_mask)
6821     }
6822     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchBase.html>"]
cmd_dispatch_base( &self, command_buffer: CommandBuffer, base_group_x: u32, base_group_y: u32, base_group_z: u32, group_count_x: u32, group_count_y: u32, group_count_z: u32, )6823     pub unsafe fn cmd_dispatch_base(
6824         &self,
6825         command_buffer: CommandBuffer,
6826         base_group_x: u32,
6827         base_group_y: u32,
6828         base_group_z: u32,
6829         group_count_x: u32,
6830         group_count_y: u32,
6831         group_count_z: u32,
6832     ) {
6833         (self.cmd_dispatch_base)(
6834             command_buffer,
6835             base_group_x,
6836             base_group_y,
6837             base_group_z,
6838             group_count_x,
6839             group_count_y,
6840             group_count_z,
6841         )
6842     }
6843     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements2.html>"]
get_image_memory_requirements2( &self, device: Device, p_info: *const ImageMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, )6844     pub unsafe fn get_image_memory_requirements2(
6845         &self,
6846         device: Device,
6847         p_info: *const ImageMemoryRequirementsInfo2,
6848         p_memory_requirements: *mut MemoryRequirements2,
6849     ) {
6850         (self.get_image_memory_requirements2)(device, p_info, p_memory_requirements)
6851     }
6852     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements2.html>"]
get_buffer_memory_requirements2( &self, device: Device, p_info: *const BufferMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, )6853     pub unsafe fn get_buffer_memory_requirements2(
6854         &self,
6855         device: Device,
6856         p_info: *const BufferMemoryRequirementsInfo2,
6857         p_memory_requirements: *mut MemoryRequirements2,
6858     ) {
6859         (self.get_buffer_memory_requirements2)(device, p_info, p_memory_requirements)
6860     }
6861     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements2.html>"]
get_image_sparse_memory_requirements2( &self, device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, )6862     pub unsafe fn get_image_sparse_memory_requirements2(
6863         &self,
6864         device: Device,
6865         p_info: *const ImageSparseMemoryRequirementsInfo2,
6866         p_sparse_memory_requirement_count: *mut u32,
6867         p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
6868     ) {
6869         (self.get_image_sparse_memory_requirements2)(
6870             device,
6871             p_info,
6872             p_sparse_memory_requirement_count,
6873             p_sparse_memory_requirements,
6874         )
6875     }
6876     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkTrimCommandPool.html>"]
trim_command_pool( &self, device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags, )6877     pub unsafe fn trim_command_pool(
6878         &self,
6879         device: Device,
6880         command_pool: CommandPool,
6881         flags: CommandPoolTrimFlags,
6882     ) {
6883         (self.trim_command_pool)(device, command_pool, flags)
6884     }
6885     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceQueue2.html>"]
get_device_queue2( &self, device: Device, p_queue_info: *const DeviceQueueInfo2, p_queue: *mut Queue, )6886     pub unsafe fn get_device_queue2(
6887         &self,
6888         device: Device,
6889         p_queue_info: *const DeviceQueueInfo2,
6890         p_queue: *mut Queue,
6891     ) {
6892         (self.get_device_queue2)(device, p_queue_info, p_queue)
6893     }
6894     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSamplerYcbcrConversion.html>"]
create_sampler_ycbcr_conversion( &self, device: Device, p_create_info: *const SamplerYcbcrConversionCreateInfo, p_allocator: *const AllocationCallbacks, p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result6895     pub unsafe fn create_sampler_ycbcr_conversion(
6896         &self,
6897         device: Device,
6898         p_create_info: *const SamplerYcbcrConversionCreateInfo,
6899         p_allocator: *const AllocationCallbacks,
6900         p_ycbcr_conversion: *mut SamplerYcbcrConversion,
6901     ) -> Result {
6902         (self.create_sampler_ycbcr_conversion)(
6903             device,
6904             p_create_info,
6905             p_allocator,
6906             p_ycbcr_conversion,
6907         )
6908     }
6909     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySamplerYcbcrConversion.html>"]
destroy_sampler_ycbcr_conversion( &self, device: Device, ycbcr_conversion: SamplerYcbcrConversion, p_allocator: *const AllocationCallbacks, )6910     pub unsafe fn destroy_sampler_ycbcr_conversion(
6911         &self,
6912         device: Device,
6913         ycbcr_conversion: SamplerYcbcrConversion,
6914         p_allocator: *const AllocationCallbacks,
6915     ) {
6916         (self.destroy_sampler_ycbcr_conversion)(device, ycbcr_conversion, p_allocator)
6917     }
6918     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorUpdateTemplate.html>"]
create_descriptor_update_template( &self, device: Device, p_create_info: *const DescriptorUpdateTemplateCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result6919     pub unsafe fn create_descriptor_update_template(
6920         &self,
6921         device: Device,
6922         p_create_info: *const DescriptorUpdateTemplateCreateInfo,
6923         p_allocator: *const AllocationCallbacks,
6924         p_descriptor_update_template: *mut DescriptorUpdateTemplate,
6925     ) -> Result {
6926         (self.create_descriptor_update_template)(
6927             device,
6928             p_create_info,
6929             p_allocator,
6930             p_descriptor_update_template,
6931         )
6932     }
6933     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorUpdateTemplate.html>"]
destroy_descriptor_update_template( &self, device: Device, descriptor_update_template: DescriptorUpdateTemplate, p_allocator: *const AllocationCallbacks, )6934     pub unsafe fn destroy_descriptor_update_template(
6935         &self,
6936         device: Device,
6937         descriptor_update_template: DescriptorUpdateTemplate,
6938         p_allocator: *const AllocationCallbacks,
6939     ) {
6940         (self.destroy_descriptor_update_template)(device, descriptor_update_template, p_allocator)
6941     }
6942     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSetWithTemplate.html>"]
update_descriptor_set_with_template( &self, device: Device, descriptor_set: DescriptorSet, descriptor_update_template: DescriptorUpdateTemplate, p_data: *const c_void, )6943     pub unsafe fn update_descriptor_set_with_template(
6944         &self,
6945         device: Device,
6946         descriptor_set: DescriptorSet,
6947         descriptor_update_template: DescriptorUpdateTemplate,
6948         p_data: *const c_void,
6949     ) {
6950         (self.update_descriptor_set_with_template)(
6951             device,
6952             descriptor_set,
6953             descriptor_update_template,
6954             p_data,
6955         )
6956     }
6957     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDescriptorSetLayoutSupport.html>"]
get_descriptor_set_layout_support( &self, device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_support: *mut DescriptorSetLayoutSupport, )6958     pub unsafe fn get_descriptor_set_layout_support(
6959         &self,
6960         device: Device,
6961         p_create_info: *const DescriptorSetLayoutCreateInfo,
6962         p_support: *mut DescriptorSetLayoutSupport,
6963     ) {
6964         (self.get_descriptor_set_layout_support)(device, p_create_info, p_support)
6965     }
6966 }
6967 pub struct EntryFnV1_2 {}
6968 unsafe impl Send for EntryFnV1_2 {}
6969 unsafe impl Sync for EntryFnV1_2 {}
6970 impl ::std::clone::Clone for EntryFnV1_2 {
clone(&self) -> Self6971     fn clone(&self) -> Self {
6972         EntryFnV1_2 {}
6973     }
6974 }
6975 impl EntryFnV1_2 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,6976     pub fn load<F>(mut _f: F) -> Self
6977     where
6978         F: FnMut(&::std::ffi::CStr) -> *const c_void,
6979     {
6980         EntryFnV1_2 {}
6981     }
6982 }
6983 pub struct InstanceFnV1_2 {}
6984 unsafe impl Send for InstanceFnV1_2 {}
6985 unsafe impl Sync for InstanceFnV1_2 {}
6986 impl ::std::clone::Clone for InstanceFnV1_2 {
clone(&self) -> Self6987     fn clone(&self) -> Self {
6988         InstanceFnV1_2 {}
6989     }
6990 }
6991 impl InstanceFnV1_2 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,6992     pub fn load<F>(mut _f: F) -> Self
6993     where
6994         F: FnMut(&::std::ffi::CStr) -> *const c_void,
6995     {
6996         InstanceFnV1_2 {}
6997     }
6998 }
6999 pub struct DeviceFnV1_2 {
7000     pub cmd_draw_indirect_count: extern "system" fn(
7001         command_buffer: CommandBuffer,
7002         buffer: Buffer,
7003         offset: DeviceSize,
7004         count_buffer: Buffer,
7005         count_buffer_offset: DeviceSize,
7006         max_draw_count: u32,
7007         stride: u32,
7008     ),
7009     pub cmd_draw_indexed_indirect_count: extern "system" fn(
7010         command_buffer: CommandBuffer,
7011         buffer: Buffer,
7012         offset: DeviceSize,
7013         count_buffer: Buffer,
7014         count_buffer_offset: DeviceSize,
7015         max_draw_count: u32,
7016         stride: u32,
7017     ),
7018     pub create_render_pass2: extern "system" fn(
7019         device: Device,
7020         p_create_info: *const RenderPassCreateInfo2,
7021         p_allocator: *const AllocationCallbacks,
7022         p_render_pass: *mut RenderPass,
7023     ) -> Result,
7024     pub cmd_begin_render_pass2: extern "system" fn(
7025         command_buffer: CommandBuffer,
7026         p_render_pass_begin: *const RenderPassBeginInfo,
7027         p_subpass_begin_info: *const SubpassBeginInfo,
7028     ),
7029     pub cmd_next_subpass2: extern "system" fn(
7030         command_buffer: CommandBuffer,
7031         p_subpass_begin_info: *const SubpassBeginInfo,
7032         p_subpass_end_info: *const SubpassEndInfo,
7033     ),
7034     pub cmd_end_render_pass2: extern "system" fn(
7035         command_buffer: CommandBuffer,
7036         p_subpass_end_info: *const SubpassEndInfo,
7037     ),
7038     pub reset_query_pool: extern "system" fn(
7039         device: Device,
7040         query_pool: QueryPool,
7041         first_query: u32,
7042         query_count: u32,
7043     ),
7044     pub get_semaphore_counter_value:
7045         extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result,
7046     pub wait_semaphores: extern "system" fn(
7047         device: Device,
7048         p_wait_info: *const SemaphoreWaitInfo,
7049         timeout: u64,
7050     ) -> Result,
7051     pub signal_semaphore:
7052         extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result,
7053     pub get_buffer_device_address:
7054         extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress,
7055     pub get_buffer_opaque_capture_address:
7056         extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64,
7057     pub get_device_memory_opaque_capture_address: extern "system" fn(
7058         device: Device,
7059         p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
7060     ) -> u64,
7061 }
7062 unsafe impl Send for DeviceFnV1_2 {}
7063 unsafe impl Sync for DeviceFnV1_2 {}
7064 impl ::std::clone::Clone for DeviceFnV1_2 {
clone(&self) -> Self7065     fn clone(&self) -> Self {
7066         DeviceFnV1_2 {
7067             cmd_draw_indirect_count: self.cmd_draw_indirect_count,
7068             cmd_draw_indexed_indirect_count: self.cmd_draw_indexed_indirect_count,
7069             create_render_pass2: self.create_render_pass2,
7070             cmd_begin_render_pass2: self.cmd_begin_render_pass2,
7071             cmd_next_subpass2: self.cmd_next_subpass2,
7072             cmd_end_render_pass2: self.cmd_end_render_pass2,
7073             reset_query_pool: self.reset_query_pool,
7074             get_semaphore_counter_value: self.get_semaphore_counter_value,
7075             wait_semaphores: self.wait_semaphores,
7076             signal_semaphore: self.signal_semaphore,
7077             get_buffer_device_address: self.get_buffer_device_address,
7078             get_buffer_opaque_capture_address: self.get_buffer_opaque_capture_address,
7079             get_device_memory_opaque_capture_address: self.get_device_memory_opaque_capture_address,
7080         }
7081     }
7082 }
7083 impl DeviceFnV1_2 {
load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,7084     pub fn load<F>(mut _f: F) -> Self
7085     where
7086         F: FnMut(&::std::ffi::CStr) -> *const c_void,
7087     {
7088         DeviceFnV1_2 {
7089             cmd_draw_indirect_count: unsafe {
7090                 extern "system" fn cmd_draw_indirect_count(
7091                     _command_buffer: CommandBuffer,
7092                     _buffer: Buffer,
7093                     _offset: DeviceSize,
7094                     _count_buffer: Buffer,
7095                     _count_buffer_offset: DeviceSize,
7096                     _max_draw_count: u32,
7097                     _stride: u32,
7098                 ) {
7099                     panic!(concat!(
7100                         "Unable to load ",
7101                         stringify!(cmd_draw_indirect_count)
7102                     ))
7103                 }
7104                 let cname =
7105                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCount\0");
7106                 let val = _f(cname);
7107                 if val.is_null() {
7108                     cmd_draw_indirect_count
7109                 } else {
7110                     ::std::mem::transmute(val)
7111                 }
7112             },
7113             cmd_draw_indexed_indirect_count: unsafe {
7114                 extern "system" fn cmd_draw_indexed_indirect_count(
7115                     _command_buffer: CommandBuffer,
7116                     _buffer: Buffer,
7117                     _offset: DeviceSize,
7118                     _count_buffer: Buffer,
7119                     _count_buffer_offset: DeviceSize,
7120                     _max_draw_count: u32,
7121                     _stride: u32,
7122                 ) {
7123                     panic!(concat!(
7124                         "Unable to load ",
7125                         stringify!(cmd_draw_indexed_indirect_count)
7126                     ))
7127                 }
7128                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7129                     b"vkCmdDrawIndexedIndirectCount\0",
7130                 );
7131                 let val = _f(cname);
7132                 if val.is_null() {
7133                     cmd_draw_indexed_indirect_count
7134                 } else {
7135                     ::std::mem::transmute(val)
7136                 }
7137             },
7138             create_render_pass2: unsafe {
7139                 extern "system" fn create_render_pass2(
7140                     _device: Device,
7141                     _p_create_info: *const RenderPassCreateInfo2,
7142                     _p_allocator: *const AllocationCallbacks,
7143                     _p_render_pass: *mut RenderPass,
7144                 ) -> Result {
7145                     panic!(concat!("Unable to load ", stringify!(create_render_pass2)))
7146                 }
7147                 let cname =
7148                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2\0");
7149                 let val = _f(cname);
7150                 if val.is_null() {
7151                     create_render_pass2
7152                 } else {
7153                     ::std::mem::transmute(val)
7154                 }
7155             },
7156             cmd_begin_render_pass2: unsafe {
7157                 extern "system" fn cmd_begin_render_pass2(
7158                     _command_buffer: CommandBuffer,
7159                     _p_render_pass_begin: *const RenderPassBeginInfo,
7160                     _p_subpass_begin_info: *const SubpassBeginInfo,
7161                 ) {
7162                     panic!(concat!(
7163                         "Unable to load ",
7164                         stringify!(cmd_begin_render_pass2)
7165                     ))
7166                 }
7167                 let cname =
7168                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2\0");
7169                 let val = _f(cname);
7170                 if val.is_null() {
7171                     cmd_begin_render_pass2
7172                 } else {
7173                     ::std::mem::transmute(val)
7174                 }
7175             },
7176             cmd_next_subpass2: unsafe {
7177                 extern "system" fn cmd_next_subpass2(
7178                     _command_buffer: CommandBuffer,
7179                     _p_subpass_begin_info: *const SubpassBeginInfo,
7180                     _p_subpass_end_info: *const SubpassEndInfo,
7181                 ) {
7182                     panic!(concat!("Unable to load ", stringify!(cmd_next_subpass2)))
7183                 }
7184                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2\0");
7185                 let val = _f(cname);
7186                 if val.is_null() {
7187                     cmd_next_subpass2
7188                 } else {
7189                     ::std::mem::transmute(val)
7190                 }
7191             },
7192             cmd_end_render_pass2: unsafe {
7193                 extern "system" fn cmd_end_render_pass2(
7194                     _command_buffer: CommandBuffer,
7195                     _p_subpass_end_info: *const SubpassEndInfo,
7196                 ) {
7197                     panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass2)))
7198                 }
7199                 let cname =
7200                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2\0");
7201                 let val = _f(cname);
7202                 if val.is_null() {
7203                     cmd_end_render_pass2
7204                 } else {
7205                     ::std::mem::transmute(val)
7206                 }
7207             },
7208             reset_query_pool: unsafe {
7209                 extern "system" fn reset_query_pool(
7210                     _device: Device,
7211                     _query_pool: QueryPool,
7212                     _first_query: u32,
7213                     _query_count: u32,
7214                 ) {
7215                     panic!(concat!("Unable to load ", stringify!(reset_query_pool)))
7216                 }
7217                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPool\0");
7218                 let val = _f(cname);
7219                 if val.is_null() {
7220                     reset_query_pool
7221                 } else {
7222                     ::std::mem::transmute(val)
7223                 }
7224             },
7225             get_semaphore_counter_value: unsafe {
7226                 extern "system" fn get_semaphore_counter_value(
7227                     _device: Device,
7228                     _semaphore: Semaphore,
7229                     _p_value: *mut u64,
7230                 ) -> Result {
7231                     panic!(concat!(
7232                         "Unable to load ",
7233                         stringify!(get_semaphore_counter_value)
7234                     ))
7235                 }
7236                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7237                     b"vkGetSemaphoreCounterValue\0",
7238                 );
7239                 let val = _f(cname);
7240                 if val.is_null() {
7241                     get_semaphore_counter_value
7242                 } else {
7243                     ::std::mem::transmute(val)
7244                 }
7245             },
7246             wait_semaphores: unsafe {
7247                 extern "system" fn wait_semaphores(
7248                     _device: Device,
7249                     _p_wait_info: *const SemaphoreWaitInfo,
7250                     _timeout: u64,
7251                 ) -> Result {
7252                     panic!(concat!("Unable to load ", stringify!(wait_semaphores)))
7253                 }
7254                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphores\0");
7255                 let val = _f(cname);
7256                 if val.is_null() {
7257                     wait_semaphores
7258                 } else {
7259                     ::std::mem::transmute(val)
7260                 }
7261             },
7262             signal_semaphore: unsafe {
7263                 extern "system" fn signal_semaphore(
7264                     _device: Device,
7265                     _p_signal_info: *const SemaphoreSignalInfo,
7266                 ) -> Result {
7267                     panic!(concat!("Unable to load ", stringify!(signal_semaphore)))
7268                 }
7269                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphore\0");
7270                 let val = _f(cname);
7271                 if val.is_null() {
7272                     signal_semaphore
7273                 } else {
7274                     ::std::mem::transmute(val)
7275                 }
7276             },
7277             get_buffer_device_address: unsafe {
7278                 extern "system" fn get_buffer_device_address(
7279                     _device: Device,
7280                     _p_info: *const BufferDeviceAddressInfo,
7281                 ) -> DeviceAddress {
7282                     panic!(concat!(
7283                         "Unable to load ",
7284                         stringify!(get_buffer_device_address)
7285                     ))
7286                 }
7287                 let cname =
7288                     ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddress\0");
7289                 let val = _f(cname);
7290                 if val.is_null() {
7291                     get_buffer_device_address
7292                 } else {
7293                     ::std::mem::transmute(val)
7294                 }
7295             },
7296             get_buffer_opaque_capture_address: unsafe {
7297                 extern "system" fn get_buffer_opaque_capture_address(
7298                     _device: Device,
7299                     _p_info: *const BufferDeviceAddressInfo,
7300                 ) -> u64 {
7301                     panic!(concat!(
7302                         "Unable to load ",
7303                         stringify!(get_buffer_opaque_capture_address)
7304                     ))
7305                 }
7306                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7307                     b"vkGetBufferOpaqueCaptureAddress\0",
7308                 );
7309                 let val = _f(cname);
7310                 if val.is_null() {
7311                     get_buffer_opaque_capture_address
7312                 } else {
7313                     ::std::mem::transmute(val)
7314                 }
7315             },
7316             get_device_memory_opaque_capture_address: unsafe {
7317                 extern "system" fn get_device_memory_opaque_capture_address(
7318                     _device: Device,
7319                     _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
7320                 ) -> u64 {
7321                     panic!(concat!(
7322                         "Unable to load ",
7323                         stringify!(get_device_memory_opaque_capture_address)
7324                     ))
7325                 }
7326                 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7327                     b"vkGetDeviceMemoryOpaqueCaptureAddress\0",
7328                 );
7329                 let val = _f(cname);
7330                 if val.is_null() {
7331                     get_device_memory_opaque_capture_address
7332                 } else {
7333                     ::std::mem::transmute(val)
7334                 }
7335             },
7336         }
7337     }
7338     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirectCount.html>"]
cmd_draw_indirect_count( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, )7339     pub unsafe fn cmd_draw_indirect_count(
7340         &self,
7341         command_buffer: CommandBuffer,
7342         buffer: Buffer,
7343         offset: DeviceSize,
7344         count_buffer: Buffer,
7345         count_buffer_offset: DeviceSize,
7346         max_draw_count: u32,
7347         stride: u32,
7348     ) {
7349         (self.cmd_draw_indirect_count)(
7350             command_buffer,
7351             buffer,
7352             offset,
7353             count_buffer,
7354             count_buffer_offset,
7355             max_draw_count,
7356             stride,
7357         )
7358     }
7359     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirectCount.html>"]
cmd_draw_indexed_indirect_count( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, )7360     pub unsafe fn cmd_draw_indexed_indirect_count(
7361         &self,
7362         command_buffer: CommandBuffer,
7363         buffer: Buffer,
7364         offset: DeviceSize,
7365         count_buffer: Buffer,
7366         count_buffer_offset: DeviceSize,
7367         max_draw_count: u32,
7368         stride: u32,
7369     ) {
7370         (self.cmd_draw_indexed_indirect_count)(
7371             command_buffer,
7372             buffer,
7373             offset,
7374             count_buffer,
7375             count_buffer_offset,
7376             max_draw_count,
7377             stride,
7378         )
7379     }
7380     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass2.html>"]
create_render_pass2( &self, device: Device, p_create_info: *const RenderPassCreateInfo2, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result7381     pub unsafe fn create_render_pass2(
7382         &self,
7383         device: Device,
7384         p_create_info: *const RenderPassCreateInfo2,
7385         p_allocator: *const AllocationCallbacks,
7386         p_render_pass: *mut RenderPass,
7387     ) -> Result {
7388         (self.create_render_pass2)(device, p_create_info, p_allocator, p_render_pass)
7389     }
7390     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass2.html>"]
cmd_begin_render_pass2( &self, command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, p_subpass_begin_info: *const SubpassBeginInfo, )7391     pub unsafe fn cmd_begin_render_pass2(
7392         &self,
7393         command_buffer: CommandBuffer,
7394         p_render_pass_begin: *const RenderPassBeginInfo,
7395         p_subpass_begin_info: *const SubpassBeginInfo,
7396     ) {
7397         (self.cmd_begin_render_pass2)(command_buffer, p_render_pass_begin, p_subpass_begin_info)
7398     }
7399     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass2.html>"]
cmd_next_subpass2( &self, command_buffer: CommandBuffer, p_subpass_begin_info: *const SubpassBeginInfo, p_subpass_end_info: *const SubpassEndInfo, )7400     pub unsafe fn cmd_next_subpass2(
7401         &self,
7402         command_buffer: CommandBuffer,
7403         p_subpass_begin_info: *const SubpassBeginInfo,
7404         p_subpass_end_info: *const SubpassEndInfo,
7405     ) {
7406         (self.cmd_next_subpass2)(command_buffer, p_subpass_begin_info, p_subpass_end_info)
7407     }
7408     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass2.html>"]
cmd_end_render_pass2( &self, command_buffer: CommandBuffer, p_subpass_end_info: *const SubpassEndInfo, )7409     pub unsafe fn cmd_end_render_pass2(
7410         &self,
7411         command_buffer: CommandBuffer,
7412         p_subpass_end_info: *const SubpassEndInfo,
7413     ) {
7414         (self.cmd_end_render_pass2)(command_buffer, p_subpass_end_info)
7415     }
7416     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetQueryPool.html>"]
reset_query_pool( &self, device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, )7417     pub unsafe fn reset_query_pool(
7418         &self,
7419         device: Device,
7420         query_pool: QueryPool,
7421         first_query: u32,
7422         query_count: u32,
7423     ) {
7424         (self.reset_query_pool)(device, query_pool, first_query, query_count)
7425     }
7426     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreCounterValue.html>"]
get_semaphore_counter_value( &self, device: Device, semaphore: Semaphore, p_value: *mut u64, ) -> Result7427     pub unsafe fn get_semaphore_counter_value(
7428         &self,
7429         device: Device,
7430         semaphore: Semaphore,
7431         p_value: *mut u64,
7432     ) -> Result {
7433         (self.get_semaphore_counter_value)(device, semaphore, p_value)
7434     }
7435     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitSemaphores.html>"]
wait_semaphores( &self, device: Device, p_wait_info: *const SemaphoreWaitInfo, timeout: u64, ) -> Result7436     pub unsafe fn wait_semaphores(
7437         &self,
7438         device: Device,
7439         p_wait_info: *const SemaphoreWaitInfo,
7440         timeout: u64,
7441     ) -> Result {
7442         (self.wait_semaphores)(device, p_wait_info, timeout)
7443     }
7444     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSignalSemaphore.html>"]
signal_semaphore( &self, device: Device, p_signal_info: *const SemaphoreSignalInfo, ) -> Result7445     pub unsafe fn signal_semaphore(
7446         &self,
7447         device: Device,
7448         p_signal_info: *const SemaphoreSignalInfo,
7449     ) -> Result {
7450         (self.signal_semaphore)(device, p_signal_info)
7451     }
7452     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddress.html>"]
get_buffer_device_address( &self, device: Device, p_info: *const BufferDeviceAddressInfo, ) -> DeviceAddress7453     pub unsafe fn get_buffer_device_address(
7454         &self,
7455         device: Device,
7456         p_info: *const BufferDeviceAddressInfo,
7457     ) -> DeviceAddress {
7458         (self.get_buffer_device_address)(device, p_info)
7459     }
7460     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferOpaqueCaptureAddress.html>"]
get_buffer_opaque_capture_address( &self, device: Device, p_info: *const BufferDeviceAddressInfo, ) -> u647461     pub unsafe fn get_buffer_opaque_capture_address(
7462         &self,
7463         device: Device,
7464         p_info: *const BufferDeviceAddressInfo,
7465     ) -> u64 {
7466         (self.get_buffer_opaque_capture_address)(device, p_info)
7467     }
7468     #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html>"]
get_device_memory_opaque_capture_address( &self, device: Device, p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, ) -> u647469     pub unsafe fn get_device_memory_opaque_capture_address(
7470         &self,
7471         device: Device,
7472         p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
7473     ) -> u64 {
7474         (self.get_device_memory_opaque_capture_address)(device, p_info)
7475     }
7476 }
7477