Adding upstream version 124.0.1.upstream/124.0.1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 5353 insertions, 0 deletions

diff --git a/third_party/rust/ash/src/vk/features.rs b/third_party/rust/ash/src/vk/features.rs
new file mode 100644
index 0000000000..f7ddc8e6be
--- /dev/null
+++ b/third_party/rust/ash/src/vk/features.rs
@@ -0,0 +1,5353 @@
+use crate::vk::bitflags::*;
+use crate::vk::definitions::*;
+use crate::vk::enums::*;
+use std::os::raw::*;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetInstanceProcAddr =
+    unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction;
+#[derive(Clone)]
+pub struct StaticFn {
+    pub get_instance_proc_addr: PFN_vkGetInstanceProcAddr,
+}
+unsafe impl Send for StaticFn {}
+unsafe impl Sync for StaticFn {}
+impl StaticFn {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_instance_proc_addr: unsafe {
+                unsafe extern "system" fn get_instance_proc_addr(
+                    _instance: Instance,
+                    _p_name: *const c_char,
+                ) -> PFN_vkVoidFunction {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_instance_proc_addr)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetInstanceProcAddr\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_instance_proc_addr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateInstance = unsafe extern "system" fn(
+    p_create_info: *const InstanceCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_instance: *mut Instance,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn(
+    p_layer_name: *const c_char,
+    p_property_count: *mut u32,
+    p_properties: *mut ExtensionProperties,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn(
+    p_property_count: *mut u32,
+    p_properties: *mut LayerProperties,
+) -> Result;
+#[derive(Clone)]
+pub struct EntryFnV1_0 {
+    pub create_instance: PFN_vkCreateInstance,
+    pub enumerate_instance_extension_properties: PFN_vkEnumerateInstanceExtensionProperties,
+    pub enumerate_instance_layer_properties: PFN_vkEnumerateInstanceLayerProperties,
+}
+unsafe impl Send for EntryFnV1_0 {}
+unsafe impl Sync for EntryFnV1_0 {}
+impl EntryFnV1_0 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            create_instance: unsafe {
+                unsafe extern "system" fn create_instance(
+                    _p_create_info: *const InstanceCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_instance: *mut Instance,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_instance)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateInstance\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_instance
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            enumerate_instance_extension_properties: unsafe {
+                unsafe extern "system" fn enumerate_instance_extension_properties(
+                    _p_layer_name: *const c_char,
+                    _p_property_count: *mut u32,
+                    _p_properties: *mut ExtensionProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(enumerate_instance_extension_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumerateInstanceExtensionProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    enumerate_instance_extension_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            enumerate_instance_layer_properties: unsafe {
+                unsafe extern "system" fn enumerate_instance_layer_properties(
+                    _p_property_count: *mut u32,
+                    _p_properties: *mut LayerProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(enumerate_instance_layer_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumerateInstanceLayerProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    enumerate_instance_layer_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyInstance =
+    unsafe extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks);
+#[allow(non_camel_case_types)]
+pub type PFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn(
+    instance: Instance,
+    p_physical_device_count: *mut u32,
+    p_physical_devices: *mut PhysicalDevice,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_features: *mut PhysicalDeviceFeatures,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    format: Format,
+    p_format_properties: *mut FormatProperties,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    format: Format,
+    ty: ImageType,
+    tiling: ImageTiling,
+    usage: ImageUsageFlags,
+    flags: ImageCreateFlags,
+    p_image_format_properties: *mut ImageFormatProperties,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_properties: *mut PhysicalDeviceProperties,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_queue_family_property_count: *mut u32,
+    p_queue_family_properties: *mut QueueFamilyProperties,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_memory_properties: *mut PhysicalDeviceMemoryProperties,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceProcAddr =
+    unsafe extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateDevice = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_create_info: *const DeviceCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_device: *mut Device,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_layer_name: *const c_char,
+    p_property_count: *mut u32,
+    p_properties: *mut ExtensionProperties,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    p_property_count: *mut u32,
+    p_properties: *mut LayerProperties,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn(
+    physical_device: PhysicalDevice,
+    format: Format,
+    ty: ImageType,
+    samples: SampleCountFlags,
+    usage: ImageUsageFlags,
+    tiling: ImageTiling,
+    p_property_count: *mut u32,
+    p_properties: *mut SparseImageFormatProperties,
+);
+#[derive(Clone)]
+pub struct InstanceFnV1_0 {
+    pub destroy_instance: PFN_vkDestroyInstance,
+    pub enumerate_physical_devices: PFN_vkEnumeratePhysicalDevices,
+    pub get_physical_device_features: PFN_vkGetPhysicalDeviceFeatures,
+    pub get_physical_device_format_properties: PFN_vkGetPhysicalDeviceFormatProperties,
+    pub get_physical_device_image_format_properties: PFN_vkGetPhysicalDeviceImageFormatProperties,
+    pub get_physical_device_properties: PFN_vkGetPhysicalDeviceProperties,
+    pub get_physical_device_queue_family_properties: PFN_vkGetPhysicalDeviceQueueFamilyProperties,
+    pub get_physical_device_memory_properties: PFN_vkGetPhysicalDeviceMemoryProperties,
+    pub get_device_proc_addr: PFN_vkGetDeviceProcAddr,
+    pub create_device: PFN_vkCreateDevice,
+    pub enumerate_device_extension_properties: PFN_vkEnumerateDeviceExtensionProperties,
+    pub enumerate_device_layer_properties: PFN_vkEnumerateDeviceLayerProperties,
+    pub get_physical_device_sparse_image_format_properties:
+        PFN_vkGetPhysicalDeviceSparseImageFormatProperties,
+}
+unsafe impl Send for InstanceFnV1_0 {}
+unsafe impl Sync for InstanceFnV1_0 {}
+impl InstanceFnV1_0 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            destroy_instance: unsafe {
+                unsafe extern "system" fn destroy_instance(
+                    _instance: Instance,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_instance)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyInstance\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_instance
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            enumerate_physical_devices: unsafe {
+                unsafe extern "system" fn enumerate_physical_devices(
+                    _instance: Instance,
+                    _p_physical_device_count: *mut u32,
+                    _p_physical_devices: *mut PhysicalDevice,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(enumerate_physical_devices)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumeratePhysicalDevices\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    enumerate_physical_devices
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_features: unsafe {
+                unsafe extern "system" fn get_physical_device_features(
+                    _physical_device: PhysicalDevice,
+                    _p_features: *mut PhysicalDeviceFeatures,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_features)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceFeatures\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_features
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_format_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_format_properties(
+                    _physical_device: PhysicalDevice,
+                    _format: Format,
+                    _p_format_properties: *mut FormatProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_format_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceFormatProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_format_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_image_format_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_image_format_properties(
+                    _physical_device: PhysicalDevice,
+                    _format: Format,
+                    _ty: ImageType,
+                    _tiling: ImageTiling,
+                    _usage: ImageUsageFlags,
+                    _flags: ImageCreateFlags,
+                    _p_image_format_properties: *mut ImageFormatProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_image_format_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceImageFormatProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_image_format_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_properties: *mut PhysicalDeviceProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_queue_family_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_queue_family_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_queue_family_property_count: *mut u32,
+                    _p_queue_family_properties: *mut QueueFamilyProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_queue_family_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceQueueFamilyProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_queue_family_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_memory_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_memory_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_memory_properties: *mut PhysicalDeviceMemoryProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_memory_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceMemoryProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_memory_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_proc_addr: unsafe {
+                unsafe extern "system" fn get_device_proc_addr(
+                    _device: Device,
+                    _p_name: *const c_char,
+                ) -> PFN_vkVoidFunction {
+                    panic!(concat!("Unable to load ", stringify!(get_device_proc_addr)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceProcAddr\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_proc_addr
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_device: unsafe {
+                unsafe extern "system" fn create_device(
+                    _physical_device: PhysicalDevice,
+                    _p_create_info: *const DeviceCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_device: *mut Device,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_device)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDevice\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_device
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            enumerate_device_extension_properties: unsafe {
+                unsafe extern "system" fn enumerate_device_extension_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_layer_name: *const c_char,
+                    _p_property_count: *mut u32,
+                    _p_properties: *mut ExtensionProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(enumerate_device_extension_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumerateDeviceExtensionProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    enumerate_device_extension_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            enumerate_device_layer_properties: unsafe {
+                unsafe extern "system" fn enumerate_device_layer_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_property_count: *mut u32,
+                    _p_properties: *mut LayerProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(enumerate_device_layer_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumerateDeviceLayerProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    enumerate_device_layer_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_sparse_image_format_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_sparse_image_format_properties(
+                    _physical_device: PhysicalDevice,
+                    _format: Format,
+                    _ty: ImageType,
+                    _samples: SampleCountFlags,
+                    _usage: ImageUsageFlags,
+                    _tiling: ImageTiling,
+                    _p_property_count: *mut u32,
+                    _p_properties: *mut SparseImageFormatProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_sparse_image_format_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceSparseImageFormatProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_sparse_image_format_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyDevice =
+    unsafe extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceQueue = unsafe extern "system" fn(
+    device: Device,
+    queue_family_index: u32,
+    queue_index: u32,
+    p_queue: *mut Queue,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkQueueSubmit = unsafe extern "system" fn(
+    queue: Queue,
+    submit_count: u32,
+    p_submits: *const SubmitInfo,
+    fence: Fence,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkQueueWaitIdle = unsafe extern "system" fn(queue: Queue) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDeviceWaitIdle = unsafe extern "system" fn(device: Device) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkAllocateMemory = unsafe extern "system" fn(
+    device: Device,
+    p_allocate_info: *const MemoryAllocateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_memory: *mut DeviceMemory,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkFreeMemory = unsafe extern "system" fn(
+    device: Device,
+    memory: DeviceMemory,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkMapMemory = unsafe extern "system" fn(
+    device: Device,
+    memory: DeviceMemory,
+    offset: DeviceSize,
+    size: DeviceSize,
+    flags: MemoryMapFlags,
+    pp_data: *mut *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkUnmapMemory = unsafe extern "system" fn(device: Device, memory: DeviceMemory);
+#[allow(non_camel_case_types)]
+pub type PFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn(
+    device: Device,
+    memory_range_count: u32,
+    p_memory_ranges: *const MappedMemoryRange,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn(
+    device: Device,
+    memory_range_count: u32,
+    p_memory_ranges: *const MappedMemoryRange,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn(
+    device: Device,
+    memory: DeviceMemory,
+    p_committed_memory_in_bytes: *mut DeviceSize,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkBindBufferMemory = unsafe extern "system" fn(
+    device: Device,
+    buffer: Buffer,
+    memory: DeviceMemory,
+    memory_offset: DeviceSize,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkBindImageMemory = unsafe extern "system" fn(
+    device: Device,
+    image: Image,
+    memory: DeviceMemory,
+    memory_offset: DeviceSize,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn(
+    device: Device,
+    buffer: Buffer,
+    p_memory_requirements: *mut MemoryRequirements,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetImageMemoryRequirements = unsafe extern "system" fn(
+    device: Device,
+    image: Image,
+    p_memory_requirements: *mut MemoryRequirements,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn(
+    device: Device,
+    image: Image,
+    p_sparse_memory_requirement_count: *mut u32,
+    p_sparse_memory_requirements: *mut SparseImageMemoryRequirements,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkQueueBindSparse = unsafe extern "system" fn(
+    queue: Queue,
+    bind_info_count: u32,
+    p_bind_info: *const BindSparseInfo,
+    fence: Fence,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateFence = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const FenceCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_fence: *mut Fence,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyFence = unsafe extern "system" fn(
+    device: Device,
+    fence: Fence,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkResetFences =
+    unsafe extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetFenceStatus = unsafe extern "system" fn(device: Device, fence: Fence) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkWaitForFences = unsafe extern "system" fn(
+    device: Device,
+    fence_count: u32,
+    p_fences: *const Fence,
+    wait_all: Bool32,
+    timeout: u64,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateSemaphore = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const SemaphoreCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_semaphore: *mut Semaphore,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroySemaphore = unsafe extern "system" fn(
+    device: Device,
+    semaphore: Semaphore,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateEvent = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const EventCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_event: *mut Event,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyEvent = unsafe extern "system" fn(
+    device: Device,
+    event: Event,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetEventStatus = unsafe extern "system" fn(device: Device, event: Event) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkSetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkResetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateQueryPool = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const QueryPoolCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_query_pool: *mut QueryPool,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyQueryPool = unsafe extern "system" fn(
+    device: Device,
+    query_pool: QueryPool,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetQueryPoolResults = unsafe extern "system" fn(
+    device: Device,
+    query_pool: QueryPool,
+    first_query: u32,
+    query_count: u32,
+    data_size: usize,
+    p_data: *mut c_void,
+    stride: DeviceSize,
+    flags: QueryResultFlags,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateBuffer = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const BufferCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_buffer: *mut Buffer,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyBuffer = unsafe extern "system" fn(
+    device: Device,
+    buffer: Buffer,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateBufferView = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const BufferViewCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_view: *mut BufferView,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyBufferView = unsafe extern "system" fn(
+    device: Device,
+    buffer_view: BufferView,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateImage = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const ImageCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_image: *mut Image,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyImage = unsafe extern "system" fn(
+    device: Device,
+    image: Image,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetImageSubresourceLayout = unsafe extern "system" fn(
+    device: Device,
+    image: Image,
+    p_subresource: *const ImageSubresource,
+    p_layout: *mut SubresourceLayout,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateImageView = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const ImageViewCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_view: *mut ImageView,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyImageView = unsafe extern "system" fn(
+    device: Device,
+    image_view: ImageView,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateShaderModule = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const ShaderModuleCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_shader_module: *mut ShaderModule,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyShaderModule = unsafe extern "system" fn(
+    device: Device,
+    shader_module: ShaderModule,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreatePipelineCache = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const PipelineCacheCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_pipeline_cache: *mut PipelineCache,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyPipelineCache = unsafe extern "system" fn(
+    device: Device,
+    pipeline_cache: PipelineCache,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetPipelineCacheData = unsafe extern "system" fn(
+    device: Device,
+    pipeline_cache: PipelineCache,
+    p_data_size: *mut usize,
+    p_data: *mut c_void,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkMergePipelineCaches = unsafe extern "system" fn(
+    device: Device,
+    dst_cache: PipelineCache,
+    src_cache_count: u32,
+    p_src_caches: *const PipelineCache,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateGraphicsPipelines = unsafe extern "system" fn(
+    device: Device,
+    pipeline_cache: PipelineCache,
+    create_info_count: u32,
+    p_create_infos: *const GraphicsPipelineCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_pipelines: *mut Pipeline,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateComputePipelines = unsafe extern "system" fn(
+    device: Device,
+    pipeline_cache: PipelineCache,
+    create_info_count: u32,
+    p_create_infos: *const ComputePipelineCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_pipelines: *mut Pipeline,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyPipeline = unsafe extern "system" fn(
+    device: Device,
+    pipeline: Pipeline,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreatePipelineLayout = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const PipelineLayoutCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_pipeline_layout: *mut PipelineLayout,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyPipelineLayout = unsafe extern "system" fn(
+    device: Device,
+    pipeline_layout: PipelineLayout,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateSampler = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const SamplerCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_sampler: *mut Sampler,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroySampler = unsafe extern "system" fn(
+    device: Device,
+    sampler: Sampler,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const DescriptorSetLayoutCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_set_layout: *mut DescriptorSetLayout,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn(
+    device: Device,
+    descriptor_set_layout: DescriptorSetLayout,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateDescriptorPool = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const DescriptorPoolCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_descriptor_pool: *mut DescriptorPool,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyDescriptorPool = unsafe extern "system" fn(
+    device: Device,
+    descriptor_pool: DescriptorPool,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkResetDescriptorPool = unsafe extern "system" fn(
+    device: Device,
+    descriptor_pool: DescriptorPool,
+    flags: DescriptorPoolResetFlags,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkAllocateDescriptorSets = unsafe extern "system" fn(
+    device: Device,
+    p_allocate_info: *const DescriptorSetAllocateInfo,
+    p_descriptor_sets: *mut DescriptorSet,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkFreeDescriptorSets = unsafe extern "system" fn(
+    device: Device,
+    descriptor_pool: DescriptorPool,
+    descriptor_set_count: u32,
+    p_descriptor_sets: *const DescriptorSet,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkUpdateDescriptorSets = unsafe extern "system" fn(
+    device: Device,
+    descriptor_write_count: u32,
+    p_descriptor_writes: *const WriteDescriptorSet,
+    descriptor_copy_count: u32,
+    p_descriptor_copies: *const CopyDescriptorSet,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateFramebuffer = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const FramebufferCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_framebuffer: *mut Framebuffer,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyFramebuffer = unsafe extern "system" fn(
+    device: Device,
+    framebuffer: Framebuffer,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateRenderPass = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const RenderPassCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_render_pass: *mut RenderPass,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyRenderPass = unsafe extern "system" fn(
+    device: Device,
+    render_pass: RenderPass,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetRenderAreaGranularity = unsafe extern "system" fn(
+    device: Device,
+    render_pass: RenderPass,
+    p_granularity: *mut Extent2D,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCreateCommandPool = unsafe extern "system" fn(
+    device: Device,
+    p_create_info: *const CommandPoolCreateInfo,
+    p_allocator: *const AllocationCallbacks,
+    p_command_pool: *mut CommandPool,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkDestroyCommandPool = unsafe extern "system" fn(
+    device: Device,
+    command_pool: CommandPool,
+    p_allocator: *const AllocationCallbacks,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkResetCommandPool = unsafe extern "system" fn(
+    device: Device,
+    command_pool: CommandPool,
+    flags: CommandPoolResetFlags,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkAllocateCommandBuffers = unsafe extern "system" fn(
+    device: Device,
+    p_allocate_info: *const CommandBufferAllocateInfo,
+    p_command_buffers: *mut CommandBuffer,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkFreeCommandBuffers = unsafe extern "system" fn(
+    device: Device,
+    command_pool: CommandPool,
+    command_buffer_count: u32,
+    p_command_buffers: *const CommandBuffer,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkBeginCommandBuffer = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    p_begin_info: *const CommandBufferBeginInfo,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkEndCommandBuffer =
+    unsafe extern "system" fn(command_buffer: CommandBuffer) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkResetCommandBuffer = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    flags: CommandBufferResetFlags,
+) -> Result;
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindPipeline = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    pipeline_bind_point: PipelineBindPoint,
+    pipeline: Pipeline,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetViewport = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_viewport: u32,
+    viewport_count: u32,
+    p_viewports: *const Viewport,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetScissor = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_scissor: u32,
+    scissor_count: u32,
+    p_scissors: *const Rect2D,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetLineWidth =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, line_width: f32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDepthBias = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    depth_bias_constant_factor: f32,
+    depth_bias_clamp: f32,
+    depth_bias_slope_factor: f32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetBlendConstants =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4usize]);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetDepthBounds = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    min_depth_bounds: f32,
+    max_depth_bounds: f32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    face_mask: StencilFaceFlags,
+    compare_mask: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    face_mask: StencilFaceFlags,
+    write_mask: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetStencilReference = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    face_mask: StencilFaceFlags,
+    reference: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindDescriptorSets = unsafe extern "system" fn(
+    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,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindIndexBuffer = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    buffer: Buffer,
+    offset: DeviceSize,
+    index_type: IndexType,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBindVertexBuffers = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    first_binding: u32,
+    binding_count: u32,
+    p_buffers: *const Buffer,
+    p_offsets: *const DeviceSize,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDraw = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    vertex_count: u32,
+    instance_count: u32,
+    first_vertex: u32,
+    first_instance: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawIndexed = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    index_count: u32,
+    instance_count: u32,
+    first_index: u32,
+    vertex_offset: i32,
+    first_instance: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawIndirect = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    buffer: Buffer,
+    offset: DeviceSize,
+    draw_count: u32,
+    stride: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    buffer: Buffer,
+    offset: DeviceSize,
+    draw_count: u32,
+    stride: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDispatch = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    group_count_x: u32,
+    group_count_y: u32,
+    group_count_z: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdDispatchIndirect =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyBuffer = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    src_buffer: Buffer,
+    dst_buffer: Buffer,
+    region_count: u32,
+    p_regions: *const BufferCopy,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyImage = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    src_image: Image,
+    src_image_layout: ImageLayout,
+    dst_image: Image,
+    dst_image_layout: ImageLayout,
+    region_count: u32,
+    p_regions: *const ImageCopy,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBlitImage = unsafe extern "system" fn(
+    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,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyBufferToImage = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    src_buffer: Buffer,
+    dst_image: Image,
+    dst_image_layout: ImageLayout,
+    region_count: u32,
+    p_regions: *const BufferImageCopy,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    src_image: Image,
+    src_image_layout: ImageLayout,
+    dst_buffer: Buffer,
+    region_count: u32,
+    p_regions: *const BufferImageCopy,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdUpdateBuffer = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    dst_buffer: Buffer,
+    dst_offset: DeviceSize,
+    data_size: DeviceSize,
+    p_data: *const c_void,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdFillBuffer = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    dst_buffer: Buffer,
+    dst_offset: DeviceSize,
+    size: DeviceSize,
+    data: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdClearColorImage = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    image: Image,
+    image_layout: ImageLayout,
+    p_color: *const ClearColorValue,
+    range_count: u32,
+    p_ranges: *const ImageSubresourceRange,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    image: Image,
+    image_layout: ImageLayout,
+    p_depth_stencil: *const ClearDepthStencilValue,
+    range_count: u32,
+    p_ranges: *const ImageSubresourceRange,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdClearAttachments = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    attachment_count: u32,
+    p_attachments: *const ClearAttachment,
+    rect_count: u32,
+    p_rects: *const ClearRect,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdResolveImage = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    src_image: Image,
+    src_image_layout: ImageLayout,
+    dst_image: Image,
+    dst_image_layout: ImageLayout,
+    region_count: u32,
+    p_regions: *const ImageResolve,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdSetEvent = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    event: Event,
+    stage_mask: PipelineStageFlags,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdResetEvent = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    event: Event,
+    stage_mask: PipelineStageFlags,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdWaitEvents = unsafe extern "system" fn(
+    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,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdPipelineBarrier = unsafe extern "system" fn(
+    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,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBeginQuery = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    query_pool: QueryPool,
+    query: u32,
+    flags: QueryControlFlags,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdEndQuery =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdResetQueryPool = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    query_pool: QueryPool,
+    first_query: u32,
+    query_count: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdWriteTimestamp = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    pipeline_stage: PipelineStageFlags,
+    query_pool: QueryPool,
+    query: u32,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    query_pool: QueryPool,
+    first_query: u32,
+    query_count: u32,
+    dst_buffer: Buffer,
+    dst_offset: DeviceSize,
+    stride: DeviceSize,
+    flags: QueryResultFlags,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdPushConstants = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    layout: PipelineLayout,
+    stage_flags: ShaderStageFlags,
+    offset: u32,
+    size: u32,
+    p_values: *const c_void,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdBeginRenderPass = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    p_render_pass_begin: *const RenderPassBeginInfo,
+    contents: SubpassContents,
+);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdNextSubpass =
+    unsafe extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdEndRenderPass = unsafe extern "system" fn(command_buffer: CommandBuffer);
+#[allow(non_camel_case_types)]
+pub type PFN_vkCmdExecuteCommands = unsafe extern "system" fn(
+    command_buffer: CommandBuffer,
+    command_buffer_count: u32,
+    p_command_buffers: *const CommandBuffer,
+);
+#[derive(Clone)]
+pub struct DeviceFnV1_0 {
+    pub destroy_device: PFN_vkDestroyDevice,
+    pub get_device_queue: PFN_vkGetDeviceQueue,
+    pub queue_submit: PFN_vkQueueSubmit,
+    pub queue_wait_idle: PFN_vkQueueWaitIdle,
+    pub device_wait_idle: PFN_vkDeviceWaitIdle,
+    pub allocate_memory: PFN_vkAllocateMemory,
+    pub free_memory: PFN_vkFreeMemory,
+    pub map_memory: PFN_vkMapMemory,
+    pub unmap_memory: PFN_vkUnmapMemory,
+    pub flush_mapped_memory_ranges: PFN_vkFlushMappedMemoryRanges,
+    pub invalidate_mapped_memory_ranges: PFN_vkInvalidateMappedMemoryRanges,
+    pub get_device_memory_commitment: PFN_vkGetDeviceMemoryCommitment,
+    pub bind_buffer_memory: PFN_vkBindBufferMemory,
+    pub bind_image_memory: PFN_vkBindImageMemory,
+    pub get_buffer_memory_requirements: PFN_vkGetBufferMemoryRequirements,
+    pub get_image_memory_requirements: PFN_vkGetImageMemoryRequirements,
+    pub get_image_sparse_memory_requirements: PFN_vkGetImageSparseMemoryRequirements,
+    pub queue_bind_sparse: PFN_vkQueueBindSparse,
+    pub create_fence: PFN_vkCreateFence,
+    pub destroy_fence: PFN_vkDestroyFence,
+    pub reset_fences: PFN_vkResetFences,
+    pub get_fence_status: PFN_vkGetFenceStatus,
+    pub wait_for_fences: PFN_vkWaitForFences,
+    pub create_semaphore: PFN_vkCreateSemaphore,
+    pub destroy_semaphore: PFN_vkDestroySemaphore,
+    pub create_event: PFN_vkCreateEvent,
+    pub destroy_event: PFN_vkDestroyEvent,
+    pub get_event_status: PFN_vkGetEventStatus,
+    pub set_event: PFN_vkSetEvent,
+    pub reset_event: PFN_vkResetEvent,
+    pub create_query_pool: PFN_vkCreateQueryPool,
+    pub destroy_query_pool: PFN_vkDestroyQueryPool,
+    pub get_query_pool_results: PFN_vkGetQueryPoolResults,
+    pub create_buffer: PFN_vkCreateBuffer,
+    pub destroy_buffer: PFN_vkDestroyBuffer,
+    pub create_buffer_view: PFN_vkCreateBufferView,
+    pub destroy_buffer_view: PFN_vkDestroyBufferView,
+    pub create_image: PFN_vkCreateImage,
+    pub destroy_image: PFN_vkDestroyImage,
+    pub get_image_subresource_layout: PFN_vkGetImageSubresourceLayout,
+    pub create_image_view: PFN_vkCreateImageView,
+    pub destroy_image_view: PFN_vkDestroyImageView,
+    pub create_shader_module: PFN_vkCreateShaderModule,
+    pub destroy_shader_module: PFN_vkDestroyShaderModule,
+    pub create_pipeline_cache: PFN_vkCreatePipelineCache,
+    pub destroy_pipeline_cache: PFN_vkDestroyPipelineCache,
+    pub get_pipeline_cache_data: PFN_vkGetPipelineCacheData,
+    pub merge_pipeline_caches: PFN_vkMergePipelineCaches,
+    pub create_graphics_pipelines: PFN_vkCreateGraphicsPipelines,
+    pub create_compute_pipelines: PFN_vkCreateComputePipelines,
+    pub destroy_pipeline: PFN_vkDestroyPipeline,
+    pub create_pipeline_layout: PFN_vkCreatePipelineLayout,
+    pub destroy_pipeline_layout: PFN_vkDestroyPipelineLayout,
+    pub create_sampler: PFN_vkCreateSampler,
+    pub destroy_sampler: PFN_vkDestroySampler,
+    pub create_descriptor_set_layout: PFN_vkCreateDescriptorSetLayout,
+    pub destroy_descriptor_set_layout: PFN_vkDestroyDescriptorSetLayout,
+    pub create_descriptor_pool: PFN_vkCreateDescriptorPool,
+    pub destroy_descriptor_pool: PFN_vkDestroyDescriptorPool,
+    pub reset_descriptor_pool: PFN_vkResetDescriptorPool,
+    pub allocate_descriptor_sets: PFN_vkAllocateDescriptorSets,
+    pub free_descriptor_sets: PFN_vkFreeDescriptorSets,
+    pub update_descriptor_sets: PFN_vkUpdateDescriptorSets,
+    pub create_framebuffer: PFN_vkCreateFramebuffer,
+    pub destroy_framebuffer: PFN_vkDestroyFramebuffer,
+    pub create_render_pass: PFN_vkCreateRenderPass,
+    pub destroy_render_pass: PFN_vkDestroyRenderPass,
+    pub get_render_area_granularity: PFN_vkGetRenderAreaGranularity,
+    pub create_command_pool: PFN_vkCreateCommandPool,
+    pub destroy_command_pool: PFN_vkDestroyCommandPool,
+    pub reset_command_pool: PFN_vkResetCommandPool,
+    pub allocate_command_buffers: PFN_vkAllocateCommandBuffers,
+    pub free_command_buffers: PFN_vkFreeCommandBuffers,
+    pub begin_command_buffer: PFN_vkBeginCommandBuffer,
+    pub end_command_buffer: PFN_vkEndCommandBuffer,
+    pub reset_command_buffer: PFN_vkResetCommandBuffer,
+    pub cmd_bind_pipeline: PFN_vkCmdBindPipeline,
+    pub cmd_set_viewport: PFN_vkCmdSetViewport,
+    pub cmd_set_scissor: PFN_vkCmdSetScissor,
+    pub cmd_set_line_width: PFN_vkCmdSetLineWidth,
+    pub cmd_set_depth_bias: PFN_vkCmdSetDepthBias,
+    pub cmd_set_blend_constants: PFN_vkCmdSetBlendConstants,
+    pub cmd_set_depth_bounds: PFN_vkCmdSetDepthBounds,
+    pub cmd_set_stencil_compare_mask: PFN_vkCmdSetStencilCompareMask,
+    pub cmd_set_stencil_write_mask: PFN_vkCmdSetStencilWriteMask,
+    pub cmd_set_stencil_reference: PFN_vkCmdSetStencilReference,
+    pub cmd_bind_descriptor_sets: PFN_vkCmdBindDescriptorSets,
+    pub cmd_bind_index_buffer: PFN_vkCmdBindIndexBuffer,
+    pub cmd_bind_vertex_buffers: PFN_vkCmdBindVertexBuffers,
+    pub cmd_draw: PFN_vkCmdDraw,
+    pub cmd_draw_indexed: PFN_vkCmdDrawIndexed,
+    pub cmd_draw_indirect: PFN_vkCmdDrawIndirect,
+    pub cmd_draw_indexed_indirect: PFN_vkCmdDrawIndexedIndirect,
+    pub cmd_dispatch: PFN_vkCmdDispatch,
+    pub cmd_dispatch_indirect: PFN_vkCmdDispatchIndirect,
+    pub cmd_copy_buffer: PFN_vkCmdCopyBuffer,
+    pub cmd_copy_image: PFN_vkCmdCopyImage,
+    pub cmd_blit_image: PFN_vkCmdBlitImage,
+    pub cmd_copy_buffer_to_image: PFN_vkCmdCopyBufferToImage,
+    pub cmd_copy_image_to_buffer: PFN_vkCmdCopyImageToBuffer,
+    pub cmd_update_buffer: PFN_vkCmdUpdateBuffer,
+    pub cmd_fill_buffer: PFN_vkCmdFillBuffer,
+    pub cmd_clear_color_image: PFN_vkCmdClearColorImage,
+    pub cmd_clear_depth_stencil_image: PFN_vkCmdClearDepthStencilImage,
+    pub cmd_clear_attachments: PFN_vkCmdClearAttachments,
+    pub cmd_resolve_image: PFN_vkCmdResolveImage,
+    pub cmd_set_event: PFN_vkCmdSetEvent,
+    pub cmd_reset_event: PFN_vkCmdResetEvent,
+    pub cmd_wait_events: PFN_vkCmdWaitEvents,
+    pub cmd_pipeline_barrier: PFN_vkCmdPipelineBarrier,
+    pub cmd_begin_query: PFN_vkCmdBeginQuery,
+    pub cmd_end_query: PFN_vkCmdEndQuery,
+    pub cmd_reset_query_pool: PFN_vkCmdResetQueryPool,
+    pub cmd_write_timestamp: PFN_vkCmdWriteTimestamp,
+    pub cmd_copy_query_pool_results: PFN_vkCmdCopyQueryPoolResults,
+    pub cmd_push_constants: PFN_vkCmdPushConstants,
+    pub cmd_begin_render_pass: PFN_vkCmdBeginRenderPass,
+    pub cmd_next_subpass: PFN_vkCmdNextSubpass,
+    pub cmd_end_render_pass: PFN_vkCmdEndRenderPass,
+    pub cmd_execute_commands: PFN_vkCmdExecuteCommands,
+}
+unsafe impl Send for DeviceFnV1_0 {}
+unsafe impl Sync for DeviceFnV1_0 {}
+impl DeviceFnV1_0 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            destroy_device: unsafe {
+                unsafe extern "system" fn destroy_device(
+                    _device: Device,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_device)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDevice\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_device
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_queue: unsafe {
+                unsafe extern "system" fn get_device_queue(
+                    _device: Device,
+                    _queue_family_index: u32,
+                    _queue_index: u32,
+                    _p_queue: *mut Queue,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(get_device_queue)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_queue
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            queue_submit: unsafe {
+                unsafe extern "system" fn queue_submit(
+                    _queue: Queue,
+                    _submit_count: u32,
+                    _p_submits: *const SubmitInfo,
+                    _fence: Fence,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(queue_submit)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    queue_submit
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            queue_wait_idle: unsafe {
+                unsafe extern "system" fn queue_wait_idle(_queue: Queue) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(queue_wait_idle)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueWaitIdle\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    queue_wait_idle
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            device_wait_idle: unsafe {
+                unsafe extern "system" fn device_wait_idle(_device: Device) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(device_wait_idle)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDeviceWaitIdle\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    device_wait_idle
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            allocate_memory: unsafe {
+                unsafe extern "system" fn allocate_memory(
+                    _device: Device,
+                    _p_allocate_info: *const MemoryAllocateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_memory: *mut DeviceMemory,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(allocate_memory)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateMemory\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    allocate_memory
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            free_memory: unsafe {
+                unsafe extern "system" fn free_memory(
+                    _device: Device,
+                    _memory: DeviceMemory,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(free_memory)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeMemory\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    free_memory
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            map_memory: unsafe {
+                unsafe extern "system" fn map_memory(
+                    _device: Device,
+                    _memory: DeviceMemory,
+                    _offset: DeviceSize,
+                    _size: DeviceSize,
+                    _flags: MemoryMapFlags,
+                    _pp_data: *mut *mut c_void,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(map_memory)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    map_memory
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            unmap_memory: unsafe {
+                unsafe extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) {
+                    panic!(concat!("Unable to load ", stringify!(unmap_memory)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    unmap_memory
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            flush_mapped_memory_ranges: unsafe {
+                unsafe extern "system" fn flush_mapped_memory_ranges(
+                    _device: Device,
+                    _memory_range_count: u32,
+                    _p_memory_ranges: *const MappedMemoryRange,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(flush_mapped_memory_ranges)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFlushMappedMemoryRanges\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    flush_mapped_memory_ranges
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            invalidate_mapped_memory_ranges: unsafe {
+                unsafe extern "system" fn invalidate_mapped_memory_ranges(
+                    _device: Device,
+                    _memory_range_count: u32,
+                    _p_memory_ranges: *const MappedMemoryRange,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(invalidate_mapped_memory_ranges)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkInvalidateMappedMemoryRanges\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    invalidate_mapped_memory_ranges
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_memory_commitment: unsafe {
+                unsafe extern "system" fn get_device_memory_commitment(
+                    _device: Device,
+                    _memory: DeviceMemory,
+                    _p_committed_memory_in_bytes: *mut DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_memory_commitment)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceMemoryCommitment\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_memory_commitment
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            bind_buffer_memory: unsafe {
+                unsafe extern "system" fn bind_buffer_memory(
+                    _device: Device,
+                    _buffer: Buffer,
+                    _memory: DeviceMemory,
+                    _memory_offset: DeviceSize,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(bind_buffer_memory)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    bind_buffer_memory
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            bind_image_memory: unsafe {
+                unsafe extern "system" fn bind_image_memory(
+                    _device: Device,
+                    _image: Image,
+                    _memory: DeviceMemory,
+                    _memory_offset: DeviceSize,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(bind_image_memory)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    bind_image_memory
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_buffer_memory_requirements: unsafe {
+                unsafe extern "system" fn get_buffer_memory_requirements(
+                    _device: Device,
+                    _buffer: Buffer,
+                    _p_memory_requirements: *mut MemoryRequirements,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_buffer_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetBufferMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_buffer_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_image_memory_requirements: unsafe {
+                unsafe extern "system" fn get_image_memory_requirements(
+                    _device: Device,
+                    _image: Image,
+                    _p_memory_requirements: *mut MemoryRequirements,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_image_sparse_memory_requirements: unsafe {
+                unsafe extern "system" fn get_image_sparse_memory_requirements(
+                    _device: Device,
+                    _image: Image,
+                    _p_sparse_memory_requirement_count: *mut u32,
+                    _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_sparse_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageSparseMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_sparse_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            queue_bind_sparse: unsafe {
+                unsafe extern "system" fn queue_bind_sparse(
+                    _queue: Queue,
+                    _bind_info_count: u32,
+                    _p_bind_info: *const BindSparseInfo,
+                    _fence: Fence,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(queue_bind_sparse)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueBindSparse\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    queue_bind_sparse
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_fence: unsafe {
+                unsafe extern "system" fn create_fence(
+                    _device: Device,
+                    _p_create_info: *const FenceCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_fence: *mut Fence,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_fence)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFence\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_fence
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_fence: unsafe {
+                unsafe extern "system" fn destroy_fence(
+                    _device: Device,
+                    _fence: Fence,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_fence)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFence\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_fence
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            reset_fences: unsafe {
+                unsafe extern "system" fn reset_fences(
+                    _device: Device,
+                    _fence_count: u32,
+                    _p_fences: *const Fence,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(reset_fences)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetFences\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    reset_fences
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_fence_status: unsafe {
+                unsafe extern "system" fn get_fence_status(
+                    _device: Device,
+                    _fence: Fence,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(get_fence_status)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceStatus\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_fence_status
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            wait_for_fences: unsafe {
+                unsafe extern "system" fn wait_for_fences(
+                    _device: Device,
+                    _fence_count: u32,
+                    _p_fences: *const Fence,
+                    _wait_all: Bool32,
+                    _timeout: u64,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(wait_for_fences)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForFences\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    wait_for_fences
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_semaphore: unsafe {
+                unsafe extern "system" fn create_semaphore(
+                    _device: Device,
+                    _p_create_info: *const SemaphoreCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_semaphore: *mut Semaphore,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_semaphore)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSemaphore\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_semaphore
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_semaphore: unsafe {
+                unsafe extern "system" fn destroy_semaphore(
+                    _device: Device,
+                    _semaphore: Semaphore,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_semaphore)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySemaphore\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_semaphore
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_event: unsafe {
+                unsafe extern "system" fn create_event(
+                    _device: Device,
+                    _p_create_info: *const EventCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_event: *mut Event,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_event)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateEvent\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_event
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_event: unsafe {
+                unsafe extern "system" fn destroy_event(
+                    _device: Device,
+                    _event: Event,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_event)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyEvent\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_event
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_event_status: unsafe {
+                unsafe extern "system" fn get_event_status(
+                    _device: Device,
+                    _event: Event,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(get_event_status)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetEventStatus\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_event_status
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            set_event: unsafe {
+                unsafe extern "system" fn set_event(_device: Device, _event: Event) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(set_event)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetEvent\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    set_event
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            reset_event: unsafe {
+                unsafe extern "system" fn reset_event(_device: Device, _event: Event) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(reset_event)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetEvent\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    reset_event
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_query_pool: unsafe {
+                unsafe extern "system" fn create_query_pool(
+                    _device: Device,
+                    _p_create_info: *const QueryPoolCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_query_pool: *mut QueryPool,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_query_pool)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateQueryPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_query_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_query_pool: unsafe {
+                unsafe extern "system" fn destroy_query_pool(
+                    _device: Device,
+                    _query_pool: QueryPool,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_query_pool)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyQueryPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_query_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_query_pool_results: unsafe {
+                unsafe extern "system" fn get_query_pool_results(
+                    _device: Device,
+                    _query_pool: QueryPool,
+                    _first_query: u32,
+                    _query_count: u32,
+                    _data_size: usize,
+                    _p_data: *mut c_void,
+                    _stride: DeviceSize,
+                    _flags: QueryResultFlags,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_query_pool_results)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetQueryPoolResults\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_query_pool_results
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_buffer: unsafe {
+                unsafe extern "system" fn create_buffer(
+                    _device: Device,
+                    _p_create_info: *const BufferCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_buffer: *mut Buffer,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_buffer)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_buffer: unsafe {
+                unsafe extern "system" fn destroy_buffer(
+                    _device: Device,
+                    _buffer: Buffer,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_buffer)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_buffer_view: unsafe {
+                unsafe extern "system" fn create_buffer_view(
+                    _device: Device,
+                    _p_create_info: *const BufferViewCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_view: *mut BufferView,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_buffer_view)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBufferView\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_buffer_view
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_buffer_view: unsafe {
+                unsafe extern "system" fn destroy_buffer_view(
+                    _device: Device,
+                    _buffer_view: BufferView,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_buffer_view)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBufferView\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_buffer_view
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_image: unsafe {
+                unsafe extern "system" fn create_image(
+                    _device: Device,
+                    _p_create_info: *const ImageCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_image: *mut Image,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_image)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImage\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_image: unsafe {
+                unsafe extern "system" fn destroy_image(
+                    _device: Device,
+                    _image: Image,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_image)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImage\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_image_subresource_layout: unsafe {
+                unsafe extern "system" fn get_image_subresource_layout(
+                    _device: Device,
+                    _image: Image,
+                    _p_subresource: *const ImageSubresource,
+                    _p_layout: *mut SubresourceLayout,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_subresource_layout)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageSubresourceLayout\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_subresource_layout
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_image_view: unsafe {
+                unsafe extern "system" fn create_image_view(
+                    _device: Device,
+                    _p_create_info: *const ImageViewCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_view: *mut ImageView,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_image_view)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImageView\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_image_view
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_image_view: unsafe {
+                unsafe extern "system" fn destroy_image_view(
+                    _device: Device,
+                    _image_view: ImageView,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_image_view)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImageView\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_image_view
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_shader_module: unsafe {
+                unsafe extern "system" fn create_shader_module(
+                    _device: Device,
+                    _p_create_info: *const ShaderModuleCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_shader_module: *mut ShaderModule,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_shader_module)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShaderModule\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_shader_module
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_shader_module: unsafe {
+                unsafe extern "system" fn destroy_shader_module(
+                    _device: Device,
+                    _shader_module: ShaderModule,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_shader_module)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderModule\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_shader_module
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_pipeline_cache: unsafe {
+                unsafe extern "system" fn create_pipeline_cache(
+                    _device: Device,
+                    _p_create_info: *const PipelineCacheCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_pipeline_cache: *mut PipelineCache,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_pipeline_cache)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineCache\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_pipeline_cache
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_pipeline_cache: unsafe {
+                unsafe extern "system" fn destroy_pipeline_cache(
+                    _device: Device,
+                    _pipeline_cache: PipelineCache,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_pipeline_cache)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineCache\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_pipeline_cache
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_pipeline_cache_data: unsafe {
+                unsafe extern "system" fn get_pipeline_cache_data(
+                    _device: Device,
+                    _pipeline_cache: PipelineCache,
+                    _p_data_size: *mut usize,
+                    _p_data: *mut c_void,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_pipeline_cache_data)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPipelineCacheData\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_pipeline_cache_data
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            merge_pipeline_caches: unsafe {
+                unsafe extern "system" fn merge_pipeline_caches(
+                    _device: Device,
+                    _dst_cache: PipelineCache,
+                    _src_cache_count: u32,
+                    _p_src_caches: *const PipelineCache,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(merge_pipeline_caches)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMergePipelineCaches\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    merge_pipeline_caches
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_graphics_pipelines: unsafe {
+                unsafe extern "system" fn create_graphics_pipelines(
+                    _device: Device,
+                    _pipeline_cache: PipelineCache,
+                    _create_info_count: u32,
+                    _p_create_infos: *const GraphicsPipelineCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_pipelines: *mut Pipeline,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_graphics_pipelines)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGraphicsPipelines\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_graphics_pipelines
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_compute_pipelines: unsafe {
+                unsafe extern "system" fn create_compute_pipelines(
+                    _device: Device,
+                    _pipeline_cache: PipelineCache,
+                    _create_info_count: u32,
+                    _p_create_infos: *const ComputePipelineCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_pipelines: *mut Pipeline,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_compute_pipelines)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateComputePipelines\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_compute_pipelines
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_pipeline: unsafe {
+                unsafe extern "system" fn destroy_pipeline(
+                    _device: Device,
+                    _pipeline: Pipeline,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_pipeline)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipeline\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_pipeline
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_pipeline_layout: unsafe {
+                unsafe extern "system" fn create_pipeline_layout(
+                    _device: Device,
+                    _p_create_info: *const PipelineLayoutCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_pipeline_layout: *mut PipelineLayout,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_pipeline_layout)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineLayout\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_pipeline_layout
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_pipeline_layout: unsafe {
+                unsafe extern "system" fn destroy_pipeline_layout(
+                    _device: Device,
+                    _pipeline_layout: PipelineLayout,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_pipeline_layout)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineLayout\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_pipeline_layout
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_sampler: unsafe {
+                unsafe extern "system" fn create_sampler(
+                    _device: Device,
+                    _p_create_info: *const SamplerCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_sampler: *mut Sampler,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_sampler)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSampler\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_sampler
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_sampler: unsafe {
+                unsafe extern "system" fn destroy_sampler(
+                    _device: Device,
+                    _sampler: Sampler,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_sampler)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySampler\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_sampler
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_descriptor_set_layout: unsafe {
+                unsafe extern "system" fn create_descriptor_set_layout(
+                    _device: Device,
+                    _p_create_info: *const DescriptorSetLayoutCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_set_layout: *mut DescriptorSetLayout,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_descriptor_set_layout)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCreateDescriptorSetLayout\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    create_descriptor_set_layout
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_descriptor_set_layout: unsafe {
+                unsafe extern "system" fn destroy_descriptor_set_layout(
+                    _device: Device,
+                    _descriptor_set_layout: DescriptorSetLayout,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_descriptor_set_layout)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkDestroyDescriptorSetLayout\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_descriptor_set_layout
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_descriptor_pool: unsafe {
+                unsafe extern "system" fn create_descriptor_pool(
+                    _device: Device,
+                    _p_create_info: *const DescriptorPoolCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_descriptor_pool: *mut DescriptorPool,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_descriptor_pool)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDescriptorPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_descriptor_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_descriptor_pool: unsafe {
+                unsafe extern "system" fn destroy_descriptor_pool(
+                    _device: Device,
+                    _descriptor_pool: DescriptorPool,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_descriptor_pool)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDescriptorPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_descriptor_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            reset_descriptor_pool: unsafe {
+                unsafe extern "system" fn reset_descriptor_pool(
+                    _device: Device,
+                    _descriptor_pool: DescriptorPool,
+                    _flags: DescriptorPoolResetFlags,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(reset_descriptor_pool)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetDescriptorPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    reset_descriptor_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            allocate_descriptor_sets: unsafe {
+                unsafe extern "system" fn allocate_descriptor_sets(
+                    _device: Device,
+                    _p_allocate_info: *const DescriptorSetAllocateInfo,
+                    _p_descriptor_sets: *mut DescriptorSet,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(allocate_descriptor_sets)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateDescriptorSets\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    allocate_descriptor_sets
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            free_descriptor_sets: unsafe {
+                unsafe extern "system" fn free_descriptor_sets(
+                    _device: Device,
+                    _descriptor_pool: DescriptorPool,
+                    _descriptor_set_count: u32,
+                    _p_descriptor_sets: *const DescriptorSet,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(free_descriptor_sets)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeDescriptorSets\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    free_descriptor_sets
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            update_descriptor_sets: unsafe {
+                unsafe extern "system" fn update_descriptor_sets(
+                    _device: Device,
+                    _descriptor_write_count: u32,
+                    _p_descriptor_writes: *const WriteDescriptorSet,
+                    _descriptor_copy_count: u32,
+                    _p_descriptor_copies: *const CopyDescriptorSet,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(update_descriptor_sets)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUpdateDescriptorSets\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    update_descriptor_sets
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_framebuffer: unsafe {
+                unsafe extern "system" fn create_framebuffer(
+                    _device: Device,
+                    _p_create_info: *const FramebufferCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_framebuffer: *mut Framebuffer,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_framebuffer)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFramebuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_framebuffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_framebuffer: unsafe {
+                unsafe extern "system" fn destroy_framebuffer(
+                    _device: Device,
+                    _framebuffer: Framebuffer,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_framebuffer)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFramebuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_framebuffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_render_pass: unsafe {
+                unsafe extern "system" fn create_render_pass(
+                    _device: Device,
+                    _p_create_info: *const RenderPassCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_render_pass: *mut RenderPass,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_render_pass)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_render_pass
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_render_pass: unsafe {
+                unsafe extern "system" fn destroy_render_pass(
+                    _device: Device,
+                    _render_pass: RenderPass,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_render_pass)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyRenderPass\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_render_pass
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_render_area_granularity: unsafe {
+                unsafe extern "system" fn get_render_area_granularity(
+                    _device: Device,
+                    _render_pass: RenderPass,
+                    _p_granularity: *mut Extent2D,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_render_area_granularity)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetRenderAreaGranularity\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_render_area_granularity
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_command_pool: unsafe {
+                unsafe extern "system" fn create_command_pool(
+                    _device: Device,
+                    _p_create_info: *const CommandPoolCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_command_pool: *mut CommandPool,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_command_pool)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCommandPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_command_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_command_pool: unsafe {
+                unsafe extern "system" fn destroy_command_pool(
+                    _device: Device,
+                    _command_pool: CommandPool,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(destroy_command_pool)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCommandPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_command_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            reset_command_pool: unsafe {
+                unsafe extern "system" fn reset_command_pool(
+                    _device: Device,
+                    _command_pool: CommandPool,
+                    _flags: CommandPoolResetFlags,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(reset_command_pool)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    reset_command_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            allocate_command_buffers: unsafe {
+                unsafe extern "system" fn allocate_command_buffers(
+                    _device: Device,
+                    _p_allocate_info: *const CommandBufferAllocateInfo,
+                    _p_command_buffers: *mut CommandBuffer,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(allocate_command_buffers)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateCommandBuffers\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    allocate_command_buffers
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            free_command_buffers: unsafe {
+                unsafe extern "system" fn free_command_buffers(
+                    _device: Device,
+                    _command_pool: CommandPool,
+                    _command_buffer_count: u32,
+                    _p_command_buffers: *const CommandBuffer,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(free_command_buffers)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeCommandBuffers\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    free_command_buffers
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            begin_command_buffer: unsafe {
+                unsafe extern "system" fn begin_command_buffer(
+                    _command_buffer: CommandBuffer,
+                    _p_begin_info: *const CommandBufferBeginInfo,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(begin_command_buffer)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBeginCommandBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    begin_command_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            end_command_buffer: unsafe {
+                unsafe extern "system" fn end_command_buffer(
+                    _command_buffer: CommandBuffer,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(end_command_buffer)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkEndCommandBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    end_command_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            reset_command_buffer: unsafe {
+                unsafe extern "system" fn reset_command_buffer(
+                    _command_buffer: CommandBuffer,
+                    _flags: CommandBufferResetFlags,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(reset_command_buffer)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    reset_command_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_pipeline: unsafe {
+                unsafe extern "system" fn cmd_bind_pipeline(
+                    _command_buffer: CommandBuffer,
+                    _pipeline_bind_point: PipelineBindPoint,
+                    _pipeline: Pipeline,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindPipeline\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_pipeline
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport: unsafe {
+                unsafe extern "system" fn cmd_set_viewport(
+                    _command_buffer: CommandBuffer,
+                    _first_viewport: u32,
+                    _viewport_count: u32,
+                    _p_viewports: *const Viewport,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_viewport)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewport\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_scissor: unsafe {
+                unsafe extern "system" fn cmd_set_scissor(
+                    _command_buffer: CommandBuffer,
+                    _first_scissor: u32,
+                    _scissor_count: u32,
+                    _p_scissors: *const Rect2D,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_scissor)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissor\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_scissor
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_line_width: unsafe {
+                unsafe extern "system" fn cmd_set_line_width(
+                    _command_buffer: CommandBuffer,
+                    _line_width: f32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_line_width)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineWidth\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_line_width
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bias: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bias(
+                    _command_buffer: CommandBuffer,
+                    _depth_bias_constant_factor: f32,
+                    _depth_bias_clamp: f32,
+                    _depth_bias_slope_factor: f32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bias
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_blend_constants: unsafe {
+                unsafe extern "system" fn cmd_set_blend_constants(
+                    _command_buffer: CommandBuffer,
+                    _blend_constants: *const [f32; 4usize],
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_blend_constants)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetBlendConstants\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_blend_constants
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bounds: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bounds(
+                    _command_buffer: CommandBuffer,
+                    _min_depth_bounds: f32,
+                    _max_depth_bounds: f32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBounds\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bounds
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_compare_mask: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_compare_mask(
+                    _command_buffer: CommandBuffer,
+                    _face_mask: StencilFaceFlags,
+                    _compare_mask: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_stencil_compare_mask)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetStencilCompareMask\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_compare_mask
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_write_mask: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_write_mask(
+                    _command_buffer: CommandBuffer,
+                    _face_mask: StencilFaceFlags,
+                    _write_mask: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_stencil_write_mask)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilWriteMask\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_write_mask
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_reference: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_reference(
+                    _command_buffer: CommandBuffer,
+                    _face_mask: StencilFaceFlags,
+                    _reference: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_stencil_reference)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilReference\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_reference
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_descriptor_sets: unsafe {
+                unsafe extern "system" fn cmd_bind_descriptor_sets(
+                    _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,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_descriptor_sets)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorSets\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_descriptor_sets
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_index_buffer: unsafe {
+                unsafe extern "system" fn cmd_bind_index_buffer(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                    _index_type: IndexType,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_index_buffer)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_index_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_vertex_buffers: unsafe {
+                unsafe extern "system" fn cmd_bind_vertex_buffers(
+                    _command_buffer: CommandBuffer,
+                    _first_binding: u32,
+                    _binding_count: u32,
+                    _p_buffers: *const Buffer,
+                    _p_offsets: *const DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_vertex_buffers)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_vertex_buffers
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw: unsafe {
+                unsafe extern "system" fn cmd_draw(
+                    _command_buffer: CommandBuffer,
+                    _vertex_count: u32,
+                    _instance_count: u32,
+                    _first_vertex: u32,
+                    _first_instance: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_draw)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDraw\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw_indexed: unsafe {
+                unsafe extern "system" fn cmd_draw_indexed(
+                    _command_buffer: CommandBuffer,
+                    _index_count: u32,
+                    _instance_count: u32,
+                    _first_index: u32,
+                    _vertex_offset: i32,
+                    _first_instance: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexed\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_indexed
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw_indirect: unsafe {
+                unsafe extern "system" fn cmd_draw_indirect(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                    _draw_count: u32,
+                    _stride: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirect\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_indirect
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw_indexed_indirect: unsafe {
+                unsafe extern "system" fn cmd_draw_indexed_indirect(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                    _draw_count: u32,
+                    _stride: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_indexed_indirect)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexedIndirect\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_indexed_indirect
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_dispatch: unsafe {
+                unsafe extern "system" fn cmd_dispatch(
+                    _command_buffer: CommandBuffer,
+                    _group_count_x: u32,
+                    _group_count_y: u32,
+                    _group_count_z: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_dispatch)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatch\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_dispatch
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_dispatch_indirect: unsafe {
+                unsafe extern "system" fn cmd_dispatch_indirect(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_dispatch_indirect)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchIndirect\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_dispatch_indirect
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_buffer: unsafe {
+                unsafe extern "system" fn cmd_copy_buffer(
+                    _command_buffer: CommandBuffer,
+                    _src_buffer: Buffer,
+                    _dst_buffer: Buffer,
+                    _region_count: u32,
+                    _p_regions: *const BufferCopy,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_image: unsafe {
+                unsafe extern "system" fn cmd_copy_image(
+                    _command_buffer: CommandBuffer,
+                    _src_image: Image,
+                    _src_image_layout: ImageLayout,
+                    _dst_image: Image,
+                    _dst_image_layout: ImageLayout,
+                    _region_count: u32,
+                    _p_regions: *const ImageCopy,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_copy_image)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_blit_image: unsafe {
+                unsafe extern "system" fn cmd_blit_image(
+                    _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,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_blit_image)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_blit_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_buffer_to_image: unsafe {
+                unsafe extern "system" fn cmd_copy_buffer_to_image(
+                    _command_buffer: CommandBuffer,
+                    _src_buffer: Buffer,
+                    _dst_image: Image,
+                    _dst_image_layout: ImageLayout,
+                    _region_count: u32,
+                    _p_regions: *const BufferImageCopy,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_buffer_to_image)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_buffer_to_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_image_to_buffer: unsafe {
+                unsafe extern "system" fn cmd_copy_image_to_buffer(
+                    _command_buffer: CommandBuffer,
+                    _src_image: Image,
+                    _src_image_layout: ImageLayout,
+                    _dst_buffer: Buffer,
+                    _region_count: u32,
+                    _p_regions: *const BufferImageCopy,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_image_to_buffer)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_image_to_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_update_buffer: unsafe {
+                unsafe extern "system" fn cmd_update_buffer(
+                    _command_buffer: CommandBuffer,
+                    _dst_buffer: Buffer,
+                    _dst_offset: DeviceSize,
+                    _data_size: DeviceSize,
+                    _p_data: *const c_void,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_update_buffer)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdUpdateBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_update_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_fill_buffer: unsafe {
+                unsafe extern "system" fn cmd_fill_buffer(
+                    _command_buffer: CommandBuffer,
+                    _dst_buffer: Buffer,
+                    _dst_offset: DeviceSize,
+                    _size: DeviceSize,
+                    _data: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdFillBuffer\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_fill_buffer
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_clear_color_image: unsafe {
+                unsafe extern "system" fn cmd_clear_color_image(
+                    _command_buffer: CommandBuffer,
+                    _image: Image,
+                    _image_layout: ImageLayout,
+                    _p_color: *const ClearColorValue,
+                    _range_count: u32,
+                    _p_ranges: *const ImageSubresourceRange,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_clear_color_image)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearColorImage\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_clear_color_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_clear_depth_stencil_image: unsafe {
+                unsafe extern "system" fn cmd_clear_depth_stencil_image(
+                    _command_buffer: CommandBuffer,
+                    _image: Image,
+                    _image_layout: ImageLayout,
+                    _p_depth_stencil: *const ClearDepthStencilValue,
+                    _range_count: u32,
+                    _p_ranges: *const ImageSubresourceRange,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_clear_depth_stencil_image)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdClearDepthStencilImage\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_clear_depth_stencil_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_clear_attachments: unsafe {
+                unsafe extern "system" fn cmd_clear_attachments(
+                    _command_buffer: CommandBuffer,
+                    _attachment_count: u32,
+                    _p_attachments: *const ClearAttachment,
+                    _rect_count: u32,
+                    _p_rects: *const ClearRect,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_clear_attachments)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearAttachments\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_clear_attachments
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_resolve_image: unsafe {
+                unsafe extern "system" fn cmd_resolve_image(
+                    _command_buffer: CommandBuffer,
+                    _src_image: Image,
+                    _src_image_layout: ImageLayout,
+                    _dst_image: Image,
+                    _dst_image_layout: ImageLayout,
+                    _region_count: u32,
+                    _p_regions: *const ImageResolve,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_resolve_image)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_resolve_image
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_event: unsafe {
+                unsafe extern "system" fn cmd_set_event(
+                    _command_buffer: CommandBuffer,
+                    _event: Event,
+                    _stage_mask: PipelineStageFlags,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_event)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_event
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_reset_event: unsafe {
+                unsafe extern "system" fn cmd_reset_event(
+                    _command_buffer: CommandBuffer,
+                    _event: Event,
+                    _stage_mask: PipelineStageFlags,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_reset_event)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_reset_event
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_wait_events: unsafe {
+                unsafe extern "system" fn cmd_wait_events(
+                    _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,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_wait_events)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_wait_events
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_pipeline_barrier: unsafe {
+                unsafe extern "system" fn cmd_pipeline_barrier(
+                    _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,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_pipeline_barrier
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_begin_query: unsafe {
+                unsafe extern "system" fn cmd_begin_query(
+                    _command_buffer: CommandBuffer,
+                    _query_pool: QueryPool,
+                    _query: u32,
+                    _flags: QueryControlFlags,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_begin_query)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQuery\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_begin_query
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_end_query: unsafe {
+                unsafe extern "system" fn cmd_end_query(
+                    _command_buffer: CommandBuffer,
+                    _query_pool: QueryPool,
+                    _query: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_end_query)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQuery\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_end_query
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_reset_query_pool: unsafe {
+                unsafe extern "system" fn cmd_reset_query_pool(
+                    _command_buffer: CommandBuffer,
+                    _query_pool: QueryPool,
+                    _first_query: u32,
+                    _query_count: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetQueryPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_reset_query_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_write_timestamp: unsafe {
+                unsafe extern "system" fn cmd_write_timestamp(
+                    _command_buffer: CommandBuffer,
+                    _pipeline_stage: PipelineStageFlags,
+                    _query_pool: QueryPool,
+                    _query: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_write_timestamp
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_query_pool_results: unsafe {
+                unsafe extern "system" fn cmd_copy_query_pool_results(
+                    _command_buffer: CommandBuffer,
+                    _query_pool: QueryPool,
+                    _first_query: u32,
+                    _query_count: u32,
+                    _dst_buffer: Buffer,
+                    _dst_offset: DeviceSize,
+                    _stride: DeviceSize,
+                    _flags: QueryResultFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_query_pool_results)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyQueryPoolResults\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_query_pool_results
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_push_constants: unsafe {
+                unsafe extern "system" fn cmd_push_constants(
+                    _command_buffer: CommandBuffer,
+                    _layout: PipelineLayout,
+                    _stage_flags: ShaderStageFlags,
+                    _offset: u32,
+                    _size: u32,
+                    _p_values: *const c_void,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_push_constants)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushConstants\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_push_constants
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_begin_render_pass: unsafe {
+                unsafe extern "system" fn cmd_begin_render_pass(
+                    _command_buffer: CommandBuffer,
+                    _p_render_pass_begin: *const RenderPassBeginInfo,
+                    _contents: SubpassContents,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_begin_render_pass)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_begin_render_pass
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_next_subpass: unsafe {
+                unsafe extern "system" fn cmd_next_subpass(
+                    _command_buffer: CommandBuffer,
+                    _contents: SubpassContents,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_next_subpass)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_next_subpass
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_end_render_pass: unsafe {
+                unsafe extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_end_render_pass
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_execute_commands: unsafe {
+                unsafe extern "system" fn cmd_execute_commands(
+                    _command_buffer: CommandBuffer,
+                    _command_buffer_count: u32,
+                    _p_command_buffers: *const CommandBuffer,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_execute_commands)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdExecuteCommands\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_execute_commands
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkEnumerateInstanceVersion =
+    unsafe extern "system" fn(p_api_version: *mut u32) -> Result;
+#[derive(Clone)]
+pub struct EntryFnV1_1 {
+    pub enumerate_instance_version: PFN_vkEnumerateInstanceVersion,
+}
+unsafe impl Send for EntryFnV1_1 {}
+unsafe impl Sync for EntryFnV1_1 {}
+impl EntryFnV1_1 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            enumerate_instance_version: unsafe {
+                unsafe extern "system" fn enumerate_instance_version(
+                    _p_api_version: *mut u32,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(enumerate_instance_version)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumerateInstanceVersion\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    enumerate_instance_version
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[derive(Clone)]
+pub struct InstanceFnV1_1 {
+    pub enumerate_physical_device_groups: crate::vk::PFN_vkEnumeratePhysicalDeviceGroups,
+    pub get_physical_device_features2: crate::vk::PFN_vkGetPhysicalDeviceFeatures2,
+    pub get_physical_device_properties2: crate::vk::PFN_vkGetPhysicalDeviceProperties2,
+    pub get_physical_device_format_properties2: crate::vk::PFN_vkGetPhysicalDeviceFormatProperties2,
+    pub get_physical_device_image_format_properties2:
+        crate::vk::PFN_vkGetPhysicalDeviceImageFormatProperties2,
+    pub get_physical_device_queue_family_properties2:
+        crate::vk::PFN_vkGetPhysicalDeviceQueueFamilyProperties2,
+    pub get_physical_device_memory_properties2: crate::vk::PFN_vkGetPhysicalDeviceMemoryProperties2,
+    pub get_physical_device_sparse_image_format_properties2:
+        crate::vk::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2,
+    pub get_physical_device_external_buffer_properties:
+        crate::vk::PFN_vkGetPhysicalDeviceExternalBufferProperties,
+    pub get_physical_device_external_fence_properties:
+        crate::vk::PFN_vkGetPhysicalDeviceExternalFenceProperties,
+    pub get_physical_device_external_semaphore_properties:
+        crate::vk::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties,
+}
+unsafe impl Send for InstanceFnV1_1 {}
+unsafe impl Sync for InstanceFnV1_1 {}
+impl InstanceFnV1_1 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            enumerate_physical_device_groups: unsafe {
+                unsafe extern "system" fn enumerate_physical_device_groups(
+                    _instance: Instance,
+                    _p_physical_device_group_count: *mut u32,
+                    _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(enumerate_physical_device_groups)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkEnumeratePhysicalDeviceGroups\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    enumerate_physical_device_groups
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_features2: unsafe {
+                unsafe extern "system" fn get_physical_device_features2(
+                    _physical_device: PhysicalDevice,
+                    _p_features: *mut PhysicalDeviceFeatures2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_features2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceFeatures2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_features2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_properties2: unsafe {
+                unsafe extern "system" fn get_physical_device_properties2(
+                    _physical_device: PhysicalDevice,
+                    _p_properties: *mut PhysicalDeviceProperties2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_properties2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceProperties2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_properties2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_format_properties2: unsafe {
+                unsafe extern "system" fn get_physical_device_format_properties2(
+                    _physical_device: PhysicalDevice,
+                    _format: Format,
+                    _p_format_properties: *mut FormatProperties2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_format_properties2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceFormatProperties2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_format_properties2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_image_format_properties2: unsafe {
+                unsafe extern "system" fn get_physical_device_image_format_properties2(
+                    _physical_device: PhysicalDevice,
+                    _p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
+                    _p_image_format_properties: *mut ImageFormatProperties2,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_image_format_properties2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceImageFormatProperties2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_image_format_properties2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_queue_family_properties2: unsafe {
+                unsafe extern "system" fn get_physical_device_queue_family_properties2(
+                    _physical_device: PhysicalDevice,
+                    _p_queue_family_property_count: *mut u32,
+                    _p_queue_family_properties: *mut QueueFamilyProperties2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_queue_family_properties2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceQueueFamilyProperties2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_queue_family_properties2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_memory_properties2: unsafe {
+                unsafe extern "system" fn get_physical_device_memory_properties2(
+                    _physical_device: PhysicalDevice,
+                    _p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_memory_properties2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceMemoryProperties2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_memory_properties2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_sparse_image_format_properties2: unsafe {
+                unsafe extern "system" fn get_physical_device_sparse_image_format_properties2(
+                    _physical_device: PhysicalDevice,
+                    _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
+                    _p_property_count: *mut u32,
+                    _p_properties: *mut SparseImageFormatProperties2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_sparse_image_format_properties2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceSparseImageFormatProperties2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_sparse_image_format_properties2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_external_buffer_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_external_buffer_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
+                    _p_external_buffer_properties: *mut ExternalBufferProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_external_buffer_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceExternalBufferProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_external_buffer_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_external_fence_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_external_fence_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
+                    _p_external_fence_properties: *mut ExternalFenceProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_external_fence_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceExternalFenceProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_external_fence_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_physical_device_external_semaphore_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_external_semaphore_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
+                    _p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_external_semaphore_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceExternalSemaphoreProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_external_semaphore_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[allow(non_camel_case_types)]
+pub type PFN_vkGetDeviceQueue2 = unsafe extern "system" fn(
+    device: Device,
+    p_queue_info: *const DeviceQueueInfo2,
+    p_queue: *mut Queue,
+);
+#[derive(Clone)]
+pub struct DeviceFnV1_1 {
+    pub bind_buffer_memory2: crate::vk::PFN_vkBindBufferMemory2,
+    pub bind_image_memory2: crate::vk::PFN_vkBindImageMemory2,
+    pub get_device_group_peer_memory_features: crate::vk::PFN_vkGetDeviceGroupPeerMemoryFeatures,
+    pub cmd_set_device_mask: crate::vk::PFN_vkCmdSetDeviceMask,
+    pub cmd_dispatch_base: crate::vk::PFN_vkCmdDispatchBase,
+    pub get_image_memory_requirements2: crate::vk::PFN_vkGetImageMemoryRequirements2,
+    pub get_buffer_memory_requirements2: crate::vk::PFN_vkGetBufferMemoryRequirements2,
+    pub get_image_sparse_memory_requirements2: crate::vk::PFN_vkGetImageSparseMemoryRequirements2,
+    pub trim_command_pool: crate::vk::PFN_vkTrimCommandPool,
+    pub get_device_queue2: PFN_vkGetDeviceQueue2,
+    pub create_sampler_ycbcr_conversion: crate::vk::PFN_vkCreateSamplerYcbcrConversion,
+    pub destroy_sampler_ycbcr_conversion: crate::vk::PFN_vkDestroySamplerYcbcrConversion,
+    pub create_descriptor_update_template: crate::vk::PFN_vkCreateDescriptorUpdateTemplate,
+    pub destroy_descriptor_update_template: crate::vk::PFN_vkDestroyDescriptorUpdateTemplate,
+    pub update_descriptor_set_with_template: crate::vk::PFN_vkUpdateDescriptorSetWithTemplate,
+    pub get_descriptor_set_layout_support: crate::vk::PFN_vkGetDescriptorSetLayoutSupport,
+}
+unsafe impl Send for DeviceFnV1_1 {}
+unsafe impl Sync for DeviceFnV1_1 {}
+impl DeviceFnV1_1 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            bind_buffer_memory2: unsafe {
+                unsafe extern "system" fn bind_buffer_memory2(
+                    _device: Device,
+                    _bind_info_count: u32,
+                    _p_bind_infos: *const BindBufferMemoryInfo,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    bind_buffer_memory2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            bind_image_memory2: unsafe {
+                unsafe extern "system" fn bind_image_memory2(
+                    _device: Device,
+                    _bind_info_count: u32,
+                    _p_bind_infos: *const BindImageMemoryInfo,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(bind_image_memory2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    bind_image_memory2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_group_peer_memory_features: unsafe {
+                unsafe extern "system" fn get_device_group_peer_memory_features(
+                    _device: Device,
+                    _heap_index: u32,
+                    _local_device_index: u32,
+                    _remote_device_index: u32,
+                    _p_peer_memory_features: *mut PeerMemoryFeatureFlags,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_group_peer_memory_features)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceGroupPeerMemoryFeatures\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_group_peer_memory_features
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_device_mask: unsafe {
+                unsafe extern "system" fn cmd_set_device_mask(
+                    _command_buffer: CommandBuffer,
+                    _device_mask: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMask\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_device_mask
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_dispatch_base: unsafe {
+                unsafe extern "system" fn cmd_dispatch_base(
+                    _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,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBase\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_dispatch_base
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_image_memory_requirements2: unsafe {
+                unsafe extern "system" fn get_image_memory_requirements2(
+                    _device: Device,
+                    _p_info: *const ImageMemoryRequirementsInfo2,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_memory_requirements2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageMemoryRequirements2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_memory_requirements2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_buffer_memory_requirements2: unsafe {
+                unsafe extern "system" fn get_buffer_memory_requirements2(
+                    _device: Device,
+                    _p_info: *const BufferMemoryRequirementsInfo2,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_buffer_memory_requirements2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetBufferMemoryRequirements2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_buffer_memory_requirements2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_image_sparse_memory_requirements2: unsafe {
+                unsafe extern "system" fn get_image_sparse_memory_requirements2(
+                    _device: Device,
+                    _p_info: *const ImageSparseMemoryRequirementsInfo2,
+                    _p_sparse_memory_requirement_count: *mut u32,
+                    _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_image_sparse_memory_requirements2)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetImageSparseMemoryRequirements2\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_image_sparse_memory_requirements2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            trim_command_pool: unsafe {
+                unsafe extern "system" fn trim_command_pool(
+                    _device: Device,
+                    _command_pool: CommandPool,
+                    _flags: CommandPoolTrimFlags,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(trim_command_pool)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    trim_command_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_queue2: unsafe {
+                unsafe extern "system" fn get_device_queue2(
+                    _device: Device,
+                    _p_queue_info: *const DeviceQueueInfo2,
+                    _p_queue: *mut Queue,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(get_device_queue2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_queue2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_sampler_ycbcr_conversion: unsafe {
+                unsafe extern "system" fn create_sampler_ycbcr_conversion(
+                    _device: Device,
+                    _p_create_info: *const SamplerYcbcrConversionCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_ycbcr_conversion: *mut SamplerYcbcrConversion,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_sampler_ycbcr_conversion)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCreateSamplerYcbcrConversion\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    create_sampler_ycbcr_conversion
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_sampler_ycbcr_conversion: unsafe {
+                unsafe extern "system" fn destroy_sampler_ycbcr_conversion(
+                    _device: Device,
+                    _ycbcr_conversion: SamplerYcbcrConversion,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_sampler_ycbcr_conversion)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkDestroySamplerYcbcrConversion\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_sampler_ycbcr_conversion
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_descriptor_update_template: unsafe {
+                unsafe extern "system" fn create_descriptor_update_template(
+                    _device: Device,
+                    _p_create_info: *const DescriptorUpdateTemplateCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_descriptor_update_template: *mut DescriptorUpdateTemplate,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_descriptor_update_template)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCreateDescriptorUpdateTemplate\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    create_descriptor_update_template
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_descriptor_update_template: unsafe {
+                unsafe extern "system" fn destroy_descriptor_update_template(
+                    _device: Device,
+                    _descriptor_update_template: DescriptorUpdateTemplate,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_descriptor_update_template)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkDestroyDescriptorUpdateTemplate\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_descriptor_update_template
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            update_descriptor_set_with_template: unsafe {
+                unsafe extern "system" fn update_descriptor_set_with_template(
+                    _device: Device,
+                    _descriptor_set: DescriptorSet,
+                    _descriptor_update_template: DescriptorUpdateTemplate,
+                    _p_data: *const c_void,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(update_descriptor_set_with_template)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkUpdateDescriptorSetWithTemplate\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    update_descriptor_set_with_template
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_descriptor_set_layout_support: unsafe {
+                unsafe extern "system" fn get_descriptor_set_layout_support(
+                    _device: Device,
+                    _p_create_info: *const DescriptorSetLayoutCreateInfo,
+                    _p_support: *mut DescriptorSetLayoutSupport,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_descriptor_set_layout_support)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDescriptorSetLayoutSupport\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_descriptor_set_layout_support
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[derive(Clone)]
+pub struct EntryFnV1_2 {}
+unsafe impl Send for EntryFnV1_2 {}
+unsafe impl Sync for EntryFnV1_2 {}
+impl EntryFnV1_2 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[derive(Clone)]
+pub struct InstanceFnV1_2 {}
+unsafe impl Send for InstanceFnV1_2 {}
+unsafe impl Sync for InstanceFnV1_2 {}
+impl InstanceFnV1_2 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[derive(Clone)]
+pub struct DeviceFnV1_2 {
+    pub cmd_draw_indirect_count: crate::vk::PFN_vkCmdDrawIndirectCount,
+    pub cmd_draw_indexed_indirect_count: crate::vk::PFN_vkCmdDrawIndexedIndirectCount,
+    pub create_render_pass2: crate::vk::PFN_vkCreateRenderPass2,
+    pub cmd_begin_render_pass2: crate::vk::PFN_vkCmdBeginRenderPass2,
+    pub cmd_next_subpass2: crate::vk::PFN_vkCmdNextSubpass2,
+    pub cmd_end_render_pass2: crate::vk::PFN_vkCmdEndRenderPass2,
+    pub reset_query_pool: crate::vk::PFN_vkResetQueryPool,
+    pub get_semaphore_counter_value: crate::vk::PFN_vkGetSemaphoreCounterValue,
+    pub wait_semaphores: crate::vk::PFN_vkWaitSemaphores,
+    pub signal_semaphore: crate::vk::PFN_vkSignalSemaphore,
+    pub get_buffer_device_address: crate::vk::PFN_vkGetBufferDeviceAddress,
+    pub get_buffer_opaque_capture_address: crate::vk::PFN_vkGetBufferOpaqueCaptureAddress,
+    pub get_device_memory_opaque_capture_address:
+        crate::vk::PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
+}
+unsafe impl Send for DeviceFnV1_2 {}
+unsafe impl Sync for DeviceFnV1_2 {}
+impl DeviceFnV1_2 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            cmd_draw_indirect_count: unsafe {
+                unsafe extern "system" fn cmd_draw_indirect_count(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                    _count_buffer: Buffer,
+                    _count_buffer_offset: DeviceSize,
+                    _max_draw_count: u32,
+                    _stride: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_indirect_count)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCount\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_indirect_count
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_draw_indexed_indirect_count: unsafe {
+                unsafe extern "system" fn cmd_draw_indexed_indirect_count(
+                    _command_buffer: CommandBuffer,
+                    _buffer: Buffer,
+                    _offset: DeviceSize,
+                    _count_buffer: Buffer,
+                    _count_buffer_offset: DeviceSize,
+                    _max_draw_count: u32,
+                    _stride: u32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_draw_indexed_indirect_count)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdDrawIndexedIndirectCount\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_draw_indexed_indirect_count
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            create_render_pass2: unsafe {
+                unsafe extern "system" fn create_render_pass2(
+                    _device: Device,
+                    _p_create_info: *const RenderPassCreateInfo2,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_render_pass: *mut RenderPass,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(create_render_pass2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_render_pass2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_begin_render_pass2: unsafe {
+                unsafe extern "system" fn cmd_begin_render_pass2(
+                    _command_buffer: CommandBuffer,
+                    _p_render_pass_begin: *const RenderPassBeginInfo,
+                    _p_subpass_begin_info: *const SubpassBeginInfo,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_begin_render_pass2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_begin_render_pass2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_next_subpass2: unsafe {
+                unsafe extern "system" fn cmd_next_subpass2(
+                    _command_buffer: CommandBuffer,
+                    _p_subpass_begin_info: *const SubpassBeginInfo,
+                    _p_subpass_end_info: *const SubpassEndInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_next_subpass2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_next_subpass2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_end_render_pass2: unsafe {
+                unsafe extern "system" fn cmd_end_render_pass2(
+                    _command_buffer: CommandBuffer,
+                    _p_subpass_end_info: *const SubpassEndInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_end_render_pass2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            reset_query_pool: unsafe {
+                unsafe extern "system" fn reset_query_pool(
+                    _device: Device,
+                    _query_pool: QueryPool,
+                    _first_query: u32,
+                    _query_count: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(reset_query_pool)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPool\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    reset_query_pool
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_semaphore_counter_value: unsafe {
+                unsafe extern "system" fn get_semaphore_counter_value(
+                    _device: Device,
+                    _semaphore: Semaphore,
+                    _p_value: *mut u64,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_semaphore_counter_value)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetSemaphoreCounterValue\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_semaphore_counter_value
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            wait_semaphores: unsafe {
+                unsafe extern "system" fn wait_semaphores(
+                    _device: Device,
+                    _p_wait_info: *const SemaphoreWaitInfo,
+                    _timeout: u64,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(wait_semaphores)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphores\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    wait_semaphores
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            signal_semaphore: unsafe {
+                unsafe extern "system" fn signal_semaphore(
+                    _device: Device,
+                    _p_signal_info: *const SemaphoreSignalInfo,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(signal_semaphore)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphore\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    signal_semaphore
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_buffer_device_address: unsafe {
+                unsafe extern "system" fn get_buffer_device_address(
+                    _device: Device,
+                    _p_info: *const BufferDeviceAddressInfo,
+                ) -> DeviceAddress {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_buffer_device_address)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddress\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_buffer_device_address
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_buffer_opaque_capture_address: unsafe {
+                unsafe extern "system" fn get_buffer_opaque_capture_address(
+                    _device: Device,
+                    _p_info: *const BufferDeviceAddressInfo,
+                ) -> u64 {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_buffer_opaque_capture_address)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetBufferOpaqueCaptureAddress\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_buffer_opaque_capture_address
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_memory_opaque_capture_address: unsafe {
+                unsafe extern "system" fn get_device_memory_opaque_capture_address(
+                    _device: Device,
+                    _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
+                ) -> u64 {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_memory_opaque_capture_address)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceMemoryOpaqueCaptureAddress\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_memory_opaque_capture_address
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[derive(Clone)]
+pub struct EntryFnV1_3 {}
+unsafe impl Send for EntryFnV1_3 {}
+unsafe impl Sync for EntryFnV1_3 {}
+impl EntryFnV1_3 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {}
+    }
+}
+#[derive(Clone)]
+pub struct InstanceFnV1_3 {
+    pub get_physical_device_tool_properties: crate::vk::PFN_vkGetPhysicalDeviceToolProperties,
+}
+unsafe impl Send for InstanceFnV1_3 {}
+unsafe impl Sync for InstanceFnV1_3 {}
+impl InstanceFnV1_3 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            get_physical_device_tool_properties: unsafe {
+                unsafe extern "system" fn get_physical_device_tool_properties(
+                    _physical_device: PhysicalDevice,
+                    _p_tool_count: *mut u32,
+                    _p_tool_properties: *mut PhysicalDeviceToolProperties,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_physical_device_tool_properties)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetPhysicalDeviceToolProperties\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_physical_device_tool_properties
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}
+#[derive(Clone)]
+pub struct DeviceFnV1_3 {
+    pub create_private_data_slot: crate::vk::PFN_vkCreatePrivateDataSlot,
+    pub destroy_private_data_slot: crate::vk::PFN_vkDestroyPrivateDataSlot,
+    pub set_private_data: crate::vk::PFN_vkSetPrivateData,
+    pub get_private_data: crate::vk::PFN_vkGetPrivateData,
+    pub cmd_set_event2: crate::vk::PFN_vkCmdSetEvent2,
+    pub cmd_reset_event2: crate::vk::PFN_vkCmdResetEvent2,
+    pub cmd_wait_events2: crate::vk::PFN_vkCmdWaitEvents2,
+    pub cmd_pipeline_barrier2: crate::vk::PFN_vkCmdPipelineBarrier2,
+    pub cmd_write_timestamp2: crate::vk::PFN_vkCmdWriteTimestamp2,
+    pub queue_submit2: crate::vk::PFN_vkQueueSubmit2,
+    pub cmd_copy_buffer2: crate::vk::PFN_vkCmdCopyBuffer2,
+    pub cmd_copy_image2: crate::vk::PFN_vkCmdCopyImage2,
+    pub cmd_copy_buffer_to_image2: crate::vk::PFN_vkCmdCopyBufferToImage2,
+    pub cmd_copy_image_to_buffer2: crate::vk::PFN_vkCmdCopyImageToBuffer2,
+    pub cmd_blit_image2: crate::vk::PFN_vkCmdBlitImage2,
+    pub cmd_resolve_image2: crate::vk::PFN_vkCmdResolveImage2,
+    pub cmd_begin_rendering: crate::vk::PFN_vkCmdBeginRendering,
+    pub cmd_end_rendering: crate::vk::PFN_vkCmdEndRendering,
+    pub cmd_set_cull_mode: crate::vk::PFN_vkCmdSetCullMode,
+    pub cmd_set_front_face: crate::vk::PFN_vkCmdSetFrontFace,
+    pub cmd_set_primitive_topology: crate::vk::PFN_vkCmdSetPrimitiveTopology,
+    pub cmd_set_viewport_with_count: crate::vk::PFN_vkCmdSetViewportWithCount,
+    pub cmd_set_scissor_with_count: crate::vk::PFN_vkCmdSetScissorWithCount,
+    pub cmd_bind_vertex_buffers2: crate::vk::PFN_vkCmdBindVertexBuffers2,
+    pub cmd_set_depth_test_enable: crate::vk::PFN_vkCmdSetDepthTestEnable,
+    pub cmd_set_depth_write_enable: crate::vk::PFN_vkCmdSetDepthWriteEnable,
+    pub cmd_set_depth_compare_op: crate::vk::PFN_vkCmdSetDepthCompareOp,
+    pub cmd_set_depth_bounds_test_enable: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable,
+    pub cmd_set_stencil_test_enable: crate::vk::PFN_vkCmdSetStencilTestEnable,
+    pub cmd_set_stencil_op: crate::vk::PFN_vkCmdSetStencilOp,
+    pub cmd_set_rasterizer_discard_enable: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable,
+    pub cmd_set_depth_bias_enable: crate::vk::PFN_vkCmdSetDepthBiasEnable,
+    pub cmd_set_primitive_restart_enable: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable,
+    pub get_device_buffer_memory_requirements: crate::vk::PFN_vkGetDeviceBufferMemoryRequirements,
+    pub get_device_image_memory_requirements: crate::vk::PFN_vkGetDeviceImageMemoryRequirements,
+    pub get_device_image_sparse_memory_requirements:
+        crate::vk::PFN_vkGetDeviceImageSparseMemoryRequirements,
+}
+unsafe impl Send for DeviceFnV1_3 {}
+unsafe impl Sync for DeviceFnV1_3 {}
+impl DeviceFnV1_3 {
+    pub fn load<F>(mut _f: F) -> Self
+    where
+        F: FnMut(&::std::ffi::CStr) -> *const c_void,
+    {
+        Self {
+            create_private_data_slot: unsafe {
+                unsafe extern "system" fn create_private_data_slot(
+                    _device: Device,
+                    _p_create_info: *const PrivateDataSlotCreateInfo,
+                    _p_allocator: *const AllocationCallbacks,
+                    _p_private_data_slot: *mut PrivateDataSlot,
+                ) -> Result {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(create_private_data_slot)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlot\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    create_private_data_slot
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            destroy_private_data_slot: unsafe {
+                unsafe extern "system" fn destroy_private_data_slot(
+                    _device: Device,
+                    _private_data_slot: PrivateDataSlot,
+                    _p_allocator: *const AllocationCallbacks,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(destroy_private_data_slot)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlot\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    destroy_private_data_slot
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            set_private_data: unsafe {
+                unsafe extern "system" fn set_private_data(
+                    _device: Device,
+                    _object_type: ObjectType,
+                    _object_handle: u64,
+                    _private_data_slot: PrivateDataSlot,
+                    _data: u64,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(set_private_data)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateData\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    set_private_data
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_private_data: unsafe {
+                unsafe extern "system" fn get_private_data(
+                    _device: Device,
+                    _object_type: ObjectType,
+                    _object_handle: u64,
+                    _private_data_slot: PrivateDataSlot,
+                    _p_data: *mut u64,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(get_private_data)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateData\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    get_private_data
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_event2: unsafe {
+                unsafe extern "system" fn cmd_set_event2(
+                    _command_buffer: CommandBuffer,
+                    _event: Event,
+                    _p_dependency_info: *const DependencyInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_event2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_event2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_reset_event2: unsafe {
+                unsafe extern "system" fn cmd_reset_event2(
+                    _command_buffer: CommandBuffer,
+                    _event: Event,
+                    _stage_mask: PipelineStageFlags2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_reset_event2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_reset_event2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_wait_events2: unsafe {
+                unsafe extern "system" fn cmd_wait_events2(
+                    _command_buffer: CommandBuffer,
+                    _event_count: u32,
+                    _p_events: *const Event,
+                    _p_dependency_infos: *const DependencyInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_wait_events2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_wait_events2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_pipeline_barrier2: unsafe {
+                unsafe extern "system" fn cmd_pipeline_barrier2(
+                    _command_buffer: CommandBuffer,
+                    _p_dependency_info: *const DependencyInfo,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_pipeline_barrier2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_pipeline_barrier2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_write_timestamp2: unsafe {
+                unsafe extern "system" fn cmd_write_timestamp2(
+                    _command_buffer: CommandBuffer,
+                    _stage: PipelineStageFlags2,
+                    _query_pool: QueryPool,
+                    _query: u32,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_write_timestamp2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            queue_submit2: unsafe {
+                unsafe extern "system" fn queue_submit2(
+                    _queue: Queue,
+                    _submit_count: u32,
+                    _p_submits: *const SubmitInfo2,
+                    _fence: Fence,
+                ) -> Result {
+                    panic!(concat!("Unable to load ", stringify!(queue_submit2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    queue_submit2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_buffer2: unsafe {
+                unsafe extern "system" fn cmd_copy_buffer2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_buffer_info: *const CopyBufferInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_buffer2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_image2: unsafe {
+                unsafe extern "system" fn cmd_copy_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_image_info: *const CopyImageInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_copy_image2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_buffer_to_image2: unsafe {
+                unsafe extern "system" fn cmd_copy_buffer_to_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_buffer_to_image2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_buffer_to_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_copy_image_to_buffer2: unsafe {
+                unsafe extern "system" fn cmd_copy_image_to_buffer2(
+                    _command_buffer: CommandBuffer,
+                    _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_copy_image_to_buffer2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_copy_image_to_buffer2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_blit_image2: unsafe {
+                unsafe extern "system" fn cmd_blit_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_blit_image_info: *const BlitImageInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_blit_image2)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_blit_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_resolve_image2: unsafe {
+                unsafe extern "system" fn cmd_resolve_image2(
+                    _command_buffer: CommandBuffer,
+                    _p_resolve_image_info: *const ResolveImageInfo2,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_resolve_image2)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_resolve_image2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_begin_rendering: unsafe {
+                unsafe extern "system" fn cmd_begin_rendering(
+                    _command_buffer: CommandBuffer,
+                    _p_rendering_info: *const RenderingInfo,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_begin_rendering)))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRendering\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_begin_rendering
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_end_rendering: unsafe {
+                unsafe extern "system" fn cmd_end_rendering(_command_buffer: CommandBuffer) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_end_rendering)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRendering\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_end_rendering
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_cull_mode: unsafe {
+                unsafe extern "system" fn cmd_set_cull_mode(
+                    _command_buffer: CommandBuffer,
+                    _cull_mode: CullModeFlags,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_cull_mode)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullMode\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_cull_mode
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_front_face: unsafe {
+                unsafe extern "system" fn cmd_set_front_face(
+                    _command_buffer: CommandBuffer,
+                    _front_face: FrontFace,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_front_face)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFace\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_front_face
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_primitive_topology: unsafe {
+                unsafe extern "system" fn cmd_set_primitive_topology(
+                    _command_buffer: CommandBuffer,
+                    _primitive_topology: PrimitiveTopology,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_primitive_topology)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopology\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_primitive_topology
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_viewport_with_count: unsafe {
+                unsafe extern "system" fn cmd_set_viewport_with_count(
+                    _command_buffer: CommandBuffer,
+                    _viewport_count: u32,
+                    _p_viewports: *const Viewport,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_viewport_with_count)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCount\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_viewport_with_count
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_scissor_with_count: unsafe {
+                unsafe extern "system" fn cmd_set_scissor_with_count(
+                    _command_buffer: CommandBuffer,
+                    _scissor_count: u32,
+                    _p_scissors: *const Rect2D,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_scissor_with_count)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCount\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_scissor_with_count
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_bind_vertex_buffers2: unsafe {
+                unsafe extern "system" fn cmd_bind_vertex_buffers2(
+                    _command_buffer: CommandBuffer,
+                    _first_binding: u32,
+                    _binding_count: u32,
+                    _p_buffers: *const Buffer,
+                    _p_offsets: *const DeviceSize,
+                    _p_sizes: *const DeviceSize,
+                    _p_strides: *const DeviceSize,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_bind_vertex_buffers2)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_bind_vertex_buffers2
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_test_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_test_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_test_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_test_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_write_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_write_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_write_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_write_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_write_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_compare_op: unsafe {
+                unsafe extern "system" fn cmd_set_depth_compare_op(
+                    _command_buffer: CommandBuffer,
+                    _depth_compare_op: CompareOp,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_compare_op)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOp\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_compare_op
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bounds_test_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bounds_test_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_bounds_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_bounds_test_enable)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetDepthBoundsTestEnable\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bounds_test_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_test_enable: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_test_enable(
+                    _command_buffer: CommandBuffer,
+                    _stencil_test_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_stencil_test_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_test_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_stencil_op: unsafe {
+                unsafe extern "system" fn cmd_set_stencil_op(
+                    _command_buffer: CommandBuffer,
+                    _face_mask: StencilFaceFlags,
+                    _fail_op: StencilOp,
+                    _pass_op: StencilOp,
+                    _depth_fail_op: StencilOp,
+                    _compare_op: CompareOp,
+                ) {
+                    panic!(concat!("Unable to load ", stringify!(cmd_set_stencil_op)))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOp\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_stencil_op
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_rasterizer_discard_enable: unsafe {
+                unsafe extern "system" fn cmd_set_rasterizer_discard_enable(
+                    _command_buffer: CommandBuffer,
+                    _rasterizer_discard_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_rasterizer_discard_enable)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetRasterizerDiscardEnable\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_rasterizer_discard_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_depth_bias_enable: unsafe {
+                unsafe extern "system" fn cmd_set_depth_bias_enable(
+                    _command_buffer: CommandBuffer,
+                    _depth_bias_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_depth_bias_enable)
+                    ))
+                }
+                let cname =
+                    ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnable\0");
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_depth_bias_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            cmd_set_primitive_restart_enable: unsafe {
+                unsafe extern "system" fn cmd_set_primitive_restart_enable(
+                    _command_buffer: CommandBuffer,
+                    _primitive_restart_enable: Bool32,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(cmd_set_primitive_restart_enable)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkCmdSetPrimitiveRestartEnable\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    cmd_set_primitive_restart_enable
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_buffer_memory_requirements: unsafe {
+                unsafe extern "system" fn get_device_buffer_memory_requirements(
+                    _device: Device,
+                    _p_info: *const DeviceBufferMemoryRequirements,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_buffer_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceBufferMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_buffer_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_image_memory_requirements: unsafe {
+                unsafe extern "system" fn get_device_image_memory_requirements(
+                    _device: Device,
+                    _p_info: *const DeviceImageMemoryRequirements,
+                    _p_memory_requirements: *mut MemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_image_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceImageMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_image_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+            get_device_image_sparse_memory_requirements: unsafe {
+                unsafe extern "system" fn get_device_image_sparse_memory_requirements(
+                    _device: Device,
+                    _p_info: *const DeviceImageMemoryRequirements,
+                    _p_sparse_memory_requirement_count: *mut u32,
+                    _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
+                ) {
+                    panic!(concat!(
+                        "Unable to load ",
+                        stringify!(get_device_image_sparse_memory_requirements)
+                    ))
+                }
+                let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
+                    b"vkGetDeviceImageSparseMemoryRequirements\0",
+                );
+                let val = _f(cname);
+                if val.is_null() {
+                    get_device_image_sparse_memory_requirements
+                } else {
+                    ::std::mem::transmute(val)
+                }
+            },
+        }
+    }
+}