| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/C/Firefox/third_party/rust/ash/src/ (Browser von der Mozilla Stiftung Version 136.0.1©) Datei vom 10.2.2025 mit Größe 899 kB |
|
Impressum extensions_generated.rs Sprache: unbekannt |
|
|
Spracherkennung für: .rs vermutete Sprache: Unknown {[0] [0] [0]} [Methode: Schwerpunktbildung, einfache Gewichte, sechs Dimensionen] #![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_vkCmdInitializeGraphScratchMemor pub cmd_dispatch_graph_amdx: PFN_vkCmdDispatchGraphAMDX, pub cmd_dispatch_graph_indirect_amdx: PFN_vkCmdDispatchGraphIndirectAMDX, pub cmd_dispatch_graph_indirect_count_amdx: PFN_vkCmdDispatchGraphIndirectCountAMD } 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_VE }; #[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 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_vkCmdBindTransformFeedbackBuffers 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 ", stringify!(cmd_begin_conditional_rendering_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdBeginConditionalRenderingEXT\0", ); let val = _f(cname); if val.is_null() { cmd_begin_conditional_rendering_ext } else { ::core::mem::transmute(val) } }, cmd_end_conditional_rendering_ext: unsafe { unsafe extern "system" fn cmd_end_conditional_rendering_ext( _command_buffer: CommandBuffer, ) { panic!(concat!( "Unable to load ", stringify!(cmd_end_conditional_rendering_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdEndConditionalRenderingEXT\0", ); let val = _f(cname); if val.is_null() { cmd_end_conditional_rendering_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_direct_mode_display"] pub mod direct_mode_display { use super::super::*; pub use { crate::vk::EXT_DIRECT_MODE_DISPLAY_NAME as NAME, crate::vk::EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_direct_mode_display 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_direct_mode_display instance-level function pointers"] pub struct InstanceFn { pub release_display_ext: PFN_vkReleaseDisplayEXT, } 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 { release_display_ext: unsafe { unsafe extern "system" fn release_display_ext( _physical_device: PhysicalDevice, _display: DisplayKHR, ) -> Result { panic!(concat!("Unable to load ", stringify!(release_display_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkReleaseDisplayEXT\0"); let val = _f(cname); if val.is_null() { release_display_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_acquire_xlib_display"] pub mod acquire_xlib_display { use super::super::*; pub use { crate::vk::EXT_ACQUIRE_XLIB_DISPLAY_NAME as NAME, crate::vk::EXT_ACQUIRE_XLIB_DISPLAY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_acquire_xlib_display 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_acquire_xlib_display instance-level function pointers"] pub struct InstanceFn { pub acquire_xlib_display_ext: PFN_vkAcquireXlibDisplayEXT, pub get_rand_r_output_display_ext: PFN_vkGetRandROutputDisplayEXT, } 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 { acquire_xlib_display_ext: unsafe { unsafe extern "system" fn acquire_xlib_display_ext( _physical_device: PhysicalDevice, _dpy: *mut Display, _display: DisplayKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(acquire_xlib_display_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireXlibDisplayEXT\0"); let val = _f(cname); if val.is_null() { acquire_xlib_display_ext } else { ::core::mem::transmute(val) } }, get_rand_r_output_display_ext: unsafe { unsafe extern "system" fn get_rand_r_output_display_ext( _physical_device: PhysicalDevice, _dpy: *mut Display, _rr_output: RROutput, _p_display: *mut DisplayKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_rand_r_output_display_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetRandROutputDisplayEXT\0"); let val = _f(cname); if val.is_null() { get_rand_r_output_display_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_display_surface_counter"] pub mod display_surface_counter { use super::super::*; pub use { crate::vk::EXT_DISPLAY_SURFACE_COUNTER_NAME as NAME, crate::vk::EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_display_surface_counter 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_display_surface_counter instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_surface_capabilities2_ext: PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT, } 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 { get_physical_device_surface_capabilities2_ext: unsafe { unsafe extern "system" fn get_physical_device_surface_capabilities2_ext( _physical_device: PhysicalDevice, _surface: SurfaceKHR, _p_surface_capabilities: *mut SurfaceCapabilities2EXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_surface_capabilities2_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceSurfaceCapabilities2EXT\0", ); let val = _f(cname); if val.is_null() { get_physical_device_surface_capabilities2_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_display_control"] pub mod display_control { use super::super::*; pub use { crate::vk::EXT_DISPLAY_CONTROL_NAME as NAME, crate::vk::EXT_DISPLAY_CONTROL_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_display_control 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_display_control device-level function pointers"] pub struct DeviceFn { pub display_power_control_ext: PFN_vkDisplayPowerControlEXT, pub register_device_event_ext: PFN_vkRegisterDeviceEventEXT, pub register_display_event_ext: PFN_vkRegisterDisplayEventEXT, pub get_swapchain_counter_ext: PFN_vkGetSwapchainCounterEXT, } 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 { display_power_control_ext: unsafe { unsafe extern "system" fn display_power_control_ext( _device: crate::vk::Device, _display: DisplayKHR, _p_display_power_info: *const DisplayPowerInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(display_power_control_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDisplayPowerControlEXT\0"); let val = _f(cname); if val.is_null() { display_power_control_ext } else { ::core::mem::transmute(val) } }, register_device_event_ext: unsafe { unsafe extern "system" fn register_device_event_ext( _device: crate::vk::Device, _p_device_event_info: *const DeviceEventInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_fence: *mut Fence, ) -> Result { panic!(concat!( "Unable to load ", stringify!(register_device_event_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkRegisterDeviceEventEXT\0"); let val = _f(cname); if val.is_null() { register_device_event_ext } else { ::core::mem::transmute(val) } }, register_display_event_ext: unsafe { unsafe extern "system" fn register_display_event_ext( _device: crate::vk::Device, _display: DisplayKHR, _p_display_event_info: *const DisplayEventInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_fence: *mut Fence, ) -> Result { panic!(concat!( "Unable to load ", stringify!(register_display_event_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkRegisterDisplayEventEXT\0"); let val = _f(cname); if val.is_null() { register_display_event_ext } else { ::core::mem::transmute(val) } }, get_swapchain_counter_ext: unsafe { unsafe extern "system" fn get_swapchain_counter_ext( _device: crate::vk::Device, _swapchain: SwapchainKHR, _counter: SurfaceCounterFlagsEXT, _p_counter_value: *mut u64, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_swapchain_counter_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainCounterEXT\0"); let val = _f(cname); if val.is_null() { get_swapchain_counter_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_discard_rectangles"] pub mod discard_rectangles { use super::super::*; pub use { crate::vk::EXT_DISCARD_RECTANGLES_NAME as NAME, crate::vk::EXT_DISCARD_RECTANGLES_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_discard_rectangles 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_discard_rectangles device-level function pointers"] pub struct DeviceFn { pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT, pub cmd_set_discard_rectangle_enable_ext: PFN_vkCmdSetDiscardRectangleEnableEXT, pub cmd_set_discard_rectangle_mode_ext: PFN_vkCmdSetDiscardRectangleModeEXT, } 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_set_discard_rectangle_ext: unsafe { unsafe extern "system" fn cmd_set_discard_rectangle_ext( _command_buffer: CommandBuffer, _first_discard_rectangle: u32, _discard_rectangle_count: u32, _p_discard_rectangles: *const Rect2D, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_discard_rectangle_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDiscardRectangleEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_discard_rectangle_ext } else { ::core::mem::transmute(val) } }, cmd_set_discard_rectangle_enable_ext: unsafe { unsafe extern "system" fn cmd_set_discard_rectangle_enable_ext( _command_buffer: CommandBuffer, _discard_rectangle_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_discard_rectangle_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetDiscardRectangleEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_discard_rectangle_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_discard_rectangle_mode_ext: unsafe { unsafe extern "system" fn cmd_set_discard_rectangle_mode_ext( _command_buffer: CommandBuffer, _discard_rectangle_mode: DiscardRectangleModeEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_discard_rectangle_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetDiscardRectangleModeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_discard_rectangle_mode_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_conservative_rasterization"] pub mod conservative_rasterization { use super::super::*; pub use { crate::vk::EXT_CONSERVATIVE_RASTERIZATION_NAME as NAME, crate::vk::EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_depth_clip_enable"] pub mod depth_clip_enable { use super::super::*; pub use { crate::vk::EXT_DEPTH_CLIP_ENABLE_NAME as NAME, crate::vk::EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_swapchain_colorspace"] pub mod swapchain_colorspace { use super::super::*; pub use { crate::vk::EXT_SWAPCHAIN_COLORSPACE_NAME as NAME, crate::vk::EXT_SWAPCHAIN_COLORSPACE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_hdr_metadata"] pub mod hdr_metadata { use super::super::*; pub use { crate::vk::EXT_HDR_METADATA_NAME as NAME, crate::vk::EXT_HDR_METADATA_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_hdr_metadata 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_hdr_metadata device-level function pointers"] pub struct DeviceFn { pub set_hdr_metadata_ext: PFN_vkSetHdrMetadataEXT, } 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_hdr_metadata_ext: unsafe { unsafe extern "system" fn set_hdr_metadata_ext( _device: crate::vk::Device, _swapchain_count: u32, _p_swapchains: *const SwapchainKHR, _p_metadata: *const HdrMetadataEXT<'_>, ) { panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetHdrMetadataEXT\0"); let val = _f(cname); if val.is_null() { set_hdr_metadata_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_external_memory_dma_buf"] pub mod external_memory_dma_buf { use super::super::*; pub use { crate::vk::EXT_EXTERNAL_MEMORY_DMA_BUF_NAME as NAME, crate::vk::EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_queue_family_foreign"] pub mod queue_family_foreign { use super::super::*; pub use { crate::vk::EXT_QUEUE_FAMILY_FOREIGN_NAME as NAME, crate::vk::EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_debug_utils"] pub mod debug_utils { use super::super::*; pub use { crate::vk::EXT_DEBUG_UTILS_NAME as NAME, crate::vk::EXT_DEBUG_UTILS_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_debug_utils 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_utils instance-level function pointers"] pub struct InstanceFn { pub create_debug_utils_messenger_ext: PFN_vkCreateDebugUtilsMessengerEXT, pub destroy_debug_utils_messenger_ext: PFN_vkDestroyDebugUtilsMessengerEXT, pub submit_debug_utils_message_ext: PFN_vkSubmitDebugUtilsMessageEXT, } 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_utils_messenger_ext: unsafe { unsafe extern "system" fn create_debug_utils_messenger_ext( _instance: crate::vk::Instance, _p_create_info: *const DebugUtilsMessengerCreateInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_messenger: *mut DebugUtilsMessengerEXT, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_debug_utils_messenger_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCreateDebugUtilsMessengerEXT\0", ); let val = _f(cname); if val.is_null() { create_debug_utils_messenger_ext } else { ::core::mem::transmute(val) } }, destroy_debug_utils_messenger_ext: unsafe { unsafe extern "system" fn destroy_debug_utils_messenger_ext( _instance: crate::vk::Instance, _messenger: DebugUtilsMessengerEXT, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!( "Unable to load ", stringify!(destroy_debug_utils_messenger_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkDestroyDebugUtilsMessengerEXT\0", ); let val = _f(cname); if val.is_null() { destroy_debug_utils_messenger_ext } else { ::core::mem::transmute(val) } }, submit_debug_utils_message_ext: unsafe { unsafe extern "system" fn submit_debug_utils_message_ext( _instance: crate::vk::Instance, _message_severity: DebugUtilsMessageSeverityFlagsEXT, _message_types: DebugUtilsMessageTypeFlagsEXT, _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(submit_debug_utils_message_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkSubmitDebugUtilsMessageEXT\0"); let val = _f(cname); if val.is_null() { submit_debug_utils_message_ext } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_EXT_debug_utils 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_utils device-level function pointers"] pub struct DeviceFn { pub set_debug_utils_object_name_ext: PFN_vkSetDebugUtilsObjectNameEXT, pub set_debug_utils_object_tag_ext: PFN_vkSetDebugUtilsObjectTagEXT, pub queue_begin_debug_utils_label_ext: PFN_vkQueueBeginDebugUtilsLabelEXT, pub queue_end_debug_utils_label_ext: PFN_vkQueueEndDebugUtilsLabelEXT, pub queue_insert_debug_utils_label_ext: PFN_vkQueueInsertDebugUtilsLabelEXT, pub cmd_begin_debug_utils_label_ext: PFN_vkCmdBeginDebugUtilsLabelEXT, pub cmd_end_debug_utils_label_ext: PFN_vkCmdEndDebugUtilsLabelEXT, pub cmd_insert_debug_utils_label_ext: PFN_vkCmdInsertDebugUtilsLabelEXT, } 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_debug_utils_object_name_ext: unsafe { unsafe extern "system" fn set_debug_utils_object_name_ext( _device: crate::vk::Device, _p_name_info: *const DebugUtilsObjectNameInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(set_debug_utils_object_name_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetDebugUtilsObjectNameEXT\0"); let val = _f(cname); if val.is_null() { set_debug_utils_object_name_ext } else { ::core::mem::transmute(val) } }, set_debug_utils_object_tag_ext: unsafe { unsafe extern "system" fn set_debug_utils_object_tag_ext( _device: crate::vk::Device, _p_tag_info: *const DebugUtilsObjectTagInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(set_debug_utils_object_tag_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetDebugUtilsObjectTagEXT\0"); let val = _f(cname); if val.is_null() { set_debug_utils_object_tag_ext } else { ::core::mem::transmute(val) } }, queue_begin_debug_utils_label_ext: unsafe { unsafe extern "system" fn queue_begin_debug_utils_label_ext( _queue: Queue, _p_label_info: *const DebugUtilsLabelEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(queue_begin_debug_utils_label_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkQueueBeginDebugUtilsLabelEXT\0", ); let val = _f(cname); if val.is_null() { queue_begin_debug_utils_label_ext } else { ::core::mem::transmute(val) } }, queue_end_debug_utils_label_ext: unsafe { unsafe extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) { panic!(concat!( "Unable to load ", stringify!(queue_end_debug_utils_label_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkQueueEndDebugUtilsLabelEXT\0"); let val = _f(cname); if val.is_null() { queue_end_debug_utils_label_ext } else { ::core::mem::transmute(val) } }, queue_insert_debug_utils_label_ext: unsafe { unsafe extern "system" fn queue_insert_debug_utils_label_ext( _queue: Queue, _p_label_info: *const DebugUtilsLabelEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(queue_insert_debug_utils_label_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkQueueInsertDebugUtilsLabelEXT\0", ); let val = _f(cname); if val.is_null() { queue_insert_debug_utils_label_ext } else { ::core::mem::transmute(val) } }, cmd_begin_debug_utils_label_ext: unsafe { unsafe extern "system" fn cmd_begin_debug_utils_label_ext( _command_buffer: CommandBuffer, _p_label_info: *const DebugUtilsLabelEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_begin_debug_utils_label_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginDebugUtilsLabelEXT\0"); let val = _f(cname); if val.is_null() { cmd_begin_debug_utils_label_ext } else { ::core::mem::transmute(val) } }, cmd_end_debug_utils_label_ext: unsafe { unsafe extern "system" fn cmd_end_debug_utils_label_ext( _command_buffer: CommandBuffer, ) { panic!(concat!( "Unable to load ", stringify!(cmd_end_debug_utils_label_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdEndDebugUtilsLabelEXT\0"); let val = _f(cname); if val.is_null() { cmd_end_debug_utils_label_ext } else { ::core::mem::transmute(val) } }, cmd_insert_debug_utils_label_ext: unsafe { unsafe extern "system" fn cmd_insert_debug_utils_label_ext( _command_buffer: CommandBuffer, _p_label_info: *const DebugUtilsLabelEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_insert_debug_utils_label_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdInsertDebugUtilsLabelEXT\0"); let val = _f(cname); if val.is_null() { cmd_insert_debug_utils_label_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_sampler_filter_minmax"] pub mod sampler_filter_minmax { use super::super::*; pub use { crate::vk::EXT_SAMPLER_FILTER_MINMAX_NAME as NAME, crate::vk::EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_inline_uniform_block"] pub mod inline_uniform_block { use super::super::*; pub use { crate::vk::EXT_INLINE_UNIFORM_BLOCK_NAME as NAME, crate::vk::EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_shader_stencil_export"] pub mod shader_stencil_export { use super::super::*; pub use { crate::vk::EXT_SHADER_STENCIL_EXPORT_NAME as NAME, crate::vk::EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_sample_locations"] pub mod sample_locations { use super::super::*; pub use { crate::vk::EXT_SAMPLE_LOCATIONS_NAME as NAME, crate::vk::EXT_SAMPLE_LOCATIONS_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_sample_locations 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_sample_locations instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_multisample_properties_ext: PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT, } 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 { get_physical_device_multisample_properties_ext: unsafe { unsafe extern "system" fn get_physical_device_multisample_properties_ext( _physical_device: PhysicalDevice, _samples: SampleCountFlags, _p_multisample_properties: *mut MultisamplePropertiesEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_physical_device_multisample_properties_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceMultisamplePropertiesEXT\0", ); let val = _f(cname); if val.is_null() { get_physical_device_multisample_properties_ext } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_EXT_sample_locations 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_sample_locations device-level function pointers"] pub struct DeviceFn { pub cmd_set_sample_locations_ext: PFN_vkCmdSetSampleLocationsEXT, } 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_set_sample_locations_ext: unsafe { unsafe extern "system" fn cmd_set_sample_locations_ext( _command_buffer: CommandBuffer, _p_sample_locations_info: *const SampleLocationsInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_sample_locations_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleLocationsEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_sample_locations_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_blend_operation_advanced"] pub mod blend_operation_advanced { use super::super::*; pub use { crate::vk::EXT_BLEND_OPERATION_ADVANCED_NAME as NAME, crate::vk::EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_post_depth_coverage"] pub mod post_depth_coverage { use super::super::*; pub use { crate::vk::EXT_POST_DEPTH_COVERAGE_NAME as NAME, crate::vk::EXT_POST_DEPTH_COVERAGE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_image_drm_format_modifier"] pub mod image_drm_format_modifier { use super::super::*; pub use { crate::vk::EXT_IMAGE_DRM_FORMAT_MODIFIER_NAME as NAME, crate::vk::EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_image_drm_format_modifier 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_image_drm_format_modifier device-level function pointers"] pub struct DeviceFn { pub get_image_drm_format_modifier_properties_ext: PFN_vkGetImageDrmFormatModifierPropertiesEXT, } 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_image_drm_format_modifier_properties_ext: unsafe { unsafe extern "system" fn get_image_drm_format_modifier_properties_ext( _device: crate::vk::Device, _image: Image, _p_properties: *mut ImageDrmFormatModifierPropertiesEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_image_drm_format_modifier_properties_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetImageDrmFormatModifierPropertiesEXT\0", ); let val = _f(cname); if val.is_null() { get_image_drm_format_modifier_properties_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_validation_cache"] pub mod validation_cache { use super::super::*; pub use { crate::vk::EXT_VALIDATION_CACHE_NAME as NAME, crate::vk::EXT_VALIDATION_CACHE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_validation_cache 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_validation_cache device-level function pointers"] pub struct DeviceFn { pub create_validation_cache_ext: PFN_vkCreateValidationCacheEXT, pub destroy_validation_cache_ext: PFN_vkDestroyValidationCacheEXT, pub merge_validation_caches_ext: PFN_vkMergeValidationCachesEXT, pub get_validation_cache_data_ext: PFN_vkGetValidationCacheDataEXT, } 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_validation_cache_ext: unsafe { unsafe extern "system" fn create_validation_cache_ext( _device: crate::vk::Device, _p_create_info: *const ValidationCacheCreateInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_validation_cache: *mut ValidationCacheEXT, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_validation_cache_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateValidationCacheEXT\0"); let val = _f(cname); if val.is_null() { create_validation_cache_ext } else { ::core::mem::transmute(val) } }, destroy_validation_cache_ext: unsafe { unsafe extern "system" fn destroy_validation_cache_ext( _device: crate::vk::Device, _validation_cache: ValidationCacheEXT, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!( "Unable to load ", stringify!(destroy_validation_cache_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyValidationCacheEXT\0"); let val = _f(cname); if val.is_null() { destroy_validation_cache_ext } else { ::core::mem::transmute(val) } }, merge_validation_caches_ext: unsafe { unsafe extern "system" fn merge_validation_caches_ext( _device: crate::vk::Device, _dst_cache: ValidationCacheEXT, _src_cache_count: u32, _p_src_caches: *const ValidationCacheEXT, ) -> Result { panic!(concat!( "Unable to load ", stringify!(merge_validation_caches_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkMergeValidationCachesEXT\0"); let val = _f(cname); if val.is_null() { merge_validation_caches_ext } else { ::core::mem::transmute(val) } }, get_validation_cache_data_ext: unsafe { unsafe extern "system" fn get_validation_cache_data_ext( _device: crate::vk::Device, _validation_cache: ValidationCacheEXT, _p_data_size: *mut usize, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_validation_cache_data_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetValidationCacheDataEXT\0"); let val = _f(cname); if val.is_null() { get_validation_cache_data_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_descriptor_indexing"] pub mod descriptor_indexing { use super::super::*; pub use { crate::vk::EXT_DESCRIPTOR_INDEXING_NAME as NAME, crate::vk::EXT_DESCRIPTOR_INDEXING_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_shader_viewport_index_layer"] pub mod shader_viewport_index_layer { use super::super::*; pub use { crate::vk::EXT_SHADER_VIEWPORT_INDEX_LAYER_NAME as NAME, crate::vk::EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_filter_cubic"] pub mod filter_cubic { use super::super::*; pub use { crate::vk::EXT_FILTER_CUBIC_NAME as NAME, crate::vk::EXT_FILTER_CUBIC_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_global_priority"] pub mod global_priority { use super::super::*; pub use { crate::vk::EXT_GLOBAL_PRIORITY_NAME as NAME, crate::vk::EXT_GLOBAL_PRIORITY_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_external_memory_host"] pub mod external_memory_host { use super::super::*; pub use { crate::vk::EXT_EXTERNAL_MEMORY_HOST_NAME as NAME, crate::vk::EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_external_memory_host 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_external_memory_host device-level function pointers"] pub struct DeviceFn { pub get_memory_host_pointer_properties_ext: PFN_vkGetMemoryHostPointerPropertiesEX } 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_memory_host_pointer_properties_ext: unsafe { unsafe extern "system" fn get_memory_host_pointer_properties_ext( _device: crate::vk::Device, _handle_type: ExternalMemoryHandleTypeFlags, _p_host_pointer: *const c_void, _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT< '_, >, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_memory_host_pointer_properties_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetMemoryHostPointerPropertiesEXT\0", ); let val = _f(cname); if val.is_null() { get_memory_host_pointer_properties_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_calibrated_timestamps"] pub mod calibrated_timestamps { use super::super::*; pub use { crate::vk::EXT_CALIBRATED_TIMESTAMPS_NAME as NAME, crate::vk::EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_calibrated_timestamps 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_calibrated_timestamps instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_calibrateable_time_domains_ext: PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, } 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 { get_physical_device_calibrateable_time_domains_ext: unsafe { unsafe extern "system" fn get_physical_device_calibrateable_time_domains_ext( _physical_device: PhysicalDevice, _p_time_domain_count: *mut u32, _p_time_domains: *mut TimeDomainKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_calibrateable_time_domains_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\0", ); let val = _f(cname); if val.is_null() { get_physical_device_calibrateable_time_domains_ext } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_EXT_calibrated_timestamps 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_calibrated_timestamps device-level function pointers"] pub struct DeviceFn { pub get_calibrated_timestamps_ext: PFN_vkGetCalibratedTimestampsKHR, } 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_calibrated_timestamps_ext: unsafe { unsafe extern "system" fn get_calibrated_timestamps_ext( _device: crate::vk::Device, _timestamp_count: u32, _p_timestamp_infos: *const CalibratedTimestampInfoKHR<'_>, _p_timestamps: *mut u64, _p_max_deviation: *mut u64, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_calibrated_timestamps_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetCalibratedTimestampsEXT\0"); let val = _f(cname); if val.is_null() { get_calibrated_timestamps_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_vertex_attribute_divisor"] pub mod vertex_attribute_divisor { use super::super::*; pub use { crate::vk::EXT_VERTEX_ATTRIBUTE_DIVISOR_NAME as NAME, crate::vk::EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_pipeline_creation_feedback"] pub mod pipeline_creation_feedback { use super::super::*; pub use { crate::vk::EXT_PIPELINE_CREATION_FEEDBACK_NAME as NAME, crate::vk::EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_pci_bus_info"] pub mod pci_bus_info { use super::super::*; pub use { crate::vk::EXT_PCI_BUS_INFO_NAME as NAME, crate::vk::EXT_PCI_BUS_INFO_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_metal_surface"] pub mod metal_surface { use super::super::*; pub use { crate::vk::EXT_METAL_SURFACE_NAME as NAME, crate::vk::EXT_METAL_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_metal_surface 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_metal_surface instance-level function pointers"] pub struct InstanceFn { pub create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT, } 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_metal_surface_ext: unsafe { unsafe extern "system" fn create_metal_surface_ext( _instance: crate::vk::Instance, _p_create_info: *const MetalSurfaceCreateInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_metal_surface_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateMetalSurfaceEXT\0"); let val = _f(cname); if val.is_null() { create_metal_surface_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_fragment_density_map"] pub mod fragment_density_map { use super::super::*; pub use { crate::vk::EXT_FRAGMENT_DENSITY_MAP_NAME as NAME, crate::vk::EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_scalar_block_layout"] pub mod scalar_block_layout { use super::super::*; pub use { crate::vk::EXT_SCALAR_BLOCK_LAYOUT_NAME as NAME, crate::vk::EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_subgroup_size_control"] pub mod subgroup_size_control { use super::super::*; pub use { crate::vk::EXT_SUBGROUP_SIZE_CONTROL_NAME as NAME, crate::vk::EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_shader_image_atomic_int64"] pub mod shader_image_atomic_int64 { use super::super::*; pub use { crate::vk::EXT_SHADER_IMAGE_ATOMIC_INT64_NAME as NAME, crate::vk::EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_memory_budget"] pub mod memory_budget { use super::super::*; pub use { crate::vk::EXT_MEMORY_BUDGET_NAME as NAME, crate::vk::EXT_MEMORY_BUDGET_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_memory_priority"] pub mod memory_priority { use super::super::*; pub use { crate::vk::EXT_MEMORY_PRIORITY_NAME as NAME, crate::vk::EXT_MEMORY_PRIORITY_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_buffer_device_address"] pub mod buffer_device_address { use super::super::*; pub use { crate::vk::EXT_BUFFER_DEVICE_ADDRESS_NAME as NAME, crate::vk::EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_buffer_device_address 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_buffer_device_address device-level function pointers"] pub struct DeviceFn { pub get_buffer_device_address_ext: PFN_vkGetBufferDeviceAddress, } 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_buffer_device_address_ext: unsafe { unsafe extern "system" fn get_buffer_device_address_ext( _device: crate::vk::Device, _p_info: *const BufferDeviceAddressInfo<'_>, ) -> DeviceAddress { panic!(concat!( "Unable to load ", stringify!(get_buffer_device_address_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddressEXT\0"); let val = _f(cname); if val.is_null() { get_buffer_device_address_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_tooling_info"] pub mod tooling_info { use super::super::*; pub use { crate::vk::EXT_TOOLING_INFO_NAME as NAME, crate::vk::EXT_TOOLING_INFO_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_tooling_info 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_tooling_info instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties } 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 { get_physical_device_tool_properties_ext: unsafe { unsafe extern "system" fn get_physical_device_tool_properties_ext( _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_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceToolPropertiesEXT\0", ); let val = _f(cname); if val.is_null() { get_physical_device_tool_properties_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_separate_stencil_usage"] pub mod separate_stencil_usage { use super::super::*; pub use { crate::vk::EXT_SEPARATE_STENCIL_USAGE_NAME as NAME, crate::vk::EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_validation_features"] pub mod validation_features { use super::super::*; pub use { crate::vk::EXT_VALIDATION_FEATURES_NAME as NAME, crate::vk::EXT_VALIDATION_FEATURES_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_fragment_shader_interlock"] pub mod fragment_shader_interlock { use super::super::*; pub use { crate::vk::EXT_FRAGMENT_SHADER_INTERLOCK_NAME as NAME, crate::vk::EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_ycbcr_image_arrays"] pub mod ycbcr_image_arrays { use super::super::*; pub use { crate::vk::EXT_YCBCR_IMAGE_ARRAYS_NAME as NAME, crate::vk::EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_provoking_vertex"] pub mod provoking_vertex { use super::super::*; pub use { crate::vk::EXT_PROVOKING_VERTEX_NAME as NAME, crate::vk::EXT_PROVOKING_VERTEX_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_full_screen_exclusive"] pub mod full_screen_exclusive { use super::super::*; pub use { crate::vk::EXT_FULL_SCREEN_EXCLUSIVE_NAME as NAME, crate::vk::EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_full_screen_exclusive 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_full_screen_exclusive instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_surface_present_modes2_ext: PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT, } 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 { get_physical_device_surface_present_modes2_ext: unsafe { unsafe extern "system" fn get_physical_device_surface_present_modes2_ext( _physical_device: PhysicalDevice, _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>, _p_present_mode_count: *mut u32, _p_present_modes: *mut PresentModeKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_surface_present_modes2_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceSurfacePresentModes2EXT\0", ); let val = _f(cname); if val.is_null() { get_physical_device_surface_present_modes2_ext } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_EXT_full_screen_exclusive 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_full_screen_exclusive device-level function pointers"] pub struct DeviceFn { pub acquire_full_screen_exclusive_mode_ext: PFN_vkAcquireFullScreenExclusiveModeEX pub release_full_screen_exclusive_mode_ext: PFN_vkReleaseFullScreenExclusiveModeEX pub get_device_group_surface_present_modes2_ext: PFN_vkGetDeviceGroupSurfacePresentModes2EXT, } 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 { acquire_full_screen_exclusive_mode_ext: unsafe { unsafe extern "system" fn acquire_full_screen_exclusive_mode_ext( _device: crate::vk::Device, _swapchain: SwapchainKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(acquire_full_screen_exclusive_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkAcquireFullScreenExclusiveModeEXT\0", ); let val = _f(cname); if val.is_null() { acquire_full_screen_exclusive_mode_ext } else { ::core::mem::transmute(val) } }, release_full_screen_exclusive_mode_ext: unsafe { unsafe extern "system" fn release_full_screen_exclusive_mode_ext( _device: crate::vk::Device, _swapchain: SwapchainKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(release_full_screen_exclusive_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkReleaseFullScreenExclusiveModeEXT\0", ); let val = _f(cname); if val.is_null() { release_full_screen_exclusive_mode_ext } else { ::core::mem::transmute(val) } }, get_device_group_surface_present_modes2_ext: unsafe { unsafe extern "system" fn get_device_group_surface_present_modes2_ext( _device: crate::vk::Device, _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR<'_>, _p_modes: *mut DeviceGroupPresentModeFlagsKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_device_group_surface_present_modes2_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDeviceGroupSurfacePresentModes2EXT\0", ); let val = _f(cname); if val.is_null() { get_device_group_surface_present_modes2_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_headless_surface"] pub mod headless_surface { use super::super::*; pub use { crate::vk::EXT_HEADLESS_SURFACE_NAME as NAME, crate::vk::EXT_HEADLESS_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_headless_surface 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_headless_surface instance-level function pointers"] pub struct InstanceFn { pub create_headless_surface_ext: PFN_vkCreateHeadlessSurfaceEXT, } 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_headless_surface_ext: unsafe { unsafe extern "system" fn create_headless_surface_ext( _instance: crate::vk::Instance, _p_create_info: *const HeadlessSurfaceCreateInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_headless_surface_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateHeadlessSurfaceEXT\0"); let val = _f(cname); if val.is_null() { create_headless_surface_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_line_rasterization"] pub mod line_rasterization { use super::super::*; pub use { crate::vk::EXT_LINE_RASTERIZATION_NAME as NAME, crate::vk::EXT_LINE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_line_rasterization 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_line_rasterization device-level function pointers"] pub struct DeviceFn { pub cmd_set_line_stipple_ext: PFN_vkCmdSetLineStippleKHR, } 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_set_line_stipple_ext: unsafe { unsafe extern "system" fn cmd_set_line_stipple_ext( _command_buffer: CommandBuffer, _line_stipple_factor: u32, _line_stipple_pattern: u16, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_line_stipple_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_line_stipple_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_shader_atomic_float"] pub mod shader_atomic_float { use super::super::*; pub use { crate::vk::EXT_SHADER_ATOMIC_FLOAT_NAME as NAME, crate::vk::EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_host_query_reset"] pub mod host_query_reset { use super::super::*; pub use { crate::vk::EXT_HOST_QUERY_RESET_NAME as NAME, crate::vk::EXT_HOST_QUERY_RESET_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_host_query_reset 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_host_query_reset device-level function pointers"] pub struct DeviceFn { pub reset_query_pool_ext: PFN_vkResetQueryPool, } 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 { reset_query_pool_ext: unsafe { unsafe extern "system" fn reset_query_pool_ext( _device: crate::vk::Device, _query_pool: QueryPool, _first_query: u32, _query_count: u32, ) { panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0"); let val = _f(cname); if val.is_null() { reset_query_pool_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_index_type_uint8"] pub mod index_type_uint8 { use super::super::*; pub use { crate::vk::EXT_INDEX_TYPE_UINT8_NAME as NAME, crate::vk::EXT_INDEX_TYPE_UINT8_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_extended_dynamic_state"] pub mod extended_dynamic_state { use super::super::*; pub use { crate::vk::EXT_EXTENDED_DYNAMIC_STATE_NAME as NAME, crate::vk::EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_extended_dynamic_state 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_extended_dynamic_state device-level function pointers"] pub struct DeviceFn { pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode, pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace, pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology, pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount, pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount, pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2, pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable, pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable, pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp, pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable, pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable, pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp, } 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_set_cull_mode_ext: unsafe { unsafe extern "system" fn cmd_set_cull_mode_ext( _command_buffer: CommandBuffer, _cull_mode: CullModeFlags, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_cull_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_cull_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_front_face_ext: unsafe { unsafe extern "system" fn cmd_set_front_face_ext( _command_buffer: CommandBuffer, _front_face: FrontFace, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_front_face_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_front_face_ext } else { ::core::mem::transmute(val) } }, cmd_set_primitive_topology_ext: unsafe { unsafe extern "system" fn cmd_set_primitive_topology_ext( _command_buffer: CommandBuffer, _primitive_topology: PrimitiveTopology, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_primitive_topology_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopologyEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_primitive_topology_ext } else { ::core::mem::transmute(val) } }, cmd_set_viewport_with_count_ext: unsafe { unsafe extern "system" fn cmd_set_viewport_with_count_ext( _command_buffer: CommandBuffer, _viewport_count: u32, _p_viewports: *const Viewport, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_viewport_with_count_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCountEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_viewport_with_count_ext } else { ::core::mem::transmute(val) } }, cmd_set_scissor_with_count_ext: unsafe { unsafe extern "system" fn cmd_set_scissor_with_count_ext( _command_buffer: CommandBuffer, _scissor_count: u32, _p_scissors: *const Rect2D, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_scissor_with_count_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCountEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_scissor_with_count_ext } else { ::core::mem::transmute(val) } }, cmd_bind_vertex_buffers2_ext: unsafe { unsafe extern "system" fn cmd_bind_vertex_buffers2_ext( _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_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2EXT\0"); let val = _f(cname); if val.is_null() { cmd_bind_vertex_buffers2_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_test_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_test_enable_ext( _command_buffer: CommandBuffer, _depth_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_test_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_test_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_write_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_write_enable_ext( _command_buffer: CommandBuffer, _depth_write_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_write_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_write_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_compare_op_ext: unsafe { unsafe extern "system" fn cmd_set_depth_compare_op_ext( _command_buffer: CommandBuffer, _depth_compare_op: CompareOp, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_compare_op_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_compare_op_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_bounds_test_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext( _command_buffer: CommandBuffer, _depth_bounds_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_bounds_test_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetDepthBoundsTestEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_depth_bounds_test_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_stencil_test_enable_ext: unsafe { unsafe extern "system" fn cmd_set_stencil_test_enable_ext( _command_buffer: CommandBuffer, _stencil_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_stencil_test_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_stencil_test_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_stencil_op_ext: unsafe { unsafe extern "system" fn cmd_set_stencil_op_ext( _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_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_stencil_op_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_host_image_copy"] pub mod host_image_copy { use super::super::*; pub use { crate::vk::EXT_HOST_IMAGE_COPY_NAME as NAME, crate::vk::EXT_HOST_IMAGE_COPY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_host_image_copy 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_host_image_copy device-level function pointers"] pub struct DeviceFn { pub copy_memory_to_image_ext: PFN_vkCopyMemoryToImageEXT, pub copy_image_to_memory_ext: PFN_vkCopyImageToMemoryEXT, pub copy_image_to_image_ext: PFN_vkCopyImageToImageEXT, pub transition_image_layout_ext: PFN_vkTransitionImageLayoutEXT, pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2KHR, } 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 { copy_memory_to_image_ext: unsafe { unsafe extern "system" fn copy_memory_to_image_ext( _device: crate::vk::Device, _p_copy_memory_to_image_info: *const CopyMemoryToImageInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(copy_memory_to_image_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToImageEXT\0"); let val = _f(cname); if val.is_null() { copy_memory_to_image_ext } else { ::core::mem::transmute(val) } }, copy_image_to_memory_ext: unsafe { unsafe extern "system" fn copy_image_to_memory_ext( _device: crate::vk::Device, _p_copy_image_to_memory_info: *const CopyImageToMemoryInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(copy_image_to_memory_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToMemoryEXT\0"); let val = _f(cname); if val.is_null() { copy_image_to_memory_ext } else { ::core::mem::transmute(val) } }, copy_image_to_image_ext: unsafe { unsafe extern "system" fn copy_image_to_image_ext( _device: crate::vk::Device, _p_copy_image_to_image_info: *const CopyImageToImageInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(copy_image_to_image_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyImageToImageEXT\0"); let val = _f(cname); if val.is_null() { copy_image_to_image_ext } else { ::core::mem::transmute(val) } }, transition_image_layout_ext: unsafe { unsafe extern "system" fn transition_image_layout_ext( _device: crate::vk::Device, _transition_count: u32, _p_transitions: *const HostImageLayoutTransitionInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(transition_image_layout_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkTransitionImageLayoutEXT\0"); let val = _f(cname); if val.is_null() { transition_image_layout_ext } else { ::core::mem::transmute(val) } }, get_image_subresource_layout2_ext: unsafe { unsafe extern "system" fn get_image_subresource_layout2_ext( _device: crate::vk::Device, _image: Image, _p_subresource: *const ImageSubresource2KHR<'_>, _p_layout: *mut SubresourceLayout2KHR<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_image_subresource_layout2_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetImageSubresourceLayout2EXT\0", ); let val = _f(cname); if val.is_null() { get_image_subresource_layout2_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_map_memory_placed"] pub mod map_memory_placed { use super::super::*; pub use { crate::vk::EXT_MAP_MEMORY_PLACED_NAME as NAME, crate::vk::EXT_MAP_MEMORY_PLACED_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_shader_atomic_float2"] pub mod shader_atomic_float2 { use super::super::*; pub use { crate::vk::EXT_SHADER_ATOMIC_FLOAT2_NAME as NAME, crate::vk::EXT_SHADER_ATOMIC_FLOAT2_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_surface_maintenance1"] pub mod surface_maintenance1 { use super::super::*; pub use { crate::vk::EXT_SURFACE_MAINTENANCE1_NAME as NAME, crate::vk::EXT_SURFACE_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_swapchain_maintenance1"] pub mod swapchain_maintenance1 { use super::super::*; pub use { crate::vk::EXT_SWAPCHAIN_MAINTENANCE1_NAME as NAME, crate::vk::EXT_SWAPCHAIN_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_swapchain_maintenance1 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_swapchain_maintenance1 device-level function pointers"] pub struct DeviceFn { pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT, } 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 { release_swapchain_images_ext: unsafe { unsafe extern "system" fn release_swapchain_images_ext( _device: crate::vk::Device, _p_release_info: *const ReleaseSwapchainImagesInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(release_swapchain_images_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkReleaseSwapchainImagesEXT\0"); let val = _f(cname); if val.is_null() { release_swapchain_images_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_shader_demote_to_helper_invocation"] pub mod shader_demote_to_helper_invocation { use super::super::*; pub use { crate::vk::EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_NAME as NAME, crate::vk::EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_texel_buffer_alignment"] pub mod texel_buffer_alignment { use super::super::*; pub use { crate::vk::EXT_TEXEL_BUFFER_ALIGNMENT_NAME as NAME, crate::vk::EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_depth_bias_control"] pub mod depth_bias_control { use super::super::*; pub use { crate::vk::EXT_DEPTH_BIAS_CONTROL_NAME as NAME, crate::vk::EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_depth_bias_control 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_depth_bias_control device-level function pointers"] pub struct DeviceFn { pub cmd_set_depth_bias2_ext: PFN_vkCmdSetDepthBias2EXT, } 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_set_depth_bias2_ext: unsafe { unsafe extern "system" fn cmd_set_depth_bias2_ext( _command_buffer: CommandBuffer, _p_depth_bias_info: *const DepthBiasInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_bias2_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias2EXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_bias2_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_device_memory_report"] pub mod device_memory_report { use super::super::*; pub use { crate::vk::EXT_DEVICE_MEMORY_REPORT_NAME as NAME, crate::vk::EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_acquire_drm_display"] pub mod acquire_drm_display { use super::super::*; pub use { crate::vk::EXT_ACQUIRE_DRM_DISPLAY_NAME as NAME, crate::vk::EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_acquire_drm_display 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_acquire_drm_display instance-level function pointers"] pub struct InstanceFn { pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXT, pub get_drm_display_ext: PFN_vkGetDrmDisplayEXT, } 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 { acquire_drm_display_ext: unsafe { unsafe extern "system" fn acquire_drm_display_ext( _physical_device: PhysicalDevice, _drm_fd: i32, _display: DisplayKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(acquire_drm_display_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireDrmDisplayEXT\0"); let val = _f(cname); if val.is_null() { acquire_drm_display_ext } else { ::core::mem::transmute(val) } }, get_drm_display_ext: unsafe { unsafe extern "system" fn get_drm_display_ext( _physical_device: PhysicalDevice, _drm_fd: i32, _connector_id: u32, _display: *mut DisplayKHR, ) -> Result { panic!(concat!("Unable to load ", stringify!(get_drm_display_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetDrmDisplayEXT\0"); let val = _f(cname); if val.is_null() { get_drm_display_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_robustness2"] pub mod robustness2 { use super::super::*; pub use { crate::vk::EXT_ROBUSTNESS2_NAME as NAME, crate::vk::EXT_ROBUSTNESS2_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_custom_border_color"] pub mod custom_border_color { use super::super::*; pub use { crate::vk::EXT_CUSTOM_BORDER_COLOR_NAME as NAME, crate::vk::EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_private_data"] pub mod private_data { use super::super::*; pub use { crate::vk::EXT_PRIVATE_DATA_NAME as NAME, crate::vk::EXT_PRIVATE_DATA_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_private_data 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_private_data device-level function pointers"] pub struct DeviceFn { pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot, pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlot, pub set_private_data_ext: PFN_vkSetPrivateData, pub get_private_data_ext: PFN_vkGetPrivateData, } 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_private_data_slot_ext: unsafe { unsafe extern "system" fn create_private_data_slot_ext( _device: crate::vk::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_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlotEXT\0"); let val = _f(cname); if val.is_null() { create_private_data_slot_ext } else { ::core::mem::transmute(val) } }, destroy_private_data_slot_ext: unsafe { unsafe extern "system" fn destroy_private_data_slot_ext( _device: crate::vk::Device, _private_data_slot: PrivateDataSlot, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!( "Unable to load ", stringify!(destroy_private_data_slot_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlotEXT\0"); let val = _f(cname); if val.is_null() { destroy_private_data_slot_ext } else { ::core::mem::transmute(val) } }, set_private_data_ext: unsafe { unsafe extern "system" fn set_private_data_ext( _device: crate::vk::Device, _object_type: ObjectType, _object_handle: u64, _private_data_slot: PrivateDataSlot, _data: u64, ) -> Result { panic!(concat!("Unable to load ", stringify!(set_private_data_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateDataEXT\0"); let val = _f(cname); if val.is_null() { set_private_data_ext } else { ::core::mem::transmute(val) } }, get_private_data_ext: unsafe { unsafe extern "system" fn get_private_data_ext( _device: crate::vk::Device, _object_type: ObjectType, _object_handle: u64, _private_data_slot: PrivateDataSlot, _p_data: *mut u64, ) { panic!(concat!("Unable to load ", stringify!(get_private_data_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0"); let val = _f(cname); if val.is_null() { get_private_data_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_pipeline_creation_cache_control"] pub mod pipeline_creation_cache_control { use super::super::*; pub use { crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_NAME as NAME, crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_metal_objects"] pub mod metal_objects { use super::super::*; pub use { crate::vk::EXT_METAL_OBJECTS_NAME as NAME, crate::vk::EXT_METAL_OBJECTS_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_metal_objects 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_metal_objects device-level function pointers"] pub struct DeviceFn { pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT, } 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 { export_metal_objects_ext: unsafe { unsafe extern "system" fn export_metal_objects_ext( _device: crate::vk::Device, _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(export_metal_objects_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0"); let val = _f(cname); if val.is_null() { export_metal_objects_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_descriptor_buffer"] pub mod descriptor_buffer { use super::super::*; pub use { crate::vk::EXT_DESCRIPTOR_BUFFER_NAME as NAME, crate::vk::EXT_DESCRIPTOR_BUFFER_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_descriptor_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_EXT_descriptor_buffer device-level function pointers"] pub struct DeviceFn { pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT, pub get_descriptor_set_layout_binding_offset_ext: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT, pub get_descriptor_ext: PFN_vkGetDescriptorEXT, pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT, pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT, pub cmd_bind_descriptor_buffer_embedded_samplers_ext: PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT, pub get_buffer_opaque_capture_descriptor_data_ext: PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT, pub get_image_opaque_capture_descriptor_data_ext: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT, pub get_image_view_opaque_capture_descriptor_data_ext: PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT, pub get_sampler_opaque_capture_descriptor_data_ext: PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT, pub get_acceleration_structure_opaque_capture_descriptor_data_ext: PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, } 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_descriptor_set_layout_size_ext: unsafe { unsafe extern "system" fn get_descriptor_set_layout_size_ext( _device: crate::vk::Device, _layout: DescriptorSetLayout, _p_layout_size_in_bytes: *mut DeviceSize, ) { panic!(concat!( "Unable to load ", stringify!(get_descriptor_set_layout_size_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDescriptorSetLayoutSizeEXT\0", ); let val = _f(cname); if val.is_null() { get_descriptor_set_layout_size_ext } else { ::core::mem::transmute(val) } }, get_descriptor_set_layout_binding_offset_ext: unsafe { unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext( _device: crate::vk::Device, _layout: DescriptorSetLayout, _binding: u32, _p_offset: *mut DeviceSize, ) { panic!(concat!( "Unable to load ", stringify!(get_descriptor_set_layout_binding_offset_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDescriptorSetLayoutBindingOffsetEXT\0", ); let val = _f(cname); if val.is_null() { get_descriptor_set_layout_binding_offset_ext } else { ::core::mem::transmute(val) } }, get_descriptor_ext: unsafe { unsafe extern "system" fn get_descriptor_ext( _device: crate::vk::Device, _p_descriptor_info: *const DescriptorGetInfoEXT<'_>, _data_size: usize, _p_descriptor: *mut c_void, ) { panic!(concat!("Unable to load ", stringify!(get_descriptor_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0"); let val = _f(cname); if val.is_null() { get_descriptor_ext } else { ::core::mem::transmute(val) } }, cmd_bind_descriptor_buffers_ext: unsafe { unsafe extern "system" fn cmd_bind_descriptor_buffers_ext( _command_buffer: CommandBuffer, _buffer_count: u32, _p_binding_infos: *const DescriptorBufferBindingInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_bind_descriptor_buffers_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorBuffersEXT\0"); let val = _f(cname); if val.is_null() { cmd_bind_descriptor_buffers_ext } else { ::core::mem::transmute(val) } }, cmd_set_descriptor_buffer_offsets_ext: unsafe { unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext( _command_buffer: CommandBuffer, _pipeline_bind_point: PipelineBindPoint, _layout: PipelineLayout, _first_set: u32, _set_count: u32, _p_buffer_indices: *const u32, _p_offsets: *const DeviceSize, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_descriptor_buffer_offsets_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetDescriptorBufferOffsetsEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_descriptor_buffer_offsets_ext } else { ::core::mem::transmute(val) } }, cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe { unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext( _command_buffer: CommandBuffer, _pipeline_bind_point: PipelineBindPoint, _layout: PipelineLayout, _set: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0", ); let val = _f(cname); if val.is_null() { cmd_bind_descriptor_buffer_embedded_samplers_ext } else { ::core::mem::transmute(val) } }, get_buffer_opaque_capture_descriptor_data_ext: unsafe { unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext( _device: crate::vk::Device, _p_info: *const BufferCaptureDescriptorDataInfoEXT<'_>, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_buffer_opaque_capture_descriptor_data_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0", ); let val = _f(cname); if val.is_null() { get_buffer_opaque_capture_descriptor_data_ext } else { ::core::mem::transmute(val) } }, get_image_opaque_capture_descriptor_data_ext: unsafe { unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext( _device: crate::vk::Device, _p_info: *const ImageCaptureDescriptorDataInfoEXT<'_>, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_image_opaque_capture_descriptor_data_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetImageOpaqueCaptureDescriptorDataEXT\0", ); let val = _f(cname); if val.is_null() { get_image_opaque_capture_descriptor_data_ext } else { ::core::mem::transmute(val) } }, get_image_view_opaque_capture_descriptor_data_ext: unsafe { unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext( _device: crate::vk::Device, _p_info: *const ImageViewCaptureDescriptorDataInfoEXT<'_>, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_image_view_opaque_capture_descriptor_data_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0", ); let val = _f(cname); if val.is_null() { get_image_view_opaque_capture_descriptor_data_ext } else { ::core::mem::transmute(val) } }, get_sampler_opaque_capture_descriptor_data_ext: unsafe { unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext( _device: crate::vk::Device, _p_info: *const SamplerCaptureDescriptorDataInfoEXT<'_>, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_sampler_opaque_capture_descriptor_data_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0", ); let val = _f(cname); if val.is_null() { get_sampler_opaque_capture_descriptor_data_ext } else { ::core::mem::transmute(val) } }, get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe { unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ _device: crate::vk::Device, _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT<'_>, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!( get_acceleration_structure_opaque_capture_descriptor_data_ext ) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0", ); let val = _f(cname); if val.is_null() { get_acceleration_structure_opaque_capture_descriptor_data_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_graphics_pipeline_library"] pub mod graphics_pipeline_library { use super::super::*; pub use { crate::vk::EXT_GRAPHICS_PIPELINE_LIBRARY_NAME as NAME, crate::vk::EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_mesh_shader"] pub mod mesh_shader { use super::super::*; pub use { crate::vk::EXT_MESH_SHADER_NAME as NAME, crate::vk::EXT_MESH_SHADER_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_mesh_shader 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_mesh_shader device-level function pointers"] pub struct DeviceFn { pub cmd_draw_mesh_tasks_ext: PFN_vkCmdDrawMeshTasksEXT, pub cmd_draw_mesh_tasks_indirect_ext: PFN_vkCmdDrawMeshTasksIndirectEXT, pub cmd_draw_mesh_tasks_indirect_count_ext: PFN_vkCmdDrawMeshTasksIndirectCountEXT } 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_mesh_tasks_ext: unsafe { unsafe extern "system" fn cmd_draw_mesh_tasks_ext( _command_buffer: CommandBuffer, _group_count_x: u32, _group_count_y: u32, _group_count_z: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_draw_mesh_tasks_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksEXT\0"); let val = _f(cname); if val.is_null() { cmd_draw_mesh_tasks_ext } else { ::core::mem::transmute(val) } }, cmd_draw_mesh_tasks_indirect_ext: unsafe { unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_ext( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, _draw_count: u32, _stride: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_draw_mesh_tasks_indirect_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksIndirectEXT\0"); let val = _f(cname); if val.is_null() { cmd_draw_mesh_tasks_indirect_ext } else { ::core::mem::transmute(val) } }, cmd_draw_mesh_tasks_indirect_count_ext: unsafe { unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_ext( _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_mesh_tasks_indirect_count_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdDrawMeshTasksIndirectCountEXT\0", ); let val = _f(cname); if val.is_null() { cmd_draw_mesh_tasks_indirect_count_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_ycbcr_2plane_444_formats"] pub mod ycbcr_2plane_444_formats { use super::super::*; pub use { crate::vk::EXT_YCBCR_2PLANE_444_FORMATS_NAME as NAME, crate::vk::EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_fragment_density_map2"] pub mod fragment_density_map2 { use super::super::*; pub use { crate::vk::EXT_FRAGMENT_DENSITY_MAP2_NAME as NAME, crate::vk::EXT_FRAGMENT_DENSITY_MAP2_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_image_robustness"] pub mod image_robustness { use super::super::*; pub use { crate::vk::EXT_IMAGE_ROBUSTNESS_NAME as NAME, crate::vk::EXT_IMAGE_ROBUSTNESS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_image_compression_control"] pub mod image_compression_control { use super::super::*; pub use { crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_NAME as NAME, crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_image_compression_control 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_image_compression_control device-level function pointers"] pub struct DeviceFn { pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2KHR, } 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_image_subresource_layout2_ext: unsafe { unsafe extern "system" fn get_image_subresource_layout2_ext( _device: crate::vk::Device, _image: Image, _p_subresource: *const ImageSubresource2KHR<'_>, _p_layout: *mut SubresourceLayout2KHR<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_image_subresource_layout2_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetImageSubresourceLayout2EXT\0", ); let val = _f(cname); if val.is_null() { get_image_subresource_layout2_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_attachment_feedback_loop_layout"] pub mod attachment_feedback_loop_layout { use super::super::*; pub use { crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_NAME as NAME, crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_4444_formats"] pub mod _4444_formats { use super::super::*; pub use { crate::vk::EXT_4444_FORMATS_NAME as NAME, crate::vk::EXT_4444_FORMATS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_device_fault"] pub mod device_fault { use super::super::*; pub use { crate::vk::EXT_DEVICE_FAULT_NAME as NAME, crate::vk::EXT_DEVICE_FAULT_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_device_fault 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_device_fault device-level function pointers"] pub struct DeviceFn { pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT, } 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_device_fault_info_ext: unsafe { unsafe extern "system" fn get_device_fault_info_ext( _device: crate::vk::Device, _p_fault_counts: *mut DeviceFaultCountsEXT<'_>, _p_fault_info: *mut DeviceFaultInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_device_fault_info_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0"); let val = _f(cname); if val.is_null() { get_device_fault_info_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_rgba10x6_formats"] pub mod rgba10x6_formats { use super::super::*; pub use { crate::vk::EXT_RGBA10X6_FORMATS_NAME as NAME, crate::vk::EXT_RGBA10X6_FORMATS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_directfb_surface"] pub mod directfb_surface { use super::super::*; pub use { crate::vk::EXT_DIRECTFB_SURFACE_NAME as NAME, crate::vk::EXT_DIRECTFB_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_directfb_surface 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_directfb_surface instance-level function pointers"] pub struct InstanceFn { pub create_direct_fb_surface_ext: PFN_vkCreateDirectFBSurfaceEXT, pub get_physical_device_direct_fb_presentation_support_ext: PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT, } 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_direct_fb_surface_ext: unsafe { unsafe extern "system" fn create_direct_fb_surface_ext( _instance: crate::vk::Instance, _p_create_info: *const DirectFBSurfaceCreateInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_direct_fb_surface_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateDirectFBSurfaceEXT\0"); let val = _f(cname); if val.is_null() { create_direct_fb_surface_ext } else { ::core::mem::transmute(val) } }, get_physical_device_direct_fb_presentation_support_ext: unsafe { unsafe extern "system" fn get_physical_device_direct_fb_presentation_support_ext( _physical_device: PhysicalDevice, _queue_family_index: u32, _dfb: *mut IDirectFB, ) -> Bool32 { panic!(concat!( "Unable to load ", stringify!(get_physical_device_direct_fb_presentation_support_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceDirectFBPresentationSupportEXT\0", ); let val = _f(cname); if val.is_null() { get_physical_device_direct_fb_presentation_support_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_vertex_input_dynamic_state"] pub mod vertex_input_dynamic_state { use super::super::*; pub use { crate::vk::EXT_VERTEX_INPUT_DYNAMIC_STATE_NAME as NAME, crate::vk::EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_vertex_input_dynamic_state 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_vertex_input_dynamic_state device-level function pointers"] pub struct DeviceFn { pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT, } 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_set_vertex_input_ext: unsafe { unsafe extern "system" fn cmd_set_vertex_input_ext( _command_buffer: CommandBuffer, _vertex_binding_description_count: u32, _p_vertex_binding_descriptions : * const VertexInputBindingDescription2EXT < '_ >, _vertex_attribute_description_count: u32, _p_vertex_attribute_descriptions : * const VertexInputAttributeDescription2EXT < '_ >, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_vertex_input_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_vertex_input_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_physical_device_drm"] pub mod physical_device_drm { use super::super::*; pub use { crate::vk::EXT_PHYSICAL_DEVICE_DRM_NAME as NAME, crate::vk::EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_device_address_binding_report"] pub mod device_address_binding_report { use super::super::*; pub use { crate::vk::EXT_DEVICE_ADDRESS_BINDING_REPORT_NAME as NAME, crate::vk::EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_depth_clip_control"] pub mod depth_clip_control { use super::super::*; pub use { crate::vk::EXT_DEPTH_CLIP_CONTROL_NAME as NAME, crate::vk::EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_primitive_topology_list_restart"] pub mod primitive_topology_list_restart { use super::super::*; pub use { crate::vk::EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_NAME as NAME, crate::vk::EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_pipeline_properties"] pub mod pipeline_properties { use super::super::*; pub use { crate::vk::EXT_PIPELINE_PROPERTIES_NAME as NAME, crate::vk::EXT_PIPELINE_PROPERTIES_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_pipeline_properties 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 } } #[allow(non_camel_case_types)] #[doc = "Implemented for all types that can be passed as argument to `pipeline_properties` in [ pub unsafe trait GetPipelinePropertiesEXTParamPipelineProperties {} unsafe impl GetPipelinePropertiesEXTParamPipelineProperties for PipelinePropertiesIdentifierEXT<'_> { } #[derive(Clone)] #[doc = "Raw VK_EXT_pipeline_properties device-level function pointers"] pub struct DeviceFn { pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT, } 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_pipeline_properties_ext: unsafe { unsafe extern "system" fn get_pipeline_properties_ext( _device: crate::vk::Device, _p_pipeline_info: *const PipelineInfoEXT<'_>, _p_pipeline_properties: *mut BaseOutStructure<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_pipeline_properties_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetPipelinePropertiesEXT\0"); let val = _f(cname); if val.is_null() { get_pipeline_properties_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_frame_boundary"] pub mod frame_boundary { use super::super::*; pub use { crate::vk::EXT_FRAME_BOUNDARY_NAME as NAME, crate::vk::EXT_FRAME_BOUNDARY_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_multisampled_render_to_single_sampled"] pub mod multisampled_render_to_single_sampled { use super::super::*; pub use { crate::vk::EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_NAME as NAME, crate::vk::EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_extended_dynamic_state2"] pub mod extended_dynamic_state2 { use super::super::*; pub use { crate::vk::EXT_EXTENDED_DYNAMIC_STATE2_NAME as NAME, crate::vk::EXT_EXTENDED_DYNAMIC_STATE2_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_extended_dynamic_state2 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_extended_dynamic_state2 device-level function pointers"] pub struct DeviceFn { pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT, pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable, pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable, pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT, pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable, } 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_set_patch_control_points_ext: unsafe { unsafe extern "system" fn cmd_set_patch_control_points_ext( _command_buffer: CommandBuffer, _patch_control_points: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_patch_control_points_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPatchControlPointsEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_patch_control_points_ext } else { ::core::mem::transmute(val) } }, cmd_set_rasterizer_discard_enable_ext: unsafe { unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext( _command_buffer: CommandBuffer, _rasterizer_discard_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_rasterizer_discard_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRasterizerDiscardEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_rasterizer_discard_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_bias_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_bias_enable_ext( _command_buffer: CommandBuffer, _depth_bias_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_bias_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_bias_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_logic_op_ext: unsafe { unsafe extern "system" fn cmd_set_logic_op_ext( _command_buffer: CommandBuffer, _logic_op: LogicOp, ) { panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_logic_op_ext } else { ::core::mem::transmute(val) } }, cmd_set_primitive_restart_enable_ext: unsafe { unsafe extern "system" fn cmd_set_primitive_restart_enable_ext( _command_buffer: CommandBuffer, _primitive_restart_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_primitive_restart_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetPrimitiveRestartEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_primitive_restart_enable_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_color_write_enable"] pub mod color_write_enable { use super::super::*; pub use { crate::vk::EXT_COLOR_WRITE_ENABLE_NAME as NAME, crate::vk::EXT_COLOR_WRITE_ENABLE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_color_write_enable 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_color_write_enable device-level function pointers"] pub struct DeviceFn { pub cmd_set_color_write_enable_ext: PFN_vkCmdSetColorWriteEnableEXT, } 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_set_color_write_enable_ext: unsafe { unsafe extern "system" fn cmd_set_color_write_enable_ext( _command_buffer: CommandBuffer, _attachment_count: u32, _p_color_write_enables: *const Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_write_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_write_enable_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_primitives_generated_query"] pub mod primitives_generated_query { use super::super::*; pub use { crate::vk::EXT_PRIMITIVES_GENERATED_QUERY_NAME as NAME, crate::vk::EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_global_priority_query"] pub mod global_priority_query { use super::super::*; pub use { crate::vk::EXT_GLOBAL_PRIORITY_QUERY_NAME as NAME, crate::vk::EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_image_view_min_lod"] pub mod image_view_min_lod { use super::super::*; pub use { crate::vk::EXT_IMAGE_VIEW_MIN_LOD_NAME as NAME, crate::vk::EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_multi_draw"] pub mod multi_draw { use super::super::*; pub use { crate::vk::EXT_MULTI_DRAW_NAME as NAME, crate::vk::EXT_MULTI_DRAW_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_multi_draw 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_multi_draw device-level function pointers"] pub struct DeviceFn { pub cmd_draw_multi_ext: PFN_vkCmdDrawMultiEXT, pub cmd_draw_multi_indexed_ext: PFN_vkCmdDrawMultiIndexedEXT, } 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_multi_ext: unsafe { unsafe extern "system" fn cmd_draw_multi_ext( _command_buffer: CommandBuffer, _draw_count: u32, _p_vertex_info: *const MultiDrawInfoEXT, _instance_count: u32, _first_instance: u32, _stride: u32, ) { panic!(concat!("Unable to load ", stringify!(cmd_draw_multi_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiEXT\0"); let val = _f(cname); if val.is_null() { cmd_draw_multi_ext } else { ::core::mem::transmute(val) } }, cmd_draw_multi_indexed_ext: unsafe { unsafe extern "system" fn cmd_draw_multi_indexed_ext( _command_buffer: CommandBuffer, _draw_count: u32, _p_index_info: *const MultiDrawIndexedInfoEXT, _instance_count: u32, _first_instance: u32, _stride: u32, _p_vertex_offset: *const i32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_draw_multi_indexed_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiIndexedEXT\0"); let val = _f(cname); if val.is_null() { cmd_draw_multi_indexed_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_image_2d_view_of_3d"] pub mod image_2d_view_of_3d { use super::super::*; pub use { crate::vk::EXT_IMAGE_2D_VIEW_OF_3D_NAME as NAME, crate::vk::EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_shader_tile_image"] pub mod shader_tile_image { use super::super::*; pub use { crate::vk::EXT_SHADER_TILE_IMAGE_NAME as NAME, crate::vk::EXT_SHADER_TILE_IMAGE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_opacity_micromap"] pub mod opacity_micromap { use super::super::*; pub use { crate::vk::EXT_OPACITY_MICROMAP_NAME as NAME, crate::vk::EXT_OPACITY_MICROMAP_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_opacity_micromap 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_opacity_micromap device-level function pointers"] pub struct DeviceFn { pub create_micromap_ext: PFN_vkCreateMicromapEXT, pub destroy_micromap_ext: PFN_vkDestroyMicromapEXT, pub cmd_build_micromaps_ext: PFN_vkCmdBuildMicromapsEXT, pub build_micromaps_ext: PFN_vkBuildMicromapsEXT, pub copy_micromap_ext: PFN_vkCopyMicromapEXT, pub copy_micromap_to_memory_ext: PFN_vkCopyMicromapToMemoryEXT, pub copy_memory_to_micromap_ext: PFN_vkCopyMemoryToMicromapEXT, pub write_micromaps_properties_ext: PFN_vkWriteMicromapsPropertiesEXT, pub cmd_copy_micromap_ext: PFN_vkCmdCopyMicromapEXT, pub cmd_copy_micromap_to_memory_ext: PFN_vkCmdCopyMicromapToMemoryEXT, pub cmd_copy_memory_to_micromap_ext: PFN_vkCmdCopyMemoryToMicromapEXT, pub cmd_write_micromaps_properties_ext: PFN_vkCmdWriteMicromapsPropertiesEXT, pub get_device_micromap_compatibility_ext: PFN_vkGetDeviceMicromapCompatibilityEXT pub get_micromap_build_sizes_ext: PFN_vkGetMicromapBuildSizesEXT, } 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_micromap_ext: unsafe { unsafe extern "system" fn create_micromap_ext( _device: crate::vk::Device, _p_create_info: *const MicromapCreateInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_micromap: *mut MicromapEXT, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_micromap_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0"); let val = _f(cname); if val.is_null() { create_micromap_ext } else { ::core::mem::transmute(val) } }, destroy_micromap_ext: unsafe { unsafe extern "system" fn destroy_micromap_ext( _device: crate::vk::Device, _micromap: MicromapEXT, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0"); let val = _f(cname); if val.is_null() { destroy_micromap_ext } else { ::core::mem::transmute(val) } }, cmd_build_micromaps_ext: unsafe { unsafe extern "system" fn cmd_build_micromaps_ext( _command_buffer: CommandBuffer, _info_count: u32, _p_infos: *const MicromapBuildInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_build_micromaps_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0"); let val = _f(cname); if val.is_null() { cmd_build_micromaps_ext } else { ::core::mem::transmute(val) } }, build_micromaps_ext: unsafe { unsafe extern "system" fn build_micromaps_ext( _device: crate::vk::Device, _deferred_operation: DeferredOperationKHR, _info_count: u32, _p_infos: *const MicromapBuildInfoEXT<'_>, ) -> Result { panic!(concat!("Unable to load ", stringify!(build_micromaps_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0"); let val = _f(cname); if val.is_null() { build_micromaps_ext } else { ::core::mem::transmute(val) } }, copy_micromap_ext: unsafe { unsafe extern "system" fn copy_micromap_ext( _device: crate::vk::Device, _deferred_operation: DeferredOperationKHR, _p_info: *const CopyMicromapInfoEXT<'_>, ) -> Result { panic!(concat!("Unable to load ", stringify!(copy_micromap_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0"); let val = _f(cname); if val.is_null() { copy_micromap_ext } else { ::core::mem::transmute(val) } }, copy_micromap_to_memory_ext: unsafe { unsafe extern "system" fn copy_micromap_to_memory_ext( _device: crate::vk::Device, _deferred_operation: DeferredOperationKHR, _p_info: *const CopyMicromapToMemoryInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(copy_micromap_to_memory_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0"); let val = _f(cname); if val.is_null() { copy_micromap_to_memory_ext } else { ::core::mem::transmute(val) } }, copy_memory_to_micromap_ext: unsafe { unsafe extern "system" fn copy_memory_to_micromap_ext( _device: crate::vk::Device, _deferred_operation: DeferredOperationKHR, _p_info: *const CopyMemoryToMicromapInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(copy_memory_to_micromap_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0"); let val = _f(cname); if val.is_null() { copy_memory_to_micromap_ext } else { ::core::mem::transmute(val) } }, write_micromaps_properties_ext: unsafe { unsafe extern "system" fn write_micromaps_properties_ext( _device: crate::vk::Device, _micromap_count: u32, _p_micromaps: *const MicromapEXT, _query_type: QueryType, _data_size: usize, _p_data: *mut c_void, _stride: usize, ) -> Result { panic!(concat!( "Unable to load ", stringify!(write_micromaps_properties_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkWriteMicromapsPropertiesEXT\0"); let val = _f(cname); if val.is_null() { write_micromaps_properties_ext } else { ::core::mem::transmute(val) } }, cmd_copy_micromap_ext: unsafe { unsafe extern "system" fn cmd_copy_micromap_ext( _command_buffer: CommandBuffer, _p_info: *const CopyMicromapInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_copy_micromap_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0"); let val = _f(cname); if val.is_null() { cmd_copy_micromap_ext } else { ::core::mem::transmute(val) } }, cmd_copy_micromap_to_memory_ext: unsafe { unsafe extern "system" fn cmd_copy_micromap_to_memory_ext( _command_buffer: CommandBuffer, _p_info: *const CopyMicromapToMemoryInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_copy_micromap_to_memory_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapToMemoryEXT\0"); let val = _f(cname); if val.is_null() { cmd_copy_micromap_to_memory_ext } else { ::core::mem::transmute(val) } }, cmd_copy_memory_to_micromap_ext: unsafe { unsafe extern "system" fn cmd_copy_memory_to_micromap_ext( _command_buffer: CommandBuffer, _p_info: *const CopyMemoryToMicromapInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_copy_memory_to_micromap_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryToMicromapEXT\0"); let val = _f(cname); if val.is_null() { cmd_copy_memory_to_micromap_ext } else { ::core::mem::transmute(val) } }, cmd_write_micromaps_properties_ext: unsafe { unsafe extern "system" fn cmd_write_micromaps_properties_ext( _command_buffer: CommandBuffer, _micromap_count: u32, _p_micromaps: *const MicromapEXT, _query_type: QueryType, _query_pool: QueryPool, _first_query: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_write_micromaps_properties_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdWriteMicromapsPropertiesEXT\0", ); let val = _f(cname); if val.is_null() { cmd_write_micromaps_properties_ext } else { ::core::mem::transmute(val) } }, get_device_micromap_compatibility_ext: unsafe { unsafe extern "system" fn get_device_micromap_compatibility_ext( _device: crate::vk::Device, _p_version_info: *const MicromapVersionInfoEXT<'_>, _p_compatibility: *mut AccelerationStructureCompatibilityKHR, ) { panic!(concat!( "Unable to load ", stringify!(get_device_micromap_compatibility_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDeviceMicromapCompatibilityEXT\0", ); let val = _f(cname); if val.is_null() { get_device_micromap_compatibility_ext } else { ::core::mem::transmute(val) } }, get_micromap_build_sizes_ext: unsafe { unsafe extern "system" fn get_micromap_build_sizes_ext( _device: crate::vk::Device, _build_type: AccelerationStructureBuildTypeKHR, _p_build_info: *const MicromapBuildInfoEXT<'_>, _p_size_info: *mut MicromapBuildSizesInfoEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_micromap_build_sizes_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetMicromapBuildSizesEXT\0"); let val = _f(cname); if val.is_null() { get_micromap_build_sizes_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_load_store_op_none"] pub mod load_store_op_none { use super::super::*; pub use { crate::vk::EXT_LOAD_STORE_OP_NONE_NAME as NAME, crate::vk::EXT_LOAD_STORE_OP_NONE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_border_color_swizzle"] pub mod border_color_swizzle { use super::super::*; pub use { crate::vk::EXT_BORDER_COLOR_SWIZZLE_NAME as NAME, crate::vk::EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_pageable_device_local_memory"] pub mod pageable_device_local_memory { use super::super::*; pub use { crate::vk::EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_NAME as NAME, crate::vk::EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_pageable_device_local_memory 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_pageable_device_local_memory device-level function pointers"] pub struct DeviceFn { pub set_device_memory_priority_ext: PFN_vkSetDeviceMemoryPriorityEXT, } 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_device_memory_priority_ext: unsafe { unsafe extern "system" fn set_device_memory_priority_ext( _device: crate::vk::Device, _memory: DeviceMemory, _priority: f32, ) { panic!(concat!( "Unable to load ", stringify!(set_device_memory_priority_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkSetDeviceMemoryPriorityEXT\0"); let val = _f(cname); if val.is_null() { set_device_memory_priority_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_image_sliced_view_of_3d"] pub mod image_sliced_view_of_3d { use super::super::*; pub use { crate::vk::EXT_IMAGE_SLICED_VIEW_OF_3D_NAME as NAME, crate::vk::EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_depth_clamp_zero_one"] pub mod depth_clamp_zero_one { use super::super::*; pub use { crate::vk::EXT_DEPTH_CLAMP_ZERO_ONE_NAME as NAME, crate::vk::EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_non_seamless_cube_map"] pub mod non_seamless_cube_map { use super::super::*; pub use { crate::vk::EXT_NON_SEAMLESS_CUBE_MAP_NAME as NAME, crate::vk::EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_image_compression_control_swapchain"] pub mod image_compression_control_swapchain { use super::super::*; pub use { crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_NAME as NAME, crate::vk::EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_nested_command_buffer"] pub mod nested_command_buffer { use super::super::*; pub use { crate::vk::EXT_NESTED_COMMAND_BUFFER_NAME as NAME, crate::vk::EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_external_memory_acquire_unmodified"] pub mod external_memory_acquire_unmodified { use super::super::*; pub use { crate::vk::EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_NAME as NAME, crate::vk::EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_extended_dynamic_state3"] pub mod extended_dynamic_state3 { use super::super::*; pub use { crate::vk::EXT_EXTENDED_DYNAMIC_STATE3_NAME as NAME, crate::vk::EXT_EXTENDED_DYNAMIC_STATE3_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_extended_dynamic_state3 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_extended_dynamic_state3 device-level function pointers"] pub struct DeviceFn { pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT, pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT, pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT, pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT, pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT, pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT, pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT, pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT, pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT, pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT, pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEX pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT, pub cmd_set_conservative_rasterization_mode_ext: PFN_vkCmdSetConservativeRasterizationModeEXT, pub cmd_set_extra_primitive_overestimation_size_ext: PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT, pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT, pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT, pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT, pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT, pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT, pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT, pub cmd_set_depth_clip_negative_one_to_one_ext: PFN_vkCmdSetDepthClipNegativeOneToOneEXT, pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV, pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV, pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV, pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV, pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV, pub cmd_set_coverage_modulation_table_enable_nv: PFN_vkCmdSetCoverageModulationTableEnableNV, pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV, pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV, pub cmd_set_representative_fragment_test_enable_nv: PFN_vkCmdSetRepresentativeFragmentTestEnableNV, pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV, } 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_set_depth_clamp_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_clamp_enable_ext( _command_buffer: CommandBuffer, _depth_clamp_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_clamp_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClampEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_clamp_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_polygon_mode_ext: unsafe { unsafe extern "system" fn cmd_set_polygon_mode_ext( _command_buffer: CommandBuffer, _polygon_mode: PolygonMode, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_polygon_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_polygon_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_rasterization_samples_ext: unsafe { unsafe extern "system" fn cmd_set_rasterization_samples_ext( _command_buffer: CommandBuffer, _rasterization_samples: SampleCountFlags, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_rasterization_samples_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRasterizationSamplesEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_rasterization_samples_ext } else { ::core::mem::transmute(val) } }, cmd_set_sample_mask_ext: unsafe { unsafe extern "system" fn cmd_set_sample_mask_ext( _command_buffer: CommandBuffer, _samples: SampleCountFlags, _p_sample_mask: *const SampleMask, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_sample_mask_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_sample_mask_ext } else { ::core::mem::transmute(val) } }, cmd_set_alpha_to_coverage_enable_ext: unsafe { unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext( _command_buffer: CommandBuffer, _alpha_to_coverage_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_alpha_to_coverage_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetAlphaToCoverageEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_alpha_to_coverage_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_alpha_to_one_enable_ext: unsafe { unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext( _command_buffer: CommandBuffer, _alpha_to_one_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_alpha_to_one_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetAlphaToOneEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_alpha_to_one_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_logic_op_enable_ext: unsafe { unsafe extern "system" fn cmd_set_logic_op_enable_ext( _command_buffer: CommandBuffer, _logic_op_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_logic_op_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_logic_op_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_blend_enable_ext: unsafe { unsafe extern "system" fn cmd_set_color_blend_enable_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_blend_enables: *const Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_blend_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_blend_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_blend_equation_ext: unsafe { unsafe extern "system" fn cmd_set_color_blend_equation_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_blend_equations: *const ColorBlendEquationEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_blend_equation_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEquationEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_blend_equation_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_write_mask_ext: unsafe { unsafe extern "system" fn cmd_set_color_write_mask_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_write_masks: *const ColorComponentFlags, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_write_mask_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_write_mask_ext } else { ::core::mem::transmute(val) } }, cmd_set_tessellation_domain_origin_ext: unsafe { unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext( _command_buffer: CommandBuffer, _domain_origin: TessellationDomainOrigin, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_tessellation_domain_origin_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetTessellationDomainOriginEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_tessellation_domain_origin_ext } else { ::core::mem::transmute(val) } }, cmd_set_rasterization_stream_ext: unsafe { unsafe extern "system" fn cmd_set_rasterization_stream_ext( _command_buffer: CommandBuffer, _rasterization_stream: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_rasterization_stream_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRasterizationStreamEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_rasterization_stream_ext } else { ::core::mem::transmute(val) } }, cmd_set_conservative_rasterization_mode_ext: unsafe { unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext( _command_buffer: CommandBuffer, _conservative_rasterization_mode: ConservativeRasterizationModeEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_conservative_rasterization_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetConservativeRasterizationModeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_conservative_rasterization_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_extra_primitive_overestimation_size_ext: unsafe { unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext( _command_buffer: CommandBuffer, _extra_primitive_overestimation_size: f32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_extra_primitive_overestimation_size_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_extra_primitive_overestimation_size_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_clip_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_clip_enable_ext( _command_buffer: CommandBuffer, _depth_clip_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_clip_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClipEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_clip_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_sample_locations_enable_ext: unsafe { unsafe extern "system" fn cmd_set_sample_locations_enable_ext( _command_buffer: CommandBuffer, _sample_locations_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_sample_locations_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetSampleLocationsEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_sample_locations_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_blend_advanced_ext: unsafe { unsafe extern "system" fn cmd_set_color_blend_advanced_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_blend_advanced: *const ColorBlendAdvancedEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_blend_advanced_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendAdvancedEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_blend_advanced_ext } else { ::core::mem::transmute(val) } }, cmd_set_provoking_vertex_mode_ext: unsafe { unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext( _command_buffer: CommandBuffer, _provoking_vertex_mode: ProvokingVertexModeEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_provoking_vertex_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetProvokingVertexModeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_provoking_vertex_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_line_rasterization_mode_ext: unsafe { unsafe extern "system" fn cmd_set_line_rasterization_mode_ext( _command_buffer: CommandBuffer, _line_rasterization_mode: LineRasterizationModeEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_line_rasterization_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetLineRasterizationModeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_line_rasterization_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_line_stipple_enable_ext: unsafe { unsafe extern "system" fn cmd_set_line_stipple_enable_ext( _command_buffer: CommandBuffer, _stippled_line_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_line_stipple_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_line_stipple_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_clip_negative_one_to_one_ext: unsafe { unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext( _command_buffer: CommandBuffer, _negative_one_to_one: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_clip_negative_one_to_one_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetDepthClipNegativeOneToOneEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_depth_clip_negative_one_to_one_ext } else { ::core::mem::transmute(val) } }, cmd_set_viewport_w_scaling_enable_nv: unsafe { unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv( _command_buffer: CommandBuffer, _viewport_w_scaling_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_viewport_w_scaling_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetViewportWScalingEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_viewport_w_scaling_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_viewport_swizzle_nv: unsafe { unsafe extern "system" fn cmd_set_viewport_swizzle_nv( _command_buffer: CommandBuffer, _first_viewport: u32, _viewport_count: u32, _p_viewport_swizzles: *const ViewportSwizzleNV, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_viewport_swizzle_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0"); let val = _f(cname); if val.is_null() { cmd_set_viewport_swizzle_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_to_color_enable_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv( _command_buffer: CommandBuffer, _coverage_to_color_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_to_color_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageToColorEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_to_color_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_to_color_location_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_to_color_location_nv( _command_buffer: CommandBuffer, _coverage_to_color_location: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_to_color_location_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageToColorLocationNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_to_color_location_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_modulation_mode_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv( _command_buffer: CommandBuffer, _coverage_modulation_mode: CoverageModulationModeNV, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_modulation_mode_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageModulationModeNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_modulation_mode_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_modulation_table_enable_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv( _command_buffer: CommandBuffer, _coverage_modulation_table_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_modulation_table_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageModulationTableEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_modulation_table_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_modulation_table_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_modulation_table_nv( _command_buffer: CommandBuffer, _coverage_modulation_table_count: u32, _p_coverage_modulation_table: *const f32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_modulation_table_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageModulationTableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_modulation_table_nv } else { ::core::mem::transmute(val) } }, cmd_set_shading_rate_image_enable_nv: unsafe { unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv( _command_buffer: CommandBuffer, _shading_rate_image_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_shading_rate_image_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetShadingRateImageEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_shading_rate_image_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_representative_fragment_test_enable_nv: unsafe { unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv( _command_buffer: CommandBuffer, _representative_fragment_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_representative_fragment_test_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRepresentativeFragmentTestEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_representative_fragment_test_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_reduction_mode_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv( _command_buffer: CommandBuffer, _coverage_reduction_mode: CoverageReductionModeNV, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_reduction_mode_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageReductionModeNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_reduction_mode_nv } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_subpass_merge_feedback"] pub mod subpass_merge_feedback { use super::super::*; pub use { crate::vk::EXT_SUBPASS_MERGE_FEEDBACK_NAME as NAME, crate::vk::EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_shader_module_identifier"] pub mod shader_module_identifier { use super::super::*; pub use { crate::vk::EXT_SHADER_MODULE_IDENTIFIER_NAME as NAME, crate::vk::EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_shader_module_identifier 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_shader_module_identifier device-level function pointers"] pub struct DeviceFn { pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT, pub get_shader_module_create_info_identifier_ext: PFN_vkGetShaderModuleCreateInfoIdentifierEXT, } 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_module_identifier_ext: unsafe { unsafe extern "system" fn get_shader_module_identifier_ext( _device: crate::vk::Device, _shader_module: ShaderModule, _p_identifier: *mut ShaderModuleIdentifierEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_shader_module_identifier_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetShaderModuleIdentifierEXT\0", ); let val = _f(cname); if val.is_null() { get_shader_module_identifier_ext } else { ::core::mem::transmute(val) } }, get_shader_module_create_info_identifier_ext: unsafe { unsafe extern "system" fn get_shader_module_create_info_identifier_ext( _device: crate::vk::Device, _p_create_info: *const ShaderModuleCreateInfo<'_>, _p_identifier: *mut ShaderModuleIdentifierEXT<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_shader_module_create_info_identifier_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetShaderModuleCreateInfoIdentifierEXT\0", ); let val = _f(cname); if val.is_null() { get_shader_module_create_info_identifier_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_rasterization_order_attachment_access"] pub mod rasterization_order_attachment_access { use super::super::*; pub use { crate::vk::EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_NAME as NAME, crate::vk::EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_legacy_dithering"] pub mod legacy_dithering { use super::super::*; pub use { crate::vk::EXT_LEGACY_DITHERING_NAME as NAME, crate::vk::EXT_LEGACY_DITHERING_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_pipeline_protected_access"] pub mod pipeline_protected_access { use super::super::*; pub use { crate::vk::EXT_PIPELINE_PROTECTED_ACCESS_NAME as NAME, crate::vk::EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_shader_object"] pub mod shader_object { use super::super::*; pub use { crate::vk::EXT_SHADER_OBJECT_NAME as NAME, crate::vk::EXT_SHADER_OBJECT_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_shader_object 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_shader_object device-level function pointers"] pub struct DeviceFn { pub create_shaders_ext: PFN_vkCreateShadersEXT, pub destroy_shader_ext: PFN_vkDestroyShaderEXT, pub get_shader_binary_data_ext: PFN_vkGetShaderBinaryDataEXT, pub cmd_bind_shaders_ext: PFN_vkCmdBindShadersEXT, pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode, pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace, pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology, pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount, pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount, pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2, pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable, pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable, pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp, pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable, pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable, pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp, pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT, pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT, pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable, pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable, pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT, pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable, pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEX pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT, pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT, pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT, pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT, pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT, pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT, pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT, pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT, pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT, pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT, pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT, pub cmd_set_conservative_rasterization_mode_ext: PFN_vkCmdSetConservativeRasterizationModeEXT, pub cmd_set_extra_primitive_overestimation_size_ext: PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT, pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT, pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT, pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT, pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT, pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT, pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT, pub cmd_set_depth_clip_negative_one_to_one_ext: PFN_vkCmdSetDepthClipNegativeOneToOneEXT, pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV, pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV, pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV, pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV, pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV, pub cmd_set_coverage_modulation_table_enable_nv: PFN_vkCmdSetCoverageModulationTableEnableNV, pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV, pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV, pub cmd_set_representative_fragment_test_enable_nv: PFN_vkCmdSetRepresentativeFragmentTestEnableNV, pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV, } 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_shaders_ext: unsafe { unsafe extern "system" fn create_shaders_ext( _device: crate::vk::Device, _create_info_count: u32, _p_create_infos: *const ShaderCreateInfoEXT<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_shaders: *mut ShaderEXT, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_shaders_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateShadersEXT\0"); let val = _f(cname); if val.is_null() { create_shaders_ext } else { ::core::mem::transmute(val) } }, destroy_shader_ext: unsafe { unsafe extern "system" fn destroy_shader_ext( _device: crate::vk::Device, _shader: ShaderEXT, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!("Unable to load ", stringify!(destroy_shader_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderEXT\0"); let val = _f(cname); if val.is_null() { destroy_shader_ext } else { ::core::mem::transmute(val) } }, get_shader_binary_data_ext: unsafe { unsafe extern "system" fn get_shader_binary_data_ext( _device: crate::vk::Device, _shader: ShaderEXT, _p_data_size: *mut usize, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_shader_binary_data_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetShaderBinaryDataEXT\0"); let val = _f(cname); if val.is_null() { get_shader_binary_data_ext } else { ::core::mem::transmute(val) } }, cmd_bind_shaders_ext: unsafe { unsafe extern "system" fn cmd_bind_shaders_ext( _command_buffer: CommandBuffer, _stage_count: u32, _p_stages: *const ShaderStageFlags, _p_shaders: *const ShaderEXT, ) { panic!(concat!("Unable to load ", stringify!(cmd_bind_shaders_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBindShadersEXT\0"); let val = _f(cname); if val.is_null() { cmd_bind_shaders_ext } else { ::core::mem::transmute(val) } }, cmd_set_cull_mode_ext: unsafe { unsafe extern "system" fn cmd_set_cull_mode_ext( _command_buffer: CommandBuffer, _cull_mode: CullModeFlags, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_cull_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_cull_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_front_face_ext: unsafe { unsafe extern "system" fn cmd_set_front_face_ext( _command_buffer: CommandBuffer, _front_face: FrontFace, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_front_face_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_front_face_ext } else { ::core::mem::transmute(val) } }, cmd_set_primitive_topology_ext: unsafe { unsafe extern "system" fn cmd_set_primitive_topology_ext( _command_buffer: CommandBuffer, _primitive_topology: PrimitiveTopology, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_primitive_topology_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopologyEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_primitive_topology_ext } else { ::core::mem::transmute(val) } }, cmd_set_viewport_with_count_ext: unsafe { unsafe extern "system" fn cmd_set_viewport_with_count_ext( _command_buffer: CommandBuffer, _viewport_count: u32, _p_viewports: *const Viewport, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_viewport_with_count_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCountEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_viewport_with_count_ext } else { ::core::mem::transmute(val) } }, cmd_set_scissor_with_count_ext: unsafe { unsafe extern "system" fn cmd_set_scissor_with_count_ext( _command_buffer: CommandBuffer, _scissor_count: u32, _p_scissors: *const Rect2D, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_scissor_with_count_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCountEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_scissor_with_count_ext } else { ::core::mem::transmute(val) } }, cmd_bind_vertex_buffers2_ext: unsafe { unsafe extern "system" fn cmd_bind_vertex_buffers2_ext( _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_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2EXT\0"); let val = _f(cname); if val.is_null() { cmd_bind_vertex_buffers2_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_test_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_test_enable_ext( _command_buffer: CommandBuffer, _depth_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_test_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_test_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_write_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_write_enable_ext( _command_buffer: CommandBuffer, _depth_write_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_write_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_write_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_compare_op_ext: unsafe { unsafe extern "system" fn cmd_set_depth_compare_op_ext( _command_buffer: CommandBuffer, _depth_compare_op: CompareOp, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_compare_op_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_compare_op_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_bounds_test_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext( _command_buffer: CommandBuffer, _depth_bounds_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_bounds_test_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetDepthBoundsTestEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_depth_bounds_test_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_stencil_test_enable_ext: unsafe { unsafe extern "system" fn cmd_set_stencil_test_enable_ext( _command_buffer: CommandBuffer, _stencil_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_stencil_test_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_stencil_test_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_stencil_op_ext: unsafe { unsafe extern "system" fn cmd_set_stencil_op_ext( _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_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_stencil_op_ext } else { ::core::mem::transmute(val) } }, cmd_set_vertex_input_ext: unsafe { unsafe extern "system" fn cmd_set_vertex_input_ext( _command_buffer: CommandBuffer, _vertex_binding_description_count: u32, _p_vertex_binding_descriptions : * const VertexInputBindingDescription2EXT < '_ >, _vertex_attribute_description_count: u32, _p_vertex_attribute_descriptions : * const VertexInputAttributeDescription2EXT < '_ >, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_vertex_input_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_vertex_input_ext } else { ::core::mem::transmute(val) } }, cmd_set_patch_control_points_ext: unsafe { unsafe extern "system" fn cmd_set_patch_control_points_ext( _command_buffer: CommandBuffer, _patch_control_points: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_patch_control_points_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPatchControlPointsEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_patch_control_points_ext } else { ::core::mem::transmute(val) } }, cmd_set_rasterizer_discard_enable_ext: unsafe { unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext( _command_buffer: CommandBuffer, _rasterizer_discard_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_rasterizer_discard_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRasterizerDiscardEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_rasterizer_discard_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_bias_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_bias_enable_ext( _command_buffer: CommandBuffer, _depth_bias_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_bias_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_bias_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_logic_op_ext: unsafe { unsafe extern "system" fn cmd_set_logic_op_ext( _command_buffer: CommandBuffer, _logic_op: LogicOp, ) { panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_logic_op_ext } else { ::core::mem::transmute(val) } }, cmd_set_primitive_restart_enable_ext: unsafe { unsafe extern "system" fn cmd_set_primitive_restart_enable_ext( _command_buffer: CommandBuffer, _primitive_restart_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_primitive_restart_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetPrimitiveRestartEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_primitive_restart_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_tessellation_domain_origin_ext: unsafe { unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext( _command_buffer: CommandBuffer, _domain_origin: TessellationDomainOrigin, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_tessellation_domain_origin_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetTessellationDomainOriginEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_tessellation_domain_origin_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_clamp_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_clamp_enable_ext( _command_buffer: CommandBuffer, _depth_clamp_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_clamp_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClampEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_clamp_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_polygon_mode_ext: unsafe { unsafe extern "system" fn cmd_set_polygon_mode_ext( _command_buffer: CommandBuffer, _polygon_mode: PolygonMode, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_polygon_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_polygon_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_rasterization_samples_ext: unsafe { unsafe extern "system" fn cmd_set_rasterization_samples_ext( _command_buffer: CommandBuffer, _rasterization_samples: SampleCountFlags, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_rasterization_samples_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRasterizationSamplesEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_rasterization_samples_ext } else { ::core::mem::transmute(val) } }, cmd_set_sample_mask_ext: unsafe { unsafe extern "system" fn cmd_set_sample_mask_ext( _command_buffer: CommandBuffer, _samples: SampleCountFlags, _p_sample_mask: *const SampleMask, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_sample_mask_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_sample_mask_ext } else { ::core::mem::transmute(val) } }, cmd_set_alpha_to_coverage_enable_ext: unsafe { unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext( _command_buffer: CommandBuffer, _alpha_to_coverage_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_alpha_to_coverage_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetAlphaToCoverageEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_alpha_to_coverage_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_alpha_to_one_enable_ext: unsafe { unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext( _command_buffer: CommandBuffer, _alpha_to_one_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_alpha_to_one_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetAlphaToOneEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_alpha_to_one_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_logic_op_enable_ext: unsafe { unsafe extern "system" fn cmd_set_logic_op_enable_ext( _command_buffer: CommandBuffer, _logic_op_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_logic_op_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_logic_op_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_blend_enable_ext: unsafe { unsafe extern "system" fn cmd_set_color_blend_enable_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_blend_enables: *const Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_blend_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_blend_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_blend_equation_ext: unsafe { unsafe extern "system" fn cmd_set_color_blend_equation_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_blend_equations: *const ColorBlendEquationEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_blend_equation_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendEquationEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_blend_equation_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_write_mask_ext: unsafe { unsafe extern "system" fn cmd_set_color_write_mask_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_write_masks: *const ColorComponentFlags, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_write_mask_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_write_mask_ext } else { ::core::mem::transmute(val) } }, cmd_set_rasterization_stream_ext: unsafe { unsafe extern "system" fn cmd_set_rasterization_stream_ext( _command_buffer: CommandBuffer, _rasterization_stream: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_rasterization_stream_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRasterizationStreamEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_rasterization_stream_ext } else { ::core::mem::transmute(val) } }, cmd_set_conservative_rasterization_mode_ext: unsafe { unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext( _command_buffer: CommandBuffer, _conservative_rasterization_mode: ConservativeRasterizationModeEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_conservative_rasterization_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetConservativeRasterizationModeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_conservative_rasterization_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_extra_primitive_overestimation_size_ext: unsafe { unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext( _command_buffer: CommandBuffer, _extra_primitive_overestimation_size: f32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_extra_primitive_overestimation_size_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_extra_primitive_overestimation_size_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_clip_enable_ext: unsafe { unsafe extern "system" fn cmd_set_depth_clip_enable_ext( _command_buffer: CommandBuffer, _depth_clip_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_clip_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthClipEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_depth_clip_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_sample_locations_enable_ext: unsafe { unsafe extern "system" fn cmd_set_sample_locations_enable_ext( _command_buffer: CommandBuffer, _sample_locations_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_sample_locations_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetSampleLocationsEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_sample_locations_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_color_blend_advanced_ext: unsafe { unsafe extern "system" fn cmd_set_color_blend_advanced_ext( _command_buffer: CommandBuffer, _first_attachment: u32, _attachment_count: u32, _p_color_blend_advanced: *const ColorBlendAdvancedEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_color_blend_advanced_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorBlendAdvancedEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_color_blend_advanced_ext } else { ::core::mem::transmute(val) } }, cmd_set_provoking_vertex_mode_ext: unsafe { unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext( _command_buffer: CommandBuffer, _provoking_vertex_mode: ProvokingVertexModeEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_provoking_vertex_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetProvokingVertexModeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_provoking_vertex_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_line_rasterization_mode_ext: unsafe { unsafe extern "system" fn cmd_set_line_rasterization_mode_ext( _command_buffer: CommandBuffer, _line_rasterization_mode: LineRasterizationModeEXT, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_line_rasterization_mode_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetLineRasterizationModeEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_line_rasterization_mode_ext } else { ::core::mem::transmute(val) } }, cmd_set_line_stipple_enable_ext: unsafe { unsafe extern "system" fn cmd_set_line_stipple_enable_ext( _command_buffer: CommandBuffer, _stippled_line_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_line_stipple_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEnableEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_line_stipple_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_depth_clip_negative_one_to_one_ext: unsafe { unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext( _command_buffer: CommandBuffer, _negative_one_to_one: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_depth_clip_negative_one_to_one_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetDepthClipNegativeOneToOneEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_depth_clip_negative_one_to_one_ext } else { ::core::mem::transmute(val) } }, cmd_set_viewport_w_scaling_enable_nv: unsafe { unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv( _command_buffer: CommandBuffer, _viewport_w_scaling_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_viewport_w_scaling_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetViewportWScalingEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_viewport_w_scaling_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_viewport_swizzle_nv: unsafe { unsafe extern "system" fn cmd_set_viewport_swizzle_nv( _command_buffer: CommandBuffer, _first_viewport: u32, _viewport_count: u32, _p_viewport_swizzles: *const ViewportSwizzleNV, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_viewport_swizzle_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0"); let val = _f(cname); if val.is_null() { cmd_set_viewport_swizzle_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_to_color_enable_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv( _command_buffer: CommandBuffer, _coverage_to_color_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_to_color_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageToColorEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_to_color_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_to_color_location_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_to_color_location_nv( _command_buffer: CommandBuffer, _coverage_to_color_location: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_to_color_location_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageToColorLocationNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_to_color_location_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_modulation_mode_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv( _command_buffer: CommandBuffer, _coverage_modulation_mode: CoverageModulationModeNV, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_modulation_mode_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageModulationModeNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_modulation_mode_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_modulation_table_enable_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv( _command_buffer: CommandBuffer, _coverage_modulation_table_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_modulation_table_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageModulationTableEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_modulation_table_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_modulation_table_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_modulation_table_nv( _command_buffer: CommandBuffer, _coverage_modulation_table_count: u32, _p_coverage_modulation_table: *const f32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_modulation_table_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageModulationTableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_modulation_table_nv } else { ::core::mem::transmute(val) } }, cmd_set_shading_rate_image_enable_nv: unsafe { unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv( _command_buffer: CommandBuffer, _shading_rate_image_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_shading_rate_image_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetShadingRateImageEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_shading_rate_image_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_representative_fragment_test_enable_nv: unsafe { unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv( _command_buffer: CommandBuffer, _representative_fragment_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_representative_fragment_test_enable_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRepresentativeFragmentTestEnableNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_representative_fragment_test_enable_nv } else { ::core::mem::transmute(val) } }, cmd_set_coverage_reduction_mode_nv: unsafe { unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv( _command_buffer: CommandBuffer, _coverage_reduction_mode: CoverageReductionModeNV, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_coverage_reduction_mode_nv) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetCoverageReductionModeNV\0", ); let val = _f(cname); if val.is_null() { cmd_set_coverage_reduction_mode_nv } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_mutable_descriptor_type"] pub mod mutable_descriptor_type { use super::super::*; pub use { crate::vk::EXT_MUTABLE_DESCRIPTOR_TYPE_NAME as NAME, crate::vk::EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_layer_settings"] pub mod layer_settings { use super::super::*; pub use { crate::vk::EXT_LAYER_SETTINGS_NAME as NAME, crate::vk::EXT_LAYER_SETTINGS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_pipeline_library_group_handles"] pub mod pipeline_library_group_handles { use super::super::*; pub use { crate::vk::EXT_PIPELINE_LIBRARY_GROUP_HANDLES_NAME as NAME, crate::vk::EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_dynamic_rendering_unused_attachments"] pub mod dynamic_rendering_unused_attachments { use super::super::*; pub use { crate::vk::EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_NAME as NAME, crate::vk::EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_attachment_feedback_loop_dynamic_state"] pub mod attachment_feedback_loop_dynamic_state { use super::super::*; pub use { crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_NAME as NAME, crate::vk::EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION as SPEC_VERSION }; #[doc = "VK_EXT_attachment_feedback_loop_dynamic_state 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_attachment_feedback_loop_dynamic_state device-level function point pub struct DeviceFn { pub cmd_set_attachment_feedback_loop_enable_ext: PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT, } 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_set_attachment_feedback_loop_enable_ext: unsafe { unsafe extern "system" fn cmd_set_attachment_feedback_loop_enable_ext( _command_buffer: CommandBuffer, _aspect_mask: ImageAspectFlags, ) { panic!(concat!( "Unable to load ", stringify!(cmd_set_attachment_feedback_loop_enable_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetAttachmentFeedbackLoopEnableEXT\0", ); let val = _f(cname); if val.is_null() { cmd_set_attachment_feedback_loop_enable_ext } else { ::core::mem::transmute(val) } }, } } } } } #[doc = "Extensions tagged FUCHSIA"] pub mod fuchsia { #[doc = "VK_FUCHSIA_imagepipe_surface"] pub mod imagepipe_surface { use super::super::*; pub use { crate::vk::FUCHSIA_IMAGEPIPE_SURFACE_NAME as NAME, crate::vk::FUCHSIA_IMAGEPIPE_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_FUCHSIA_imagepipe_surface 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_FUCHSIA_imagepipe_surface instance-level function pointers"] pub struct InstanceFn { pub create_image_pipe_surface_fuchsia: PFN_vkCreateImagePipeSurfaceFUCHSIA, } 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_image_pipe_surface_fuchsia: unsafe { unsafe extern "system" fn create_image_pipe_surface_fuchsia( _instance: crate::vk::Instance, _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_image_pipe_surface_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCreateImagePipeSurfaceFUCHSIA\0", ); let val = _f(cname); if val.is_null() { create_image_pipe_surface_fuchsia } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_FUCHSIA_external_memory"] pub mod external_memory { use super::super::*; pub use { crate::vk::FUCHSIA_EXTERNAL_MEMORY_NAME as NAME, crate::vk::FUCHSIA_EXTERNAL_MEMORY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_FUCHSIA_external_memory 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_FUCHSIA_external_memory device-level function pointers"] pub struct DeviceFn { pub get_memory_zircon_handle_fuchsia: PFN_vkGetMemoryZirconHandleFUCHSIA, pub get_memory_zircon_handle_properties_fuchsia: PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA, } 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_memory_zircon_handle_fuchsia: unsafe { unsafe extern "system" fn get_memory_zircon_handle_fuchsia( _device: crate::vk::Device, _p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA<'_>, _p_zircon_handle: *mut zx_handle_t, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_memory_zircon_handle_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetMemoryZirconHandleFUCHSIA\0", ); let val = _f(cname); if val.is_null() { get_memory_zircon_handle_fuchsia } else { ::core::mem::transmute(val) } }, get_memory_zircon_handle_properties_fuchsia: unsafe { unsafe extern "system" fn get_memory_zircon_handle_properties_fuchsia( _device: crate::vk::Device, _handle_type: ExternalMemoryHandleTypeFlags, _zircon_handle: zx_handle_t, _p_memory_zircon_handle_properties : * mut MemoryZirconHandlePropertiesFUCHSIA < '_ >, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_memory_zircon_handle_properties_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetMemoryZirconHandlePropertiesFUCHSIA\0", ); let val = _f(cname); if val.is_null() { get_memory_zircon_handle_properties_fuchsia } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_FUCHSIA_external_semaphore"] pub mod external_semaphore { use super::super::*; pub use { crate::vk::FUCHSIA_EXTERNAL_SEMAPHORE_NAME as NAME, crate::vk::FUCHSIA_EXTERNAL_SEMAPHORE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_FUCHSIA_external_semaphore 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_FUCHSIA_external_semaphore device-level function pointers"] pub struct DeviceFn { pub import_semaphore_zircon_handle_fuchsia: PFN_vkImportSemaphoreZirconHandleFUCHS pub get_semaphore_zircon_handle_fuchsia: PFN_vkGetSemaphoreZirconHandleFUCHSIA, } 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 { import_semaphore_zircon_handle_fuchsia: unsafe { unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia( _device: crate::vk::Device, _p_import_semaphore_zircon_handle_info : * const ImportSemaphoreZirconHandleInfoFUCH ) -> Result { panic!(concat!( "Unable to load ", stringify!(import_semaphore_zircon_handle_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkImportSemaphoreZirconHandleFUCHSIA\0", ); let val = _f(cname); if val.is_null() { import_semaphore_zircon_handle_fuchsia } else { ::core::mem::transmute(val) } }, get_semaphore_zircon_handle_fuchsia: unsafe { unsafe extern "system" fn get_semaphore_zircon_handle_fuchsia( _device: crate::vk::Device, _p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA< '_, >, _p_zircon_handle: *mut zx_handle_t, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_semaphore_zircon_handle_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetSemaphoreZirconHandleFUCHSIA\0", ); let val = _f(cname); if val.is_null() { get_semaphore_zircon_handle_fuchsia } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_FUCHSIA_buffer_collection"] pub mod buffer_collection { use super::super::*; pub use { crate::vk::FUCHSIA_BUFFER_COLLECTION_NAME as NAME, crate::vk::FUCHSIA_BUFFER_COLLECTION_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_FUCHSIA_buffer_collection 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_FUCHSIA_buffer_collection device-level function pointers"] pub struct DeviceFn { pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA, pub set_buffer_collection_image_constraints_fuchsia: PFN_vkSetBufferCollectionImageConstraintsFUCHSIA, pub set_buffer_collection_buffer_constraints_fuchsia: PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA, pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA, pub get_buffer_collection_properties_fuchsia: PFN_vkGetBufferCollectionPropertiesFUCHSIA, } 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_buffer_collection_fuchsia: unsafe { unsafe extern "system" fn create_buffer_collection_fuchsia( _device: crate::vk::Device, _p_create_info: *const BufferCollectionCreateInfoFUCHSIA<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_collection: *mut BufferCollectionFUCHSIA, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_buffer_collection_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCreateBufferCollectionFUCHSIA\0", ); let val = _f(cname); if val.is_null() { create_buffer_collection_fuchsia } else { ::core::mem::transmute(val) } }, set_buffer_collection_image_constraints_fuchsia: unsafe { unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia( _device: crate::vk::Device, _collection: BufferCollectionFUCHSIA, _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(set_buffer_collection_image_constraints_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkSetBufferCollectionImageConstraintsFUCHSIA\0", ); let val = _f(cname); if val.is_null() { set_buffer_collection_image_constraints_fuchsia } else { ::core::mem::transmute(val) } }, set_buffer_collection_buffer_constraints_fuchsia: unsafe { unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia( _device: crate::vk::Device, _collection: BufferCollectionFUCHSIA, _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(set_buffer_collection_buffer_constraints_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0", ); let val = _f(cname); if val.is_null() { set_buffer_collection_buffer_constraints_fuchsia } else { ::core::mem::transmute(val) } }, destroy_buffer_collection_fuchsia: unsafe { unsafe extern "system" fn destroy_buffer_collection_fuchsia( _device: crate::vk::Device, _collection: BufferCollectionFUCHSIA, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!( "Unable to load ", stringify!(destroy_buffer_collection_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkDestroyBufferCollectionFUCHSIA\0", ); let val = _f(cname); if val.is_null() { destroy_buffer_collection_fuchsia } else { ::core::mem::transmute(val) } }, get_buffer_collection_properties_fuchsia: unsafe { unsafe extern "system" fn get_buffer_collection_properties_fuchsia( _device: crate::vk::Device, _collection: BufferCollectionFUCHSIA, _p_properties: *mut BufferCollectionPropertiesFUCHSIA<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_buffer_collection_properties_fuchsia) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetBufferCollectionPropertiesFUCHSIA\0", ); let val = _f(cname); if val.is_null() { get_buffer_collection_properties_fuchsia } else { ::core::mem::transmute(val) } }, } } } } } #[doc = "Extensions tagged GGP"] pub mod ggp { #[doc = "VK_GGP_stream_descriptor_surface"] pub mod stream_descriptor_surface { use super::super::*; pub use { crate::vk::GGP_STREAM_DESCRIPTOR_SURFACE_NAME as NAME, crate::vk::GGP_STREAM_DESCRIPTOR_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_GGP_stream_descriptor_surface 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_GGP_stream_descriptor_surface instance-level function pointers"] pub struct InstanceFn { pub create_stream_descriptor_surface_ggp: PFN_vkCreateStreamDescriptorSurfaceGGP, } 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_stream_descriptor_surface_ggp: unsafe { unsafe extern "system" fn create_stream_descriptor_surface_ggp( _instance: crate::vk::Instance, _p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_stream_descriptor_surface_ggp) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCreateStreamDescriptorSurfaceGGP\0", ); let val = _f(cname); if val.is_null() { create_stream_descriptor_surface_ggp } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_GGP_frame_token"] pub mod frame_token { use super::super::*; pub use { crate::vk::GGP_FRAME_TOKEN_NAME as NAME, crate::vk::GGP_FRAME_TOKEN_SPEC_VERSION as SPEC_VERSION, }; } } #[doc = "Extensions tagged GOOGLE"] pub mod google { #[doc = "VK_GOOGLE_display_timing"] pub mod display_timing { use super::super::*; pub use { crate::vk::GOOGLE_DISPLAY_TIMING_NAME as NAME, crate::vk::GOOGLE_DISPLAY_TIMING_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_GOOGLE_display_timing 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_GOOGLE_display_timing device-level function pointers"] pub struct DeviceFn { pub get_refresh_cycle_duration_google: PFN_vkGetRefreshCycleDurationGOOGLE, pub get_past_presentation_timing_google: PFN_vkGetPastPresentationTimingGOOGLE, } 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_refresh_cycle_duration_google: unsafe { unsafe extern "system" fn get_refresh_cycle_duration_google( _device: crate::vk::Device, _swapchain: SwapchainKHR, _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_refresh_cycle_duration_google) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetRefreshCycleDurationGOOGLE\0", ); let val = _f(cname); if val.is_null() { get_refresh_cycle_duration_google } else { ::core::mem::transmute(val) } }, get_past_presentation_timing_google: unsafe { unsafe extern "system" fn get_past_presentation_timing_google( _device: crate::vk::Device, _swapchain: SwapchainKHR, _p_presentation_timing_count: *mut u32, _p_presentation_timings: *mut PastPresentationTimingGOOGLE, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_past_presentation_timing_google) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPastPresentationTimingGOOGLE\0", ); let val = _f(cname); if val.is_null() { get_past_presentation_timing_google } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_GOOGLE_hlsl_functionality1"] pub mod hlsl_functionality1 { use super::super::*; pub use { crate::vk::GOOGLE_HLSL_FUNCTIONALITY1_NAME as NAME, crate::vk::GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_GOOGLE_decorate_string"] pub mod decorate_string { use super::super::*; pub use { crate::vk::GOOGLE_DECORATE_STRING_NAME as NAME, crate::vk::GOOGLE_DECORATE_STRING_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_GOOGLE_user_type"] pub mod user_type { use super::super::*; pub use { crate::vk::GOOGLE_USER_TYPE_NAME as NAME, crate::vk::GOOGLE_USER_TYPE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_GOOGLE_surfaceless_query"] pub mod surfaceless_query { use super::super::*; pub use { crate::vk::GOOGLE_SURFACELESS_QUERY_NAME as NAME, crate::vk::GOOGLE_SURFACELESS_QUERY_SPEC_VERSION as SPEC_VERSION, }; } } #[doc = "Extensions tagged HUAWEI"] pub mod huawei { #[doc = "VK_HUAWEI_subpass_shading"] pub mod subpass_shading { use super::super::*; pub use { crate::vk::HUAWEI_SUBPASS_SHADING_NAME as NAME, crate::vk::HUAWEI_SUBPASS_SHADING_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_HUAWEI_subpass_shading 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_HUAWEI_subpass_shading device-level function pointers"] pub struct DeviceFn { pub get_device_subpass_shading_max_workgroup_size_huawei: PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI, pub cmd_subpass_shading_huawei: PFN_vkCmdSubpassShadingHUAWEI, } 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_device_subpass_shading_max_workgroup_size_huawei: unsafe { unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei( _device: crate::vk::Device, _renderpass: RenderPass, _p_max_workgroup_size: *mut Extent2D, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_device_subpass_shading_max_workgroup_size_huawei) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\0", ); let val = _f(cname); if val.is_null() { get_device_subpass_shading_max_workgroup_size_huawei } else { ::core::mem::transmute(val) } }, cmd_subpass_shading_huawei: unsafe { unsafe extern "system" fn cmd_subpass_shading_huawei( _command_buffer: CommandBuffer, ) { panic!(concat!( "Unable to load ", stringify!(cmd_subpass_shading_huawei) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSubpassShadingHUAWEI\0"); let val = _f(cname); if val.is_null() { cmd_subpass_shading_huawei } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_HUAWEI_invocation_mask"] pub mod invocation_mask { use super::super::*; pub use { crate::vk::HUAWEI_INVOCATION_MASK_NAME as NAME, crate::vk::HUAWEI_INVOCATION_MASK_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_HUAWEI_invocation_mask 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_HUAWEI_invocation_mask device-level function pointers"] pub struct DeviceFn { pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI, } 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_invocation_mask_huawei: unsafe { unsafe extern "system" fn cmd_bind_invocation_mask_huawei( _command_buffer: CommandBuffer, _image_view: ImageView, _image_layout: ImageLayout, ) { panic!(concat!( "Unable to load ", stringify!(cmd_bind_invocation_mask_huawei) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBindInvocationMaskHUAWEI\0"); let val = _f(cname); if val.is_null() { cmd_bind_invocation_mask_huawei } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_HUAWEI_cluster_culling_shader"] pub mod cluster_culling_shader { use super::super::*; pub use { crate::vk::HUAWEI_CLUSTER_CULLING_SHADER_NAME as NAME, crate::vk::HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_HUAWEI_cluster_culling_shader 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_HUAWEI_cluster_culling_shader device-level function pointers"] pub struct DeviceFn { pub cmd_draw_cluster_huawei: PFN_vkCmdDrawClusterHUAWEI, pub cmd_draw_cluster_indirect_huawei: PFN_vkCmdDrawClusterIndirectHUAWEI, } 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_cluster_huawei: unsafe { unsafe extern "system" fn cmd_draw_cluster_huawei( _command_buffer: CommandBuffer, _group_count_x: u32, _group_count_y: u32, _group_count_z: u32, ) { panic!(concat!( "Unable to load ", stringify!(cmd_draw_cluster_huawei) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawClusterHUAWEI\0"); let val = _f(cname); if val.is_null() { cmd_draw_cluster_huawei } else { ::core::mem::transmute(val) } }, cmd_draw_cluster_indirect_huawei: unsafe { unsafe extern "system" fn cmd_draw_cluster_indirect_huawei( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, ) { panic!(concat!( "Unable to load ", stringify!(cmd_draw_cluster_indirect_huawei) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdDrawClusterIndirectHUAWEI\0", ); let val = _f(cname); if val.is_null() { cmd_draw_cluster_indirect_huawei } else { ::core::mem::transmute(val) } }, } } } } } #[doc = "Extensions tagged IMG"] pub mod img { #[doc = "VK_IMG_filter_cubic"] pub mod filter_cubic { use super::super::*; pub use { crate::vk::IMG_FILTER_CUBIC_NAME as NAME, crate::vk::IMG_FILTER_CUBIC_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_IMG_format_pvrtc"] pub mod format_pvrtc { use super::super::*; pub use { crate::vk::IMG_FORMAT_PVRTC_NAME as NAME, crate::vk::IMG_FORMAT_PVRTC_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_IMG_relaxed_line_rasterization"] pub mod relaxed_line_rasterization { use super::super::*; pub use { crate::vk::IMG_RELAXED_LINE_RASTERIZATION_NAME as NAME, crate::vk::IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION as SPEC_VERSION, }; } } #[doc = "Extensions tagged INTEL"] pub mod intel { #[doc = "VK_INTEL_shader_integer_functions2"] pub mod shader_integer_functions2 { use super::super::*; pub use { crate::vk::INTEL_SHADER_INTEGER_FUNCTIONS2_NAME as NAME, crate::vk::INTEL_SHADER_INTEGER_FUNCTIONS2_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_INTEL_performance_query"] pub mod performance_query { use super::super::*; pub use { crate::vk::INTEL_PERFORMANCE_QUERY_NAME as NAME, crate::vk::INTEL_PERFORMANCE_QUERY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_INTEL_performance_query 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_INTEL_performance_query device-level function pointers"] pub struct DeviceFn { pub initialize_performance_api_intel: PFN_vkInitializePerformanceApiINTEL, pub uninitialize_performance_api_intel: PFN_vkUninitializePerformanceApiINTEL, pub cmd_set_performance_marker_intel: PFN_vkCmdSetPerformanceMarkerINTEL, pub cmd_set_performance_stream_marker_intel: PFN_vkCmdSetPerformanceStreamMarkerIN pub cmd_set_performance_override_intel: PFN_vkCmdSetPerformanceOverrideINTEL, pub acquire_performance_configuration_intel: PFN_vkAcquirePerformanceConfiguration pub release_performance_configuration_intel: PFN_vkReleasePerformanceConfiguration pub queue_set_performance_configuration_intel: PFN_vkQueueSetPerformanceConfigurationINTEL, pub get_performance_parameter_intel: PFN_vkGetPerformanceParameterINTEL, } 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 { initialize_performance_api_intel: unsafe { unsafe extern "system" fn initialize_performance_api_intel( _device: crate::vk::Device, _p_initialize_info: *const InitializePerformanceApiInfoINTEL<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(initialize_performance_api_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkInitializePerformanceApiINTEL\0", ); let val = _f(cname); if val.is_null() { initialize_performance_api_intel } else { ::core::mem::transmute(val) } }, uninitialize_performance_api_intel: unsafe { unsafe extern "system" fn uninitialize_performance_api_intel( _device: crate::vk::Device, ) { panic!(concat!( "Unable to load ", stringify!(uninitialize_performance_api_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkUninitializePerformanceApiINTEL\0", ); let val = _f(cname); if val.is_null() { uninitialize_performance_api_intel } else { ::core::mem::transmute(val) } }, cmd_set_performance_marker_intel: unsafe { unsafe extern "system" fn cmd_set_performance_marker_intel( _command_buffer: CommandBuffer, _p_marker_info: *const PerformanceMarkerInfoINTEL<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(cmd_set_performance_marker_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetPerformanceMarkerINTEL\0", ); let val = _f(cname); if val.is_null() { cmd_set_performance_marker_intel } else { ::core::mem::transmute(val) } }, cmd_set_performance_stream_marker_intel: unsafe { unsafe extern "system" fn cmd_set_performance_stream_marker_intel( _command_buffer: CommandBuffer, _p_marker_info: *const PerformanceStreamMarkerInfoINTEL<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(cmd_set_performance_stream_marker_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetPerformanceStreamMarkerINTEL\0", ); let val = _f(cname); if val.is_null() { cmd_set_performance_stream_marker_intel } else { ::core::mem::transmute(val) } }, cmd_set_performance_override_intel: unsafe { unsafe extern "system" fn cmd_set_performance_override_intel( _command_buffer: CommandBuffer, _p_override_info: *const PerformanceOverrideInfoINTEL<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(cmd_set_performance_override_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetPerformanceOverrideINTEL\0", ); let val = _f(cname); if val.is_null() { cmd_set_performance_override_intel } else { ::core::mem::transmute(val) } }, acquire_performance_configuration_intel: unsafe { unsafe extern "system" fn acquire_performance_configuration_intel( _device: crate::vk::Device, _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL<'_>, _p_configuration: *mut PerformanceConfigurationINTEL, ) -> Result { panic!(concat!( "Unable to load ", stringify!(acquire_performance_configuration_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkAcquirePerformanceConfigurationINTEL\0", ); let val = _f(cname); if val.is_null() { acquire_performance_configuration_intel } else { ::core::mem::transmute(val) } }, release_performance_configuration_intel: unsafe { unsafe extern "system" fn release_performance_configuration_intel( _device: crate::vk::Device, _configuration: PerformanceConfigurationINTEL, ) -> Result { panic!(concat!( "Unable to load ", stringify!(release_performance_configuration_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkReleasePerformanceConfigurationINTEL\0", ); let val = _f(cname); if val.is_null() { release_performance_configuration_intel } else { ::core::mem::transmute(val) } }, queue_set_performance_configuration_intel: unsafe { unsafe extern "system" fn queue_set_performance_configuration_intel( _queue: Queue, _configuration: PerformanceConfigurationINTEL, ) -> Result { panic!(concat!( "Unable to load ", stringify!(queue_set_performance_configuration_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkQueueSetPerformanceConfigurationINTEL\0", ); let val = _f(cname); if val.is_null() { queue_set_performance_configuration_intel } else { ::core::mem::transmute(val) } }, get_performance_parameter_intel: unsafe { unsafe extern "system" fn get_performance_parameter_intel( _device: crate::vk::Device, _parameter: PerformanceParameterTypeINTEL, _p_value: *mut PerformanceValueINTEL, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_performance_parameter_intel) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPerformanceParameterINTEL\0", ); let val = _f(cname); if val.is_null() { get_performance_parameter_intel } else { ::core::mem::transmute(val) } }, } } } } } #[doc = "Extensions tagged KHR"] pub mod khr { #[doc = "VK_KHR_surface"] pub mod surface { use super::super::*; pub use { crate::vk::KHR_SURFACE_NAME as NAME, crate::vk::KHR_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_surface 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_KHR_surface instance-level function pointers"] pub struct InstanceFn { pub destroy_surface_khr: PFN_vkDestroySurfaceKHR, pub get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupport pub get_physical_device_surface_capabilities_khr: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR, pub get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormats pub get_physical_device_surface_present_modes_khr: PFN_vkGetPhysicalDeviceSurfacePresentModesKHR, } 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 { destroy_surface_khr: unsafe { unsafe extern "system" fn destroy_surface_khr( _instance: crate::vk::Instance, _surface: SurfaceKHR, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!("Unable to load ", stringify!(destroy_surface_khr))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroySurfaceKHR\0"); let val = _f(cname); if val.is_null() { destroy_surface_khr } else { ::core::mem::transmute(val) } }, get_physical_device_surface_support_khr: unsafe { unsafe extern "system" fn get_physical_device_surface_support_khr( _physical_device: PhysicalDevice, _queue_family_index: u32, _surface: SurfaceKHR, _p_supported: *mut Bool32, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_surface_support_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceSurfaceSupportKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_surface_support_khr } else { ::core::mem::transmute(val) } }, get_physical_device_surface_capabilities_khr: unsafe { unsafe extern "system" fn get_physical_device_surface_capabilities_khr( _physical_device: PhysicalDevice, _surface: SurfaceKHR, _p_surface_capabilities: *mut SurfaceCapabilitiesKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_surface_capabilities_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_surface_capabilities_khr } else { ::core::mem::transmute(val) } }, get_physical_device_surface_formats_khr: unsafe { unsafe extern "system" fn get_physical_device_surface_formats_khr( _physical_device: PhysicalDevice, _surface: SurfaceKHR, _p_surface_format_count: *mut u32, _p_surface_formats: *mut SurfaceFormatKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_surface_formats_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceSurfaceFormatsKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_surface_formats_khr } else { ::core::mem::transmute(val) } }, get_physical_device_surface_present_modes_khr: unsafe { unsafe extern "system" fn get_physical_device_surface_present_modes_khr( _physical_device: PhysicalDevice, _surface: SurfaceKHR, _p_present_mode_count: *mut u32, _p_present_modes: *mut PresentModeKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_surface_present_modes_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceSurfacePresentModesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_surface_present_modes_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_swapchain"] pub mod swapchain { use super::super::*; pub use { crate::vk::KHR_SWAPCHAIN_NAME as NAME, crate::vk::KHR_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_swapchain 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_KHR_swapchain instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_present_rectangles_khr: PFN_vkGetPhysicalDevicePresentRectanglesKHR, } 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 { get_physical_device_present_rectangles_khr: unsafe { unsafe extern "system" fn get_physical_device_present_rectangles_khr( _physical_device: PhysicalDevice, _surface: SurfaceKHR, _p_rect_count: *mut u32, _p_rects: *mut Rect2D, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_present_rectangles_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDevicePresentRectanglesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_present_rectangles_khr } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_KHR_swapchain 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_KHR_swapchain device-level function pointers"] pub struct DeviceFn { pub create_swapchain_khr: PFN_vkCreateSwapchainKHR, pub destroy_swapchain_khr: PFN_vkDestroySwapchainKHR, pub get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR, pub acquire_next_image_khr: PFN_vkAcquireNextImageKHR, pub queue_present_khr: PFN_vkQueuePresentKHR, pub get_device_group_present_capabilities_khr: PFN_vkGetDeviceGroupPresentCapabilitiesKHR, pub get_device_group_surface_present_modes_khr: PFN_vkGetDeviceGroupSurfacePresentModesKHR, pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR, } 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_swapchain_khr: unsafe { unsafe extern "system" fn create_swapchain_khr( _device: crate::vk::Device, _p_create_info: *const SwapchainCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_swapchain: *mut SwapchainKHR, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_swapchain_khr))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateSwapchainKHR\0"); let val = _f(cname); if val.is_null() { create_swapchain_khr } else { ::core::mem::transmute(val) } }, destroy_swapchain_khr: unsafe { unsafe extern "system" fn destroy_swapchain_khr( _device: crate::vk::Device, _swapchain: SwapchainKHR, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!( "Unable to load ", stringify!(destroy_swapchain_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroySwapchainKHR\0"); let val = _f(cname); if val.is_null() { destroy_swapchain_khr } else { ::core::mem::transmute(val) } }, get_swapchain_images_khr: unsafe { unsafe extern "system" fn get_swapchain_images_khr( _device: crate::vk::Device, _swapchain: SwapchainKHR, _p_swapchain_image_count: *mut u32, _p_swapchain_images: *mut Image, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_swapchain_images_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainImagesKHR\0"); let val = _f(cname); if val.is_null() { get_swapchain_images_khr } else { ::core::mem::transmute(val) } }, acquire_next_image_khr: unsafe { unsafe extern "system" fn acquire_next_image_khr( _device: crate::vk::Device, _swapchain: SwapchainKHR, _timeout: u64, _semaphore: Semaphore, _fence: Fence, _p_image_index: *mut u32, ) -> Result { panic!(concat!( "Unable to load ", stringify!(acquire_next_image_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImageKHR\0"); let val = _f(cname); if val.is_null() { acquire_next_image_khr } else { ::core::mem::transmute(val) } }, queue_present_khr: unsafe { unsafe extern "system" fn queue_present_khr( _queue: Queue, _p_present_info: *const PresentInfoKHR<'_>, ) -> Result { panic!(concat!("Unable to load ", stringify!(queue_present_khr))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkQueuePresentKHR\0"); let val = _f(cname); if val.is_null() { queue_present_khr } else { ::core::mem::transmute(val) } }, get_device_group_present_capabilities_khr: unsafe { unsafe extern "system" fn get_device_group_present_capabilities_khr( _device: crate::vk::Device, _p_device_group_present_capabilities : * mut DeviceGroupPresentCapabilitiesKHR < '_ >, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_device_group_present_capabilities_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDeviceGroupPresentCapabilitiesKHR\0", ); let val = _f(cname); if val.is_null() { get_device_group_present_capabilities_khr } else { ::core::mem::transmute(val) } }, get_device_group_surface_present_modes_khr: unsafe { unsafe extern "system" fn get_device_group_surface_present_modes_khr( _device: crate::vk::Device, _surface: SurfaceKHR, _p_modes: *mut DeviceGroupPresentModeFlagsKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_device_group_surface_present_modes_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDeviceGroupSurfacePresentModesKHR\0", ); let val = _f(cname); if val.is_null() { get_device_group_surface_present_modes_khr } else { ::core::mem::transmute(val) } }, acquire_next_image2_khr: unsafe { unsafe extern "system" fn acquire_next_image2_khr( _device: crate::vk::Device, _p_acquire_info: *const AcquireNextImageInfoKHR<'_>, _p_image_index: *mut u32, ) -> Result { panic!(concat!( "Unable to load ", stringify!(acquire_next_image2_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0"); let val = _f(cname); if val.is_null() { acquire_next_image2_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_display"] pub mod display { use super::super::*; pub use { crate::vk::KHR_DISPLAY_NAME as NAME, crate::vk::KHR_DISPLAY_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_display 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_KHR_display instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_display_properties_khr: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR, pub get_physical_device_display_plane_properties_khr: PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR, pub get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDispla pub get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR, pub create_display_mode_khr: PFN_vkCreateDisplayModeKHR, pub get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR, pub create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR, } 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 { get_physical_device_display_properties_khr: unsafe { unsafe extern "system" fn get_physical_device_display_properties_khr( _physical_device: PhysicalDevice, _p_property_count: *mut u32, _p_properties: *mut DisplayPropertiesKHR<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_display_properties_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceDisplayPropertiesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_display_properties_khr } else { ::core::mem::transmute(val) } }, get_physical_device_display_plane_properties_khr: unsafe { unsafe extern "system" fn get_physical_device_display_plane_properties_khr( _physical_device: PhysicalDevice, _p_property_count: *mut u32, _p_properties: *mut DisplayPlanePropertiesKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_display_plane_properties_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceDisplayPlanePropertiesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_display_plane_properties_khr } else { ::core::mem::transmute(val) } }, get_display_plane_supported_displays_khr: unsafe { unsafe extern "system" fn get_display_plane_supported_displays_khr( _physical_device: PhysicalDevice, _plane_index: u32, _p_display_count: *mut u32, _p_displays: *mut DisplayKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_display_plane_supported_displays_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDisplayPlaneSupportedDisplaysKHR\0", ); let val = _f(cname); if val.is_null() { get_display_plane_supported_displays_khr } else { ::core::mem::transmute(val) } }, get_display_mode_properties_khr: unsafe { unsafe extern "system" fn get_display_mode_properties_khr( _physical_device: PhysicalDevice, _display: DisplayKHR, _p_property_count: *mut u32, _p_properties: *mut DisplayModePropertiesKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_display_mode_properties_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetDisplayModePropertiesKHR\0"); let val = _f(cname); if val.is_null() { get_display_mode_properties_khr } else { ::core::mem::transmute(val) } }, create_display_mode_khr: unsafe { unsafe extern "system" fn create_display_mode_khr( _physical_device: PhysicalDevice, _display: DisplayKHR, _p_create_info: *const DisplayModeCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_mode: *mut DisplayModeKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_display_mode_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateDisplayModeKHR\0"); let val = _f(cname); if val.is_null() { create_display_mode_khr } else { ::core::mem::transmute(val) } }, get_display_plane_capabilities_khr: unsafe { unsafe extern "system" fn get_display_plane_capabilities_khr( _physical_device: PhysicalDevice, _mode: DisplayModeKHR, _plane_index: u32, _p_capabilities: *mut DisplayPlaneCapabilitiesKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_display_plane_capabilities_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDisplayPlaneCapabilitiesKHR\0", ); let val = _f(cname); if val.is_null() { get_display_plane_capabilities_khr } else { ::core::mem::transmute(val) } }, create_display_plane_surface_khr: unsafe { unsafe extern "system" fn create_display_plane_surface_khr( _instance: crate::vk::Instance, _p_create_info: *const DisplaySurfaceCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_display_plane_surface_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCreateDisplayPlaneSurfaceKHR\0", ); let val = _f(cname); if val.is_null() { create_display_plane_surface_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_display_swapchain"] pub mod display_swapchain { use super::super::*; pub use { crate::vk::KHR_DISPLAY_SWAPCHAIN_NAME as NAME, crate::vk::KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_display_swapchain 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_KHR_display_swapchain device-level function pointers"] pub struct DeviceFn { pub create_shared_swapchains_khr: PFN_vkCreateSharedSwapchainsKHR, } 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_shared_swapchains_khr: unsafe { unsafe extern "system" fn create_shared_swapchains_khr( _device: crate::vk::Device, _swapchain_count: u32, _p_create_infos: *const SwapchainCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_swapchains: *mut SwapchainKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_shared_swapchains_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateSharedSwapchainsKHR\0"); let val = _f(cname); if val.is_null() { create_shared_swapchains_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_xlib_surface"] pub mod xlib_surface { use super::super::*; pub use { crate::vk::KHR_XLIB_SURFACE_NAME as NAME, crate::vk::KHR_XLIB_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_xlib_surface 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_KHR_xlib_surface instance-level function pointers"] pub struct InstanceFn { pub create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR, pub get_physical_device_xlib_presentation_support_khr: PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR, } 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_xlib_surface_khr: unsafe { unsafe extern "system" fn create_xlib_surface_khr( _instance: crate::vk::Instance, _p_create_info: *const XlibSurfaceCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_xlib_surface_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateXlibSurfaceKHR\0"); let val = _f(cname); if val.is_null() { create_xlib_surface_khr } else { ::core::mem::transmute(val) } }, get_physical_device_xlib_presentation_support_khr: unsafe { unsafe extern "system" fn get_physical_device_xlib_presentation_support_khr( _physical_device: PhysicalDevice, _queue_family_index: u32, _dpy: *mut Display, _visual_id: VisualID, ) -> Bool32 { panic!(concat!( "Unable to load ", stringify!(get_physical_device_xlib_presentation_support_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceXlibPresentationSupportKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_xlib_presentation_support_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_xcb_surface"] pub mod xcb_surface { use super::super::*; pub use { crate::vk::KHR_XCB_SURFACE_NAME as NAME, crate::vk::KHR_XCB_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_xcb_surface 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_KHR_xcb_surface instance-level function pointers"] pub struct InstanceFn { pub create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR, pub get_physical_device_xcb_presentation_support_khr: PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR, } 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_xcb_surface_khr: unsafe { unsafe extern "system" fn create_xcb_surface_khr( _instance: crate::vk::Instance, _p_create_info: *const XcbSurfaceCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_xcb_surface_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateXcbSurfaceKHR\0"); let val = _f(cname); if val.is_null() { create_xcb_surface_khr } else { ::core::mem::transmute(val) } }, get_physical_device_xcb_presentation_support_khr: unsafe { unsafe extern "system" fn get_physical_device_xcb_presentation_support_khr( _physical_device: PhysicalDevice, _queue_family_index: u32, _connection: *mut xcb_connection_t, _visual_id: xcb_visualid_t, ) -> Bool32 { panic!(concat!( "Unable to load ", stringify!(get_physical_device_xcb_presentation_support_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceXcbPresentationSupportKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_xcb_presentation_support_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_wayland_surface"] pub mod wayland_surface { use super::super::*; pub use { crate::vk::KHR_WAYLAND_SURFACE_NAME as NAME, crate::vk::KHR_WAYLAND_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_wayland_surface 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_KHR_wayland_surface instance-level function pointers"] pub struct InstanceFn { pub create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR, pub get_physical_device_wayland_presentation_support_khr: PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR, } 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_wayland_surface_khr: unsafe { unsafe extern "system" fn create_wayland_surface_khr( _instance: crate::vk::Instance, _p_create_info: *const WaylandSurfaceCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_wayland_surface_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateWaylandSurfaceKHR\0"); let val = _f(cname); if val.is_null() { create_wayland_surface_khr } else { ::core::mem::transmute(val) } }, get_physical_device_wayland_presentation_support_khr: unsafe { unsafe extern "system" fn get_physical_device_wayland_presentation_support_khr( _physical_device: PhysicalDevice, _queue_family_index: u32, _display: *mut wl_display, ) -> Bool32 { panic!(concat!( "Unable to load ", stringify!(get_physical_device_wayland_presentation_support_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceWaylandPresentationSupportKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_wayland_presentation_support_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_android_surface"] pub mod android_surface { use super::super::*; pub use { crate::vk::KHR_ANDROID_SURFACE_NAME as NAME, crate::vk::KHR_ANDROID_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_android_surface 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_KHR_android_surface instance-level function pointers"] pub struct InstanceFn { pub create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR, } 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_android_surface_khr: unsafe { unsafe extern "system" fn create_android_surface_khr( _instance: crate::vk::Instance, _p_create_info: *const AndroidSurfaceCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_android_surface_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateAndroidSurfaceKHR\0"); let val = _f(cname); if val.is_null() { create_android_surface_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_win32_surface"] pub mod win32_surface { use super::super::*; pub use { crate::vk::KHR_WIN32_SURFACE_NAME as NAME, crate::vk::KHR_WIN32_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_win32_surface 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_KHR_win32_surface instance-level function pointers"] pub struct InstanceFn { pub create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR, pub get_physical_device_win32_presentation_support_khr: PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR, } 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_win32_surface_khr: unsafe { unsafe extern "system" fn create_win32_surface_khr( _instance: crate::vk::Instance, _p_create_info: *const Win32SurfaceCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_surface: *mut SurfaceKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_win32_surface_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateWin32SurfaceKHR\0"); let val = _f(cname); if val.is_null() { create_win32_surface_khr } else { ::core::mem::transmute(val) } }, get_physical_device_win32_presentation_support_khr: unsafe { unsafe extern "system" fn get_physical_device_win32_presentation_support_khr( _physical_device: PhysicalDevice, _queue_family_index: u32, ) -> Bool32 { panic!(concat!( "Unable to load ", stringify!(get_physical_device_win32_presentation_support_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceWin32PresentationSupportKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_win32_presentation_support_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_sampler_mirror_clamp_to_edge"] pub mod sampler_mirror_clamp_to_edge { use super::super::*; pub use { crate::vk::KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_NAME as NAME, crate::vk::KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_KHR_video_queue"] pub mod video_queue { use super::super::*; pub use { crate::vk::KHR_VIDEO_QUEUE_NAME as NAME, crate::vk::KHR_VIDEO_QUEUE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_video_queue 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_KHR_video_queue instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_video_capabilities_khr: PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR, pub get_physical_device_video_format_properties_khr: PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR, } 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 { get_physical_device_video_capabilities_khr: unsafe { unsafe extern "system" fn get_physical_device_video_capabilities_khr( _physical_device: PhysicalDevice, _p_video_profile: *const VideoProfileInfoKHR<'_>, _p_capabilities: *mut VideoCapabilitiesKHR<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_video_capabilities_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceVideoCapabilitiesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_video_capabilities_khr } else { ::core::mem::transmute(val) } }, get_physical_device_video_format_properties_khr: unsafe { unsafe extern "system" fn get_physical_device_video_format_properties_khr( _physical_device: PhysicalDevice, _p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR<'_>, _p_video_format_property_count: *mut u32, _p_video_format_properties: *mut VideoFormatPropertiesKHR<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_video_format_properties_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceVideoFormatPropertiesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_video_format_properties_khr } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_KHR_video_queue 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_KHR_video_queue device-level function pointers"] pub struct DeviceFn { pub create_video_session_khr: PFN_vkCreateVideoSessionKHR, pub destroy_video_session_khr: PFN_vkDestroyVideoSessionKHR, pub get_video_session_memory_requirements_khr: PFN_vkGetVideoSessionMemoryRequirementsKHR, pub bind_video_session_memory_khr: PFN_vkBindVideoSessionMemoryKHR, pub create_video_session_parameters_khr: PFN_vkCreateVideoSessionParametersKHR, pub update_video_session_parameters_khr: PFN_vkUpdateVideoSessionParametersKHR, pub destroy_video_session_parameters_khr: PFN_vkDestroyVideoSessionParametersKHR, pub cmd_begin_video_coding_khr: PFN_vkCmdBeginVideoCodingKHR, pub cmd_end_video_coding_khr: PFN_vkCmdEndVideoCodingKHR, pub cmd_control_video_coding_khr: PFN_vkCmdControlVideoCodingKHR, } 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_video_session_khr: unsafe { unsafe extern "system" fn create_video_session_khr( _device: crate::vk::Device, _p_create_info: *const VideoSessionCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_video_session: *mut VideoSessionKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_video_session_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCreateVideoSessionKHR\0"); let val = _f(cname); if val.is_null() { create_video_session_khr } else { ::core::mem::transmute(val) } }, destroy_video_session_khr: unsafe { unsafe extern "system" fn destroy_video_session_khr( _device: crate::vk::Device, _video_session: VideoSessionKHR, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!( "Unable to load ", stringify!(destroy_video_session_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyVideoSessionKHR\0"); let val = _f(cname); if val.is_null() { destroy_video_session_khr } else { ::core::mem::transmute(val) } }, get_video_session_memory_requirements_khr: unsafe { unsafe extern "system" fn get_video_session_memory_requirements_khr( _device: crate::vk::Device, _video_session: VideoSessionKHR, _p_memory_requirements_count: *mut u32, _p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_video_session_memory_requirements_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetVideoSessionMemoryRequirementsKHR\0", ); let val = _f(cname); if val.is_null() { get_video_session_memory_requirements_khr } else { ::core::mem::transmute(val) } }, bind_video_session_memory_khr: unsafe { unsafe extern "system" fn bind_video_session_memory_khr( _device: crate::vk::Device, _video_session: VideoSessionKHR, _bind_session_memory_info_count: u32, _p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(bind_video_session_memory_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkBindVideoSessionMemoryKHR\0"); let val = _f(cname); if val.is_null() { bind_video_session_memory_khr } else { ::core::mem::transmute(val) } }, create_video_session_parameters_khr: unsafe { unsafe extern "system" fn create_video_session_parameters_khr( _device: crate::vk::Device, _p_create_info: *const VideoSessionParametersCreateInfoKHR<'_>, _p_allocator: *const AllocationCallbacks<'_>, _p_video_session_parameters: *mut VideoSessionParametersKHR, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_video_session_parameters_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCreateVideoSessionParametersKHR\0", ); let val = _f(cname); if val.is_null() { create_video_session_parameters_khr } else { ::core::mem::transmute(val) } }, update_video_session_parameters_khr: unsafe { unsafe extern "system" fn update_video_session_parameters_khr( _device: crate::vk::Device, _video_session_parameters: VideoSessionParametersKHR, _p_update_info: *const VideoSessionParametersUpdateInfoKHR<'_>, ) -> Result { panic!(concat!( "Unable to load ", stringify!(update_video_session_parameters_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkUpdateVideoSessionParametersKHR\0", ); let val = _f(cname); if val.is_null() { update_video_session_parameters_khr } else { ::core::mem::transmute(val) } }, destroy_video_session_parameters_khr: unsafe { unsafe extern "system" fn destroy_video_session_parameters_khr( _device: crate::vk::Device, _video_session_parameters: VideoSessionParametersKHR, _p_allocator: *const AllocationCallbacks<'_>, ) { panic!(concat!( "Unable to load ", stringify!(destroy_video_session_parameters_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkDestroyVideoSessionParametersKHR\0", ); let val = _f(cname); if val.is_null() { destroy_video_session_parameters_khr } else { ::core::mem::transmute(val) } }, cmd_begin_video_coding_khr: unsafe { unsafe extern "system" fn cmd_begin_video_coding_khr( _command_buffer: CommandBuffer, _p_begin_info: *const VideoBeginCodingInfoKHR<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_begin_video_coding_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginVideoCodingKHR\0"); let val = _f(cname); if val.is_null() { cmd_begin_video_coding_khr } else { ::core::mem::transmute(val) } }, cmd_end_video_coding_khr: unsafe { unsafe extern "system" fn cmd_end_video_coding_khr( _command_buffer: CommandBuffer, _p_end_coding_info: *const VideoEndCodingInfoKHR<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_end_video_coding_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdEndVideoCodingKHR\0"); let val = _f(cname); if val.is_null() { cmd_end_video_coding_khr } else { ::core::mem::transmute(val) } }, cmd_control_video_coding_khr: unsafe { unsafe extern "system" fn cmd_control_video_coding_khr( _command_buffer: CommandBuffer, _p_coding_control_info: *const VideoCodingControlInfoKHR<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_control_video_coding_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdControlVideoCodingKHR\0"); let val = _f(cname); if val.is_null() { cmd_control_video_coding_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_video_decode_queue"] pub mod video_decode_queue { use super::super::*; pub use { crate::vk::KHR_VIDEO_DECODE_QUEUE_NAME as NAME, crate::vk::KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_video_decode_queue 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_KHR_video_decode_queue device-level function pointers"] pub struct DeviceFn { pub cmd_decode_video_khr: PFN_vkCmdDecodeVideoKHR, } 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_decode_video_khr: unsafe { unsafe extern "system" fn cmd_decode_video_khr( _command_buffer: CommandBuffer, _p_decode_info: *const VideoDecodeInfoKHR<'_>, ) { panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdDecodeVideoKHR\0"); let val = _f(cname); if val.is_null() { cmd_decode_video_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_video_encode_h264"] pub mod video_encode_h264 { use super::super::*; pub use { crate::vk::KHR_VIDEO_ENCODE_H264_NAME as NAME, crate::vk::KHR_VIDEO_ENCODE_H264_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_KHR_video_encode_h265"] pub mod video_encode_h265 { use super::super::*; pub use { crate::vk::KHR_VIDEO_ENCODE_H265_NAME as NAME, crate::vk::KHR_VIDEO_ENCODE_H265_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_KHR_video_decode_h264"] pub mod video_decode_h264 { use super::super::*; pub use { crate::vk::KHR_VIDEO_DECODE_H264_NAME as NAME, crate::vk::KHR_VIDEO_DECODE_H264_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_KHR_dynamic_rendering"] pub mod dynamic_rendering { use super::super::*; pub use { crate::vk::KHR_DYNAMIC_RENDERING_NAME as NAME, crate::vk::KHR_DYNAMIC_RENDERING_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_dynamic_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_KHR_dynamic_rendering device-level function pointers"] pub struct DeviceFn { pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering, pub cmd_end_rendering_khr: PFN_vkCmdEndRendering, } 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_rendering_khr: unsafe { unsafe extern "system" fn cmd_begin_rendering_khr( _command_buffer: CommandBuffer, _p_rendering_info: *const RenderingInfo<'_>, ) { panic!(concat!( "Unable to load ", stringify!(cmd_begin_rendering_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0"); let val = _f(cname); if val.is_null() { cmd_begin_rendering_khr } else { ::core::mem::transmute(val) } }, cmd_end_rendering_khr: unsafe { unsafe extern "system" fn cmd_end_rendering_khr( _command_buffer: CommandBuffer, ) { panic!(concat!( "Unable to load ", stringify!(cmd_end_rendering_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0"); let val = _f(cname); if val.is_null() { cmd_end_rendering_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_multiview"] pub mod multiview { use super::super::*; pub use { crate::vk::KHR_MULTIVIEW_NAME as NAME, crate::vk::KHR_MULTIVIEW_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_KHR_get_physical_device_properties2"] pub mod get_physical_device_properties2 { use super::super::*; pub use { crate::vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_NAME as NAME, crate::vk::KHR_GET_PHYSICAL_DEVICE_PROPERTIES2_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_get_physical_device_properties2 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_KHR_get_physical_device_properties2 instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_features2_khr: PFN_vkGetPhysicalDeviceFeatures2, pub get_physical_device_properties2_khr: PFN_vkGetPhysicalDeviceProperties2, pub get_physical_device_format_properties2_khr: PFN_vkGetPhysicalDeviceFormatProperties2, pub get_physical_device_image_format_properties2_khr: PFN_vkGetPhysicalDeviceImageFormatProperties2, pub get_physical_device_queue_family_properties2_khr: PFN_vkGetPhysicalDeviceQueueFamilyProperties2, pub get_physical_device_memory_properties2_khr: PFN_vkGetPhysicalDeviceMemoryProperties2, pub get_physical_device_sparse_image_format_properties2_khr: PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, } 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 { get_physical_device_features2_khr: unsafe { unsafe extern "system" fn get_physical_device_features2_khr( _physical_device: PhysicalDevice, _p_features: *mut PhysicalDeviceFeatures2<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_physical_device_features2_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceFeatures2KHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_features2_khr } else { ::core::mem::transmute(val) } }, get_physical_device_properties2_khr: unsafe { unsafe extern "system" fn get_physical_device_properties2_khr( _physical_device: PhysicalDevice, _p_properties: *mut PhysicalDeviceProperties2<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_physical_device_properties2_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceProperties2KHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_properties2_khr } else { ::core::mem::transmute(val) } }, get_physical_device_format_properties2_khr: unsafe { unsafe extern "system" fn get_physical_device_format_properties2_khr( _physical_device: PhysicalDevice, _format: Format, _p_format_properties: *mut FormatProperties2<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_physical_device_format_properties2_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceFormatProperties2KHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_format_properties2_khr } else { ::core::mem::transmute(val) } }, get_physical_device_image_format_properties2_khr: unsafe { unsafe extern "system" fn get_physical_device_image_format_properties2_khr( _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_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceImageFormatProperties2KHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_image_format_properties2_khr } else { ::core::mem::transmute(val) } }, get_physical_device_queue_family_properties2_khr: unsafe { unsafe extern "system" fn get_physical_device_queue_family_properties2_khr( _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_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceQueueFamilyProperties2KHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_queue_family_properties2_khr } else { ::core::mem::transmute(val) } }, get_physical_device_memory_properties2_khr: unsafe { unsafe extern "system" fn get_physical_device_memory_properties2_khr( _physical_device: PhysicalDevice, _p_memory_properties: *mut PhysicalDeviceMemoryProperties2<'_>, ) { panic!(concat!( "Unable to load ", stringify!(get_physical_device_memory_properties2_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceMemoryProperties2KHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_memory_properties2_khr } else { ::core::mem::transmute(val) } }, get_physical_device_sparse_image_format_properties2_khr: unsafe { unsafe extern "system" fn get_physical_device_sparse_image_format_properties2_khr( _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_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDeviceSparseImageFormatProperties2KHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_sparse_image_format_properties2_khr } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_KHR_device_group"] pub mod device_group { use super::super::*; pub use { crate::vk::KHR_DEVICE_GROUP_NAME as NAME, crate::vk::KHR_DEVICE_GROUP_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_KHR_device_group 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_KHR_device_group instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_present_rectangles_khr: PFN_vkGetPhysicalDevicePresentRectanglesKHR, } 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 { get_physical_device_present_rectangles_khr: unsafe { unsafe extern "system" fn get_physical_device_present_rectangles_khr( _physical_device: PhysicalDevice, _surface: SurfaceKHR, _p_rect_count: *mut u32, _p_rects: *mut Rect2D, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_present_rectangles_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetPhysicalDevicePresentRectanglesKHR\0", ); let val = _f(cname); if val.is_null() { get_physical_device_present_rectangles_khr } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_KHR_device_group 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_KHR_device_group device-level function pointers"] pub struct DeviceFn { pub get_device_group_peer_memory_features_khr: PFN_vkGetDeviceGroupPeerMemoryFeatu pub cmd_set_device_mask_khr: PFN_vkCmdSetDeviceMask, pub cmd_dispatch_base_khr: PFN_vkCmdDispatchBase, pub get_device_group_present_capabilities_khr: PFN_vkGetDeviceGroupPresentCapabilitiesKHR, pub get_device_group_surface_present_modes_khr: PFN_vkGetDeviceGroupSurfacePresentModesKHR, pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR, } 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_device_group_peer_memory_features_khr: unsafe { unsafe extern "system" fn get_device_group_peer_memory_features_khr( _device: crate::vk::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_khr) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDeviceGroupPeerMemoryFeaturesKHR\0", ); let val = _f(cname); if val.is_null() { get_device_group_peer_memory_features_khr } else { ::core::mem::transmute(val) } }, cmd_set_device_mask_khr: unsafe { unsafe extern "system" fn cmd_set_device_mask_khr( --> -------------------- --> maximum size reached --> -------------------- [Seitenstruktur0.627Druckenetwas mehr zur Ethik2026-04-26] |
2026-05-26