SSL extensions_generated.rs   Sprache: unbekannt

#![allow(unused_imports)]
use crate::vk::*;
use core::ffi::*;
#[doc = "Extensions tagged AMD"]
pub mod amd {
    #[doc = "VK_AMD_rasterization_order"]
    pub mod rasterization_order {
        use super::super::*;
        pub use {
            crate::vk::AMD_RASTERIZATION_ORDER_NAME as NAME,
            crate::vk::AMD_RASTERIZATION_ORDER_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_shader_trinary_minmax"]
    pub mod shader_trinary_minmax {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_TRINARY_MINMAX_NAME as NAME,
            crate::vk::AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_shader_explicit_vertex_parameter"]
    pub mod shader_explicit_vertex_parameter {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_NAME as NAME,
            crate::vk::AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_gcn_shader"]
    pub mod gcn_shader {
        use super::super::*;
        pub use {
            crate::vk::AMD_GCN_SHADER_NAME as NAME,
            crate::vk::AMD_GCN_SHADER_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_draw_indirect_count"]
    pub mod draw_indirect_count {
        use super::super::*;
        pub use {
            crate::vk::AMD_DRAW_INDIRECT_COUNT_NAME as NAME,
            crate::vk::AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_AMD_draw_indirect_count device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_AMD_draw_indirect_count device-level function pointers"]
        pub struct DeviceFn {
            pub cmd_draw_indirect_count_amd: PFN_vkCmdDrawIndirectCount,
            pub cmd_draw_indexed_indirect_count_amd: PFN_vkCmdDrawIndexedIndirectCount,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    cmd_draw_indirect_count_amd: unsafe {
                        unsafe extern "system" fn cmd_draw_indirect_count_amd(
                            _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_amd)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountAMD\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_draw_indirect_count_amd
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_draw_indexed_indirect_count_amd: unsafe {
                        unsafe extern "system" fn cmd_draw_indexed_indirect_count_amd(
                            _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_amd)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCmdDrawIndexedIndirectCountAMD\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_draw_indexed_indirect_count_amd
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_AMD_negative_viewport_height"]
    pub mod negative_viewport_height {
        use super::super::*;
        pub use {
            crate::vk::AMD_NEGATIVE_VIEWPORT_HEIGHT_NAME as NAME,
            crate::vk::AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_gpu_shader_half_float"]
    pub mod gpu_shader_half_float {
        use super::super::*;
        pub use {
            crate::vk::AMD_GPU_SHADER_HALF_FLOAT_NAME as NAME,
            crate::vk::AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_shader_ballot"]
    pub mod shader_ballot {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_BALLOT_NAME as NAME,
            crate::vk::AMD_SHADER_BALLOT_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_texture_gather_bias_lod"]
    pub mod texture_gather_bias_lod {
        use super::super::*;
        pub use {
            crate::vk::AMD_TEXTURE_GATHER_BIAS_LOD_NAME as NAME,
            crate::vk::AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_shader_info"]
    pub mod shader_info {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_INFO_NAME as NAME,
            crate::vk::AMD_SHADER_INFO_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_AMD_shader_info device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_AMD_shader_info device-level function pointers"]
        pub struct DeviceFn {
            pub get_shader_info_amd: PFN_vkGetShaderInfoAMD,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    get_shader_info_amd: unsafe {
                        unsafe extern "system" fn get_shader_info_amd(
                            _device: crate::vk::Device,
                            _pipeline: Pipeline,
                            _shader_stage: ShaderStageFlags,
                            _info_type: ShaderInfoTypeAMD,
                            _p_info_size: *mut usize,
                            _p_info: *mut c_void,
                        ) -> Result {
                            panic!(concat!("Unable to load ", stringify!(get_shader_info_amd)))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetShaderInfoAMD\0");
                        let val = _f(cname);
                        if val.is_null() {
                            get_shader_info_amd
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_AMD_shader_image_load_store_lod"]
    pub mod shader_image_load_store_lod {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_IMAGE_LOAD_STORE_LOD_NAME as NAME,
            crate::vk::AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_gpu_shader_int16"]
    pub mod gpu_shader_int16 {
        use super::super::*;
        pub use {
            crate::vk::AMD_GPU_SHADER_INT16_NAME as NAME,
            crate::vk::AMD_GPU_SHADER_INT16_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_mixed_attachment_samples"]
    pub mod mixed_attachment_samples {
        use super::super::*;
        pub use {
            crate::vk::AMD_MIXED_ATTACHMENT_SAMPLES_NAME as NAME,
            crate::vk::AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_shader_fragment_mask"]
    pub mod shader_fragment_mask {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_FRAGMENT_MASK_NAME as NAME,
            crate::vk::AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_buffer_marker"]
    pub mod buffer_marker {
        use super::super::*;
        pub use {
            crate::vk::AMD_BUFFER_MARKER_NAME as NAME,
            crate::vk::AMD_BUFFER_MARKER_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_AMD_buffer_marker device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_AMD_buffer_marker device-level function pointers"]
        pub struct DeviceFn {
            pub cmd_write_buffer_marker_amd: PFN_vkCmdWriteBufferMarkerAMD,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    cmd_write_buffer_marker_amd: unsafe {
                        unsafe extern "system" fn cmd_write_buffer_marker_amd(
                            _command_buffer: CommandBuffer,
                            _pipeline_stage: PipelineStageFlags,
                            _dst_buffer: Buffer,
                            _dst_offset: DeviceSize,
                            _marker: u32,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_write_buffer_marker_amd)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarkerAMD\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_write_buffer_marker_amd
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_AMD_pipeline_compiler_control"]
    pub mod pipeline_compiler_control {
        use super::super::*;
        pub use {
            crate::vk::AMD_PIPELINE_COMPILER_CONTROL_NAME as NAME,
            crate::vk::AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_shader_core_properties"]
    pub mod shader_core_properties {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_CORE_PROPERTIES_NAME as NAME,
            crate::vk::AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_memory_overallocation_behavior"]
    pub mod memory_overallocation_behavior {
        use super::super::*;
        pub use {
            crate::vk::AMD_MEMORY_OVERALLOCATION_BEHAVIOR_NAME as NAME,
            crate::vk::AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_display_native_hdr"]
    pub mod display_native_hdr {
        use super::super::*;
        pub use {
            crate::vk::AMD_DISPLAY_NATIVE_HDR_NAME as NAME,
            crate::vk::AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_AMD_display_native_hdr device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_AMD_display_native_hdr device-level function pointers"]
        pub struct DeviceFn {
            pub set_local_dimming_amd: PFN_vkSetLocalDimmingAMD,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    set_local_dimming_amd: unsafe {
                        unsafe extern "system" fn set_local_dimming_amd(
                            _device: crate::vk::Device,
                            _swap_chain: SwapchainKHR,
                            _local_dimming_enable: Bool32,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(set_local_dimming_amd)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetLocalDimmingAMD\0");
                        let val = _f(cname);
                        if val.is_null() {
                            set_local_dimming_amd
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_AMD_shader_core_properties2"]
    pub mod shader_core_properties2 {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_CORE_PROPERTIES2_NAME as NAME,
            crate::vk::AMD_SHADER_CORE_PROPERTIES2_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_device_coherent_memory"]
    pub mod device_coherent_memory {
        use super::super::*;
        pub use {
            crate::vk::AMD_DEVICE_COHERENT_MEMORY_NAME as NAME,
            crate::vk::AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_AMD_shader_early_and_late_fragment_tests"]
    pub mod shader_early_and_late_fragment_tests {
        use super::super::*;
        pub use {
            crate::vk::AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_NAME as NAME,
            crate::vk::AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION as SPEC_VERSION,
        };
    }
}
#[doc = "Extensions tagged AMDX"]
pub mod amdx {
    #[doc = "VK_AMDX_shader_enqueue"]
    pub mod shader_enqueue {
        use super::super::*;
        pub use {
            crate::vk::AMDX_SHADER_ENQUEUE_NAME as NAME,
            crate::vk::AMDX_SHADER_ENQUEUE_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_AMDX_shader_enqueue device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_AMDX_shader_enqueue device-level function pointers"]
        pub struct DeviceFn {
            pub create_execution_graph_pipelines_amdx: PFN_vkCreateExecutionGraphPipelinesAMDX,
            pub get_execution_graph_pipeline_scratch_size_amdx:
                PFN_vkGetExecutionGraphPipelineScratchSizeAMDX,
            pub get_execution_graph_pipeline_node_index_amdx:
                PFN_vkGetExecutionGraphPipelineNodeIndexAMDX,
            pub cmd_initialize_graph_scratch_memory_amdx: PFN_vkCmdInitializeGraphScratchMemoryAMDX,
            pub cmd_dispatch_graph_amdx: PFN_vkCmdDispatchGraphAMDX,
            pub cmd_dispatch_graph_indirect_amdx: PFN_vkCmdDispatchGraphIndirectAMDX,
            pub cmd_dispatch_graph_indirect_count_amdx: PFN_vkCmdDispatchGraphIndirectCountAMDX,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    create_execution_graph_pipelines_amdx: unsafe {
                        unsafe extern "system" fn create_execution_graph_pipelines_amdx(
                            _device: crate::vk::Device,
                            _pipeline_cache: PipelineCache,
                            _create_info_count: u32,
                            _p_create_infos: *const ExecutionGraphPipelineCreateInfoAMDX<'_>,
                            _p_allocator: *const AllocationCallbacks<'_>,
                            _p_pipelines: *mut Pipeline,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(create_execution_graph_pipelines_amdx)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCreateExecutionGraphPipelinesAMDX\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            create_execution_graph_pipelines_amdx
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    get_execution_graph_pipeline_scratch_size_amdx: unsafe {
                        unsafe extern "system" fn get_execution_graph_pipeline_scratch_size_amdx(
                            _device: crate::vk::Device,
                            _execution_graph: Pipeline,
                            _p_size_info: *mut ExecutionGraphPipelineScratchSizeAMDX<'_>,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(get_execution_graph_pipeline_scratch_size_amdx)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkGetExecutionGraphPipelineScratchSizeAMDX\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            get_execution_graph_pipeline_scratch_size_amdx
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    get_execution_graph_pipeline_node_index_amdx: unsafe {
                        unsafe extern "system" fn get_execution_graph_pipeline_node_index_amdx(
                            _device: crate::vk::Device,
                            _execution_graph: Pipeline,
                            _p_node_info: *const PipelineShaderStageNodeCreateInfoAMDX<'_>,
                            _p_node_index: *mut u32,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(get_execution_graph_pipeline_node_index_amdx)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkGetExecutionGraphPipelineNodeIndexAMDX\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            get_execution_graph_pipeline_node_index_amdx
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_initialize_graph_scratch_memory_amdx: unsafe {
                        unsafe extern "system" fn cmd_initialize_graph_scratch_memory_amdx(
                            _command_buffer: CommandBuffer,
                            _scratch: DeviceAddress,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_initialize_graph_scratch_memory_amdx)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCmdInitializeGraphScratchMemoryAMDX\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_initialize_graph_scratch_memory_amdx
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_dispatch_graph_amdx: unsafe {
                        unsafe extern "system" fn cmd_dispatch_graph_amdx(
                            _command_buffer: CommandBuffer,
                            _scratch: DeviceAddress,
                            _p_count_info: *const DispatchGraphCountInfoAMDX,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_dispatch_graph_amdx)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchGraphAMDX\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_dispatch_graph_amdx
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_dispatch_graph_indirect_amdx: unsafe {
                        unsafe extern "system" fn cmd_dispatch_graph_indirect_amdx(
                            _command_buffer: CommandBuffer,
                            _scratch: DeviceAddress,
                            _p_count_info: *const DispatchGraphCountInfoAMDX,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_dispatch_graph_indirect_amdx)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCmdDispatchGraphIndirectAMDX\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_dispatch_graph_indirect_amdx
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_dispatch_graph_indirect_count_amdx: unsafe {
                        unsafe extern "system" fn cmd_dispatch_graph_indirect_count_amdx(
                            _command_buffer: CommandBuffer,
                            _scratch: DeviceAddress,
                            _count_info: DeviceAddress,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_dispatch_graph_indirect_count_amdx)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCmdDispatchGraphIndirectCountAMDX\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_dispatch_graph_indirect_count_amdx
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
}
#[doc = "Extensions tagged ANDROID"]
pub mod android {
    #[doc = "VK_ANDROID_native_buffer"]
    pub mod native_buffer {
        use super::super::*;
        pub use {
            crate::vk::ANDROID_NATIVE_BUFFER_NAME as NAME,
            crate::vk::ANDROID_NATIVE_BUFFER_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_ANDROID_native_buffer device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_ANDROID_native_buffer device-level function pointers"]
        pub struct DeviceFn {
            pub get_swapchain_gralloc_usage_android: PFN_vkGetSwapchainGrallocUsageANDROID,
            pub acquire_image_android: PFN_vkAcquireImageANDROID,
            pub queue_signal_release_image_android: PFN_vkQueueSignalReleaseImageANDROID,
            pub get_swapchain_gralloc_usage2_android: PFN_vkGetSwapchainGrallocUsage2ANDROID,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    get_swapchain_gralloc_usage_android: unsafe {
                        unsafe extern "system" fn get_swapchain_gralloc_usage_android(
                            _device: crate::vk::Device,
                            _format: Format,
                            _image_usage: ImageUsageFlags,
                            _gralloc_usage: *mut c_int,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(get_swapchain_gralloc_usage_android)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkGetSwapchainGrallocUsageANDROID\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            get_swapchain_gralloc_usage_android
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    acquire_image_android: unsafe {
                        unsafe extern "system" fn acquire_image_android(
                            _device: crate::vk::Device,
                            _image: Image,
                            _native_fence_fd: c_int,
                            _semaphore: Semaphore,
                            _fence: Fence,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(acquire_image_android)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireImageANDROID\0");
                        let val = _f(cname);
                        if val.is_null() {
                            acquire_image_android
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    queue_signal_release_image_android: unsafe {
                        unsafe extern "system" fn queue_signal_release_image_android(
                            _queue: Queue,
                            _wait_semaphore_count: u32,
                            _p_wait_semaphores: *const Semaphore,
                            _image: Image,
                            _p_native_fence_fd: *mut c_int,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(queue_signal_release_image_android)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkQueueSignalReleaseImageANDROID\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            queue_signal_release_image_android
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    get_swapchain_gralloc_usage2_android: unsafe {
                        unsafe extern "system" fn get_swapchain_gralloc_usage2_android(
                            _device: crate::vk::Device,
                            _format: Format,
                            _image_usage: ImageUsageFlags,
                            _swapchain_image_usage: SwapchainImageUsageFlagsANDROID,
                            _gralloc_consumer_usage: *mut u64,
                            _gralloc_producer_usage: *mut u64,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(get_swapchain_gralloc_usage2_android)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkGetSwapchainGrallocUsage2ANDROID\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            get_swapchain_gralloc_usage2_android
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_ANDROID_external_memory_android_hardware_buffer"]
    pub mod external_memory_android_hardware_buffer {
        use super::super::*;
        pub use {
            crate::vk::ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_NAME as NAME,
            crate::vk::ANDROID_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_ANDROID_external_memory_android_hardware_buffer device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_ANDROID_external_memory_android_hardware_buffer device-level function pointers"]
        pub struct DeviceFn {
            pub get_android_hardware_buffer_properties_android:
                PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
            pub get_memory_android_hardware_buffer_android:
                PFN_vkGetMemoryAndroidHardwareBufferANDROID,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    get_android_hardware_buffer_properties_android: unsafe {
                        unsafe extern "system" fn get_android_hardware_buffer_properties_android(
                            _device: crate::vk::Device,
                            _buffer: *const AHardwareBuffer,
                            _p_properties: *mut AndroidHardwareBufferPropertiesANDROID<'_>,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(get_android_hardware_buffer_properties_android)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkGetAndroidHardwareBufferPropertiesANDROID\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            get_android_hardware_buffer_properties_android
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    get_memory_android_hardware_buffer_android: unsafe {
                        unsafe extern "system" fn get_memory_android_hardware_buffer_android(
                            _device: crate::vk::Device,
                            _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID<'_>,
                            _p_buffer: *mut *mut AHardwareBuffer,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(get_memory_android_hardware_buffer_android)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkGetMemoryAndroidHardwareBufferANDROID\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            get_memory_android_hardware_buffer_android
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_ANDROID_external_format_resolve"]
    pub mod external_format_resolve {
        use super::super::*;
        pub use {
            crate::vk::ANDROID_EXTERNAL_FORMAT_RESOLVE_NAME as NAME,
            crate::vk::ANDROID_EXTERNAL_FORMAT_RESOLVE_SPEC_VERSION as SPEC_VERSION,
        };
    }
}
#[doc = "Extensions tagged ARM"]
pub mod arm {
    #[doc = "VK_ARM_rasterization_order_attachment_access"]
    pub mod rasterization_order_attachment_access {
        use super::super::*;
        pub use {
            crate::vk::ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_NAME as NAME,
            crate::vk::ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_ARM_shader_core_properties"]
    pub mod shader_core_properties {
        use super::super::*;
        pub use {
            crate::vk::ARM_SHADER_CORE_PROPERTIES_NAME as NAME,
            crate::vk::ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_ARM_scheduling_controls"]
    pub mod scheduling_controls {
        use super::super::*;
        pub use {
            crate::vk::ARM_SCHEDULING_CONTROLS_NAME as NAME,
            crate::vk::ARM_SCHEDULING_CONTROLS_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_ARM_render_pass_striped"]
    pub mod render_pass_striped {
        use super::super::*;
        pub use {
            crate::vk::ARM_RENDER_PASS_STRIPED_NAME as NAME,
            crate::vk::ARM_RENDER_PASS_STRIPED_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_ARM_shader_core_builtins"]
    pub mod shader_core_builtins {
        use super::super::*;
        pub use {
            crate::vk::ARM_SHADER_CORE_BUILTINS_NAME as NAME,
            crate::vk::ARM_SHADER_CORE_BUILTINS_SPEC_VERSION as SPEC_VERSION,
        };
    }
}
#[doc = "Extensions tagged EXT"]
pub mod ext {
    #[doc = "VK_EXT_debug_report"]
    pub mod debug_report {
        use super::super::*;
        pub use {
            crate::vk::EXT_DEBUG_REPORT_NAME as NAME,
            crate::vk::EXT_DEBUG_REPORT_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_EXT_debug_report instance-level functions"]
        #[derive(Clone)]
        pub struct Instance {
            pub(crate) fp: InstanceFn,
            pub(crate) handle: crate::vk::Instance,
        }
        impl Instance {
            pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> Self {
                let handle = instance.handle();
                let fp = InstanceFn::load(|name| unsafe {
                    core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &InstanceFn {
                &self.fp
            }
            #[inline]
            pub fn instance(&self) -> crate::vk::Instance {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_EXT_debug_report instance-level function pointers"]
        pub struct InstanceFn {
            pub create_debug_report_callback_ext: PFN_vkCreateDebugReportCallbackEXT,
            pub destroy_debug_report_callback_ext: PFN_vkDestroyDebugReportCallbackEXT,
            pub debug_report_message_ext: PFN_vkDebugReportMessageEXT,
        }
        unsafe impl Send for InstanceFn {}
        unsafe impl Sync for InstanceFn {}
        impl InstanceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    create_debug_report_callback_ext: unsafe {
                        unsafe extern "system" fn create_debug_report_callback_ext(
                            _instance: crate::vk::Instance,
                            _p_create_info: *const DebugReportCallbackCreateInfoEXT<'_>,
                            _p_allocator: *const AllocationCallbacks<'_>,
                            _p_callback: *mut DebugReportCallbackEXT,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(create_debug_report_callback_ext)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCreateDebugReportCallbackEXT\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            create_debug_report_callback_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    destroy_debug_report_callback_ext: unsafe {
                        unsafe extern "system" fn destroy_debug_report_callback_ext(
                            _instance: crate::vk::Instance,
                            _callback: DebugReportCallbackEXT,
                            _p_allocator: *const AllocationCallbacks<'_>,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(destroy_debug_report_callback_ext)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkDestroyDebugReportCallbackEXT\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            destroy_debug_report_callback_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    debug_report_message_ext: unsafe {
                        unsafe extern "system" fn debug_report_message_ext(
                            _instance: crate::vk::Instance,
                            _flags: DebugReportFlagsEXT,
                            _object_type: DebugReportObjectTypeEXT,
                            _object: u64,
                            _location: usize,
                            _message_code: i32,
                            _p_layer_prefix: *const c_char,
                            _p_message: *const c_char,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(debug_report_message_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkDebugReportMessageEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            debug_report_message_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_EXT_depth_range_unrestricted"]
    pub mod depth_range_unrestricted {
        use super::super::*;
        pub use {
            crate::vk::EXT_DEPTH_RANGE_UNRESTRICTED_NAME as NAME,
            crate::vk::EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_EXT_debug_marker"]
    pub mod debug_marker {
        use super::super::*;
        pub use {
            crate::vk::EXT_DEBUG_MARKER_NAME as NAME,
            crate::vk::EXT_DEBUG_MARKER_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_EXT_debug_marker device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_EXT_debug_marker device-level function pointers"]
        pub struct DeviceFn {
            pub debug_marker_set_object_tag_ext: PFN_vkDebugMarkerSetObjectTagEXT,
            pub debug_marker_set_object_name_ext: PFN_vkDebugMarkerSetObjectNameEXT,
            pub cmd_debug_marker_begin_ext: PFN_vkCmdDebugMarkerBeginEXT,
            pub cmd_debug_marker_end_ext: PFN_vkCmdDebugMarkerEndEXT,
            pub cmd_debug_marker_insert_ext: PFN_vkCmdDebugMarkerInsertEXT,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    debug_marker_set_object_tag_ext: unsafe {
                        unsafe extern "system" fn debug_marker_set_object_tag_ext(
                            _device: crate::vk::Device,
                            _p_tag_info: *const DebugMarkerObjectTagInfoEXT<'_>,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(debug_marker_set_object_tag_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkDebugMarkerSetObjectTagEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            debug_marker_set_object_tag_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    debug_marker_set_object_name_ext: unsafe {
                        unsafe extern "system" fn debug_marker_set_object_name_ext(
                            _device: crate::vk::Device,
                            _p_name_info: *const DebugMarkerObjectNameInfoEXT<'_>,
                        ) -> Result {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(debug_marker_set_object_name_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkDebugMarkerSetObjectNameEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            debug_marker_set_object_name_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_debug_marker_begin_ext: unsafe {
                        unsafe extern "system" fn cmd_debug_marker_begin_ext(
                            _command_buffer: CommandBuffer,
                            _p_marker_info: *const DebugMarkerMarkerInfoEXT<'_>,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_debug_marker_begin_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerBeginEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_debug_marker_begin_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_debug_marker_end_ext: unsafe {
                        unsafe extern "system" fn cmd_debug_marker_end_ext(
                            _command_buffer: CommandBuffer,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_debug_marker_end_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerEndEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_debug_marker_end_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_debug_marker_insert_ext: unsafe {
                        unsafe extern "system" fn cmd_debug_marker_insert_ext(
                            _command_buffer: CommandBuffer,
                            _p_marker_info: *const DebugMarkerMarkerInfoEXT<'_>,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_debug_marker_insert_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerInsertEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_debug_marker_insert_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_EXT_transform_feedback"]
    pub mod transform_feedback {
        use super::super::*;
        pub use {
            crate::vk::EXT_TRANSFORM_FEEDBACK_NAME as NAME,
            crate::vk::EXT_TRANSFORM_FEEDBACK_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_EXT_transform_feedback device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_EXT_transform_feedback device-level function pointers"]
        pub struct DeviceFn {
            pub cmd_bind_transform_feedback_buffers_ext: PFN_vkCmdBindTransformFeedbackBuffersEXT,
            pub cmd_begin_transform_feedback_ext: PFN_vkCmdBeginTransformFeedbackEXT,
            pub cmd_end_transform_feedback_ext: PFN_vkCmdEndTransformFeedbackEXT,
            pub cmd_begin_query_indexed_ext: PFN_vkCmdBeginQueryIndexedEXT,
            pub cmd_end_query_indexed_ext: PFN_vkCmdEndQueryIndexedEXT,
            pub cmd_draw_indirect_byte_count_ext: PFN_vkCmdDrawIndirectByteCountEXT,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    cmd_bind_transform_feedback_buffers_ext: unsafe {
                        unsafe extern "system" fn cmd_bind_transform_feedback_buffers_ext(
                            _command_buffer: CommandBuffer,
                            _first_binding: u32,
                            _binding_count: u32,
                            _p_buffers: *const Buffer,
                            _p_offsets: *const DeviceSize,
                            _p_sizes: *const DeviceSize,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_bind_transform_feedback_buffers_ext)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCmdBindTransformFeedbackBuffersEXT\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_bind_transform_feedback_buffers_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_begin_transform_feedback_ext: unsafe {
                        unsafe extern "system" fn cmd_begin_transform_feedback_ext(
                            _command_buffer: CommandBuffer,
                            _first_counter_buffer: u32,
                            _counter_buffer_count: u32,
                            _p_counter_buffers: *const Buffer,
                            _p_counter_buffer_offsets: *const DeviceSize,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_begin_transform_feedback_ext)
                            ))
                        }
                        let cname = CStr::from_bytes_with_nul_unchecked(
                            b"vkCmdBeginTransformFeedbackEXT\0",
                        );
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_begin_transform_feedback_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_end_transform_feedback_ext: unsafe {
                        unsafe extern "system" fn cmd_end_transform_feedback_ext(
                            _command_buffer: CommandBuffer,
                            _first_counter_buffer: u32,
                            _counter_buffer_count: u32,
                            _p_counter_buffers: *const Buffer,
                            _p_counter_buffer_offsets: *const DeviceSize,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_end_transform_feedback_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdEndTransformFeedbackEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_end_transform_feedback_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_begin_query_indexed_ext: unsafe {
                        unsafe extern "system" fn cmd_begin_query_indexed_ext(
                            _command_buffer: CommandBuffer,
                            _query_pool: QueryPool,
                            _query: u32,
                            _flags: QueryControlFlags,
                            _index: u32,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_begin_query_indexed_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQueryIndexedEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_begin_query_indexed_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_end_query_indexed_ext: unsafe {
                        unsafe extern "system" fn cmd_end_query_indexed_ext(
                            _command_buffer: CommandBuffer,
                            _query_pool: QueryPool,
                            _query: u32,
                            _index: u32,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_end_query_indexed_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQueryIndexedEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_end_query_indexed_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                    cmd_draw_indirect_byte_count_ext: unsafe {
                        unsafe extern "system" fn cmd_draw_indirect_byte_count_ext(
                            _command_buffer: CommandBuffer,
                            _instance_count: u32,
                            _first_instance: u32,
                            _counter_buffer: Buffer,
                            _counter_buffer_offset: DeviceSize,
                            _counter_offset: u32,
                            _vertex_stride: u32,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
                                stringify!(cmd_draw_indirect_byte_count_ext)
                            ))
                        }
                        let cname =
                            CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectByteCountEXT\0");
                        let val = _f(cname);
                        if val.is_null() {
                            cmd_draw_indirect_byte_count_ext
                        } else {
                            ::core::mem::transmute(val)
                        }
                    },
                }
            }
        }
    }
    #[doc = "VK_EXT_validation_flags"]
    pub mod validation_flags {
        use super::super::*;
        pub use {
            crate::vk::EXT_VALIDATION_FLAGS_NAME as NAME,
            crate::vk::EXT_VALIDATION_FLAGS_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_EXT_shader_subgroup_ballot"]
    pub mod shader_subgroup_ballot {
        use super::super::*;
        pub use {
            crate::vk::EXT_SHADER_SUBGROUP_BALLOT_NAME as NAME,
            crate::vk::EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_EXT_shader_subgroup_vote"]
    pub mod shader_subgroup_vote {
        use super::super::*;
        pub use {
            crate::vk::EXT_SHADER_SUBGROUP_VOTE_NAME as NAME,
            crate::vk::EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_EXT_texture_compression_astc_hdr"]
    pub mod texture_compression_astc_hdr {
        use super::super::*;
        pub use {
            crate::vk::EXT_TEXTURE_COMPRESSION_ASTC_HDR_NAME as NAME,
            crate::vk::EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_EXT_astc_decode_mode"]
    pub mod astc_decode_mode {
        use super::super::*;
        pub use {
            crate::vk::EXT_ASTC_DECODE_MODE_NAME as NAME,
            crate::vk::EXT_ASTC_DECODE_MODE_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_EXT_pipeline_robustness"]
    pub mod pipeline_robustness {
        use super::super::*;
        pub use {
            crate::vk::EXT_PIPELINE_ROBUSTNESS_NAME as NAME,
            crate::vk::EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION as SPEC_VERSION,
        };
    }
    #[doc = "VK_EXT_conditional_rendering"]
    pub mod conditional_rendering {
        use super::super::*;
        pub use {
            crate::vk::EXT_CONDITIONAL_RENDERING_NAME as NAME,
            crate::vk::EXT_CONDITIONAL_RENDERING_SPEC_VERSION as SPEC_VERSION,
        };
        #[doc = "VK_EXT_conditional_rendering device-level functions"]
        #[derive(Clone)]
        pub struct Device {
            pub(crate) fp: DeviceFn,
            pub(crate) handle: crate::vk::Device,
        }
        impl Device {
            pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self {
                let handle = device.handle();
                let fp = DeviceFn::load(|name| unsafe {
                    core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr()))
                });
                Self { handle, fp }
            }
            #[inline]
            pub fn fp(&self) -> &DeviceFn {
                &self.fp
            }
            #[inline]
            pub fn device(&self) -> crate::vk::Device {
                self.handle
            }
        }
        #[derive(Clone)]
        #[doc = "Raw VK_EXT_conditional_rendering device-level function pointers"]
        pub struct DeviceFn {
            pub cmd_begin_conditional_rendering_ext: PFN_vkCmdBeginConditionalRenderingEXT,
            pub cmd_end_conditional_rendering_ext: PFN_vkCmdEndConditionalRenderingEXT,
        }
        unsafe impl Send for DeviceFn {}
        unsafe impl Sync for DeviceFn {}
        impl DeviceFn {
            pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self {
                Self::load_erased(&mut f)
            }
            fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self {
                Self {
                    cmd_begin_conditional_rendering_ext: unsafe {
                        unsafe extern "system" fn cmd_begin_conditional_rendering_ext(
                            _command_buffer: CommandBuffer,
                            _p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT<
                                '_,
                            >,
                        ) {
                            panic!(concat!(
                                "Unable to load ",
--> --------------------

--> maximum size reached

--> --------------------