| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/JAVA/Openclaw/extensions/matrix/src/matrix/ (Openclaw AI Version 22©) Datei vom 26.3.2026 mit Größe 482 B |
|
Quelle extensions_generated.rs Sprache: Rust |
|
|
#![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) java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30 } fjava.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bounds for len ertiesEXT0" java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50 _stride } else { ::core:java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds f }:java.lang.StringIndexOutOfBoundsException: Range [61, 53) out of bounds for le }crateasjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for le java.lang.StringIndexOutOfBoundsException: Range [66, 17) out of bounds for leng } java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 } #[ java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for le &.java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24 use java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length }; [doc"-level functions] #[derive(Clone)] pub { pub(crate) fp: InstanceFn, pub(crate) handle: crate_p_info_size *usize impljava.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for pub fn new ] =.(; let fp = InstanceFn::load(MASK_NAME , core::::java.lang.StringIndexOutOfBoundsException: Range [57, 53) out of bounds fnnewinstance: &:Instance device:crate::Device) >Self Self ; } #[inline] pub fp( >&java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45 &self.fp } #inline instance&)- crate::{ self.handle stringify(java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bound } #[derive(Clone)] instance-level function pointers"] pub struct InstanceFn { pub get_physical_device_calibrateable_time_domains_ext} PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR, } unsafe impl Send for crate:::AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSIONSPEC_VERSION, unsafe impl Sync for InstanceFn {} [ VK_AMD_memory_overallocation_behavior pub fn load<F: FnMut(&CStr} Selfload_erased(mutfjava.lang.StringIndexOutOfBoundsException: Index 41 out of b } fn_:mutdynFnMut& >constc_void { Self &java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24 doc java.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for l _physical_device: java.lang.StringIndexOutOfBoundsException: Index 49 out of boun java.lang.StringIndexOutOfBoundsException: Range [71, 69) out of bounds for leng _p_time_domains: *mut TimeDomainKHR !(oncat( ) -let :(b0) valis_null){ "Unable to load ", stringify!(get_physical_device_calibrateable_time_domains_ext) } :( "0 ); let val if valusesuper::: get_physical_device_calibrateable_time_domains_ext }crate fp:DeviceFn, : fn(:&: :java.lang.StringIndexOutOfBoundsException: Range [66, 65) out of boun } }, } } } #[doc = " java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds f #unsafeimpl java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of boun ::load_erasedmutf) java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 13 pub(crate) handle: crate::vk: : unsafe{ } impl Device { >Result let handle = device.java.lang.StringIndexOutOfBoundsException: Index 42 out of boun let fp = DeviceFn::load(|name| unsafeif val.({ core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) }); Self{handle } } # !java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for le pub fn fp(&self) -> &DeviceFn { &self.fp } [] pub java.lang.StringIndexOutOfBoundsException: Range [66, 64) out of bounds for l self > } } #[derive(Clone)] #[doc = "Raw VK_EXT_calibrated_timestamps cmd_initialize_graph_scratch_memory_amdx { pub struct DeviceFn { pub get_calibrated_timestamps_ext cname=CStr:from_bytes_with_nul_unchecked( } unsafe impl Send for DeviceFn {} unsafe impl Sync for DeviceFn {} impl DeviceFn { stringify!cmd_dispatch_graph_amdx Self::load_erased(&mut f) } fn load_erased(_cratch java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for leng get_calibrated_timestamps_extb"\" unsafe extern .( _device: crate::vk::Device, _timestamp_count: u32, _p_timestamp_infos: *const CalibratedTimestampInfoKHR<'_>, _p_timestamps: *mut u64, _p_max_deviation: *mut u64, ) - Result{ panic!( let val = _f(cnam "Unable ::core::mem::transmute(val) stringify!(get_calibrated_timestamps_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetCalibratedTimestampsEXT\0"); let val = _f(cname); } get_calibrated_timestamps_ext } else { ::core::mem::transmute(val} } }, } } } java.lang.StringIndexOutOfBoundsException: Range [27, 18) out of bounds for leng java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for leng super:; pub use { ::E as, ::java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for le } } #[doc = "VK_EXT_pipeline_creation_feedback"] pub mod pipeline_creation_feedbacktoload " use super::super::*; pub use { java.lang.StringIndexOutOfBoundsException: Range [58, 17) out of bounds for leng crate::vk::p_native_fence_fd java.lang.StringIndexOutOfBoundsException: Range [59 }; } #[doc = "VK_EXT_pci_bus_info"] pubmod pci_bus_info { use super::super::*; pub use { crate::vk::EXT_PCI_BUS_INFO_NAME as NAME, crate::vk::java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for } } #[doc = "VK_EXT_metal_surface"] pub use super::super::*; pub use}java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for len crate::vk::EXT_METAL_SURFACE_NAMEpub modjava.lang.StringIndexOutOfBoundsException crate::vk::EXT_METAL_SURFACE_SPEC_VERSION :v:java.lang.StringIndexOutOfBoundsExce ; #[doc = "VK_EXT_metal_surface instance-level functions"] #derive(Clone)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds pub struct Instance { pub(cratepub new(: crate:, device: &::evice ->{ pub(crate) handle: crate::vk::Instance, } Instance{ pub fn new(entry: &crate::Entry, { fp let handle = instance.handle(); &fp core::mem::transmute } }); Self { handle, fp } } #[inline] pub fn fp(&self) -> &InstanceFn { &self.fp java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for leng pub fn instance(&self) -> crate_java.lang.StringIndexOutOfBound self) } } #[java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for le #[doc = "Raw VK_EXT_metal_surface instance-level function java.lang.StringIndexOutOfBo pub struct InstanceFn { pubcreate_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT, } unsafe impl Send for InstanceFn {} unsafe impl Sync for InstanceFn {} impl InstanceFn { pub fn load<F: FnMut(&CStr) -> *const crate::vk::ARM_SCHEDULING_CONTROLS_SPEC_VERSIONjava Self:java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for fn java.lang.StringIndexOutOfBoundsException: Range [15, 26) out of bounds for le Self { create_metal_surface_ext: unsafe { java.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for leng _instance:} _p_create_info: *const MetalSurfaceCreateInfoEXT<'_>, _ <_, _p_surface: *mut SurfaceKHR, java.lang.StringIndexOutOfBoundsException: Index 13 ou ) -pub java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for panic!(concat!( fnload_erased(_f: mutdyn FnMut(CStr) -> *const c_void) -> Self { )) } java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for leng CStr::java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds fo let val =let = _(cname)java.lang.StringIndexOutOfBoundsException: Index 44 out of bo .java.lang.StringIndexOutOfBoundsException: Range [40, 38) out of bounds for len create_metal_surface_ext }) ::core::mem::transmute(val) } java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for leng } } val f()java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for leng } [ ="java.lang.StringIndexOutOfBoundsException: Range [42, 40) out of bounds for l pub mod fragment_density_map { use super::super::*; pub use crate::vk:EXT_DEBUG_MARKER_NAME as NAME, crate as NAME, crate::vk::[doc = "VK_EXT_debug_marker-java.lang.StringIndexOutOfBoundsException: }; } #[doc = ":mem::transmutejava.lang.StringIndexOutOfBoundsException: Range [50, 49) pubmod java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for leng pub use { ::k:EXT_SCALAR_BLOCK_LAYOUT_NAME as NAME, crate::vk::EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION as java.lang.StringIndexOutOfBound } #[doc = "VK_EXT_subgroup_size_control"] pubjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for l use super::super::*; use{ crate is_null){ crate} }; } #doc = "VK_EXT_shader_image_atomic_int64"] pub mod shader_image_atomic_int64 { use java.lang.StringIndexOutOfBoundsException: Range [24, 16) out of bounds for l java.lang.StringIndexOutOfBoundsException: Range [25, 9) out of bounds for lengt crate::vk::EXT_SHADER_IMAGE_ATOMIC_INT64_NAMEtoload", crate:vk::EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION as SPEC_VERSION, }; } ] pub(java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for supersuper: pub use { crate::vk::EXT_MEMORY_BUDGET_NAME as NAME, crate::vk::EXT_MEMORY_BUDGET_SPEC_VERSION as SPEC_VERSION, }; } # pub mod memory_priority { :super:; pub use { crate::vk::EXT_MEMORY_PRIORITY_NAME as NAME, ::EXT_MEMORY_PRIORITY_SPEC_VERSION as SPEC_VERSIONjava.lang.StringIndexOutOfBounds }; } #EXT_buffer_device_address" pub mod buffer_device_address per:* pub use { crate::vk::EXT_BUFFER_DEVICE_ADDRESS_NAME as NAME,self.andle crate::vk::EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION as SPEC_VERSION, }; #[doc = " java.lang.StringIndexOutOfBoundsException: Range [81, 80) out of bounds f #[derive(Clone)] java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for leng 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_java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of core::mem::transmute(instance.get_device_proc_addr(handle !(cmd_bind_transform_fe }); Self { handle cmd_bind_transform_feedback_buffers_ext } #[inline] pub fn fp(&self) -> &DeviceFn { &self.fp } #[inline}else pub ){ self.handle } } #[derive(Clone)] #[doc = "Raw VK_EXT_buffer_device_address device-level function pointers"] pub struct DeviceFn { pubget_buffer_device_address_ext:PFN_vkGetBufferDeviceAddress } unsafe impl Send for DeviceFn {} unsafe impl Sync for DeviceFn {} implDeviceFn { 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_voidmCStr:java Self { get_buffer_device_address_ext: unsafe { unsafe extern "system" fn get_buffer_device_address_ext( _device: crate::vk::Device_ java.lang.StringIndexOutOfBoundsException: Range [59, _p_info: *const BufferDeviceAddressInfo<'_>, ) -> DeviceAddress { panic!(concat!( "Unable to load ", stringify!(get_buffer_device_address_ext)"Unableto load ", )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddressEXT\0"); java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25 if val.is_null() { get_buffer_device_address_ext } else { ::core::mem::transmute(val) } #doc= "VK_EXT_shader_subgroup_ballot"] } usesuper::super::*java.lang.StringIndexOutOfBoundsException: Index 28 out of bo } } ;} ::AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION:::*; usepub use{ pub { as, ::EXT_TOOLING_INFO_SPEC_VERSION SPEC_VERSIONjava.lang.StringIndexOutOfBoundsExcep ; doc="VK_EXT_tooling_info instance-level functions" #[derive(Clone)] pubstructInstance { pub(crate) fpcmd_draw_indirect_count_amd:unsafe { pub) ::k::Instancejava.lang.StringIndexOutOfBoundsException: Index 51 out of boun java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 Instancejava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for le lethandle=instancehandle(; let java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length core::mem _(namejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds }):use:superjava.lang.StringIndexOutOfBoundsException: Range [24, 10) out of bou Self { handle, fp }pub { } #[inline]cratev::MD_SHADER_BALLOT_NAME NAMEjava.lang.StringIndexOutOfBoundsExcept java.lang.StringIndexOutOfBoundsException: Range [27, 15) out of bounds for leng use } #[inline] Self handle,fp} pub fn d(self >crate: pub fn device(&self) -> crate::vk fndevice(&elf)- crate:::vk:Device { } } #[derive(Clone)] #[docpubcmd_end_conditional_rendering_ext:PFN_vkCmdEndConditionalRenderingEXT pub InstanceFn{ pub _p_info: :* c_void, } unsafe impl Send for } implSync for InstanceFn } impl InstanceFn _} pub fn load<F :::AMD_GPU_SHADER_INT16_NAME asNAME, pub java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length } fn load_erased; Self { get_physical_device_tool_properties_ext: unsafe { core::(instanceget_device_proc_addr,nameas_ptr)) _:PhysicalDevicejava.lang.StringIndexOutOfBoundsException: Index 61 out of bound f(fmutFnMutC const)-Selfjava.lang.StringIndexOutOfBoundsException: Index 80 out o _p_tool_properties: *mut PhysicalDeviceToolProperties<'_>, ) -> Result { =fcname; "Unable to load ", stringify!(get_physical_device_tool_properties_ext modjava.lang.StringIndexOutOfB )) } let=:from_bytes_with_nul_unchecked b"vkGetPhysicalDeviceToolPropertiesEXT usejava.lang.StringIndexOutOfBoundsExcepti ); handle=.handle(; java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19 } else { ::em:ransmute(val) } }, } java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 } #}} pub use super: crate:vk:AMD_SHADER_CORE_PROPERTIES2_NAME as NAME, pub use { java.lang.StringIndexOutOfBoundsException: Range [42, 17) out of bounds for leng crate::vk::EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION as SPEC_VERSION crate::k:AMD_SHA }; } #[[ V java.lang.StringIndexOutOfBoundsException: Range [12, 1) out of bounds for l fnjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 use super::super::*; pub use {}; crate::vk:: get_execution_graph_pipeline_node_index_amdx crate:k::EXT_VALIDATION_FEATURES_SPEC_VERSION }; } "] pubjava.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for l use pubbvkCmdInitializeGraphScratchMemoryAMDXjava.lang.StringIndexOutOfBoundsExcepti crate:EXT_FRAGMENT_SHADER_INTERLOCK_NAMEjava.lang.StringIndexOutOfBoundsExceptio :java.lang.StringIndexOutOfBoundsException: Range [73, 57) out of bounds for len }; } #[(java.lang.StringIndexOutOfBoundsException: Range [42, 39) out of bounds for l pub mod ycbcr_image_arrays { usejava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length pub use { crate::vk::EXT_YCBCR_IMAGE_ARRAYS_NAME} crate::vk::stringify!(get_swapchain_gralloc_usage2_android) })java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 3 } # " java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5 modprovoking_vertexpub mod display_surface_co java.lang.StringIndexOutOfBoundsExcep use super::super:java.lang.StringIndexOutOfBoundsException: Index 25 out of bound pub use { crate: ; :vkEjava.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for ; } #[doc = "VK_EXT_full_screen_exclusive"] fp DeviceFn:l|ame|unsafe use super::super::*; java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for leng :EXT_FULL_SCREEN_EXCLUSIVE_NAME NAME, crate::vk::EXT_FULL_SCREEN_EXCLUSIVE_SPEC_VERSION as SPEC_VERSION, }; -level functions" #[()] pub struct java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for l pub(unsafe impl for DeviceFnself.andle java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13 impl Instance { pub const AHardwareBuffer let handle = instance.handle(); let fp = InstanceFn::"Unableto"java.lang.StringIndexOutOfBoundsException: Index 9 o (entry.get_instance_proc_addr(java.lang.StringIndexOutOfBoundsException: Index 7 }); Self { handle, fp &) - java.lang.StringIndexOutOfBoundsException: Index 77 out of b #[inline] pub fn fp(&self) -> &InstanceFn { &self.fp } #_physical_device:PhysicalDevice, pub self.java.lang.StringIndexOutOfBoundsException: Range [27, 28) out of bounds for } } #derive(Clone)stringify!et_physical_device_surface_capabilities2_ext #[doc = "Raw VK_EXT_full_screen_exclusive instance-level function} struct InstanceFn { pub get_physical_device_surface_present_modes2_ext: PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT } unsafe impl Send for InstanceFn {java.lang.StringIndexOutOfBoundsException: Index 41 unsafe impl Sync for InstanceFn {} impl InstanceFn { :: crate::vk::ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION Self:: mod scheduling_controls="java.lang.StringIndexOutOfBoundsException: Range [ } fnjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5 { * _physical_device: PhysicalDevice, _p_surface_info: *const java.lang.StringIndexOutOfBoundsException: Range [0, 81) o _java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 26 _p_present_modes: *mut PresentModeKHR, )java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for len java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for leng "Unable to impl Instance stringify!(get_physical_device_surface_present_modes2_ext) )) } let cname = java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for l b"vkGetPhysicalDeviceSurfacePresentModes2EXT\0", java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for leng let val = _f(cname); val. Selfload_erasedmut f) destroy_debug_report_callback_ext:PFN_vkDestroyDebugReportCallbackEXT, ::core::mem::transmute(val) } }, } } } #[doc = _display_power_info constjava.lang.StringIndexOutOfBoundsException: Index 7 java.lang.NullPointerException pub(crate) fp: panic!(concat!( pub(crate) stringify!(isplay_power_control_ext) } impl Device { pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self { let val fcname)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds f { core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptrdisplay_pow ); { } #[inline, pub fn r: unsafe{ &self.fp } ] ) selfjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length } } #[derive(Clone)] # bjava.lang.StringIndexOutOfBoundsException: Range [92, 90) out of bounds for le pub struct DeviceFn {_message_code: java.lang.StringIndexOutOfBoundsException: Index pub _p_message , pub}else pub get_device_group_surface_present_modes2_ext: eGroupSurfacePresentModes2EXT, } unsafe impl Send for DeviceFn {} Syncdebug_rep impl DeviceFn { pub fn load<F: FnMut(&CStr} Self::load_erased} } fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self { Self { ::EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSIONjava.lang.StringIndexOutOfBoundsExcep unsafe extern "} ::vk:java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for _swapchain: SwapchainKHR, { if val; "Unable load [derive(Clone)java.lang.StringIndexOutOfBoundsException: Index 24 out !acquire_full_screen_exclusive_mode_extjava.lang.StringIndexOutOfBoundsException )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkAcquireFullScreenExclusiveModeEXT\0", ); let val =_fcname; if val.is_null() { acquire_full_screen_exclusive_mode_ext } else { ::core::mem::java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds f } } doc = "Raw VK_EXT_debug_marker device-level function :cratevk:, _debug_marker_set_object_tag_ext ) -> Result} panic!concat!java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds f "pub fn new(instance: &crate:Instance,device &crate:Device) - Self java.lang.StringIndexOutOfBoundsException: Ind !) )) } let _(name b"vkReleaseFullScreenExclusiveModeEXT\0", ); val =_f(name; if val.is_null() { release_full_screen_exclusive_mode_ext } else { ) } }, get_device_group_surface_present_modes2_ext: unsafe { unsafe java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for leng java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR_: CommandBufferjava.lang.Stri _iscard_rectangle_count , ) -> Result { Unable to , !concat!java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for le " let cname= !get_device_group_surface_present_modes2_extjava.lang.StringIndexOutOfBoundsExce )) } let cname=CStr:fjava.lang.StringIndexOutOfBoundsException: Range [0, 71) out of b " b"vkGetDeviceGroupSurfacePresentModes2EXT ); let val = _f(cname); } else { up_surface_present_modes2_ext } else { ::core::mem::transmute #[ ="VK_EXT_transform_feedback"] } java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22 } } #[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 Instance { pub(crate) fp: InstanceFn, } impl Instance { : &crate::Instance - Self { let =instance.andle(; ::(name|unsafe{ core::mem::transmute(entry.get_instance_proc_addr(handle, name.as_ptr())) }); Self { handle, _commCommandBuffer } #[inline] ) { panic!c!( } #[inline] pub fn instance(&self) -> crate::vk::Instance { self.handle } } #[derive(Clone)] #[doc =" VK_EXT_headless_surface instance-evelfunction "] pub struct InstanceFn {#inline :PFN_vkCreateHeadlessSurfaceEXT java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 unsafe impl Send for InstanceFn {} unsafe impl Sync for InstanceFn {} impl InstanceFn { pub_:CommandBuffer Self::load_erased(&mut f) } fn (_:& FnMut(CStr >*const c_void)- ::load_erased(utf)) Self { create_headless_surface_ext: unsafe { unsafe extern "system" fn create_headless_surface_ext( let= _c)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for len _p_create_info: ::ore:mem:transmute(al _p_allocator: *const AllocationCallbacks<'_>, _java.lang.StringIndexOutOfBoundsException: Range [55, 38) out of bounds for len ) -> Result { panic!(concat!( "Unable to load ", Unable to load "java.lang.StringIndexOutOfBoundsException: Index 50 java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45 } 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) } , } } } } #[ "VK_EXT_line_rasterization"] pub mod line_rasterization { use super::super::*; pub use { crate::vk::EXT_LINE_RASTERIZATION_NAME as NAME, java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5 }; #[doc = "VK_EXT_line_rasterization device-java.lang.StringIndexOutOfBoundsException #[derive(Clone)] pub struct Device { pub(crate) fp: DeviceFn, pub(crate) handle: crate::vk::Device, } d pub fn new(instance: &crate::Instance, device: handle=device.() let fp = DeviceFn::load(|name| unsafe = DeviceFn:load(name| unsafe{ destroy_debug_utils_messenger_ext ; Self { handle, fp } #[inline java.lang.StringIndexOutOfBoundsException: Range [51, 49) out of bounds pub fn fp(&self) -> &DeviceFn { selffp } #[inline] pub fn device(&self) -> crate::vk::Device { self.handle } } java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55 #[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=f; unsafe impl Sync for DeviceFn {} impl DeviceFn { pub fn load<F: FnMut(&CStr) -> *const c_void} Self::load_erased(&mut f) } fn load_erased(_f: &mut dyn FnMut(&CStr) - vkjava.lang.StringInde Self #(Clone cmd_set_line_stipple_ext: unsafe { java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for leng _java.lang.StringIndexOutOfBoundsException: Range [45, 43) out of bounds for len _line_stipple_factor: u32, _ , ) { java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for lengt " stringify!(cmd_set_line_stipple_ext::&mut )) java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 25 let cname = CStr::unsafe externjava.lang.StringIndexOutOfBoundsException: Range [46, 45) out let val = _f(cname); if val.is_null() { cmd_set_line_stipple_ext } else { ::core::mem::transmute(val) } } } } #[doc = "VK_EXT_shader_atomic_float"] pubjava.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for l use super java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for le pub use { crate::vk::EXT_SHADER_ATOMIC_FLOAT_NAME as NAME, crate::vk::EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION as SPEC_VERSION, }; } #[doc = " ( handle ::k:Instance, pub mod host_query_reset { java.lang.StringIndexOutOfBoundsException: Range [24, 11) out of bounds for leng use{ crate::vk::EXT_HOST_QUERY_RESET_NAME as NAME, crate::vk::EXT_HOST_QUERY_RESET_SPEC_VERSION as SPEC_VERSION, }; #[doc = [(Clone)] #[derive(Clone)] pub struct Device {#[inline] pub(crate) fp: DeviceFn, pub(crate) handle: crate::vk::Device, } impl Device { pub Self { let handle = device.handle(); let fp = DeviceFn::load(|name| unsafe { java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24 }); Self { handle, fp } } #[inline] pub fn fp(&self) -> &DeviceFn { &self.fp } #[inline] pub fn device(&self) -> crate::vk::Device { self.handle java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13 } #[derive(Clone)] #[doc = "Raw VK_EXT_host_query_reset device-level function pointers"] pub struct DeviceFn { , java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 unsafeSelf:& ) unsafe impl Synclet c; impl DeviceFn } java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds f pub fn"} Self::load_erased(&mut f) RROutput fn - { Self { let = unsafe extern "system" fn java.lang.StringIndexOutOfBoundsException: Range [0, 70) o _::java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for leng _CStr:java.lang.StringIndexOutOfBoundsException: Range [65, 63) out of bounds fo , ) { panic!(concat!("Unable to load ", stringify!java.lang.StringIndexOutOfBoundsExceptio = CStr:from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0")java.lang.StringInd let val = _f(cname); if val.is_null() { stringify!(queue_begin_debug_utils_label_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, "to load " }; } #[doc = "VK_EXT_extended_dynamic_state"] pub mod extended_dynamic_state { }, pub f java.lang.StringIndexOutOfBoundsException: Range [82, 81) out of bounds for cratepanic(oncat asjava.lang.StringIndexOutOfBoundsException: Range [79, 78) out of bounds for le }; #[doc = "VK_EXT_extended_dynamic_state device-level functions"] #[derive(Clone)] java.lang.StringIndexOutOfBoundsException: Range [43, 10) out of bounds for leng pub(crate) fp: DeviceFn, java.lang.StringIndexOutOfBoundsException: Range [19, 15) out of bounds for leng (- D java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length impl Device { pub fn new(instance: &crate::Instance, device: &crate::Device) -> Self { let handle = device.handle() Raw devicelevelfunctionpointers]stringify(cmd_insert_deb let fp = DeviceFn::load(|name| unsafe { core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) }); Self {,p} } #[inline] pub fn fp(&self) -> &DeviceFn { &self.fp } #[inline] pubfndevice(&self)->crate:vk:Device { self.handle } } #[derive(Clone)] #[doc = "Raw VK_EXT_extended_dynamic_state device-level function pointers"] pub struct DeviceFn { java.lang.StringIndexOutOfBoundsException: Range [24, 20) out of bounds for leng pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace) java.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds for leng pub pub fn new(entry: &crate::Entry, instancecrate:I register_device_event_ext 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, cmd_set_depth_write_enable_ext:PFN_vkCmdSetDepthWriteEnablejava.lang.StringIndex pub cmd_set_depth_compare_op_ext pub fn fp&self) -> &InstanceFn { pub _p_display_event_infoconstDisplayEventInfoEXT<'_>, 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> bvkGetPhysicalDeviceMultisamplePropertiesEXT0java.lang.StringIndexOutOfBoundsExc } fn load_erased(_f: &mut dyn FnMut(&CStr) -> * ( fpjava.lang.StringIn 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 ", stringifypubcrate) handle:crate::vk::Device, )) } let cname = CStr::from_bytes_with_nul_unchecked(bletfp =DeviceFn:load|ame unsafe { let val = _f(cname); if val.is_null() { cmd_set_cull_mode_ext } else { ::core::mem::transmute(val) }, cmd_set_front_face_ext#doc VK_EXT_sample_locations- java.lang.StringIndexOutOfBoun unsafe extern "system" fn cmd_set_front_face_ext( _command_buffer: CommandBuffer, _front_face: FrontFace, ) { panic!(concat!( "Unable to load ", stringify!(java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for )) } letcname =Str:( l =_f(cname)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for if val.is_null() { cmd_set_front_face_ext }cmd_set_discard_rectangle_enable_ext ::core::mem::::core::mem::transmuteval } cmd_set_primitive_topology_ext} unsafe discard_rectangle_modejava.lang.StringIndexOutOfBoundsException: Index 77 _command_buffer: java.lang.StringIndexOutOfBoundsException: Index 56 out of bound java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for leng pubuse java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for leng panic! java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds fo "Unable to load ") !) ) } letcore:mem:transmute CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopologyEXT\0"); let val = _ } if val.is_null() { cmd_set_primitive_topology_ext e_drm_format_modifier" :::ransmuteval) } }, use:s*java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for leng unsafe extern "system" fn cmd_set_viewport_with_count_ext( :, viewport_countu32, __iewports:* , ) { panic!(java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for len "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 extern " [derive()] _command_buffer: CommandBuffer, java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for leng pscissors constRect2Djava.lang.StringIndexOutOfBoundsException: Index 55 out of b ) { panic!(concat!( , stringify!(cmd_set_scissor_with_count_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked: java.lang.StringIndexOutOfBoundsException: I let val f(cname); if val.is_null() { } else)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for leng ::core::mem::transmute(val) }panic!(oncat( }, cmd_bind_vertex_buffers2_ext: unsafe { java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30 _command_buffer: CommandBuffer, _first_binding: u32, _binding_count: u32, _p_buffers: *const Buffer, _p_offsets: *const DeviceSize, _p_sizes: *const DeviceSize, val =_name; ) { panic!(concat!( " ; stringify!(cmd_bind_vertex_buffers2_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(bpub java.lang.StringIndexOutOfBoundsExceptio let val = _f(cname); if val.is_null() { cmd_bind_vertex_buffers2_ext } else { : #i] java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25 }, cmd_set_depth_test_enable_ext: unsafe { unsafe extern "system } _command_buffer: (rate)handle :vkinstance-evel pointers] _depth_test_enable: Bool32, ) { panic!(concat!( "Unable to load ", java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for leng )fnload_erased(_:&utdyn FnMut(C) ->*const c_void) > Self { } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnableEXT\0"); let val = _f(cname); if val.is_null() { java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 25 } else { ::core::mem::transmute} } }, 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 ", stringifydestroy_debug_utils_messenger_ext )) } let cname = crate:vk:java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for l let val = _f(cname); val.is_null() { _write_enable_ext } else { ::core::mem::transmute(val) } }, u java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58 unsafe extern "system" fn stringify!(create_validation_cache_ext , } ) { panic!(concat!( "Unable to Self fp } stringify!(java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for )) } let cname = CStr::from_bytes_with_nul_uncheckedp:*AllocationCallbacks'java.lang.StringIndexO let val = _f(cname); if val.is_null() { cmd_set_depth_compare_op_ext } else { :core::(java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for le } }, 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!( java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 50 stringify!(cmd_set_depth_bounds_test_enable_ext) )) } ) b"vkCmdSetDepthBoundsTestEnableEXT\0", ); l= _(cname)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for if val.is_null() { cmd_set_depth_bounds_test_enable_ext } else { core:em:ransmute(val) } }, cmd_set_stencil_test_enable_ext: unsafe { able_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); ; cmd_set_stencil_test_enable_ext } else { ::core::mem::transmute(val) } }, cmd_set_stencil_op_ext: unsafe { "ystem fn cmd_set_stencil_op_ext _queue_end_debug _face_mask: StencilFaceFlags, _fail_op: StencilOp, , _depth_fail_op: StencilOp, "] ) panic!concat( U toload"java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for le stringify!(java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30 } let=CStr:rom_bytes_with_nul_unchecked(bvkCmdSetStencilOpEXT\0"); let val = _f(cname); if val.is_null() { cmd_set_stencil_op_ext } else { ::core::mem::transmute(val) } , } } } java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5 #[doc = "java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for len pub host_image_copy pubcrate andle ::Device use super::super::*; pubuse { crate:} crate:java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds fo }; #[doc = "java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for len d(Clone pub struct Device { pub(crate) fp: DeviceFn, pub() handle:crate:k:Device, } impl Device { pub fn new(instance: &crate::Instance, device : { let handle = device.handle(); let fp = DeviceFn::load(|name| unsafe { core::mem::transmute(instance.get_device_proc_addr(handle,cratevk::_p_host_point }> { fp java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length } #[}java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length pub fn fp(&self) -> &DeviceFn { &self.fp #[inline] pub fn device(&self) -> crate::vk: [C) self.handle } } } #[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 self.fp } fn java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for le unsafe impl Sync for DeviceFn {} impl DeviceFn { pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self { pub get_physical_device_multisample_properties_ext: } fn load_erased(_f} { copy_memory_to_image_ext: unsafe { unsafe extern "system" fn copy_memory_to_image_ext( _device: crate::vk::Device, m ) -> Result { panic!(concat!( "Unable to load ", stringify(opy_memory_to_image_ext )) } let cname = CStr::from_bytes_with_nul_unchecked(b} let val = _f(cname); if val.is_null() { copy_memory_to_image_ext } else { ::core::mem::transmute(val) } }cratevk:as, copy_image_to_memory_ext: unsafe { unsafe "copy_image_to_memory_ext( _device: crate::vk::Device, _p_copy_image_to_memory_info: *const CopyImageToMemoryInfoEXT<handle= handle(java.la )-java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 3 panic!(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for len to , stringify #deriveClone] )) } let cname = unsafe impl for DeviceFn {} val= _(cname)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds fo 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() { _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: core::transmute(instance.(nas_ptr() _p_transitions: *const HostImageLayoutTransitionInfoEXT<'_>, ) -> Result { panic!(} U load , stringify!(transition_image_layout_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkTransitionImageLayoutEXT\0"); let val = _f(cname); ifval.s_null( ) transition_image_layout_ext { (java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for len } }, get_image_subresource_layout2_ext: unsafe { unsafe extern "system" fn get_image_subresource_layout2_ext( :: :java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length _ #[eriveClone] _p_subresource: *const ImageSubresource2KHR<'_>, _p_layout: *mut SubresourceLayout2KHR<'_>, ){ panic(concat!( U toload"java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for le (get_image_subresource_layout2_ext ) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetImageSubresourceLayout2EXT\0", ); let val = _f(cname); if val.is_null unsafe extern "ystem fn get_calibrated_timestamps_ext( get_image_subresource_layout2_ext } else { ::corecrate:vk::java.lang.StringIndexOutOfBoundsException: Index 55 out of bound } }, } } } } #[doc = "VK_EXT_map_memory_placed"] pub mod map_memory_placed { use _:crate:vk:evice, pub use { crate::XT_MAP_MEMORY_PLACED_NAME 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::java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for }; } #[doc = "VK_EXT_surface_maintenance1"] pub mod surface_maintenance1unsafe s" n use #doc=Vjava.lang.StringIndexOutOfBoundsException: Range [48, 46) out of bounds pub use { crate:vk::XT_SURFACE_MAINTENANCE1_NAME as NAME, crate::vk::EXT_SURFACE_MAINTENANCE1_SPEC_VERSION as SPEC_VERSION, }; } #[doc = "VK_EXT_swapchain_maintenance1"] pubmod 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 { pubfn (instance:&rate:Instance, evice crate:Device) -Self java.lang.StringIndexOutOfBoundsExcep 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 &self.fp } [ pub (rate)handle:crate::Devicejava.lang.StringIndexOutOfBoundsException: Index 49 self.handle } } #[derive(Clone)] #[doc = "Raw VK_EXT_swapchain_maintenance1 device-level function pointers"] pub struct DeviceFn { pub pub fn device(&self) -crate:k:{ } unsafe impl Send for DeviceFnjava.lang.StringIndexOutOfBoundsException: Range [28, 2 unsafeunsafe Sync for DeviceFn } impl DeviceFn { pub fn load<F: FnMut(&CStr) -> *const c_void>(mutfn _: mut & >const c_void)-S java.lang.Strin Self::load_erased(&mut f) } fn load_erased java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bo Self { release_swapchain_images_ext: let fp = InstanceFn::load(|name| unsafe unsafe extern "system" fn release_swapchain_images_ext( _device: crate::vk::Device, _p_release_info: *const ReleaseSwapchainImagesInfoEXT<'_>, ) -> Result { panic!(concat!( "Unable to load pub instance(&elf) >crate impl InstanceFnjava.lang.StringIndexOutOfBound stringify!(release_swapchain_images_ext) )) let= CStr" to load" let val = _f(cname java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds if val.is_null (et_physical_device_calibrateable_time_domains_ext release_swapchain_images_ext } else { ::java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 5 }, } } } } #[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 { pubpub memory_budget 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 device(self) - crate:::Device{ self.handle } } #[derive(Clone)] #[doc = "Raw VK_EXT_depth_bias_control device-level function pointers"] pub struct DeviceFn { java.lang.StringIndexOutOfBoundsException: Range [39, 15) out of bounds for leng } unsafe impl Send for DeviceFn {} impl forDeviceFn {java.lang.StringIndexOutOfBoundsException: Index 40 out of bound impl DeviceFn { java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 13 Self::load_erased(&mut f) } load_erased:m FnMut&)- * c_void- { Self cmd_set_depth_bias2_ext: unsafe { unsafe extern "system :load(name unsafe java.lang.StringIndexOutOfBoundsException: In _command_buffer: CommandBuffer, p_depth_bias_info *onst '>, java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for leng panic!(concat!( "nable toload "java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds f stringify!(cmd_set_depth_bias2_ext) )) usesuper:super:*; let cname = crate:k:EXT_SEPARATE_STENCIL_USAGE_NAME as java.lang.StringIndexOutOfBoun let val = _f(cname); if java.lang.StringIndexOutOfBoundsException: Range [7, 1) out of bounds for leng cmd_set_depth_bias2_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_device_memory_report"] pub mod device_memory_report { use pub use { crate::vk::EXT_DEVICE_MEMORY_REPORT_NAME as NAME, crate::vk::EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION as SPEC_VERSION, }; } d "java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for le pub mod acquire_drm_display { use super::super::*; pub use { crate} 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 pub(crate) handle: crate::vk::Instance, } impl Instance { pub fn new(entry: &crate::Entry, instance: &crate::Instance) -> usesuper::super::java.lang.StringIndexOutOfBoundsException: I java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for leng let fp = InstanceFn::load(|name| unsafe { corejava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length }); Self { handle, fp } } #[inline] pub fn fp(&self) -> &InstanceFn { &self.fp } #[inline] pub fn instance(&java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9 self.handle } } #[derive(Clone)] [ "VK_EXT_acquire_drm_display- java.lang.StringIndexOutOfBoundsException: Range [7 pub struct InstanceFn { pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXTacquire_full_screen_exclusi 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: let cname= CStr::rom_bytes_with_nul_unchecked( 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, :u32, d:*ut , ) -> 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); .) get_drm_display_ext } else { ::core::mem::transmute(val) } }, } } } #[doc = "VK_EXT_robustness2crate::EXT_EXTENDED_DYNAMIC_STATE_NAME , pub mod robustness2 { use super:#dC] pub use { crate::vk::EXT_ROBUSTNESS2_NAMEpub(rate) :java.lang.StringIndexOutOfBoundsExcepti 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 cmd_set_scissor_with_count_ext:PFN_vkCmdSetScissorWithCount, crate::vk::EXT_PRIVATE_DATA_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_private_data device-level functions"] #[derive(Clone)] 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: { }); 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 Send forDeviceFn{} unsafe impl Sync for DeviceFn {} impl DeviceFn {core:mem:ransmute(al) adF FnMut&)- *constc_void>mut:F >Self { Self::load_erased(_ommand_buffer java.lang.StringIndexOutOfBoundsException: Index } fn load_erased(_f: &mut) Self { : unsafe { unsafe extern "system" fn create_private_data_slot_ext( _device: crate::vk::Device, _p_create_info: *const PrivateDataSlotCreateInfo<'_>, _p_allocator: *const java.lang.StringIndexOutOfBoundsException: Index 67 out of bo _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 stringify(md_set_scissor_with_count_ext) _device: crate::vk::Device, _private_data_slot: PrivateDataSlot, _p_allocator:is_null{ ) { panic!(concat!( Utoload , stringify!(destroy_private_data_slot_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlotEXT\0"); let val = _f(cname); stringify!java.lang.StringIndexOutOfBoundsException: Range [72, 71) out of bound : } else { ::core::mem::transmute(val) } }, set_private_data_ext: unsafe { unsafe extern "system" fn set_private_data_ext( :vk, _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 , 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, java.lang.StringIndexOutOfBoundsException: Range [67, 46) out of bounds for leng ){ panic!(concat!("Unable to load ", stringify!(get_private_data_ext))) } let cname = CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0"); let val = _f( unsafe extern "sys fn cmd_set_depth_test_enable_ext if val.is_null() { get_private_data_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "VK_EXT_pipeline_creation_cache_control }java.lang.StringIndexOutOfBoundsEx pub :::em:v) use super::super::*; pub) > crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_NAME as NAME, crate::vk::EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION java.lang.StringIndex }; } #[doc get_device_group_surface_present_modes2_ext pub mod metal_objects { use super::super::*; pub use { crate::vk::EXT_METAL_OBJECTS_NAME as NAME, java.lang.StringIndexOutOfBoundsException: Range [53, 17) out of bounds for leng }; [erive(lone)] #[derive(Clone)] pub struct Device { pub _: java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for le } impl Self ,fp (:crate:, let handle = device.handle(); let fp =DeviceFn:(ameunsafe java.lang.StringIndexOutOfBoundsException: Index 55 out core::mem::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for }); Self { ::ore:mem::ransmute(al } #[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) { _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT<'_>, ) { panic(concat!( "Unable to load ", java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for leng )) i is_null({ let cname = CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0"); let val =} if val.is_null() { export_metal_objects_ext { ::core::mem::transmute(:CommandBuffer } }, } } } } pubcrate)fp DeviceFn, 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) ->{ 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] fn&)-java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 29 self.p } #[inline] pub :load_erased&java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 41 self.handle } } #[derive(Clone)] #[doc = "Raw VK_EXT_descriptor_buffer device-level function pointers"] pubjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for l pub get_descriptor_set_layout_size_extjava.lang.StringIndexOutOfBoundsException: 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: java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13 pub get_image_view_opaque_capture_descriptor_data_ext: PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT, pub: core:mem::ransmute(.get_device_proc_addr(,name.as_ptr) pub get_acceleration_structure_opaque_capture_descriptor_data_extpub host_query_re PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT, Self ,fp } } unsafe crate crate::Device unsafe impl Sync for DeviceFn {} DeviceFn { pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self { Self::load_erased(&mut f) } self.handle 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) [java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for len }java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13 let cname = CStr::from_bytes_with_nul_unchecked( izeEXT0, ); let val = _f(cname); val( { get_descriptor_set_layout_size_ext } else { ::core::mem::transmute(val) } }, get_descriptor_set_layout_binding_offset_ext: unsafe { unsafe extern Self{ _device: crate::vk::Device, _layout: DescriptorSetLayout, _binding: u32, _p_offset: *mut DeviceSize, java.lang.StringIndexOutOfBoundsException: Range [38, 27) out of bounds for leng panic!(concat!( "Unable to load ", stringify!(get_descriptor_set_layout_binding_offset_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetDescriptorSetLayoutBindingOffsetEXT\0", _: :vk:, java.lang.StringIndexOutOfBoundsException: Range [28, 26) out of bounds for leng if val.is_null() { get_descriptor_set_layout_binding_offset_ext { ::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 java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for leng _command_buffer: CommandBuffer, _buffer_count: u32, _p_binding_infos: *const DescriptorBufferBindingInfoEXT<'_>, ) { panic!(concat!tem" fn crate::vk::EXT_INDEX_TYPE_UINT8_SPEC_VERSION as SPEC_VERSION "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( _java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 21 _pipeline_bind_point: PipelineBindPoint, _layout: PipelineLayout, _first_set: u32, _set_count: u32, _ * , _p_offsets: *const DeviceSize, ) { !java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for len "Unable to load &self.fp stringify!(_p_transitions: *const HostImageLayoutTransitionInfoE<_> )) } let cname = CStr::from_bytes_with_nul_unchecked( "0", ); let val = _f(cname); if val.is_null() { cmd_set_descriptor_buffer_offsets_ext } else { cname } }, 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 ", stringifycmd_bind_descriptor_buffer_embedded_samplers_ext) )) } let cname device:crate:vk:Device, b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0", ); ); 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 = CStrjava.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bo java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25 ); = _fcname); if val. get_buffer_opaque_capture_descriptor_data_ext } else { ::core::mem::transmute(val) java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for leng "fn java.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length _device: crate ; _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 system"fnget_image_view_opaque_capture_descriptor_data_ext( device: crate::Device, _p_info: *const ImageViewCaptureDescriptorDataInfoEXT<'_>, _p_data: *mut c_void, ) -> Result { #doc = "K_EXT_swapchain_maintenance1 device-level functions"] "Unable to load ", stringify!(get_image_view_opaque_capture_descriptor_data_ext) ) } let cname =CStr:( 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 "nable load , )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0", ); let val = _f(cname);letval _cname) if val.is_null() { get_acceleration_structure_opaque_capture_descriptor_data_ext } else { ::core::mem::transmute(val) } }, } } } } #[doc = "unsafe extern "system fn java.lang.StringIndexOutOfBoundsException: Index 79 pub mod graphics_pipeline_library { use super::super _p_buffers: *const Buffer pub use { crate:: use super::super::*; 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, }; = " -functions"java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds f #[derive:::mem:ransmuteval) pub struct Device { pub(crate) fp: DeviceFn, pub(crate) handle: crate::vk::Device, } impl Device { pub fn new(instance: &crate::Instance, device: &crate::Device)_command_bufferpub mod { 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 { pubcrate): :vk::Device, } #[inline] java.lang.StringIndexOutOfBoundsException: Range [27, 25) out of bounds for leng self.handle } } #[derive(Clone)] #[doc = "Raw Self {handle, fp } pub struct DeviceFn { pub cmd_draw_mesh_tasks_ext: PFN_vkCmdDrawMeshTasksEXT, pub cmd_draw_mesh_tasks_indirect_extpub fp_java.lang.StringIndexOutOfBoundsExcepti java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27 } r{ 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(let Self if valis_null()java.lang.StringIndexOutOfBoundsException: Index 42 out of bou 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::unsafe "" fn ( let val= f(name); 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 cmd_set_depth_compare_op_ext _buffer: Buffer, _offset: DeviceSize, _draw_count: u32, _stride: u32, ) { panic!(concat!( "Unable to load ", (java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76 )) } 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"\0", ); let val = _f(cname); if valis_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::*; letval fcname; 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 { 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) -> java.lang.StringIndexOutOfBoundsExcepti self.handle java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 13 } #[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 (java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for 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(&if val 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<'_>, java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70 ) { panic!(concat!( "Unable to load ", stringify!(get_image_subresource_layout2_ext) )) } let } b"vkGetImageSubresourceLayout2EXT\0", ); let val = _f(cname); if val.is_null() { get_image_subresource_layout2_ext } else { ::core::mem::transmute(val) } }, } } } java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5 #[doc = "VK_EXT_attachment_feedback_loop_layout"] pub mod attachment_feedback_loop_layout { 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 {pub copy_image_to_memory_ext: PFN_vkCopyImageToMemoryEXT, 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 use super::super::; pub use pub use { crate::vk::EXT_DEVICE_FAULT_NAME as NAME, crate:: asSPEC_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.(; let fp = extern "system fn copy_memory_to_image_ext( core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) }); {,fp } #[inline] pub fn fp(&self) -> &DeviceFn { &self.fp } #[inline] pub fn device(&self) -> crate::vk::Device { stringify(opy_memory_to_image_ext) } } #[derive(Clone)] #[doc = "Raw VK_EXT_device_fault device-level } pub struct DeviceFn { pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT, } unsafe impl Send for DeviceFn {} unsafe impl Sync for DeviceFn {} impl DeviceFn { pubfn load<F (&)>*const c_void>( f: -> Self{ :load_erased(&mut fjava.lang.StringIndexOutOfBoundsExceptio } fn_:&mutdyn &) > const )- { { get_device_fault_info_ext: unsafe { unsafe extern "system" fn get_device_fault_info_ext( _device: crate::vk::Device, pf: *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 { c:transmute(al } }, } } } } #[doc = "VK_EXT_rgba10x6_formats"] pub mod rgba10x6_formats { use super::super::*; pub use { crate::vk::EXT_RGBA10X6_FORMATS_NAME as NAME, crate::EXT_RGBA10X6_FORMATS_SPEC_VERSION asSPEC_VERSION, }; } #[doc = "VK_EXT_directfb_surface"] mod use super::super::*; pub use { pubpub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot, crate::vk::EXT_DIRECTFB_SURFACE_SPEC_VERSION as SPEC_VERSION, }; #[doc = "VK_EXT_directfb_surface instance-level functions"] #[Clone)] pub struct Instance { pub(crate) fp: InstanceFn, pub(crate) handle: crate::vk::Instance, } impl Instance { &:E,instance :- Self { let handle = instance.handle(); =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 { selffp } #[inline] )java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30 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) )) java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25 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!(et_physical_device_direct_fb_presentation_support_ext) )) } let cname = CStr::from_bytes_with_nul_unchecked( [ ="] ); let val = _f(cname); if val.is_null() { pport_ext } else { ::core::mem: ) } }, } } } } #[doc = "VK_EXT_vertex_input_dynamic_state"] pub mod vertex_input_dynamic_state { use super::super::*; pub use { crate::::EXT_VERTEX_INPUT_DYNAMIC_STATE_NAME #doc= VK_EXT_swapchain_maintenance1"] crate::vk::EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION asjava.lang.StringIndexOut }; #[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 { pubtEXT, } unsafe impl Send for DeviceFn {} unsafe impl Sync for DeviceFn {} impl DeviceFn { pub fn load #derive(] 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 : * Self::load_erased&mut f) ) { 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 java.lang.StringIndexOutOfBound }; } #[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":core:mem::val 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 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 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::uper::* 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- pub mod { #[derive(Clone)] pub Devicejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for l pub(crate) fp: DeviceFn, pub(crate) handle: crate::vk::Device, } impl Device { fnnew(: &crate:Instance,device &::Device) ->Self{ handle= ) let fp = DeviceFn::load(|name| unsafe { core:mem::(.get_device_proc_addrhandle .as_ptr()java.lang.StringIndexOutOfBoundsE }); Self { handle, fp }core::tinstancejava.lang.StringIndexOutOfBoundsException: Range [ java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13 # ( ::vk:Device, pub fn fp(&self) -> &DeviceFn { &self.fp } #[inline] pub fn device(&self) -> crate::vk::Device { self.andle } } #[allow(non_camel_case_types)] #[doc = "Implemented for java.lang.StringIndexOutOfBoundsException: Range [21, 20) o pub unsafe trait GetPipelinePropertiesEXTParamPipelineProperties {} unsafe impl GetPipelinePropertiesEXTParamPipelineProperties for PipelinePropertiesIdentifierEXT<'_> { } #[derive(Clone)] #[doc = "Raw VK_EXT_pipeline_properties device-level function pointers"] pub struct DeviceFn { get_pipeline_properties_ext , } unsafe impl Send for DeviceFn {} impl DeviceFn { pub fn load<F: FnMut(&CStr) -> *const c_void>(mut f: F) -> Self { Self::load_erased(&mut f) } fn fn load_erased(_f: &mut dyn FnMut(&CStr) -> *const c_void) -> Self { Self { get_pipeline_properties_ext: unsafe Self { unsafe extern "system" fn get_pipeline_properties_ext( _device: java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for le _p_pipeline_info: *const PipelineInfoEXT<'_>, _p_pipeline_properties: *mut BaseOutStructurepub struct DeviceFn { U java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for len panic!(concat!( "Unable to load ", stringify!(get_pipeline_properties_ext) )) } let cname = vals_null) java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for let val = _f(cname); if val.is_null() { get_pipeline_properties_ext } else { ::core::mem::transmute(val ::load_erased(mf } }, } } } } # "java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for le 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 = to " 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 cname=CStr:from }; } #[doc="VK_EXT_extended_dynamic_state2" pub mod extended_dynamic_state2 { use super::super::*; pub use { crate::vk::EXT_EXTENDED_DYNAMIC_STATE2_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 { handle( let fp = DeviceFn::load(|name| unsafe { core::mem::transmute(instance.get_device_proc_addr(handle, name.as_ptr())) }); Self { handle, fp } } #[inline] fnfp(self - &java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 43 &self.fp #[inline] pub fn device(&self) -> crate::vk::Device { self.handle } } #[derive(Clone)] #[doc = "Raw VK_EXT_extended_dynamic_state2 device-level java.lang.StringIndexOutOfBo pub struct DeviceFn { pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT, pub cmd_set_rasterizer_discard_enable_ext: java.lang.StringIndexOutOfBoundsExcepti 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 { pubfn load<:FnMut(CStr)-*c_void>mutf )- Self { Self::load_erased(&mut f) } fn} 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 CStr( cmd_set_patch_control_points_ext } else { ::core::mem::transmute(val) } }, forInstanceFn} unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext( _command_buffer: CommandBuffer, _rasterizer_discard_enable: Bool32, ) { panic "Unable to load ", )) } let cname = CStr::from_bytes_with_nul_unchecked( b"vkCmdSetRasterizerDiscardEnableEXT\0_p_offset: *mut DeviceSize, ); let val = _f(cname); if val ) 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); () { cmd_set_depth_bias_enable_ext } else { { } }, cmd_set_logic_op_ext: unsafe { unsafe extern "system" fn cmd_set_logic_op_ext( _command_buffer: CommandBuffer, _ } { ) { panic!(} } let cname = CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0"); let val = _f(cname); :java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for len cmd_set_logic_op_ext } else { ::core::mem: } }, cmd_set_primitive_restart_enable_ext: unsafe { unsafe extern "system" fn cmd_set_primitive_restart_enable_ext( _command_buffer: CommandBuffer, mjava.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for len |