use crate::vk::bitflags::*; use crate::vk::definitions::*; use crate::vk::enums::*; use std::os::raw::*; #[allow(non_camel_case_types)] pub type PFN_vkGetInstanceProcAddr = extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction; pub struct StaticFn { pub get_instance_proc_addr: extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction, } unsafe impl Send for StaticFn {} unsafe impl Sync for StaticFn {} impl ::std::clone::Clone for StaticFn { fn clone(&self) -> Self { StaticFn { get_instance_proc_addr: self.get_instance_proc_addr, } } } impl StaticFn { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { StaticFn { get_instance_proc_addr: unsafe { extern "system" fn get_instance_proc_addr( _instance: Instance, _p_name: *const c_char, ) -> PFN_vkVoidFunction { panic!(concat!( "Unable to load ", stringify!(get_instance_proc_addr) )) } let raw_name = stringify!(vkGetInstanceProcAddr); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_instance_proc_addr } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn get_instance_proc_addr( &self, instance: Instance, p_name: *const c_char, ) -> PFN_vkVoidFunction { (self.get_instance_proc_addr)(instance, p_name) } } #[allow(non_camel_case_types)] pub type PFN_vkCreateInstance = extern "system" fn( p_create_info: *const InstanceCreateInfo, p_allocator: *const AllocationCallbacks, p_instance: *mut Instance, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkEnumerateInstanceExtensionProperties = extern "system" fn( p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkEnumerateInstanceLayerProperties = extern "system" fn(p_property_count: *mut u32, p_properties: *mut LayerProperties) -> Result; pub struct EntryFnV1_0 { pub create_instance: extern "system" fn( p_create_info: *const InstanceCreateInfo, p_allocator: *const AllocationCallbacks, p_instance: *mut Instance, ) -> Result, pub enumerate_instance_extension_properties: extern "system" fn( p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result, pub enumerate_instance_layer_properties: extern "system" fn( p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result, } unsafe impl Send for EntryFnV1_0 {} unsafe impl Sync for EntryFnV1_0 {} impl ::std::clone::Clone for EntryFnV1_0 { fn clone(&self) -> Self { EntryFnV1_0 { create_instance: self.create_instance, enumerate_instance_extension_properties: self.enumerate_instance_extension_properties, enumerate_instance_layer_properties: self.enumerate_instance_layer_properties, } } } impl EntryFnV1_0 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { EntryFnV1_0 { create_instance: unsafe { extern "system" fn create_instance( _p_create_info: *const InstanceCreateInfo, _p_allocator: *const AllocationCallbacks, _p_instance: *mut Instance, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_instance))) } let raw_name = stringify!(vkCreateInstance); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_instance } else { ::std::mem::transmute(val) } }, enumerate_instance_extension_properties: unsafe { extern "system" fn enumerate_instance_extension_properties( _p_layer_name: *const c_char, _p_property_count: *mut u32, _p_properties: *mut ExtensionProperties, ) -> Result { panic!(concat!( "Unable to load ", stringify!(enumerate_instance_extension_properties) )) } let raw_name = stringify!(vkEnumerateInstanceExtensionProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { enumerate_instance_extension_properties } else { ::std::mem::transmute(val) } }, enumerate_instance_layer_properties: unsafe { extern "system" fn enumerate_instance_layer_properties( _p_property_count: *mut u32, _p_properties: *mut LayerProperties, ) -> Result { panic!(concat!( "Unable to load ", stringify!(enumerate_instance_layer_properties) )) } let raw_name = stringify!(vkEnumerateInstanceLayerProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { enumerate_instance_layer_properties } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn create_instance( &self, p_create_info: *const InstanceCreateInfo, p_allocator: *const AllocationCallbacks, p_instance: *mut Instance, ) -> Result { (self.create_instance)(p_create_info, p_allocator, p_instance) } #[doc = ""] pub unsafe fn enumerate_instance_extension_properties( &self, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result { (self.enumerate_instance_extension_properties)(p_layer_name, p_property_count, p_properties) } #[doc = ""] pub unsafe fn enumerate_instance_layer_properties( &self, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result { (self.enumerate_instance_layer_properties)(p_property_count, p_properties) } } #[allow(non_camel_case_types)] pub type PFN_vkDestroyInstance = extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkEnumeratePhysicalDevices = extern "system" fn( instance: Instance, p_physical_device_count: *mut u32, p_physical_devices: *mut PhysicalDevice, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceFeatures = extern "system" fn( physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceFormatProperties = extern "system" fn( physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceImageFormatProperties = extern "system" fn( physical_device: PhysicalDevice, format: Format, ty: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, p_image_format_properties: *mut ImageFormatProperties, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceProperties = extern "system" fn( physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = extern "system" fn( physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceMemoryProperties = extern "system" fn( physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetDeviceProcAddr = extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction; #[allow(non_camel_case_types)] pub type PFN_vkCreateDevice = extern "system" fn( physical_device: PhysicalDevice, p_create_info: *const DeviceCreateInfo, p_allocator: *const AllocationCallbacks, p_device: *mut Device, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkEnumerateDeviceExtensionProperties = extern "system" fn( physical_device: PhysicalDevice, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkEnumerateDeviceLayerProperties = extern "system" fn( physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = extern "system" fn( physical_device: PhysicalDevice, format: Format, ty: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties, ) -> c_void; pub struct InstanceFnV1_0 { pub destroy_instance: extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks) -> c_void, pub enumerate_physical_devices: extern "system" fn( instance: Instance, p_physical_device_count: *mut u32, p_physical_devices: *mut PhysicalDevice, ) -> Result, pub get_physical_device_features: extern "system" fn( physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures, ) -> c_void, pub get_physical_device_format_properties: extern "system" fn( physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties, ) -> c_void, pub get_physical_device_image_format_properties: extern "system" fn( physical_device: PhysicalDevice, format: Format, ty: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, p_image_format_properties: *mut ImageFormatProperties, ) -> Result, pub get_physical_device_properties: extern "system" fn( physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties, ) -> c_void, pub get_physical_device_queue_family_properties: extern "system" fn( physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void, pub get_physical_device_memory_properties: extern "system" fn( physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties, ) -> c_void, pub get_device_proc_addr: extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction, pub create_device: extern "system" fn( physical_device: PhysicalDevice, p_create_info: *const DeviceCreateInfo, p_allocator: *const AllocationCallbacks, p_device: *mut Device, ) -> Result, pub enumerate_device_extension_properties: extern "system" fn( physical_device: PhysicalDevice, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result, pub enumerate_device_layer_properties: extern "system" fn( physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result, pub get_physical_device_sparse_image_format_properties: extern "system" fn( physical_device: PhysicalDevice, format: Format, ty: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties, ) -> c_void, } unsafe impl Send for InstanceFnV1_0 {} unsafe impl Sync for InstanceFnV1_0 {} impl ::std::clone::Clone for InstanceFnV1_0 { fn clone(&self) -> Self { InstanceFnV1_0 { destroy_instance: self.destroy_instance, enumerate_physical_devices: self.enumerate_physical_devices, get_physical_device_features: self.get_physical_device_features, get_physical_device_format_properties: self.get_physical_device_format_properties, get_physical_device_image_format_properties: self .get_physical_device_image_format_properties, get_physical_device_properties: self.get_physical_device_properties, get_physical_device_queue_family_properties: self .get_physical_device_queue_family_properties, get_physical_device_memory_properties: self.get_physical_device_memory_properties, get_device_proc_addr: self.get_device_proc_addr, create_device: self.create_device, enumerate_device_extension_properties: self.enumerate_device_extension_properties, enumerate_device_layer_properties: self.enumerate_device_layer_properties, get_physical_device_sparse_image_format_properties: self .get_physical_device_sparse_image_format_properties, } } } impl InstanceFnV1_0 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { InstanceFnV1_0 { destroy_instance: unsafe { extern "system" fn destroy_instance( _instance: Instance, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_instance))) } let raw_name = stringify!(vkDestroyInstance); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_instance } else { ::std::mem::transmute(val) } }, enumerate_physical_devices: unsafe { extern "system" fn enumerate_physical_devices( _instance: Instance, _p_physical_device_count: *mut u32, _p_physical_devices: *mut PhysicalDevice, ) -> Result { panic!(concat!( "Unable to load ", stringify!(enumerate_physical_devices) )) } let raw_name = stringify!(vkEnumeratePhysicalDevices); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { enumerate_physical_devices } else { ::std::mem::transmute(val) } }, get_physical_device_features: unsafe { extern "system" fn get_physical_device_features( _physical_device: PhysicalDevice, _p_features: *mut PhysicalDeviceFeatures, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_features) )) } let raw_name = stringify!(vkGetPhysicalDeviceFeatures); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_features } else { ::std::mem::transmute(val) } }, get_physical_device_format_properties: unsafe { extern "system" fn get_physical_device_format_properties( _physical_device: PhysicalDevice, _format: Format, _p_format_properties: *mut FormatProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_format_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_format_properties } else { ::std::mem::transmute(val) } }, get_physical_device_image_format_properties: unsafe { extern "system" fn get_physical_device_image_format_properties( _physical_device: PhysicalDevice, _format: Format, _ty: ImageType, _tiling: ImageTiling, _usage: ImageUsageFlags, _flags: ImageCreateFlags, _p_image_format_properties: *mut ImageFormatProperties, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_image_format_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_image_format_properties } else { ::std::mem::transmute(val) } }, get_physical_device_properties: unsafe { extern "system" fn get_physical_device_properties( _physical_device: PhysicalDevice, _p_properties: *mut PhysicalDeviceProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_properties } else { ::std::mem::transmute(val) } }, get_physical_device_queue_family_properties: unsafe { extern "system" fn get_physical_device_queue_family_properties( _physical_device: PhysicalDevice, _p_queue_family_property_count: *mut u32, _p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_queue_family_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_queue_family_properties } else { ::std::mem::transmute(val) } }, get_physical_device_memory_properties: unsafe { extern "system" fn get_physical_device_memory_properties( _physical_device: PhysicalDevice, _p_memory_properties: *mut PhysicalDeviceMemoryProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_memory_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_memory_properties } else { ::std::mem::transmute(val) } }, get_device_proc_addr: unsafe { extern "system" fn get_device_proc_addr( _device: Device, _p_name: *const c_char, ) -> PFN_vkVoidFunction { panic!(concat!("Unable to load ", stringify!(get_device_proc_addr))) } let raw_name = stringify!(vkGetDeviceProcAddr); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_device_proc_addr } else { ::std::mem::transmute(val) } }, create_device: unsafe { extern "system" fn create_device( _physical_device: PhysicalDevice, _p_create_info: *const DeviceCreateInfo, _p_allocator: *const AllocationCallbacks, _p_device: *mut Device, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_device))) } let raw_name = stringify!(vkCreateDevice); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_device } else { ::std::mem::transmute(val) } }, enumerate_device_extension_properties: unsafe { extern "system" fn enumerate_device_extension_properties( _physical_device: PhysicalDevice, _p_layer_name: *const c_char, _p_property_count: *mut u32, _p_properties: *mut ExtensionProperties, ) -> Result { panic!(concat!( "Unable to load ", stringify!(enumerate_device_extension_properties) )) } let raw_name = stringify!(vkEnumerateDeviceExtensionProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { enumerate_device_extension_properties } else { ::std::mem::transmute(val) } }, enumerate_device_layer_properties: unsafe { extern "system" fn enumerate_device_layer_properties( _physical_device: PhysicalDevice, _p_property_count: *mut u32, _p_properties: *mut LayerProperties, ) -> Result { panic!(concat!( "Unable to load ", stringify!(enumerate_device_layer_properties) )) } let raw_name = stringify!(vkEnumerateDeviceLayerProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { enumerate_device_layer_properties } else { ::std::mem::transmute(val) } }, get_physical_device_sparse_image_format_properties: unsafe { extern "system" fn get_physical_device_sparse_image_format_properties( _physical_device: PhysicalDevice, _format: Format, _ty: ImageType, _samples: SampleCountFlags, _usage: ImageUsageFlags, _tiling: ImageTiling, _p_property_count: *mut u32, _p_properties: *mut SparseImageFormatProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_sparse_image_format_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_sparse_image_format_properties } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn destroy_instance( &self, instance: Instance, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_instance)(instance, p_allocator) } #[doc = ""] pub unsafe fn enumerate_physical_devices( &self, instance: Instance, p_physical_device_count: *mut u32, p_physical_devices: *mut PhysicalDevice, ) -> Result { (self.enumerate_physical_devices)(instance, p_physical_device_count, p_physical_devices) } #[doc = ""] pub unsafe fn get_physical_device_features( &self, physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures, ) -> c_void { (self.get_physical_device_features)(physical_device, p_features) } #[doc = ""] pub unsafe fn get_physical_device_format_properties( &self, physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties, ) -> c_void { (self.get_physical_device_format_properties)(physical_device, format, p_format_properties) } #[doc = ""] pub unsafe fn get_physical_device_image_format_properties( &self, physical_device: PhysicalDevice, format: Format, ty: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, p_image_format_properties: *mut ImageFormatProperties, ) -> Result { (self.get_physical_device_image_format_properties)( physical_device, format, ty, tiling, usage, flags, p_image_format_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_properties( &self, physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties, ) -> c_void { (self.get_physical_device_properties)(physical_device, p_properties) } #[doc = ""] pub unsafe fn get_physical_device_queue_family_properties( &self, physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties, ) -> c_void { (self.get_physical_device_queue_family_properties)( physical_device, p_queue_family_property_count, p_queue_family_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_memory_properties( &self, physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties, ) -> c_void { (self.get_physical_device_memory_properties)(physical_device, p_memory_properties) } #[doc = ""] pub unsafe fn get_device_proc_addr( &self, device: Device, p_name: *const c_char, ) -> PFN_vkVoidFunction { (self.get_device_proc_addr)(device, p_name) } #[doc = ""] pub unsafe fn create_device( &self, physical_device: PhysicalDevice, p_create_info: *const DeviceCreateInfo, p_allocator: *const AllocationCallbacks, p_device: *mut Device, ) -> Result { (self.create_device)(physical_device, p_create_info, p_allocator, p_device) } #[doc = ""] pub unsafe fn enumerate_device_extension_properties( &self, physical_device: PhysicalDevice, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result { (self.enumerate_device_extension_properties)( physical_device, p_layer_name, p_property_count, p_properties, ) } #[doc = ""] pub unsafe fn enumerate_device_layer_properties( &self, physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result { (self.enumerate_device_layer_properties)(physical_device, p_property_count, p_properties) } #[doc = ""] pub unsafe fn get_physical_device_sparse_image_format_properties( &self, physical_device: PhysicalDevice, format: Format, ty: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties, ) -> c_void { (self.get_physical_device_sparse_image_format_properties)( physical_device, format, ty, samples, usage, tiling, p_property_count, p_properties, ) } } #[allow(non_camel_case_types)] pub type PFN_vkDestroyDevice = extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetDeviceQueue = extern "system" fn( device: Device, queue_family_index: u32, queue_index: u32, p_queue: *mut Queue, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkQueueSubmit = extern "system" fn( queue: Queue, submit_count: u32, p_submits: *const SubmitInfo, fence: Fence, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkQueueWaitIdle = extern "system" fn(queue: Queue) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDeviceWaitIdle = extern "system" fn(device: Device) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkAllocateMemory = extern "system" fn( device: Device, p_allocate_info: *const MemoryAllocateInfo, p_allocator: *const AllocationCallbacks, p_memory: *mut DeviceMemory, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkFreeMemory = extern "system" fn( device: Device, memory: DeviceMemory, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkMapMemory = extern "system" fn( device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, pp_data: *mut *mut c_void, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkUnmapMemory = extern "system" fn(device: Device, memory: DeviceMemory) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkFlushMappedMemoryRanges = extern "system" fn( device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkInvalidateMappedMemoryRanges = extern "system" fn( device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkGetDeviceMemoryCommitment = extern "system" fn( device: Device, memory: DeviceMemory, p_committed_memory_in_bytes: *mut DeviceSize, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkBindBufferMemory = extern "system" fn( device: Device, buffer: Buffer, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkBindImageMemory = extern "system" fn( device: Device, image: Image, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkGetBufferMemoryRequirements = extern "system" fn( device: Device, buffer: Buffer, p_memory_requirements: *mut MemoryRequirements, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetImageMemoryRequirements = extern "system" fn( device: Device, image: Image, p_memory_requirements: *mut MemoryRequirements, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetImageSparseMemoryRequirements = extern "system" fn( device: Device, image: Image, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkQueueBindSparse = extern "system" fn( queue: Queue, bind_info_count: u32, p_bind_info: *const BindSparseInfo, fence: Fence, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCreateFence = extern "system" fn( device: Device, p_create_info: *const FenceCreateInfo, p_allocator: *const AllocationCallbacks, p_fence: *mut Fence, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyFence = extern "system" fn( device: Device, fence: Fence, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkResetFences = extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkGetFenceStatus = extern "system" fn(device: Device, fence: Fence) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkWaitForFences = extern "system" fn( device: Device, fence_count: u32, p_fences: *const Fence, wait_all: Bool32, timeout: u64, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCreateSemaphore = extern "system" fn( device: Device, p_create_info: *const SemaphoreCreateInfo, p_allocator: *const AllocationCallbacks, p_semaphore: *mut Semaphore, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroySemaphore = extern "system" fn( device: Device, semaphore: Semaphore, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateEvent = extern "system" fn( device: Device, p_create_info: *const EventCreateInfo, p_allocator: *const AllocationCallbacks, p_event: *mut Event, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyEvent = extern "system" fn( device: Device, event: Event, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetEventStatus = extern "system" fn(device: Device, event: Event) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkSetEvent = extern "system" fn(device: Device, event: Event) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkResetEvent = extern "system" fn(device: Device, event: Event) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCreateQueryPool = extern "system" fn( device: Device, p_create_info: *const QueryPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_query_pool: *mut QueryPool, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyQueryPool = extern "system" fn( device: Device, query_pool: QueryPool, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetQueryPoolResults = extern "system" fn( device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, data_size: usize, p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCreateBuffer = extern "system" fn( device: Device, p_create_info: *const BufferCreateInfo, p_allocator: *const AllocationCallbacks, p_buffer: *mut Buffer, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyBuffer = extern "system" fn( device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateBufferView = extern "system" fn( device: Device, p_create_info: *const BufferViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut BufferView, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyBufferView = extern "system" fn( device: Device, buffer_view: BufferView, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateImage = extern "system" fn( device: Device, p_create_info: *const ImageCreateInfo, p_allocator: *const AllocationCallbacks, p_image: *mut Image, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyImage = extern "system" fn( device: Device, image: Image, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetImageSubresourceLayout = extern "system" fn( device: Device, image: Image, p_subresource: *const ImageSubresource, p_layout: *mut SubresourceLayout, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateImageView = extern "system" fn( device: Device, p_create_info: *const ImageViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut ImageView, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyImageView = extern "system" fn( device: Device, image_view: ImageView, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateShaderModule = extern "system" fn( device: Device, p_create_info: *const ShaderModuleCreateInfo, p_allocator: *const AllocationCallbacks, p_shader_module: *mut ShaderModule, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyShaderModule = extern "system" fn( device: Device, shader_module: ShaderModule, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreatePipelineCache = extern "system" fn( device: Device, p_create_info: *const PipelineCacheCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_cache: *mut PipelineCache, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyPipelineCache = extern "system" fn( device: Device, pipeline_cache: PipelineCache, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetPipelineCacheData = extern "system" fn( device: Device, pipeline_cache: PipelineCache, p_data_size: *mut usize, p_data: *mut c_void, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkMergePipelineCaches = extern "system" fn( device: Device, dst_cache: PipelineCache, src_cache_count: u32, p_src_caches: *const PipelineCache, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCreateGraphicsPipelines = extern "system" fn( device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCreateComputePipelines = extern "system" fn( device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyPipeline = extern "system" fn( device: Device, pipeline: Pipeline, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreatePipelineLayout = extern "system" fn( device: Device, p_create_info: *const PipelineLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_layout: *mut PipelineLayout, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyPipelineLayout = extern "system" fn( device: Device, pipeline_layout: PipelineLayout, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateSampler = extern "system" fn( device: Device, p_create_info: *const SamplerCreateInfo, p_allocator: *const AllocationCallbacks, p_sampler: *mut Sampler, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroySampler = extern "system" fn( device: Device, sampler: Sampler, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateDescriptorSetLayout = extern "system" fn( device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_set_layout: *mut DescriptorSetLayout, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyDescriptorSetLayout = extern "system" fn( device: Device, descriptor_set_layout: DescriptorSetLayout, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateDescriptorPool = extern "system" fn( device: Device, p_create_info: *const DescriptorPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_pool: *mut DescriptorPool, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyDescriptorPool = extern "system" fn( device: Device, descriptor_pool: DescriptorPool, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkResetDescriptorPool = extern "system" fn( device: Device, descriptor_pool: DescriptorPool, flags: DescriptorPoolResetFlags, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkAllocateDescriptorSets = extern "system" fn( device: Device, p_allocate_info: *const DescriptorSetAllocateInfo, p_descriptor_sets: *mut DescriptorSet, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkFreeDescriptorSets = extern "system" fn( device: Device, descriptor_pool: DescriptorPool, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkUpdateDescriptorSets = extern "system" fn( device: Device, descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, descriptor_copy_count: u32, p_descriptor_copies: *const CopyDescriptorSet, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateFramebuffer = extern "system" fn( device: Device, p_create_info: *const FramebufferCreateInfo, p_allocator: *const AllocationCallbacks, p_framebuffer: *mut Framebuffer, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyFramebuffer = extern "system" fn( device: Device, framebuffer: Framebuffer, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateRenderPass = extern "system" fn( device: Device, p_create_info: *const RenderPassCreateInfo, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyRenderPass = extern "system" fn( device: Device, render_pass: RenderPass, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkGetRenderAreaGranularity = extern "system" fn( device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCreateCommandPool = extern "system" fn( device: Device, p_create_info: *const CommandPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_command_pool: *mut CommandPool, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkDestroyCommandPool = extern "system" fn( device: Device, command_pool: CommandPool, p_allocator: *const AllocationCallbacks, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkResetCommandPool = extern "system" fn( device: Device, command_pool: CommandPool, flags: CommandPoolResetFlags, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkAllocateCommandBuffers = extern "system" fn( device: Device, p_allocate_info: *const CommandBufferAllocateInfo, p_command_buffers: *mut CommandBuffer, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkFreeCommandBuffers = extern "system" fn( device: Device, command_pool: CommandPool, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkBeginCommandBuffer = extern "system" fn( command_buffer: CommandBuffer, p_begin_info: *const CommandBufferBeginInfo, ) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkEndCommandBuffer = extern "system" fn(command_buffer: CommandBuffer) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkResetCommandBuffer = extern "system" fn(command_buffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result; #[allow(non_camel_case_types)] pub type PFN_vkCmdBindPipeline = extern "system" fn( command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, pipeline: Pipeline, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetViewport = extern "system" fn( command_buffer: CommandBuffer, first_viewport: u32, viewport_count: u32, p_viewports: *const Viewport, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetScissor = extern "system" fn( command_buffer: CommandBuffer, first_scissor: u32, scissor_count: u32, p_scissors: *const Rect2D, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetLineWidth = extern "system" fn(command_buffer: CommandBuffer, line_width: f32) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetDepthBias = extern "system" fn( command_buffer: CommandBuffer, depth_bias_constant_factor: f32, depth_bias_clamp: f32, depth_bias_slope_factor: f32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetBlendConstants = extern "system" fn(command_buffer: CommandBuffer, blend_constants: &[f32; 4]) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetDepthBounds = extern "system" fn( command_buffer: CommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetStencilCompareMask = extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, compare_mask: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetStencilWriteMask = extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, write_mask: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetStencilReference = extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, reference: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdBindDescriptorSets = extern "system" fn( command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, first_set: u32, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, dynamic_offset_count: u32, p_dynamic_offsets: *const u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdBindIndexBuffer = extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, index_type: IndexType, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdBindVertexBuffers = extern "system" fn( command_buffer: CommandBuffer, first_binding: u32, binding_count: u32, p_buffers: *const Buffer, p_offsets: *const DeviceSize, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdDraw = extern "system" fn( command_buffer: CommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdDrawIndexed = extern "system" fn( command_buffer: CommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdDrawIndirect = extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdDrawIndexedIndirect = extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdDispatch = extern "system" fn( command_buffer: CommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdDispatchIndirect = extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdCopyBuffer = extern "system" fn( command_buffer: CommandBuffer, src_buffer: Buffer, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferCopy, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdCopyImage = extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageCopy, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdBlitImage = extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageBlit, filter: Filter, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdCopyBufferToImage = extern "system" fn( command_buffer: CommandBuffer, src_buffer: Buffer, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdCopyImageToBuffer = extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdUpdateBuffer = extern "system" fn( command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, data_size: DeviceSize, p_data: *const c_void, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdFillBuffer = extern "system" fn( command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, size: DeviceSize, data: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdClearColorImage = extern "system" fn( command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_color: *const ClearColorValue, range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdClearDepthStencilImage = extern "system" fn( command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdClearAttachments = extern "system" fn( command_buffer: CommandBuffer, attachment_count: u32, p_attachments: *const ClearAttachment, rect_count: u32, p_rects: *const ClearRect, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdResolveImage = extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageResolve, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdSetEvent = extern "system" fn( command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdResetEvent = extern "system" fn( command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdWaitEvents = extern "system" fn( command_buffer: CommandBuffer, event_count: u32, p_events: *const Event, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdPipelineBarrier = extern "system" fn( command_buffer: CommandBuffer, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, dependency_flags: DependencyFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdBeginQuery = extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, flags: QueryControlFlags, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdEndQuery = extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdResetQueryPool = extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdWriteTimestamp = extern "system" fn( command_buffer: CommandBuffer, pipeline_stage: PipelineStageFlags, query_pool: QueryPool, query: u32, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdCopyQueryPoolResults = extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, dst_buffer: Buffer, dst_offset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdPushConstants = extern "system" fn( command_buffer: CommandBuffer, layout: PipelineLayout, stage_flags: ShaderStageFlags, offset: u32, size: u32, p_values: *const c_void, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdBeginRenderPass = extern "system" fn( command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, contents: SubpassContents, ) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdNextSubpass = extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdEndRenderPass = extern "system" fn(command_buffer: CommandBuffer) -> c_void; #[allow(non_camel_case_types)] pub type PFN_vkCmdExecuteCommands = extern "system" fn( command_buffer: CommandBuffer, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void; pub struct DeviceFnV1_0 { pub destroy_device: extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks) -> c_void, pub get_device_queue: extern "system" fn( device: Device, queue_family_index: u32, queue_index: u32, p_queue: *mut Queue, ) -> c_void, pub queue_submit: extern "system" fn( queue: Queue, submit_count: u32, p_submits: *const SubmitInfo, fence: Fence, ) -> Result, pub queue_wait_idle: extern "system" fn(queue: Queue) -> Result, pub device_wait_idle: extern "system" fn(device: Device) -> Result, pub allocate_memory: extern "system" fn( device: Device, p_allocate_info: *const MemoryAllocateInfo, p_allocator: *const AllocationCallbacks, p_memory: *mut DeviceMemory, ) -> Result, pub free_memory: extern "system" fn( device: Device, memory: DeviceMemory, p_allocator: *const AllocationCallbacks, ) -> c_void, pub map_memory: extern "system" fn( device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, pp_data: *mut *mut c_void, ) -> Result, pub unmap_memory: extern "system" fn(device: Device, memory: DeviceMemory) -> c_void, pub flush_mapped_memory_ranges: extern "system" fn( device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result, pub invalidate_mapped_memory_ranges: extern "system" fn( device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result, pub get_device_memory_commitment: extern "system" fn( device: Device, memory: DeviceMemory, p_committed_memory_in_bytes: *mut DeviceSize, ) -> c_void, pub bind_buffer_memory: extern "system" fn( device: Device, buffer: Buffer, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result, pub bind_image_memory: extern "system" fn( device: Device, image: Image, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result, pub get_buffer_memory_requirements: extern "system" fn( device: Device, buffer: Buffer, p_memory_requirements: *mut MemoryRequirements, ) -> c_void, pub get_image_memory_requirements: extern "system" fn( device: Device, image: Image, p_memory_requirements: *mut MemoryRequirements, ) -> c_void, pub get_image_sparse_memory_requirements: extern "system" fn( device: Device, image: Image, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void, pub queue_bind_sparse: extern "system" fn( queue: Queue, bind_info_count: u32, p_bind_info: *const BindSparseInfo, fence: Fence, ) -> Result, pub create_fence: extern "system" fn( device: Device, p_create_info: *const FenceCreateInfo, p_allocator: *const AllocationCallbacks, p_fence: *mut Fence, ) -> Result, pub destroy_fence: extern "system" fn( device: Device, fence: Fence, p_allocator: *const AllocationCallbacks, ) -> c_void, pub reset_fences: extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result, pub get_fence_status: extern "system" fn(device: Device, fence: Fence) -> Result, pub wait_for_fences: extern "system" fn( device: Device, fence_count: u32, p_fences: *const Fence, wait_all: Bool32, timeout: u64, ) -> Result, pub create_semaphore: extern "system" fn( device: Device, p_create_info: *const SemaphoreCreateInfo, p_allocator: *const AllocationCallbacks, p_semaphore: *mut Semaphore, ) -> Result, pub destroy_semaphore: extern "system" fn( device: Device, semaphore: Semaphore, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_event: extern "system" fn( device: Device, p_create_info: *const EventCreateInfo, p_allocator: *const AllocationCallbacks, p_event: *mut Event, ) -> Result, pub destroy_event: extern "system" fn( device: Device, event: Event, p_allocator: *const AllocationCallbacks, ) -> c_void, pub get_event_status: extern "system" fn(device: Device, event: Event) -> Result, pub set_event: extern "system" fn(device: Device, event: Event) -> Result, pub reset_event: extern "system" fn(device: Device, event: Event) -> Result, pub create_query_pool: extern "system" fn( device: Device, p_create_info: *const QueryPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_query_pool: *mut QueryPool, ) -> Result, pub destroy_query_pool: extern "system" fn( device: Device, query_pool: QueryPool, p_allocator: *const AllocationCallbacks, ) -> c_void, pub get_query_pool_results: extern "system" fn( device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, data_size: usize, p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, ) -> Result, pub create_buffer: extern "system" fn( device: Device, p_create_info: *const BufferCreateInfo, p_allocator: *const AllocationCallbacks, p_buffer: *mut Buffer, ) -> Result, pub destroy_buffer: extern "system" fn( device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_buffer_view: extern "system" fn( device: Device, p_create_info: *const BufferViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut BufferView, ) -> Result, pub destroy_buffer_view: extern "system" fn( device: Device, buffer_view: BufferView, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_image: extern "system" fn( device: Device, p_create_info: *const ImageCreateInfo, p_allocator: *const AllocationCallbacks, p_image: *mut Image, ) -> Result, pub destroy_image: extern "system" fn( device: Device, image: Image, p_allocator: *const AllocationCallbacks, ) -> c_void, pub get_image_subresource_layout: extern "system" fn( device: Device, image: Image, p_subresource: *const ImageSubresource, p_layout: *mut SubresourceLayout, ) -> c_void, pub create_image_view: extern "system" fn( device: Device, p_create_info: *const ImageViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut ImageView, ) -> Result, pub destroy_image_view: extern "system" fn( device: Device, image_view: ImageView, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_shader_module: extern "system" fn( device: Device, p_create_info: *const ShaderModuleCreateInfo, p_allocator: *const AllocationCallbacks, p_shader_module: *mut ShaderModule, ) -> Result, pub destroy_shader_module: extern "system" fn( device: Device, shader_module: ShaderModule, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_pipeline_cache: extern "system" fn( device: Device, p_create_info: *const PipelineCacheCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_cache: *mut PipelineCache, ) -> Result, pub destroy_pipeline_cache: extern "system" fn( device: Device, pipeline_cache: PipelineCache, p_allocator: *const AllocationCallbacks, ) -> c_void, pub get_pipeline_cache_data: extern "system" fn( device: Device, pipeline_cache: PipelineCache, p_data_size: *mut usize, p_data: *mut c_void, ) -> Result, pub merge_pipeline_caches: extern "system" fn( device: Device, dst_cache: PipelineCache, src_cache_count: u32, p_src_caches: *const PipelineCache, ) -> Result, pub create_graphics_pipelines: extern "system" fn( device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result, pub create_compute_pipelines: extern "system" fn( device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result, pub destroy_pipeline: extern "system" fn( device: Device, pipeline: Pipeline, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_pipeline_layout: extern "system" fn( device: Device, p_create_info: *const PipelineLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_layout: *mut PipelineLayout, ) -> Result, pub destroy_pipeline_layout: extern "system" fn( device: Device, pipeline_layout: PipelineLayout, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_sampler: extern "system" fn( device: Device, p_create_info: *const SamplerCreateInfo, p_allocator: *const AllocationCallbacks, p_sampler: *mut Sampler, ) -> Result, pub destroy_sampler: extern "system" fn( device: Device, sampler: Sampler, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_descriptor_set_layout: extern "system" fn( device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_set_layout: *mut DescriptorSetLayout, ) -> Result, pub destroy_descriptor_set_layout: extern "system" fn( device: Device, descriptor_set_layout: DescriptorSetLayout, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_descriptor_pool: extern "system" fn( device: Device, p_create_info: *const DescriptorPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_pool: *mut DescriptorPool, ) -> Result, pub destroy_descriptor_pool: extern "system" fn( device: Device, descriptor_pool: DescriptorPool, p_allocator: *const AllocationCallbacks, ) -> c_void, pub reset_descriptor_pool: extern "system" fn( device: Device, descriptor_pool: DescriptorPool, flags: DescriptorPoolResetFlags, ) -> Result, pub allocate_descriptor_sets: extern "system" fn( device: Device, p_allocate_info: *const DescriptorSetAllocateInfo, p_descriptor_sets: *mut DescriptorSet, ) -> Result, pub free_descriptor_sets: extern "system" fn( device: Device, descriptor_pool: DescriptorPool, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, ) -> Result, pub update_descriptor_sets: extern "system" fn( device: Device, descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, descriptor_copy_count: u32, p_descriptor_copies: *const CopyDescriptorSet, ) -> c_void, pub create_framebuffer: extern "system" fn( device: Device, p_create_info: *const FramebufferCreateInfo, p_allocator: *const AllocationCallbacks, p_framebuffer: *mut Framebuffer, ) -> Result, pub destroy_framebuffer: extern "system" fn( device: Device, framebuffer: Framebuffer, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_render_pass: extern "system" fn( device: Device, p_create_info: *const RenderPassCreateInfo, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result, pub destroy_render_pass: extern "system" fn( device: Device, render_pass: RenderPass, p_allocator: *const AllocationCallbacks, ) -> c_void, pub get_render_area_granularity: extern "system" fn( device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D, ) -> c_void, pub create_command_pool: extern "system" fn( device: Device, p_create_info: *const CommandPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_command_pool: *mut CommandPool, ) -> Result, pub destroy_command_pool: extern "system" fn( device: Device, command_pool: CommandPool, p_allocator: *const AllocationCallbacks, ) -> c_void, pub reset_command_pool: extern "system" fn( device: Device, command_pool: CommandPool, flags: CommandPoolResetFlags, ) -> Result, pub allocate_command_buffers: extern "system" fn( device: Device, p_allocate_info: *const CommandBufferAllocateInfo, p_command_buffers: *mut CommandBuffer, ) -> Result, pub free_command_buffers: extern "system" fn( device: Device, command_pool: CommandPool, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void, pub begin_command_buffer: extern "system" fn( command_buffer: CommandBuffer, p_begin_info: *const CommandBufferBeginInfo, ) -> Result, pub end_command_buffer: extern "system" fn(command_buffer: CommandBuffer) -> Result, pub reset_command_buffer: extern "system" fn(command_buffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result, pub cmd_bind_pipeline: extern "system" fn( command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, pipeline: Pipeline, ) -> c_void, pub cmd_set_viewport: extern "system" fn( command_buffer: CommandBuffer, first_viewport: u32, viewport_count: u32, p_viewports: *const Viewport, ) -> c_void, pub cmd_set_scissor: extern "system" fn( command_buffer: CommandBuffer, first_scissor: u32, scissor_count: u32, p_scissors: *const Rect2D, ) -> c_void, pub cmd_set_line_width: extern "system" fn(command_buffer: CommandBuffer, line_width: f32) -> c_void, pub cmd_set_depth_bias: extern "system" fn( command_buffer: CommandBuffer, depth_bias_constant_factor: f32, depth_bias_clamp: f32, depth_bias_slope_factor: f32, ) -> c_void, pub cmd_set_blend_constants: extern "system" fn(command_buffer: CommandBuffer, blend_constants: &[f32; 4]) -> c_void, pub cmd_set_depth_bounds: extern "system" fn( command_buffer: CommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32, ) -> c_void, pub cmd_set_stencil_compare_mask: extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, compare_mask: u32, ) -> c_void, pub cmd_set_stencil_write_mask: extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, write_mask: u32, ) -> c_void, pub cmd_set_stencil_reference: extern "system" fn( command_buffer: CommandBuffer, face_mask: StencilFaceFlags, reference: u32, ) -> c_void, pub cmd_bind_descriptor_sets: extern "system" fn( command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, first_set: u32, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, dynamic_offset_count: u32, p_dynamic_offsets: *const u32, ) -> c_void, pub cmd_bind_index_buffer: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, index_type: IndexType, ) -> c_void, pub cmd_bind_vertex_buffers: extern "system" fn( command_buffer: CommandBuffer, first_binding: u32, binding_count: u32, p_buffers: *const Buffer, p_offsets: *const DeviceSize, ) -> c_void, pub cmd_draw: extern "system" fn( command_buffer: CommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32, ) -> c_void, pub cmd_draw_indexed: extern "system" fn( command_buffer: CommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32, ) -> c_void, pub cmd_draw_indirect: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, ) -> c_void, pub cmd_draw_indexed_indirect: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, ) -> c_void, pub cmd_dispatch: extern "system" fn( command_buffer: CommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32, ) -> c_void, pub cmd_dispatch_indirect: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, ) -> c_void, pub cmd_copy_buffer: extern "system" fn( command_buffer: CommandBuffer, src_buffer: Buffer, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferCopy, ) -> c_void, pub cmd_copy_image: extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageCopy, ) -> c_void, pub cmd_blit_image: extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageBlit, filter: Filter, ) -> c_void, pub cmd_copy_buffer_to_image: extern "system" fn( command_buffer: CommandBuffer, src_buffer: Buffer, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void, pub cmd_copy_image_to_buffer: extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void, pub cmd_update_buffer: extern "system" fn( command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, data_size: DeviceSize, p_data: *const c_void, ) -> c_void, pub cmd_fill_buffer: extern "system" fn( command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, size: DeviceSize, data: u32, ) -> c_void, pub cmd_clear_color_image: extern "system" fn( command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_color: *const ClearColorValue, range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void, pub cmd_clear_depth_stencil_image: extern "system" fn( command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void, pub cmd_clear_attachments: extern "system" fn( command_buffer: CommandBuffer, attachment_count: u32, p_attachments: *const ClearAttachment, rect_count: u32, p_rects: *const ClearRect, ) -> c_void, pub cmd_resolve_image: extern "system" fn( command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageResolve, ) -> c_void, pub cmd_set_event: extern "system" fn( command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, ) -> c_void, pub cmd_reset_event: extern "system" fn( command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, ) -> c_void, pub cmd_wait_events: extern "system" fn( command_buffer: CommandBuffer, event_count: u32, p_events: *const Event, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void, pub cmd_pipeline_barrier: extern "system" fn( command_buffer: CommandBuffer, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, dependency_flags: DependencyFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void, pub cmd_begin_query: extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, flags: QueryControlFlags, ) -> c_void, pub cmd_end_query: extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, ) -> c_void, pub cmd_reset_query_pool: extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, ) -> c_void, pub cmd_write_timestamp: extern "system" fn( command_buffer: CommandBuffer, pipeline_stage: PipelineStageFlags, query_pool: QueryPool, query: u32, ) -> c_void, pub cmd_copy_query_pool_results: extern "system" fn( command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, dst_buffer: Buffer, dst_offset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags, ) -> c_void, pub cmd_push_constants: extern "system" fn( command_buffer: CommandBuffer, layout: PipelineLayout, stage_flags: ShaderStageFlags, offset: u32, size: u32, p_values: *const c_void, ) -> c_void, pub cmd_begin_render_pass: extern "system" fn( command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, contents: SubpassContents, ) -> c_void, pub cmd_next_subpass: extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents) -> c_void, pub cmd_end_render_pass: extern "system" fn(command_buffer: CommandBuffer) -> c_void, pub cmd_execute_commands: extern "system" fn( command_buffer: CommandBuffer, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void, } unsafe impl Send for DeviceFnV1_0 {} unsafe impl Sync for DeviceFnV1_0 {} impl ::std::clone::Clone for DeviceFnV1_0 { fn clone(&self) -> Self { DeviceFnV1_0 { destroy_device: self.destroy_device, get_device_queue: self.get_device_queue, queue_submit: self.queue_submit, queue_wait_idle: self.queue_wait_idle, device_wait_idle: self.device_wait_idle, allocate_memory: self.allocate_memory, free_memory: self.free_memory, map_memory: self.map_memory, unmap_memory: self.unmap_memory, flush_mapped_memory_ranges: self.flush_mapped_memory_ranges, invalidate_mapped_memory_ranges: self.invalidate_mapped_memory_ranges, get_device_memory_commitment: self.get_device_memory_commitment, bind_buffer_memory: self.bind_buffer_memory, bind_image_memory: self.bind_image_memory, get_buffer_memory_requirements: self.get_buffer_memory_requirements, get_image_memory_requirements: self.get_image_memory_requirements, get_image_sparse_memory_requirements: self.get_image_sparse_memory_requirements, queue_bind_sparse: self.queue_bind_sparse, create_fence: self.create_fence, destroy_fence: self.destroy_fence, reset_fences: self.reset_fences, get_fence_status: self.get_fence_status, wait_for_fences: self.wait_for_fences, create_semaphore: self.create_semaphore, destroy_semaphore: self.destroy_semaphore, create_event: self.create_event, destroy_event: self.destroy_event, get_event_status: self.get_event_status, set_event: self.set_event, reset_event: self.reset_event, create_query_pool: self.create_query_pool, destroy_query_pool: self.destroy_query_pool, get_query_pool_results: self.get_query_pool_results, create_buffer: self.create_buffer, destroy_buffer: self.destroy_buffer, create_buffer_view: self.create_buffer_view, destroy_buffer_view: self.destroy_buffer_view, create_image: self.create_image, destroy_image: self.destroy_image, get_image_subresource_layout: self.get_image_subresource_layout, create_image_view: self.create_image_view, destroy_image_view: self.destroy_image_view, create_shader_module: self.create_shader_module, destroy_shader_module: self.destroy_shader_module, create_pipeline_cache: self.create_pipeline_cache, destroy_pipeline_cache: self.destroy_pipeline_cache, get_pipeline_cache_data: self.get_pipeline_cache_data, merge_pipeline_caches: self.merge_pipeline_caches, create_graphics_pipelines: self.create_graphics_pipelines, create_compute_pipelines: self.create_compute_pipelines, destroy_pipeline: self.destroy_pipeline, create_pipeline_layout: self.create_pipeline_layout, destroy_pipeline_layout: self.destroy_pipeline_layout, create_sampler: self.create_sampler, destroy_sampler: self.destroy_sampler, create_descriptor_set_layout: self.create_descriptor_set_layout, destroy_descriptor_set_layout: self.destroy_descriptor_set_layout, create_descriptor_pool: self.create_descriptor_pool, destroy_descriptor_pool: self.destroy_descriptor_pool, reset_descriptor_pool: self.reset_descriptor_pool, allocate_descriptor_sets: self.allocate_descriptor_sets, free_descriptor_sets: self.free_descriptor_sets, update_descriptor_sets: self.update_descriptor_sets, create_framebuffer: self.create_framebuffer, destroy_framebuffer: self.destroy_framebuffer, create_render_pass: self.create_render_pass, destroy_render_pass: self.destroy_render_pass, get_render_area_granularity: self.get_render_area_granularity, create_command_pool: self.create_command_pool, destroy_command_pool: self.destroy_command_pool, reset_command_pool: self.reset_command_pool, allocate_command_buffers: self.allocate_command_buffers, free_command_buffers: self.free_command_buffers, begin_command_buffer: self.begin_command_buffer, end_command_buffer: self.end_command_buffer, reset_command_buffer: self.reset_command_buffer, cmd_bind_pipeline: self.cmd_bind_pipeline, cmd_set_viewport: self.cmd_set_viewport, cmd_set_scissor: self.cmd_set_scissor, cmd_set_line_width: self.cmd_set_line_width, cmd_set_depth_bias: self.cmd_set_depth_bias, cmd_set_blend_constants: self.cmd_set_blend_constants, cmd_set_depth_bounds: self.cmd_set_depth_bounds, cmd_set_stencil_compare_mask: self.cmd_set_stencil_compare_mask, cmd_set_stencil_write_mask: self.cmd_set_stencil_write_mask, cmd_set_stencil_reference: self.cmd_set_stencil_reference, cmd_bind_descriptor_sets: self.cmd_bind_descriptor_sets, cmd_bind_index_buffer: self.cmd_bind_index_buffer, cmd_bind_vertex_buffers: self.cmd_bind_vertex_buffers, cmd_draw: self.cmd_draw, cmd_draw_indexed: self.cmd_draw_indexed, cmd_draw_indirect: self.cmd_draw_indirect, cmd_draw_indexed_indirect: self.cmd_draw_indexed_indirect, cmd_dispatch: self.cmd_dispatch, cmd_dispatch_indirect: self.cmd_dispatch_indirect, cmd_copy_buffer: self.cmd_copy_buffer, cmd_copy_image: self.cmd_copy_image, cmd_blit_image: self.cmd_blit_image, cmd_copy_buffer_to_image: self.cmd_copy_buffer_to_image, cmd_copy_image_to_buffer: self.cmd_copy_image_to_buffer, cmd_update_buffer: self.cmd_update_buffer, cmd_fill_buffer: self.cmd_fill_buffer, cmd_clear_color_image: self.cmd_clear_color_image, cmd_clear_depth_stencil_image: self.cmd_clear_depth_stencil_image, cmd_clear_attachments: self.cmd_clear_attachments, cmd_resolve_image: self.cmd_resolve_image, cmd_set_event: self.cmd_set_event, cmd_reset_event: self.cmd_reset_event, cmd_wait_events: self.cmd_wait_events, cmd_pipeline_barrier: self.cmd_pipeline_barrier, cmd_begin_query: self.cmd_begin_query, cmd_end_query: self.cmd_end_query, cmd_reset_query_pool: self.cmd_reset_query_pool, cmd_write_timestamp: self.cmd_write_timestamp, cmd_copy_query_pool_results: self.cmd_copy_query_pool_results, cmd_push_constants: self.cmd_push_constants, cmd_begin_render_pass: self.cmd_begin_render_pass, cmd_next_subpass: self.cmd_next_subpass, cmd_end_render_pass: self.cmd_end_render_pass, cmd_execute_commands: self.cmd_execute_commands, } } } impl DeviceFnV1_0 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { DeviceFnV1_0 { destroy_device: unsafe { extern "system" fn destroy_device( _device: Device, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_device))) } let raw_name = stringify!(vkDestroyDevice); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_device } else { ::std::mem::transmute(val) } }, get_device_queue: unsafe { extern "system" fn get_device_queue( _device: Device, _queue_family_index: u32, _queue_index: u32, _p_queue: *mut Queue, ) -> c_void { panic!(concat!("Unable to load ", stringify!(get_device_queue))) } let raw_name = stringify!(vkGetDeviceQueue); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_device_queue } else { ::std::mem::transmute(val) } }, queue_submit: unsafe { extern "system" fn queue_submit( _queue: Queue, _submit_count: u32, _p_submits: *const SubmitInfo, _fence: Fence, ) -> Result { panic!(concat!("Unable to load ", stringify!(queue_submit))) } let raw_name = stringify!(vkQueueSubmit); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { queue_submit } else { ::std::mem::transmute(val) } }, queue_wait_idle: unsafe { extern "system" fn queue_wait_idle(_queue: Queue) -> Result { panic!(concat!("Unable to load ", stringify!(queue_wait_idle))) } let raw_name = stringify!(vkQueueWaitIdle); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { queue_wait_idle } else { ::std::mem::transmute(val) } }, device_wait_idle: unsafe { extern "system" fn device_wait_idle(_device: Device) -> Result { panic!(concat!("Unable to load ", stringify!(device_wait_idle))) } let raw_name = stringify!(vkDeviceWaitIdle); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { device_wait_idle } else { ::std::mem::transmute(val) } }, allocate_memory: unsafe { extern "system" fn allocate_memory( _device: Device, _p_allocate_info: *const MemoryAllocateInfo, _p_allocator: *const AllocationCallbacks, _p_memory: *mut DeviceMemory, ) -> Result { panic!(concat!("Unable to load ", stringify!(allocate_memory))) } let raw_name = stringify!(vkAllocateMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { allocate_memory } else { ::std::mem::transmute(val) } }, free_memory: unsafe { extern "system" fn free_memory( _device: Device, _memory: DeviceMemory, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(free_memory))) } let raw_name = stringify!(vkFreeMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { free_memory } else { ::std::mem::transmute(val) } }, map_memory: unsafe { extern "system" fn map_memory( _device: Device, _memory: DeviceMemory, _offset: DeviceSize, _size: DeviceSize, _flags: MemoryMapFlags, _pp_data: *mut *mut c_void, ) -> Result { panic!(concat!("Unable to load ", stringify!(map_memory))) } let raw_name = stringify!(vkMapMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { map_memory } else { ::std::mem::transmute(val) } }, unmap_memory: unsafe { extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) -> c_void { panic!(concat!("Unable to load ", stringify!(unmap_memory))) } let raw_name = stringify!(vkUnmapMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { unmap_memory } else { ::std::mem::transmute(val) } }, flush_mapped_memory_ranges: unsafe { extern "system" fn flush_mapped_memory_ranges( _device: Device, _memory_range_count: u32, _p_memory_ranges: *const MappedMemoryRange, ) -> Result { panic!(concat!( "Unable to load ", stringify!(flush_mapped_memory_ranges) )) } let raw_name = stringify!(vkFlushMappedMemoryRanges); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { flush_mapped_memory_ranges } else { ::std::mem::transmute(val) } }, invalidate_mapped_memory_ranges: unsafe { extern "system" fn invalidate_mapped_memory_ranges( _device: Device, _memory_range_count: u32, _p_memory_ranges: *const MappedMemoryRange, ) -> Result { panic!(concat!( "Unable to load ", stringify!(invalidate_mapped_memory_ranges) )) } let raw_name = stringify!(vkInvalidateMappedMemoryRanges); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { invalidate_mapped_memory_ranges } else { ::std::mem::transmute(val) } }, get_device_memory_commitment: unsafe { extern "system" fn get_device_memory_commitment( _device: Device, _memory: DeviceMemory, _p_committed_memory_in_bytes: *mut DeviceSize, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_device_memory_commitment) )) } let raw_name = stringify!(vkGetDeviceMemoryCommitment); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_device_memory_commitment } else { ::std::mem::transmute(val) } }, bind_buffer_memory: unsafe { extern "system" fn bind_buffer_memory( _device: Device, _buffer: Buffer, _memory: DeviceMemory, _memory_offset: DeviceSize, ) -> Result { panic!(concat!("Unable to load ", stringify!(bind_buffer_memory))) } let raw_name = stringify!(vkBindBufferMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { bind_buffer_memory } else { ::std::mem::transmute(val) } }, bind_image_memory: unsafe { extern "system" fn bind_image_memory( _device: Device, _image: Image, _memory: DeviceMemory, _memory_offset: DeviceSize, ) -> Result { panic!(concat!("Unable to load ", stringify!(bind_image_memory))) } let raw_name = stringify!(vkBindImageMemory); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { bind_image_memory } else { ::std::mem::transmute(val) } }, get_buffer_memory_requirements: unsafe { extern "system" fn get_buffer_memory_requirements( _device: Device, _buffer: Buffer, _p_memory_requirements: *mut MemoryRequirements, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_buffer_memory_requirements) )) } let raw_name = stringify!(vkGetBufferMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_buffer_memory_requirements } else { ::std::mem::transmute(val) } }, get_image_memory_requirements: unsafe { extern "system" fn get_image_memory_requirements( _device: Device, _image: Image, _p_memory_requirements: *mut MemoryRequirements, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_image_memory_requirements) )) } let raw_name = stringify!(vkGetImageMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_image_memory_requirements } else { ::std::mem::transmute(val) } }, get_image_sparse_memory_requirements: unsafe { extern "system" fn get_image_sparse_memory_requirements( _device: Device, _image: Image, _p_sparse_memory_requirement_count: *mut u32, _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_image_sparse_memory_requirements) )) } let raw_name = stringify!(vkGetImageSparseMemoryRequirements); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_image_sparse_memory_requirements } else { ::std::mem::transmute(val) } }, queue_bind_sparse: unsafe { extern "system" fn queue_bind_sparse( _queue: Queue, _bind_info_count: u32, _p_bind_info: *const BindSparseInfo, _fence: Fence, ) -> Result { panic!(concat!("Unable to load ", stringify!(queue_bind_sparse))) } let raw_name = stringify!(vkQueueBindSparse); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { queue_bind_sparse } else { ::std::mem::transmute(val) } }, create_fence: unsafe { extern "system" fn create_fence( _device: Device, _p_create_info: *const FenceCreateInfo, _p_allocator: *const AllocationCallbacks, _p_fence: *mut Fence, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_fence))) } let raw_name = stringify!(vkCreateFence); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_fence } else { ::std::mem::transmute(val) } }, destroy_fence: unsafe { extern "system" fn destroy_fence( _device: Device, _fence: Fence, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_fence))) } let raw_name = stringify!(vkDestroyFence); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_fence } else { ::std::mem::transmute(val) } }, reset_fences: unsafe { extern "system" fn reset_fences( _device: Device, _fence_count: u32, _p_fences: *const Fence, ) -> Result { panic!(concat!("Unable to load ", stringify!(reset_fences))) } let raw_name = stringify!(vkResetFences); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { reset_fences } else { ::std::mem::transmute(val) } }, get_fence_status: unsafe { extern "system" fn get_fence_status(_device: Device, _fence: Fence) -> Result { panic!(concat!("Unable to load ", stringify!(get_fence_status))) } let raw_name = stringify!(vkGetFenceStatus); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_fence_status } else { ::std::mem::transmute(val) } }, wait_for_fences: unsafe { extern "system" fn wait_for_fences( _device: Device, _fence_count: u32, _p_fences: *const Fence, _wait_all: Bool32, _timeout: u64, ) -> Result { panic!(concat!("Unable to load ", stringify!(wait_for_fences))) } let raw_name = stringify!(vkWaitForFences); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { wait_for_fences } else { ::std::mem::transmute(val) } }, create_semaphore: unsafe { extern "system" fn create_semaphore( _device: Device, _p_create_info: *const SemaphoreCreateInfo, _p_allocator: *const AllocationCallbacks, _p_semaphore: *mut Semaphore, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_semaphore))) } let raw_name = stringify!(vkCreateSemaphore); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_semaphore } else { ::std::mem::transmute(val) } }, destroy_semaphore: unsafe { extern "system" fn destroy_semaphore( _device: Device, _semaphore: Semaphore, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_semaphore))) } let raw_name = stringify!(vkDestroySemaphore); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_semaphore } else { ::std::mem::transmute(val) } }, create_event: unsafe { extern "system" fn create_event( _device: Device, _p_create_info: *const EventCreateInfo, _p_allocator: *const AllocationCallbacks, _p_event: *mut Event, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_event))) } let raw_name = stringify!(vkCreateEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_event } else { ::std::mem::transmute(val) } }, destroy_event: unsafe { extern "system" fn destroy_event( _device: Device, _event: Event, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_event))) } let raw_name = stringify!(vkDestroyEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_event } else { ::std::mem::transmute(val) } }, get_event_status: unsafe { extern "system" fn get_event_status(_device: Device, _event: Event) -> Result { panic!(concat!("Unable to load ", stringify!(get_event_status))) } let raw_name = stringify!(vkGetEventStatus); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_event_status } else { ::std::mem::transmute(val) } }, set_event: unsafe { extern "system" fn set_event(_device: Device, _event: Event) -> Result { panic!(concat!("Unable to load ", stringify!(set_event))) } let raw_name = stringify!(vkSetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { set_event } else { ::std::mem::transmute(val) } }, reset_event: unsafe { extern "system" fn reset_event(_device: Device, _event: Event) -> Result { panic!(concat!("Unable to load ", stringify!(reset_event))) } let raw_name = stringify!(vkResetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { reset_event } else { ::std::mem::transmute(val) } }, create_query_pool: unsafe { extern "system" fn create_query_pool( _device: Device, _p_create_info: *const QueryPoolCreateInfo, _p_allocator: *const AllocationCallbacks, _p_query_pool: *mut QueryPool, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_query_pool))) } let raw_name = stringify!(vkCreateQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_query_pool } else { ::std::mem::transmute(val) } }, destroy_query_pool: unsafe { extern "system" fn destroy_query_pool( _device: Device, _query_pool: QueryPool, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_query_pool))) } let raw_name = stringify!(vkDestroyQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_query_pool } else { ::std::mem::transmute(val) } }, get_query_pool_results: unsafe { extern "system" fn get_query_pool_results( _device: Device, _query_pool: QueryPool, _first_query: u32, _query_count: u32, _data_size: usize, _p_data: *mut c_void, _stride: DeviceSize, _flags: QueryResultFlags, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_query_pool_results) )) } let raw_name = stringify!(vkGetQueryPoolResults); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_query_pool_results } else { ::std::mem::transmute(val) } }, create_buffer: unsafe { extern "system" fn create_buffer( _device: Device, _p_create_info: *const BufferCreateInfo, _p_allocator: *const AllocationCallbacks, _p_buffer: *mut Buffer, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_buffer))) } let raw_name = stringify!(vkCreateBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_buffer } else { ::std::mem::transmute(val) } }, destroy_buffer: unsafe { extern "system" fn destroy_buffer( _device: Device, _buffer: Buffer, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_buffer))) } let raw_name = stringify!(vkDestroyBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_buffer } else { ::std::mem::transmute(val) } }, create_buffer_view: unsafe { extern "system" fn create_buffer_view( _device: Device, _p_create_info: *const BufferViewCreateInfo, _p_allocator: *const AllocationCallbacks, _p_view: *mut BufferView, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_buffer_view))) } let raw_name = stringify!(vkCreateBufferView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_buffer_view } else { ::std::mem::transmute(val) } }, destroy_buffer_view: unsafe { extern "system" fn destroy_buffer_view( _device: Device, _buffer_view: BufferView, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_buffer_view))) } let raw_name = stringify!(vkDestroyBufferView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_buffer_view } else { ::std::mem::transmute(val) } }, create_image: unsafe { extern "system" fn create_image( _device: Device, _p_create_info: *const ImageCreateInfo, _p_allocator: *const AllocationCallbacks, _p_image: *mut Image, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_image))) } let raw_name = stringify!(vkCreateImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_image } else { ::std::mem::transmute(val) } }, destroy_image: unsafe { extern "system" fn destroy_image( _device: Device, _image: Image, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_image))) } let raw_name = stringify!(vkDestroyImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_image } else { ::std::mem::transmute(val) } }, get_image_subresource_layout: unsafe { extern "system" fn get_image_subresource_layout( _device: Device, _image: Image, _p_subresource: *const ImageSubresource, _p_layout: *mut SubresourceLayout, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_image_subresource_layout) )) } let raw_name = stringify!(vkGetImageSubresourceLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_image_subresource_layout } else { ::std::mem::transmute(val) } }, create_image_view: unsafe { extern "system" fn create_image_view( _device: Device, _p_create_info: *const ImageViewCreateInfo, _p_allocator: *const AllocationCallbacks, _p_view: *mut ImageView, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_image_view))) } let raw_name = stringify!(vkCreateImageView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_image_view } else { ::std::mem::transmute(val) } }, destroy_image_view: unsafe { extern "system" fn destroy_image_view( _device: Device, _image_view: ImageView, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_image_view))) } let raw_name = stringify!(vkDestroyImageView); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_image_view } else { ::std::mem::transmute(val) } }, create_shader_module: unsafe { extern "system" fn create_shader_module( _device: Device, _p_create_info: *const ShaderModuleCreateInfo, _p_allocator: *const AllocationCallbacks, _p_shader_module: *mut ShaderModule, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_shader_module))) } let raw_name = stringify!(vkCreateShaderModule); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_shader_module } else { ::std::mem::transmute(val) } }, destroy_shader_module: unsafe { extern "system" fn destroy_shader_module( _device: Device, _shader_module: ShaderModule, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(destroy_shader_module) )) } let raw_name = stringify!(vkDestroyShaderModule); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_shader_module } else { ::std::mem::transmute(val) } }, create_pipeline_cache: unsafe { extern "system" fn create_pipeline_cache( _device: Device, _p_create_info: *const PipelineCacheCreateInfo, _p_allocator: *const AllocationCallbacks, _p_pipeline_cache: *mut PipelineCache, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_pipeline_cache) )) } let raw_name = stringify!(vkCreatePipelineCache); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_pipeline_cache } else { ::std::mem::transmute(val) } }, destroy_pipeline_cache: unsafe { extern "system" fn destroy_pipeline_cache( _device: Device, _pipeline_cache: PipelineCache, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(destroy_pipeline_cache) )) } let raw_name = stringify!(vkDestroyPipelineCache); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_pipeline_cache } else { ::std::mem::transmute(val) } }, get_pipeline_cache_data: unsafe { extern "system" fn get_pipeline_cache_data( _device: Device, _pipeline_cache: PipelineCache, _p_data_size: *mut usize, _p_data: *mut c_void, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_pipeline_cache_data) )) } let raw_name = stringify!(vkGetPipelineCacheData); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_pipeline_cache_data } else { ::std::mem::transmute(val) } }, merge_pipeline_caches: unsafe { extern "system" fn merge_pipeline_caches( _device: Device, _dst_cache: PipelineCache, _src_cache_count: u32, _p_src_caches: *const PipelineCache, ) -> Result { panic!(concat!( "Unable to load ", stringify!(merge_pipeline_caches) )) } let raw_name = stringify!(vkMergePipelineCaches); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { merge_pipeline_caches } else { ::std::mem::transmute(val) } }, create_graphics_pipelines: unsafe { extern "system" fn create_graphics_pipelines( _device: Device, _pipeline_cache: PipelineCache, _create_info_count: u32, _p_create_infos: *const GraphicsPipelineCreateInfo, _p_allocator: *const AllocationCallbacks, _p_pipelines: *mut Pipeline, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_graphics_pipelines) )) } let raw_name = stringify!(vkCreateGraphicsPipelines); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_graphics_pipelines } else { ::std::mem::transmute(val) } }, create_compute_pipelines: unsafe { extern "system" fn create_compute_pipelines( _device: Device, _pipeline_cache: PipelineCache, _create_info_count: u32, _p_create_infos: *const ComputePipelineCreateInfo, _p_allocator: *const AllocationCallbacks, _p_pipelines: *mut Pipeline, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_compute_pipelines) )) } let raw_name = stringify!(vkCreateComputePipelines); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_compute_pipelines } else { ::std::mem::transmute(val) } }, destroy_pipeline: unsafe { extern "system" fn destroy_pipeline( _device: Device, _pipeline: Pipeline, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_pipeline))) } let raw_name = stringify!(vkDestroyPipeline); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_pipeline } else { ::std::mem::transmute(val) } }, create_pipeline_layout: unsafe { extern "system" fn create_pipeline_layout( _device: Device, _p_create_info: *const PipelineLayoutCreateInfo, _p_allocator: *const AllocationCallbacks, _p_pipeline_layout: *mut PipelineLayout, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_pipeline_layout) )) } let raw_name = stringify!(vkCreatePipelineLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_pipeline_layout } else { ::std::mem::transmute(val) } }, destroy_pipeline_layout: unsafe { extern "system" fn destroy_pipeline_layout( _device: Device, _pipeline_layout: PipelineLayout, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(destroy_pipeline_layout) )) } let raw_name = stringify!(vkDestroyPipelineLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_pipeline_layout } else { ::std::mem::transmute(val) } }, create_sampler: unsafe { extern "system" fn create_sampler( _device: Device, _p_create_info: *const SamplerCreateInfo, _p_allocator: *const AllocationCallbacks, _p_sampler: *mut Sampler, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_sampler))) } let raw_name = stringify!(vkCreateSampler); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_sampler } else { ::std::mem::transmute(val) } }, destroy_sampler: unsafe { extern "system" fn destroy_sampler( _device: Device, _sampler: Sampler, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_sampler))) } let raw_name = stringify!(vkDestroySampler); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_sampler } else { ::std::mem::transmute(val) } }, create_descriptor_set_layout: unsafe { extern "system" fn create_descriptor_set_layout( _device: Device, _p_create_info: *const DescriptorSetLayoutCreateInfo, _p_allocator: *const AllocationCallbacks, _p_set_layout: *mut DescriptorSetLayout, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_descriptor_set_layout) )) } let raw_name = stringify!(vkCreateDescriptorSetLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_descriptor_set_layout } else { ::std::mem::transmute(val) } }, destroy_descriptor_set_layout: unsafe { extern "system" fn destroy_descriptor_set_layout( _device: Device, _descriptor_set_layout: DescriptorSetLayout, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(destroy_descriptor_set_layout) )) } let raw_name = stringify!(vkDestroyDescriptorSetLayout); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_descriptor_set_layout } else { ::std::mem::transmute(val) } }, create_descriptor_pool: unsafe { extern "system" fn create_descriptor_pool( _device: Device, _p_create_info: *const DescriptorPoolCreateInfo, _p_allocator: *const AllocationCallbacks, _p_descriptor_pool: *mut DescriptorPool, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_descriptor_pool) )) } let raw_name = stringify!(vkCreateDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_descriptor_pool } else { ::std::mem::transmute(val) } }, destroy_descriptor_pool: unsafe { extern "system" fn destroy_descriptor_pool( _device: Device, _descriptor_pool: DescriptorPool, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(destroy_descriptor_pool) )) } let raw_name = stringify!(vkDestroyDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_descriptor_pool } else { ::std::mem::transmute(val) } }, reset_descriptor_pool: unsafe { extern "system" fn reset_descriptor_pool( _device: Device, _descriptor_pool: DescriptorPool, _flags: DescriptorPoolResetFlags, ) -> Result { panic!(concat!( "Unable to load ", stringify!(reset_descriptor_pool) )) } let raw_name = stringify!(vkResetDescriptorPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { reset_descriptor_pool } else { ::std::mem::transmute(val) } }, allocate_descriptor_sets: unsafe { extern "system" fn allocate_descriptor_sets( _device: Device, _p_allocate_info: *const DescriptorSetAllocateInfo, _p_descriptor_sets: *mut DescriptorSet, ) -> Result { panic!(concat!( "Unable to load ", stringify!(allocate_descriptor_sets) )) } let raw_name = stringify!(vkAllocateDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { allocate_descriptor_sets } else { ::std::mem::transmute(val) } }, free_descriptor_sets: unsafe { extern "system" fn free_descriptor_sets( _device: Device, _descriptor_pool: DescriptorPool, _descriptor_set_count: u32, _p_descriptor_sets: *const DescriptorSet, ) -> Result { panic!(concat!("Unable to load ", stringify!(free_descriptor_sets))) } let raw_name = stringify!(vkFreeDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { free_descriptor_sets } else { ::std::mem::transmute(val) } }, update_descriptor_sets: unsafe { extern "system" fn update_descriptor_sets( _device: Device, _descriptor_write_count: u32, _p_descriptor_writes: *const WriteDescriptorSet, _descriptor_copy_count: u32, _p_descriptor_copies: *const CopyDescriptorSet, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(update_descriptor_sets) )) } let raw_name = stringify!(vkUpdateDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { update_descriptor_sets } else { ::std::mem::transmute(val) } }, create_framebuffer: unsafe { extern "system" fn create_framebuffer( _device: Device, _p_create_info: *const FramebufferCreateInfo, _p_allocator: *const AllocationCallbacks, _p_framebuffer: *mut Framebuffer, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_framebuffer))) } let raw_name = stringify!(vkCreateFramebuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_framebuffer } else { ::std::mem::transmute(val) } }, destroy_framebuffer: unsafe { extern "system" fn destroy_framebuffer( _device: Device, _framebuffer: Framebuffer, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_framebuffer))) } let raw_name = stringify!(vkDestroyFramebuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_framebuffer } else { ::std::mem::transmute(val) } }, create_render_pass: unsafe { extern "system" fn create_render_pass( _device: Device, _p_create_info: *const RenderPassCreateInfo, _p_allocator: *const AllocationCallbacks, _p_render_pass: *mut RenderPass, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_render_pass))) } let raw_name = stringify!(vkCreateRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_render_pass } else { ::std::mem::transmute(val) } }, destroy_render_pass: unsafe { extern "system" fn destroy_render_pass( _device: Device, _render_pass: RenderPass, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_render_pass))) } let raw_name = stringify!(vkDestroyRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_render_pass } else { ::std::mem::transmute(val) } }, get_render_area_granularity: unsafe { extern "system" fn get_render_area_granularity( _device: Device, _render_pass: RenderPass, _p_granularity: *mut Extent2D, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_render_area_granularity) )) } let raw_name = stringify!(vkGetRenderAreaGranularity); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_render_area_granularity } else { ::std::mem::transmute(val) } }, create_command_pool: unsafe { extern "system" fn create_command_pool( _device: Device, _p_create_info: *const CommandPoolCreateInfo, _p_allocator: *const AllocationCallbacks, _p_command_pool: *mut CommandPool, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_command_pool))) } let raw_name = stringify!(vkCreateCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_command_pool } else { ::std::mem::transmute(val) } }, destroy_command_pool: unsafe { extern "system" fn destroy_command_pool( _device: Device, _command_pool: CommandPool, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!("Unable to load ", stringify!(destroy_command_pool))) } let raw_name = stringify!(vkDestroyCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_command_pool } else { ::std::mem::transmute(val) } }, reset_command_pool: unsafe { extern "system" fn reset_command_pool( _device: Device, _command_pool: CommandPool, _flags: CommandPoolResetFlags, ) -> Result { panic!(concat!("Unable to load ", stringify!(reset_command_pool))) } let raw_name = stringify!(vkResetCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { reset_command_pool } else { ::std::mem::transmute(val) } }, allocate_command_buffers: unsafe { extern "system" fn allocate_command_buffers( _device: Device, _p_allocate_info: *const CommandBufferAllocateInfo, _p_command_buffers: *mut CommandBuffer, ) -> Result { panic!(concat!( "Unable to load ", stringify!(allocate_command_buffers) )) } let raw_name = stringify!(vkAllocateCommandBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { allocate_command_buffers } else { ::std::mem::transmute(val) } }, free_command_buffers: unsafe { extern "system" fn free_command_buffers( _device: Device, _command_pool: CommandPool, _command_buffer_count: u32, _p_command_buffers: *const CommandBuffer, ) -> c_void { panic!(concat!("Unable to load ", stringify!(free_command_buffers))) } let raw_name = stringify!(vkFreeCommandBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { free_command_buffers } else { ::std::mem::transmute(val) } }, begin_command_buffer: unsafe { extern "system" fn begin_command_buffer( _command_buffer: CommandBuffer, _p_begin_info: *const CommandBufferBeginInfo, ) -> Result { panic!(concat!("Unable to load ", stringify!(begin_command_buffer))) } let raw_name = stringify!(vkBeginCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { begin_command_buffer } else { ::std::mem::transmute(val) } }, end_command_buffer: unsafe { extern "system" fn end_command_buffer(_command_buffer: CommandBuffer) -> Result { panic!(concat!("Unable to load ", stringify!(end_command_buffer))) } let raw_name = stringify!(vkEndCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { end_command_buffer } else { ::std::mem::transmute(val) } }, reset_command_buffer: unsafe { extern "system" fn reset_command_buffer( _command_buffer: CommandBuffer, _flags: CommandBufferResetFlags, ) -> Result { panic!(concat!("Unable to load ", stringify!(reset_command_buffer))) } let raw_name = stringify!(vkResetCommandBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { reset_command_buffer } else { ::std::mem::transmute(val) } }, cmd_bind_pipeline: unsafe { extern "system" fn cmd_bind_pipeline( _command_buffer: CommandBuffer, _pipeline_bind_point: PipelineBindPoint, _pipeline: Pipeline, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline))) } let raw_name = stringify!(vkCmdBindPipeline); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_bind_pipeline } else { ::std::mem::transmute(val) } }, cmd_set_viewport: unsafe { extern "system" fn cmd_set_viewport( _command_buffer: CommandBuffer, _first_viewport: u32, _viewport_count: u32, _p_viewports: *const Viewport, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_viewport))) } let raw_name = stringify!(vkCmdSetViewport); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_viewport } else { ::std::mem::transmute(val) } }, cmd_set_scissor: unsafe { extern "system" fn cmd_set_scissor( _command_buffer: CommandBuffer, _first_scissor: u32, _scissor_count: u32, _p_scissors: *const Rect2D, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_scissor))) } let raw_name = stringify!(vkCmdSetScissor); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_scissor } else { ::std::mem::transmute(val) } }, cmd_set_line_width: unsafe { extern "system" fn cmd_set_line_width( _command_buffer: CommandBuffer, _line_width: f32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_line_width))) } let raw_name = stringify!(vkCmdSetLineWidth); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_line_width } else { ::std::mem::transmute(val) } }, cmd_set_depth_bias: unsafe { extern "system" fn cmd_set_depth_bias( _command_buffer: CommandBuffer, _depth_bias_constant_factor: f32, _depth_bias_clamp: f32, _depth_bias_slope_factor: f32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias))) } let raw_name = stringify!(vkCmdSetDepthBias); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_depth_bias } else { ::std::mem::transmute(val) } }, cmd_set_blend_constants: unsafe { extern "system" fn cmd_set_blend_constants( _command_buffer: CommandBuffer, _blend_constants: &[f32; 4], ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_set_blend_constants) )) } let raw_name = stringify!(vkCmdSetBlendConstants); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_blend_constants } else { ::std::mem::transmute(val) } }, cmd_set_depth_bounds: unsafe { extern "system" fn cmd_set_depth_bounds( _command_buffer: CommandBuffer, _min_depth_bounds: f32, _max_depth_bounds: f32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds))) } let raw_name = stringify!(vkCmdSetDepthBounds); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_depth_bounds } else { ::std::mem::transmute(val) } }, cmd_set_stencil_compare_mask: unsafe { extern "system" fn cmd_set_stencil_compare_mask( _command_buffer: CommandBuffer, _face_mask: StencilFaceFlags, _compare_mask: u32, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_set_stencil_compare_mask) )) } let raw_name = stringify!(vkCmdSetStencilCompareMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_stencil_compare_mask } else { ::std::mem::transmute(val) } }, cmd_set_stencil_write_mask: unsafe { extern "system" fn cmd_set_stencil_write_mask( _command_buffer: CommandBuffer, _face_mask: StencilFaceFlags, _write_mask: u32, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_set_stencil_write_mask) )) } let raw_name = stringify!(vkCmdSetStencilWriteMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_stencil_write_mask } else { ::std::mem::transmute(val) } }, cmd_set_stencil_reference: unsafe { extern "system" fn cmd_set_stencil_reference( _command_buffer: CommandBuffer, _face_mask: StencilFaceFlags, _reference: u32, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_set_stencil_reference) )) } let raw_name = stringify!(vkCmdSetStencilReference); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_stencil_reference } else { ::std::mem::transmute(val) } }, cmd_bind_descriptor_sets: unsafe { extern "system" fn cmd_bind_descriptor_sets( _command_buffer: CommandBuffer, _pipeline_bind_point: PipelineBindPoint, _layout: PipelineLayout, _first_set: u32, _descriptor_set_count: u32, _p_descriptor_sets: *const DescriptorSet, _dynamic_offset_count: u32, _p_dynamic_offsets: *const u32, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_bind_descriptor_sets) )) } let raw_name = stringify!(vkCmdBindDescriptorSets); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_bind_descriptor_sets } else { ::std::mem::transmute(val) } }, cmd_bind_index_buffer: unsafe { extern "system" fn cmd_bind_index_buffer( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, _index_type: IndexType, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_bind_index_buffer) )) } let raw_name = stringify!(vkCmdBindIndexBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_bind_index_buffer } else { ::std::mem::transmute(val) } }, cmd_bind_vertex_buffers: unsafe { extern "system" fn cmd_bind_vertex_buffers( _command_buffer: CommandBuffer, _first_binding: u32, _binding_count: u32, _p_buffers: *const Buffer, _p_offsets: *const DeviceSize, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_bind_vertex_buffers) )) } let raw_name = stringify!(vkCmdBindVertexBuffers); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_bind_vertex_buffers } else { ::std::mem::transmute(val) } }, cmd_draw: unsafe { extern "system" fn cmd_draw( _command_buffer: CommandBuffer, _vertex_count: u32, _instance_count: u32, _first_vertex: u32, _first_instance: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_draw))) } let raw_name = stringify!(vkCmdDraw); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_draw } else { ::std::mem::transmute(val) } }, cmd_draw_indexed: unsafe { extern "system" fn cmd_draw_indexed( _command_buffer: CommandBuffer, _index_count: u32, _instance_count: u32, _first_index: u32, _vertex_offset: i32, _first_instance: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed))) } let raw_name = stringify!(vkCmdDrawIndexed); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_draw_indexed } else { ::std::mem::transmute(val) } }, cmd_draw_indirect: unsafe { extern "system" fn cmd_draw_indirect( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, _draw_count: u32, _stride: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect))) } let raw_name = stringify!(vkCmdDrawIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_draw_indirect } else { ::std::mem::transmute(val) } }, cmd_draw_indexed_indirect: unsafe { extern "system" fn cmd_draw_indexed_indirect( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, _draw_count: u32, _stride: u32, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_draw_indexed_indirect) )) } let raw_name = stringify!(vkCmdDrawIndexedIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_draw_indexed_indirect } else { ::std::mem::transmute(val) } }, cmd_dispatch: unsafe { extern "system" fn cmd_dispatch( _command_buffer: CommandBuffer, _group_count_x: u32, _group_count_y: u32, _group_count_z: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_dispatch))) } let raw_name = stringify!(vkCmdDispatch); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_dispatch } else { ::std::mem::transmute(val) } }, cmd_dispatch_indirect: unsafe { extern "system" fn cmd_dispatch_indirect( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_dispatch_indirect) )) } let raw_name = stringify!(vkCmdDispatchIndirect); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_dispatch_indirect } else { ::std::mem::transmute(val) } }, cmd_copy_buffer: unsafe { extern "system" fn cmd_copy_buffer( _command_buffer: CommandBuffer, _src_buffer: Buffer, _dst_buffer: Buffer, _region_count: u32, _p_regions: *const BufferCopy, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer))) } let raw_name = stringify!(vkCmdCopyBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_copy_buffer } else { ::std::mem::transmute(val) } }, cmd_copy_image: unsafe { extern "system" fn cmd_copy_image( _command_buffer: CommandBuffer, _src_image: Image, _src_image_layout: ImageLayout, _dst_image: Image, _dst_image_layout: ImageLayout, _region_count: u32, _p_regions: *const ImageCopy, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_copy_image))) } let raw_name = stringify!(vkCmdCopyImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_copy_image } else { ::std::mem::transmute(val) } }, cmd_blit_image: unsafe { extern "system" fn cmd_blit_image( _command_buffer: CommandBuffer, _src_image: Image, _src_image_layout: ImageLayout, _dst_image: Image, _dst_image_layout: ImageLayout, _region_count: u32, _p_regions: *const ImageBlit, _filter: Filter, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_blit_image))) } let raw_name = stringify!(vkCmdBlitImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_blit_image } else { ::std::mem::transmute(val) } }, cmd_copy_buffer_to_image: unsafe { extern "system" fn cmd_copy_buffer_to_image( _command_buffer: CommandBuffer, _src_buffer: Buffer, _dst_image: Image, _dst_image_layout: ImageLayout, _region_count: u32, _p_regions: *const BufferImageCopy, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_copy_buffer_to_image) )) } let raw_name = stringify!(vkCmdCopyBufferToImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_copy_buffer_to_image } else { ::std::mem::transmute(val) } }, cmd_copy_image_to_buffer: unsafe { extern "system" fn cmd_copy_image_to_buffer( _command_buffer: CommandBuffer, _src_image: Image, _src_image_layout: ImageLayout, _dst_buffer: Buffer, _region_count: u32, _p_regions: *const BufferImageCopy, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_copy_image_to_buffer) )) } let raw_name = stringify!(vkCmdCopyImageToBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_copy_image_to_buffer } else { ::std::mem::transmute(val) } }, cmd_update_buffer: unsafe { extern "system" fn cmd_update_buffer( _command_buffer: CommandBuffer, _dst_buffer: Buffer, _dst_offset: DeviceSize, _data_size: DeviceSize, _p_data: *const c_void, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_update_buffer))) } let raw_name = stringify!(vkCmdUpdateBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_update_buffer } else { ::std::mem::transmute(val) } }, cmd_fill_buffer: unsafe { extern "system" fn cmd_fill_buffer( _command_buffer: CommandBuffer, _dst_buffer: Buffer, _dst_offset: DeviceSize, _size: DeviceSize, _data: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer))) } let raw_name = stringify!(vkCmdFillBuffer); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_fill_buffer } else { ::std::mem::transmute(val) } }, cmd_clear_color_image: unsafe { extern "system" fn cmd_clear_color_image( _command_buffer: CommandBuffer, _image: Image, _image_layout: ImageLayout, _p_color: *const ClearColorValue, _range_count: u32, _p_ranges: *const ImageSubresourceRange, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_clear_color_image) )) } let raw_name = stringify!(vkCmdClearColorImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_clear_color_image } else { ::std::mem::transmute(val) } }, cmd_clear_depth_stencil_image: unsafe { extern "system" fn cmd_clear_depth_stencil_image( _command_buffer: CommandBuffer, _image: Image, _image_layout: ImageLayout, _p_depth_stencil: *const ClearDepthStencilValue, _range_count: u32, _p_ranges: *const ImageSubresourceRange, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_clear_depth_stencil_image) )) } let raw_name = stringify!(vkCmdClearDepthStencilImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_clear_depth_stencil_image } else { ::std::mem::transmute(val) } }, cmd_clear_attachments: unsafe { extern "system" fn cmd_clear_attachments( _command_buffer: CommandBuffer, _attachment_count: u32, _p_attachments: *const ClearAttachment, _rect_count: u32, _p_rects: *const ClearRect, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_clear_attachments) )) } let raw_name = stringify!(vkCmdClearAttachments); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_clear_attachments } else { ::std::mem::transmute(val) } }, cmd_resolve_image: unsafe { extern "system" fn cmd_resolve_image( _command_buffer: CommandBuffer, _src_image: Image, _src_image_layout: ImageLayout, _dst_image: Image, _dst_image_layout: ImageLayout, _region_count: u32, _p_regions: *const ImageResolve, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_resolve_image))) } let raw_name = stringify!(vkCmdResolveImage); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_resolve_image } else { ::std::mem::transmute(val) } }, cmd_set_event: unsafe { extern "system" fn cmd_set_event( _command_buffer: CommandBuffer, _event: Event, _stage_mask: PipelineStageFlags, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_event))) } let raw_name = stringify!(vkCmdSetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_event } else { ::std::mem::transmute(val) } }, cmd_reset_event: unsafe { extern "system" fn cmd_reset_event( _command_buffer: CommandBuffer, _event: Event, _stage_mask: PipelineStageFlags, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_reset_event))) } let raw_name = stringify!(vkCmdResetEvent); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_reset_event } else { ::std::mem::transmute(val) } }, cmd_wait_events: unsafe { extern "system" fn cmd_wait_events( _command_buffer: CommandBuffer, _event_count: u32, _p_events: *const Event, _src_stage_mask: PipelineStageFlags, _dst_stage_mask: PipelineStageFlags, _memory_barrier_count: u32, _p_memory_barriers: *const MemoryBarrier, _buffer_memory_barrier_count: u32, _p_buffer_memory_barriers: *const BufferMemoryBarrier, _image_memory_barrier_count: u32, _p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_wait_events))) } let raw_name = stringify!(vkCmdWaitEvents); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_wait_events } else { ::std::mem::transmute(val) } }, cmd_pipeline_barrier: unsafe { extern "system" fn cmd_pipeline_barrier( _command_buffer: CommandBuffer, _src_stage_mask: PipelineStageFlags, _dst_stage_mask: PipelineStageFlags, _dependency_flags: DependencyFlags, _memory_barrier_count: u32, _p_memory_barriers: *const MemoryBarrier, _buffer_memory_barrier_count: u32, _p_buffer_memory_barriers: *const BufferMemoryBarrier, _image_memory_barrier_count: u32, _p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier))) } let raw_name = stringify!(vkCmdPipelineBarrier); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_pipeline_barrier } else { ::std::mem::transmute(val) } }, cmd_begin_query: unsafe { extern "system" fn cmd_begin_query( _command_buffer: CommandBuffer, _query_pool: QueryPool, _query: u32, _flags: QueryControlFlags, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_begin_query))) } let raw_name = stringify!(vkCmdBeginQuery); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_begin_query } else { ::std::mem::transmute(val) } }, cmd_end_query: unsafe { extern "system" fn cmd_end_query( _command_buffer: CommandBuffer, _query_pool: QueryPool, _query: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_end_query))) } let raw_name = stringify!(vkCmdEndQuery); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_end_query } else { ::std::mem::transmute(val) } }, cmd_reset_query_pool: unsafe { extern "system" fn cmd_reset_query_pool( _command_buffer: CommandBuffer, _query_pool: QueryPool, _first_query: u32, _query_count: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool))) } let raw_name = stringify!(vkCmdResetQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_reset_query_pool } else { ::std::mem::transmute(val) } }, cmd_write_timestamp: unsafe { extern "system" fn cmd_write_timestamp( _command_buffer: CommandBuffer, _pipeline_stage: PipelineStageFlags, _query_pool: QueryPool, _query: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp))) } let raw_name = stringify!(vkCmdWriteTimestamp); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_write_timestamp } else { ::std::mem::transmute(val) } }, cmd_copy_query_pool_results: unsafe { extern "system" fn cmd_copy_query_pool_results( _command_buffer: CommandBuffer, _query_pool: QueryPool, _first_query: u32, _query_count: u32, _dst_buffer: Buffer, _dst_offset: DeviceSize, _stride: DeviceSize, _flags: QueryResultFlags, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_copy_query_pool_results) )) } let raw_name = stringify!(vkCmdCopyQueryPoolResults); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_copy_query_pool_results } else { ::std::mem::transmute(val) } }, cmd_push_constants: unsafe { extern "system" fn cmd_push_constants( _command_buffer: CommandBuffer, _layout: PipelineLayout, _stage_flags: ShaderStageFlags, _offset: u32, _size: u32, _p_values: *const c_void, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_push_constants))) } let raw_name = stringify!(vkCmdPushConstants); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_push_constants } else { ::std::mem::transmute(val) } }, cmd_begin_render_pass: unsafe { extern "system" fn cmd_begin_render_pass( _command_buffer: CommandBuffer, _p_render_pass_begin: *const RenderPassBeginInfo, _contents: SubpassContents, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_begin_render_pass) )) } let raw_name = stringify!(vkCmdBeginRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_begin_render_pass } else { ::std::mem::transmute(val) } }, cmd_next_subpass: unsafe { extern "system" fn cmd_next_subpass( _command_buffer: CommandBuffer, _contents: SubpassContents, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_next_subpass))) } let raw_name = stringify!(vkCmdNextSubpass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_next_subpass } else { ::std::mem::transmute(val) } }, cmd_end_render_pass: unsafe { extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass))) } let raw_name = stringify!(vkCmdEndRenderPass); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_end_render_pass } else { ::std::mem::transmute(val) } }, cmd_execute_commands: unsafe { extern "system" fn cmd_execute_commands( _command_buffer: CommandBuffer, _command_buffer_count: u32, _p_command_buffers: *const CommandBuffer, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_execute_commands))) } let raw_name = stringify!(vkCmdExecuteCommands); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_execute_commands } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn destroy_device( &self, device: Device, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_device)(device, p_allocator) } #[doc = ""] pub unsafe fn get_device_queue( &self, device: Device, queue_family_index: u32, queue_index: u32, p_queue: *mut Queue, ) -> c_void { (self.get_device_queue)(device, queue_family_index, queue_index, p_queue) } #[doc = ""] pub unsafe fn queue_submit( &self, queue: Queue, submit_count: u32, p_submits: *const SubmitInfo, fence: Fence, ) -> Result { (self.queue_submit)(queue, submit_count, p_submits, fence) } #[doc = ""] pub unsafe fn queue_wait_idle(&self, queue: Queue) -> Result { (self.queue_wait_idle)(queue) } #[doc = ""] pub unsafe fn device_wait_idle(&self, device: Device) -> Result { (self.device_wait_idle)(device) } #[doc = ""] pub unsafe fn allocate_memory( &self, device: Device, p_allocate_info: *const MemoryAllocateInfo, p_allocator: *const AllocationCallbacks, p_memory: *mut DeviceMemory, ) -> Result { (self.allocate_memory)(device, p_allocate_info, p_allocator, p_memory) } #[doc = ""] pub unsafe fn free_memory( &self, device: Device, memory: DeviceMemory, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.free_memory)(device, memory, p_allocator) } #[doc = ""] pub unsafe fn map_memory( &self, device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, pp_data: *mut *mut c_void, ) -> Result { (self.map_memory)(device, memory, offset, size, flags, pp_data) } #[doc = ""] pub unsafe fn unmap_memory(&self, device: Device, memory: DeviceMemory) -> c_void { (self.unmap_memory)(device, memory) } #[doc = ""] pub unsafe fn flush_mapped_memory_ranges( &self, device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result { (self.flush_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) } #[doc = ""] pub unsafe fn invalidate_mapped_memory_ranges( &self, device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result { (self.invalidate_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) } #[doc = ""] pub unsafe fn get_device_memory_commitment( &self, device: Device, memory: DeviceMemory, p_committed_memory_in_bytes: *mut DeviceSize, ) -> c_void { (self.get_device_memory_commitment)(device, memory, p_committed_memory_in_bytes) } #[doc = ""] pub unsafe fn bind_buffer_memory( &self, device: Device, buffer: Buffer, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result { (self.bind_buffer_memory)(device, buffer, memory, memory_offset) } #[doc = ""] pub unsafe fn bind_image_memory( &self, device: Device, image: Image, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result { (self.bind_image_memory)(device, image, memory, memory_offset) } #[doc = ""] pub unsafe fn get_buffer_memory_requirements( &self, device: Device, buffer: Buffer, p_memory_requirements: *mut MemoryRequirements, ) -> c_void { (self.get_buffer_memory_requirements)(device, buffer, p_memory_requirements) } #[doc = ""] pub unsafe fn get_image_memory_requirements( &self, device: Device, image: Image, p_memory_requirements: *mut MemoryRequirements, ) -> c_void { (self.get_image_memory_requirements)(device, image, p_memory_requirements) } #[doc = ""] pub unsafe fn get_image_sparse_memory_requirements( &self, device: Device, image: Image, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, ) -> c_void { (self.get_image_sparse_memory_requirements)( device, image, p_sparse_memory_requirement_count, p_sparse_memory_requirements, ) } #[doc = ""] pub unsafe fn queue_bind_sparse( &self, queue: Queue, bind_info_count: u32, p_bind_info: *const BindSparseInfo, fence: Fence, ) -> Result { (self.queue_bind_sparse)(queue, bind_info_count, p_bind_info, fence) } #[doc = ""] pub unsafe fn create_fence( &self, device: Device, p_create_info: *const FenceCreateInfo, p_allocator: *const AllocationCallbacks, p_fence: *mut Fence, ) -> Result { (self.create_fence)(device, p_create_info, p_allocator, p_fence) } #[doc = ""] pub unsafe fn destroy_fence( &self, device: Device, fence: Fence, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_fence)(device, fence, p_allocator) } #[doc = ""] pub unsafe fn reset_fences( &self, device: Device, fence_count: u32, p_fences: *const Fence, ) -> Result { (self.reset_fences)(device, fence_count, p_fences) } #[doc = ""] pub unsafe fn get_fence_status(&self, device: Device, fence: Fence) -> Result { (self.get_fence_status)(device, fence) } #[doc = ""] pub unsafe fn wait_for_fences( &self, device: Device, fence_count: u32, p_fences: *const Fence, wait_all: Bool32, timeout: u64, ) -> Result { (self.wait_for_fences)(device, fence_count, p_fences, wait_all, timeout) } #[doc = ""] pub unsafe fn create_semaphore( &self, device: Device, p_create_info: *const SemaphoreCreateInfo, p_allocator: *const AllocationCallbacks, p_semaphore: *mut Semaphore, ) -> Result { (self.create_semaphore)(device, p_create_info, p_allocator, p_semaphore) } #[doc = ""] pub unsafe fn destroy_semaphore( &self, device: Device, semaphore: Semaphore, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_semaphore)(device, semaphore, p_allocator) } #[doc = ""] pub unsafe fn create_event( &self, device: Device, p_create_info: *const EventCreateInfo, p_allocator: *const AllocationCallbacks, p_event: *mut Event, ) -> Result { (self.create_event)(device, p_create_info, p_allocator, p_event) } #[doc = ""] pub unsafe fn destroy_event( &self, device: Device, event: Event, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_event)(device, event, p_allocator) } #[doc = ""] pub unsafe fn get_event_status(&self, device: Device, event: Event) -> Result { (self.get_event_status)(device, event) } #[doc = ""] pub unsafe fn set_event(&self, device: Device, event: Event) -> Result { (self.set_event)(device, event) } #[doc = ""] pub unsafe fn reset_event(&self, device: Device, event: Event) -> Result { (self.reset_event)(device, event) } #[doc = ""] pub unsafe fn create_query_pool( &self, device: Device, p_create_info: *const QueryPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_query_pool: *mut QueryPool, ) -> Result { (self.create_query_pool)(device, p_create_info, p_allocator, p_query_pool) } #[doc = ""] pub unsafe fn destroy_query_pool( &self, device: Device, query_pool: QueryPool, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_query_pool)(device, query_pool, p_allocator) } #[doc = ""] pub unsafe fn get_query_pool_results( &self, device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, data_size: usize, p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, ) -> Result { (self.get_query_pool_results)( device, query_pool, first_query, query_count, data_size, p_data, stride, flags, ) } #[doc = ""] pub unsafe fn create_buffer( &self, device: Device, p_create_info: *const BufferCreateInfo, p_allocator: *const AllocationCallbacks, p_buffer: *mut Buffer, ) -> Result { (self.create_buffer)(device, p_create_info, p_allocator, p_buffer) } #[doc = ""] pub unsafe fn destroy_buffer( &self, device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_buffer)(device, buffer, p_allocator) } #[doc = ""] pub unsafe fn create_buffer_view( &self, device: Device, p_create_info: *const BufferViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut BufferView, ) -> Result { (self.create_buffer_view)(device, p_create_info, p_allocator, p_view) } #[doc = ""] pub unsafe fn destroy_buffer_view( &self, device: Device, buffer_view: BufferView, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_buffer_view)(device, buffer_view, p_allocator) } #[doc = ""] pub unsafe fn create_image( &self, device: Device, p_create_info: *const ImageCreateInfo, p_allocator: *const AllocationCallbacks, p_image: *mut Image, ) -> Result { (self.create_image)(device, p_create_info, p_allocator, p_image) } #[doc = ""] pub unsafe fn destroy_image( &self, device: Device, image: Image, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_image)(device, image, p_allocator) } #[doc = ""] pub unsafe fn get_image_subresource_layout( &self, device: Device, image: Image, p_subresource: *const ImageSubresource, p_layout: *mut SubresourceLayout, ) -> c_void { (self.get_image_subresource_layout)(device, image, p_subresource, p_layout) } #[doc = ""] pub unsafe fn create_image_view( &self, device: Device, p_create_info: *const ImageViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut ImageView, ) -> Result { (self.create_image_view)(device, p_create_info, p_allocator, p_view) } #[doc = ""] pub unsafe fn destroy_image_view( &self, device: Device, image_view: ImageView, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_image_view)(device, image_view, p_allocator) } #[doc = ""] pub unsafe fn create_shader_module( &self, device: Device, p_create_info: *const ShaderModuleCreateInfo, p_allocator: *const AllocationCallbacks, p_shader_module: *mut ShaderModule, ) -> Result { (self.create_shader_module)(device, p_create_info, p_allocator, p_shader_module) } #[doc = ""] pub unsafe fn destroy_shader_module( &self, device: Device, shader_module: ShaderModule, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_shader_module)(device, shader_module, p_allocator) } #[doc = ""] pub unsafe fn create_pipeline_cache( &self, device: Device, p_create_info: *const PipelineCacheCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_cache: *mut PipelineCache, ) -> Result { (self.create_pipeline_cache)(device, p_create_info, p_allocator, p_pipeline_cache) } #[doc = ""] pub unsafe fn destroy_pipeline_cache( &self, device: Device, pipeline_cache: PipelineCache, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_pipeline_cache)(device, pipeline_cache, p_allocator) } #[doc = ""] pub unsafe fn get_pipeline_cache_data( &self, device: Device, pipeline_cache: PipelineCache, p_data_size: *mut usize, p_data: *mut c_void, ) -> Result { (self.get_pipeline_cache_data)(device, pipeline_cache, p_data_size, p_data) } #[doc = ""] pub unsafe fn merge_pipeline_caches( &self, device: Device, dst_cache: PipelineCache, src_cache_count: u32, p_src_caches: *const PipelineCache, ) -> Result { (self.merge_pipeline_caches)(device, dst_cache, src_cache_count, p_src_caches) } #[doc = ""] pub unsafe fn create_graphics_pipelines( &self, device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result { (self.create_graphics_pipelines)( device, pipeline_cache, create_info_count, p_create_infos, p_allocator, p_pipelines, ) } #[doc = ""] pub unsafe fn create_compute_pipelines( &self, device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result { (self.create_compute_pipelines)( device, pipeline_cache, create_info_count, p_create_infos, p_allocator, p_pipelines, ) } #[doc = ""] pub unsafe fn destroy_pipeline( &self, device: Device, pipeline: Pipeline, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_pipeline)(device, pipeline, p_allocator) } #[doc = ""] pub unsafe fn create_pipeline_layout( &self, device: Device, p_create_info: *const PipelineLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_layout: *mut PipelineLayout, ) -> Result { (self.create_pipeline_layout)(device, p_create_info, p_allocator, p_pipeline_layout) } #[doc = ""] pub unsafe fn destroy_pipeline_layout( &self, device: Device, pipeline_layout: PipelineLayout, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_pipeline_layout)(device, pipeline_layout, p_allocator) } #[doc = ""] pub unsafe fn create_sampler( &self, device: Device, p_create_info: *const SamplerCreateInfo, p_allocator: *const AllocationCallbacks, p_sampler: *mut Sampler, ) -> Result { (self.create_sampler)(device, p_create_info, p_allocator, p_sampler) } #[doc = ""] pub unsafe fn destroy_sampler( &self, device: Device, sampler: Sampler, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_sampler)(device, sampler, p_allocator) } #[doc = ""] pub unsafe fn create_descriptor_set_layout( &self, device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_set_layout: *mut DescriptorSetLayout, ) -> Result { (self.create_descriptor_set_layout)(device, p_create_info, p_allocator, p_set_layout) } #[doc = ""] pub unsafe fn destroy_descriptor_set_layout( &self, device: Device, descriptor_set_layout: DescriptorSetLayout, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_descriptor_set_layout)(device, descriptor_set_layout, p_allocator) } #[doc = ""] pub unsafe fn create_descriptor_pool( &self, device: Device, p_create_info: *const DescriptorPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_pool: *mut DescriptorPool, ) -> Result { (self.create_descriptor_pool)(device, p_create_info, p_allocator, p_descriptor_pool) } #[doc = ""] pub unsafe fn destroy_descriptor_pool( &self, device: Device, descriptor_pool: DescriptorPool, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_descriptor_pool)(device, descriptor_pool, p_allocator) } #[doc = ""] pub unsafe fn reset_descriptor_pool( &self, device: Device, descriptor_pool: DescriptorPool, flags: DescriptorPoolResetFlags, ) -> Result { (self.reset_descriptor_pool)(device, descriptor_pool, flags) } #[doc = ""] pub unsafe fn allocate_descriptor_sets( &self, device: Device, p_allocate_info: *const DescriptorSetAllocateInfo, p_descriptor_sets: *mut DescriptorSet, ) -> Result { (self.allocate_descriptor_sets)(device, p_allocate_info, p_descriptor_sets) } #[doc = ""] pub unsafe fn free_descriptor_sets( &self, device: Device, descriptor_pool: DescriptorPool, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, ) -> Result { (self.free_descriptor_sets)( device, descriptor_pool, descriptor_set_count, p_descriptor_sets, ) } #[doc = ""] pub unsafe fn update_descriptor_sets( &self, device: Device, descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, descriptor_copy_count: u32, p_descriptor_copies: *const CopyDescriptorSet, ) -> c_void { (self.update_descriptor_sets)( device, descriptor_write_count, p_descriptor_writes, descriptor_copy_count, p_descriptor_copies, ) } #[doc = ""] pub unsafe fn create_framebuffer( &self, device: Device, p_create_info: *const FramebufferCreateInfo, p_allocator: *const AllocationCallbacks, p_framebuffer: *mut Framebuffer, ) -> Result { (self.create_framebuffer)(device, p_create_info, p_allocator, p_framebuffer) } #[doc = ""] pub unsafe fn destroy_framebuffer( &self, device: Device, framebuffer: Framebuffer, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_framebuffer)(device, framebuffer, p_allocator) } #[doc = ""] pub unsafe fn create_render_pass( &self, device: Device, p_create_info: *const RenderPassCreateInfo, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result { (self.create_render_pass)(device, p_create_info, p_allocator, p_render_pass) } #[doc = ""] pub unsafe fn destroy_render_pass( &self, device: Device, render_pass: RenderPass, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_render_pass)(device, render_pass, p_allocator) } #[doc = ""] pub unsafe fn get_render_area_granularity( &self, device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D, ) -> c_void { (self.get_render_area_granularity)(device, render_pass, p_granularity) } #[doc = ""] pub unsafe fn create_command_pool( &self, device: Device, p_create_info: *const CommandPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_command_pool: *mut CommandPool, ) -> Result { (self.create_command_pool)(device, p_create_info, p_allocator, p_command_pool) } #[doc = ""] pub unsafe fn destroy_command_pool( &self, device: Device, command_pool: CommandPool, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_command_pool)(device, command_pool, p_allocator) } #[doc = ""] pub unsafe fn reset_command_pool( &self, device: Device, command_pool: CommandPool, flags: CommandPoolResetFlags, ) -> Result { (self.reset_command_pool)(device, command_pool, flags) } #[doc = ""] pub unsafe fn allocate_command_buffers( &self, device: Device, p_allocate_info: *const CommandBufferAllocateInfo, p_command_buffers: *mut CommandBuffer, ) -> Result { (self.allocate_command_buffers)(device, p_allocate_info, p_command_buffers) } #[doc = ""] pub unsafe fn free_command_buffers( &self, device: Device, command_pool: CommandPool, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void { (self.free_command_buffers)( device, command_pool, command_buffer_count, p_command_buffers, ) } #[doc = ""] pub unsafe fn begin_command_buffer( &self, command_buffer: CommandBuffer, p_begin_info: *const CommandBufferBeginInfo, ) -> Result { (self.begin_command_buffer)(command_buffer, p_begin_info) } #[doc = ""] pub unsafe fn end_command_buffer(&self, command_buffer: CommandBuffer) -> Result { (self.end_command_buffer)(command_buffer) } #[doc = ""] pub unsafe fn reset_command_buffer( &self, command_buffer: CommandBuffer, flags: CommandBufferResetFlags, ) -> Result { (self.reset_command_buffer)(command_buffer, flags) } #[doc = ""] pub unsafe fn cmd_bind_pipeline( &self, command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, pipeline: Pipeline, ) -> c_void { (self.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline) } #[doc = ""] pub unsafe fn cmd_set_viewport( &self, command_buffer: CommandBuffer, first_viewport: u32, viewport_count: u32, p_viewports: *const Viewport, ) -> c_void { (self.cmd_set_viewport)(command_buffer, first_viewport, viewport_count, p_viewports) } #[doc = ""] pub unsafe fn cmd_set_scissor( &self, command_buffer: CommandBuffer, first_scissor: u32, scissor_count: u32, p_scissors: *const Rect2D, ) -> c_void { (self.cmd_set_scissor)(command_buffer, first_scissor, scissor_count, p_scissors) } #[doc = ""] pub unsafe fn cmd_set_line_width( &self, command_buffer: CommandBuffer, line_width: f32, ) -> c_void { (self.cmd_set_line_width)(command_buffer, line_width) } #[doc = ""] pub unsafe fn cmd_set_depth_bias( &self, command_buffer: CommandBuffer, depth_bias_constant_factor: f32, depth_bias_clamp: f32, depth_bias_slope_factor: f32, ) -> c_void { (self.cmd_set_depth_bias)( command_buffer, depth_bias_constant_factor, depth_bias_clamp, depth_bias_slope_factor, ) } #[doc = ""] pub unsafe fn cmd_set_blend_constants( &self, command_buffer: CommandBuffer, blend_constants: &[f32; 4], ) -> c_void { (self.cmd_set_blend_constants)(command_buffer, blend_constants) } #[doc = ""] pub unsafe fn cmd_set_depth_bounds( &self, command_buffer: CommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32, ) -> c_void { (self.cmd_set_depth_bounds)(command_buffer, min_depth_bounds, max_depth_bounds) } #[doc = ""] pub unsafe fn cmd_set_stencil_compare_mask( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, compare_mask: u32, ) -> c_void { (self.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask) } #[doc = ""] pub unsafe fn cmd_set_stencil_write_mask( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, write_mask: u32, ) -> c_void { (self.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask) } #[doc = ""] pub unsafe fn cmd_set_stencil_reference( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, reference: u32, ) -> c_void { (self.cmd_set_stencil_reference)(command_buffer, face_mask, reference) } #[doc = ""] pub unsafe fn cmd_bind_descriptor_sets( &self, command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, first_set: u32, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, dynamic_offset_count: u32, p_dynamic_offsets: *const u32, ) -> c_void { (self.cmd_bind_descriptor_sets)( command_buffer, pipeline_bind_point, layout, first_set, descriptor_set_count, p_descriptor_sets, dynamic_offset_count, p_dynamic_offsets, ) } #[doc = ""] pub unsafe fn cmd_bind_index_buffer( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, index_type: IndexType, ) -> c_void { (self.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type) } #[doc = ""] pub unsafe fn cmd_bind_vertex_buffers( &self, command_buffer: CommandBuffer, first_binding: u32, binding_count: u32, p_buffers: *const Buffer, p_offsets: *const DeviceSize, ) -> c_void { (self.cmd_bind_vertex_buffers)( command_buffer, first_binding, binding_count, p_buffers, p_offsets, ) } #[doc = ""] pub unsafe fn cmd_draw( &self, command_buffer: CommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32, ) -> c_void { (self.cmd_draw)( command_buffer, vertex_count, instance_count, first_vertex, first_instance, ) } #[doc = ""] pub unsafe fn cmd_draw_indexed( &self, command_buffer: CommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32, ) -> c_void { (self.cmd_draw_indexed)( command_buffer, index_count, instance_count, first_index, vertex_offset, first_instance, ) } #[doc = ""] pub unsafe fn cmd_draw_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, ) -> c_void { (self.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride) } #[doc = ""] pub unsafe fn cmd_draw_indexed_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, ) -> c_void { (self.cmd_draw_indexed_indirect)(command_buffer, buffer, offset, draw_count, stride) } #[doc = ""] pub unsafe fn cmd_dispatch( &self, command_buffer: CommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32, ) -> c_void { (self.cmd_dispatch)(command_buffer, group_count_x, group_count_y, group_count_z) } #[doc = ""] pub unsafe fn cmd_dispatch_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, ) -> c_void { (self.cmd_dispatch_indirect)(command_buffer, buffer, offset) } #[doc = ""] pub unsafe fn cmd_copy_buffer( &self, command_buffer: CommandBuffer, src_buffer: Buffer, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferCopy, ) -> c_void { (self.cmd_copy_buffer)( command_buffer, src_buffer, dst_buffer, region_count, p_regions, ) } #[doc = ""] pub unsafe fn cmd_copy_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageCopy, ) -> c_void { (self.cmd_copy_image)( command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, p_regions, ) } #[doc = ""] pub unsafe fn cmd_blit_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageBlit, filter: Filter, ) -> c_void { (self.cmd_blit_image)( command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, p_regions, filter, ) } #[doc = ""] pub unsafe fn cmd_copy_buffer_to_image( &self, command_buffer: CommandBuffer, src_buffer: Buffer, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void { (self.cmd_copy_buffer_to_image)( command_buffer, src_buffer, dst_image, dst_image_layout, region_count, p_regions, ) } #[doc = ""] pub unsafe fn cmd_copy_image_to_buffer( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferImageCopy, ) -> c_void { (self.cmd_copy_image_to_buffer)( command_buffer, src_image, src_image_layout, dst_buffer, region_count, p_regions, ) } #[doc = ""] pub unsafe fn cmd_update_buffer( &self, command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, data_size: DeviceSize, p_data: *const c_void, ) -> c_void { (self.cmd_update_buffer)(command_buffer, dst_buffer, dst_offset, data_size, p_data) } #[doc = ""] pub unsafe fn cmd_fill_buffer( &self, command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, size: DeviceSize, data: u32, ) -> c_void { (self.cmd_fill_buffer)(command_buffer, dst_buffer, dst_offset, size, data) } #[doc = ""] pub unsafe fn cmd_clear_color_image( &self, command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_color: *const ClearColorValue, range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void { (self.cmd_clear_color_image)( command_buffer, image, image_layout, p_color, range_count, p_ranges, ) } #[doc = ""] pub unsafe fn cmd_clear_depth_stencil_image( &self, command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, range_count: u32, p_ranges: *const ImageSubresourceRange, ) -> c_void { (self.cmd_clear_depth_stencil_image)( command_buffer, image, image_layout, p_depth_stencil, range_count, p_ranges, ) } #[doc = ""] pub unsafe fn cmd_clear_attachments( &self, command_buffer: CommandBuffer, attachment_count: u32, p_attachments: *const ClearAttachment, rect_count: u32, p_rects: *const ClearRect, ) -> c_void { (self.cmd_clear_attachments)( command_buffer, attachment_count, p_attachments, rect_count, p_rects, ) } #[doc = ""] pub unsafe fn cmd_resolve_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageResolve, ) -> c_void { (self.cmd_resolve_image)( command_buffer, src_image, src_image_layout, dst_image, dst_image_layout, region_count, p_regions, ) } #[doc = ""] pub unsafe fn cmd_set_event( &self, command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, ) -> c_void { (self.cmd_set_event)(command_buffer, event, stage_mask) } #[doc = ""] pub unsafe fn cmd_reset_event( &self, command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, ) -> c_void { (self.cmd_reset_event)(command_buffer, event, stage_mask) } #[doc = ""] pub unsafe fn cmd_wait_events( &self, command_buffer: CommandBuffer, event_count: u32, p_events: *const Event, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { (self.cmd_wait_events)( command_buffer, event_count, p_events, src_stage_mask, dst_stage_mask, memory_barrier_count, p_memory_barriers, buffer_memory_barrier_count, p_buffer_memory_barriers, image_memory_barrier_count, p_image_memory_barriers, ) } #[doc = ""] pub unsafe fn cmd_pipeline_barrier( &self, command_buffer: CommandBuffer, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, dependency_flags: DependencyFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, ) -> c_void { (self.cmd_pipeline_barrier)( command_buffer, src_stage_mask, dst_stage_mask, dependency_flags, memory_barrier_count, p_memory_barriers, buffer_memory_barrier_count, p_buffer_memory_barriers, image_memory_barrier_count, p_image_memory_barriers, ) } #[doc = ""] pub unsafe fn cmd_begin_query( &self, command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, flags: QueryControlFlags, ) -> c_void { (self.cmd_begin_query)(command_buffer, query_pool, query, flags) } #[doc = ""] pub unsafe fn cmd_end_query( &self, command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, ) -> c_void { (self.cmd_end_query)(command_buffer, query_pool, query) } #[doc = ""] pub unsafe fn cmd_reset_query_pool( &self, command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, ) -> c_void { (self.cmd_reset_query_pool)(command_buffer, query_pool, first_query, query_count) } #[doc = ""] pub unsafe fn cmd_write_timestamp( &self, command_buffer: CommandBuffer, pipeline_stage: PipelineStageFlags, query_pool: QueryPool, query: u32, ) -> c_void { (self.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query) } #[doc = ""] pub unsafe fn cmd_copy_query_pool_results( &self, command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, dst_buffer: Buffer, dst_offset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags, ) -> c_void { (self.cmd_copy_query_pool_results)( command_buffer, query_pool, first_query, query_count, dst_buffer, dst_offset, stride, flags, ) } #[doc = ""] pub unsafe fn cmd_push_constants( &self, command_buffer: CommandBuffer, layout: PipelineLayout, stage_flags: ShaderStageFlags, offset: u32, size: u32, p_values: *const c_void, ) -> c_void { (self.cmd_push_constants)(command_buffer, layout, stage_flags, offset, size, p_values) } #[doc = ""] pub unsafe fn cmd_begin_render_pass( &self, command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, contents: SubpassContents, ) -> c_void { (self.cmd_begin_render_pass)(command_buffer, p_render_pass_begin, contents) } #[doc = ""] pub unsafe fn cmd_next_subpass( &self, command_buffer: CommandBuffer, contents: SubpassContents, ) -> c_void { (self.cmd_next_subpass)(command_buffer, contents) } #[doc = ""] pub unsafe fn cmd_end_render_pass(&self, command_buffer: CommandBuffer) -> c_void { (self.cmd_end_render_pass)(command_buffer) } #[doc = ""] pub unsafe fn cmd_execute_commands( &self, command_buffer: CommandBuffer, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, ) -> c_void { (self.cmd_execute_commands)(command_buffer, command_buffer_count, p_command_buffers) } } #[allow(non_camel_case_types)] pub type PFN_vkEnumerateInstanceVersion = extern "system" fn(p_api_version: *mut u32) -> Result; pub struct EntryFnV1_1 { pub enumerate_instance_version: extern "system" fn(p_api_version: *mut u32) -> Result, } unsafe impl Send for EntryFnV1_1 {} unsafe impl Sync for EntryFnV1_1 {} impl ::std::clone::Clone for EntryFnV1_1 { fn clone(&self) -> Self { EntryFnV1_1 { enumerate_instance_version: self.enumerate_instance_version, } } } impl EntryFnV1_1 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { EntryFnV1_1 { enumerate_instance_version: unsafe { extern "system" fn enumerate_instance_version(_p_api_version: *mut u32) -> Result { panic!(concat!( "Unable to load ", stringify!(enumerate_instance_version) )) } let raw_name = stringify!(vkEnumerateInstanceVersion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { enumerate_instance_version } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut u32) -> Result { (self.enumerate_instance_version)(p_api_version) } } pub struct InstanceFnV1_1 { pub enumerate_physical_device_groups: extern "system" fn( instance: Instance, p_physical_device_group_count: *mut u32, p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result, pub get_physical_device_features2: extern "system" fn( physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures2, ) -> c_void, pub get_physical_device_properties2: extern "system" fn( physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties2, ) -> c_void, pub get_physical_device_format_properties2: extern "system" fn( physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties2, ) -> c_void, pub get_physical_device_image_format_properties2: extern "system" fn( physical_device: PhysicalDevice, p_image_format_info: *const PhysicalDeviceImageFormatInfo2, p_image_format_properties: *mut ImageFormatProperties2, ) -> Result, pub get_physical_device_queue_family_properties2: extern "system" fn( physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties2, ) -> c_void, pub get_physical_device_memory_properties2: extern "system" fn( physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties2, ) -> c_void, pub get_physical_device_sparse_image_format_properties2: extern "system" fn( physical_device: PhysicalDevice, p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties2, ) -> c_void, pub get_physical_device_external_buffer_properties: extern "system" fn( physical_device: PhysicalDevice, p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, p_external_buffer_properties: *mut ExternalBufferProperties, ) -> c_void, pub get_physical_device_external_fence_properties: extern "system" fn( physical_device: PhysicalDevice, p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, p_external_fence_properties: *mut ExternalFenceProperties, ) -> c_void, pub get_physical_device_external_semaphore_properties: extern "system" fn( physical_device: PhysicalDevice, p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, p_external_semaphore_properties: *mut ExternalSemaphoreProperties, ) -> c_void, } unsafe impl Send for InstanceFnV1_1 {} unsafe impl Sync for InstanceFnV1_1 {} impl ::std::clone::Clone for InstanceFnV1_1 { fn clone(&self) -> Self { InstanceFnV1_1 { enumerate_physical_device_groups: self.enumerate_physical_device_groups, get_physical_device_features2: self.get_physical_device_features2, get_physical_device_properties2: self.get_physical_device_properties2, get_physical_device_format_properties2: self.get_physical_device_format_properties2, get_physical_device_image_format_properties2: self .get_physical_device_image_format_properties2, get_physical_device_queue_family_properties2: self .get_physical_device_queue_family_properties2, get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, get_physical_device_sparse_image_format_properties2: self .get_physical_device_sparse_image_format_properties2, get_physical_device_external_buffer_properties: self .get_physical_device_external_buffer_properties, get_physical_device_external_fence_properties: self .get_physical_device_external_fence_properties, get_physical_device_external_semaphore_properties: self .get_physical_device_external_semaphore_properties, } } } impl InstanceFnV1_1 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { InstanceFnV1_1 { enumerate_physical_device_groups: unsafe { extern "system" fn enumerate_physical_device_groups( _instance: Instance, _p_physical_device_group_count: *mut u32, _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result { panic!(concat!( "Unable to load ", stringify!(enumerate_physical_device_groups) )) } let raw_name = stringify!(vkEnumeratePhysicalDeviceGroups); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { enumerate_physical_device_groups } else { ::std::mem::transmute(val) } }, get_physical_device_features2: unsafe { extern "system" fn get_physical_device_features2( _physical_device: PhysicalDevice, _p_features: *mut PhysicalDeviceFeatures2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_features2) )) } let raw_name = stringify!(vkGetPhysicalDeviceFeatures2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_features2 } else { ::std::mem::transmute(val) } }, get_physical_device_properties2: unsafe { extern "system" fn get_physical_device_properties2( _physical_device: PhysicalDevice, _p_properties: *mut PhysicalDeviceProperties2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_properties2) )) } let raw_name = stringify!(vkGetPhysicalDeviceProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_properties2 } else { ::std::mem::transmute(val) } }, get_physical_device_format_properties2: unsafe { extern "system" fn get_physical_device_format_properties2( _physical_device: PhysicalDevice, _format: Format, _p_format_properties: *mut FormatProperties2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_format_properties2) )) } let raw_name = stringify!(vkGetPhysicalDeviceFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_format_properties2 } else { ::std::mem::transmute(val) } }, get_physical_device_image_format_properties2: unsafe { extern "system" fn get_physical_device_image_format_properties2( _physical_device: PhysicalDevice, _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, _p_image_format_properties: *mut ImageFormatProperties2, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_physical_device_image_format_properties2) )) } let raw_name = stringify!(vkGetPhysicalDeviceImageFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_image_format_properties2 } else { ::std::mem::transmute(val) } }, get_physical_device_queue_family_properties2: unsafe { extern "system" fn get_physical_device_queue_family_properties2( _physical_device: PhysicalDevice, _p_queue_family_property_count: *mut u32, _p_queue_family_properties: *mut QueueFamilyProperties2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_queue_family_properties2) )) } let raw_name = stringify!(vkGetPhysicalDeviceQueueFamilyProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_queue_family_properties2 } else { ::std::mem::transmute(val) } }, get_physical_device_memory_properties2: unsafe { extern "system" fn get_physical_device_memory_properties2( _physical_device: PhysicalDevice, _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_memory_properties2) )) } let raw_name = stringify!(vkGetPhysicalDeviceMemoryProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_memory_properties2 } else { ::std::mem::transmute(val) } }, get_physical_device_sparse_image_format_properties2: unsafe { extern "system" fn get_physical_device_sparse_image_format_properties2( _physical_device: PhysicalDevice, _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, _p_property_count: *mut u32, _p_properties: *mut SparseImageFormatProperties2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_sparse_image_format_properties2) )) } let raw_name = stringify!(vkGetPhysicalDeviceSparseImageFormatProperties2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_sparse_image_format_properties2 } else { ::std::mem::transmute(val) } }, get_physical_device_external_buffer_properties: unsafe { extern "system" fn get_physical_device_external_buffer_properties( _physical_device: PhysicalDevice, _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, _p_external_buffer_properties: *mut ExternalBufferProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_external_buffer_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceExternalBufferProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_external_buffer_properties } else { ::std::mem::transmute(val) } }, get_physical_device_external_fence_properties: unsafe { extern "system" fn get_physical_device_external_fence_properties( _physical_device: PhysicalDevice, _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, _p_external_fence_properties: *mut ExternalFenceProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_external_fence_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceExternalFenceProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_external_fence_properties } else { ::std::mem::transmute(val) } }, get_physical_device_external_semaphore_properties: unsafe { extern "system" fn get_physical_device_external_semaphore_properties( _physical_device: PhysicalDevice, _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_physical_device_external_semaphore_properties) )) } let raw_name = stringify!(vkGetPhysicalDeviceExternalSemaphoreProperties); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_physical_device_external_semaphore_properties } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn enumerate_physical_device_groups( &self, instance: Instance, p_physical_device_group_count: *mut u32, p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result { (self.enumerate_physical_device_groups)( instance, p_physical_device_group_count, p_physical_device_group_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_features2( &self, physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures2, ) -> c_void { (self.get_physical_device_features2)(physical_device, p_features) } #[doc = ""] pub unsafe fn get_physical_device_properties2( &self, physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties2, ) -> c_void { (self.get_physical_device_properties2)(physical_device, p_properties) } #[doc = ""] pub unsafe fn get_physical_device_format_properties2( &self, physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties2, ) -> c_void { (self.get_physical_device_format_properties2)(physical_device, format, p_format_properties) } #[doc = ""] pub unsafe fn get_physical_device_image_format_properties2( &self, physical_device: PhysicalDevice, p_image_format_info: *const PhysicalDeviceImageFormatInfo2, p_image_format_properties: *mut ImageFormatProperties2, ) -> Result { (self.get_physical_device_image_format_properties2)( physical_device, p_image_format_info, p_image_format_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_queue_family_properties2( &self, physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties2, ) -> c_void { (self.get_physical_device_queue_family_properties2)( physical_device, p_queue_family_property_count, p_queue_family_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_memory_properties2( &self, physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties2, ) -> c_void { (self.get_physical_device_memory_properties2)(physical_device, p_memory_properties) } #[doc = ""] pub unsafe fn get_physical_device_sparse_image_format_properties2( &self, physical_device: PhysicalDevice, p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties2, ) -> c_void { (self.get_physical_device_sparse_image_format_properties2)( physical_device, p_format_info, p_property_count, p_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_external_buffer_properties( &self, physical_device: PhysicalDevice, p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, p_external_buffer_properties: *mut ExternalBufferProperties, ) -> c_void { (self.get_physical_device_external_buffer_properties)( physical_device, p_external_buffer_info, p_external_buffer_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_external_fence_properties( &self, physical_device: PhysicalDevice, p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, p_external_fence_properties: *mut ExternalFenceProperties, ) -> c_void { (self.get_physical_device_external_fence_properties)( physical_device, p_external_fence_info, p_external_fence_properties, ) } #[doc = ""] pub unsafe fn get_physical_device_external_semaphore_properties( &self, physical_device: PhysicalDevice, p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, p_external_semaphore_properties: *mut ExternalSemaphoreProperties, ) -> c_void { (self.get_physical_device_external_semaphore_properties)( physical_device, p_external_semaphore_info, p_external_semaphore_properties, ) } } #[allow(non_camel_case_types)] pub type PFN_vkGetDeviceQueue2 = extern "system" fn( device: Device, bind_info_count: u32, p_bind_infos: *const BindBufferMemoryInfo, ) -> Result; pub struct DeviceFnV1_1 { pub bind_buffer_memory2: extern "system" fn( device: Device, bind_info_count: u32, p_bind_infos: *const BindBufferMemoryInfo, ) -> Result, pub bind_image_memory2: extern "system" fn( device: Device, bind_info_count: u32, p_bind_infos: *const BindImageMemoryInfo, ) -> Result, pub get_device_group_peer_memory_features: extern "system" fn( device: Device, heap_index: u32, local_device_index: u32, remote_device_index: u32, p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void, pub cmd_set_device_mask: extern "system" fn(command_buffer: CommandBuffer, device_mask: u32) -> c_void, pub cmd_dispatch_base: extern "system" fn( command_buffer: CommandBuffer, base_group_x: u32, base_group_y: u32, base_group_z: u32, group_count_x: u32, group_count_y: u32, group_count_z: u32, ) -> c_void, pub get_image_memory_requirements2: extern "system" fn( device: Device, p_info: *const ImageMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, ) -> c_void, pub get_buffer_memory_requirements2: extern "system" fn( device: Device, p_info: *const BufferMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, ) -> c_void, pub get_image_sparse_memory_requirements2: extern "system" fn( device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void, pub trim_command_pool: extern "system" fn( device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags, ) -> c_void, pub get_device_queue2: extern "system" fn( device: Device, p_queue_info: *const DeviceQueueInfo2, p_queue: *mut Queue, ) -> c_void, pub create_sampler_ycbcr_conversion: extern "system" fn( device: Device, p_create_info: *const SamplerYcbcrConversionCreateInfo, p_allocator: *const AllocationCallbacks, p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result, pub destroy_sampler_ycbcr_conversion: extern "system" fn( device: Device, ycbcr_conversion: SamplerYcbcrConversion, p_allocator: *const AllocationCallbacks, ) -> c_void, pub create_descriptor_update_template: extern "system" fn( device: Device, p_create_info: *const DescriptorUpdateTemplateCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result, pub destroy_descriptor_update_template: extern "system" fn( device: Device, descriptor_update_template: DescriptorUpdateTemplate, p_allocator: *const AllocationCallbacks, ) -> c_void, pub update_descriptor_set_with_template: extern "system" fn( device: Device, descriptor_set: DescriptorSet, descriptor_update_template: DescriptorUpdateTemplate, p_data: *const c_void, ) -> c_void, pub get_descriptor_set_layout_support: extern "system" fn( device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_support: *mut DescriptorSetLayoutSupport, ) -> c_void, } unsafe impl Send for DeviceFnV1_1 {} unsafe impl Sync for DeviceFnV1_1 {} impl ::std::clone::Clone for DeviceFnV1_1 { fn clone(&self) -> Self { DeviceFnV1_1 { bind_buffer_memory2: self.bind_buffer_memory2, bind_image_memory2: self.bind_image_memory2, get_device_group_peer_memory_features: self.get_device_group_peer_memory_features, cmd_set_device_mask: self.cmd_set_device_mask, cmd_dispatch_base: self.cmd_dispatch_base, get_image_memory_requirements2: self.get_image_memory_requirements2, get_buffer_memory_requirements2: self.get_buffer_memory_requirements2, get_image_sparse_memory_requirements2: self.get_image_sparse_memory_requirements2, trim_command_pool: self.trim_command_pool, get_device_queue2: self.get_device_queue2, create_sampler_ycbcr_conversion: self.create_sampler_ycbcr_conversion, destroy_sampler_ycbcr_conversion: self.destroy_sampler_ycbcr_conversion, create_descriptor_update_template: self.create_descriptor_update_template, destroy_descriptor_update_template: self.destroy_descriptor_update_template, update_descriptor_set_with_template: self.update_descriptor_set_with_template, get_descriptor_set_layout_support: self.get_descriptor_set_layout_support, } } } impl DeviceFnV1_1 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { DeviceFnV1_1 { bind_buffer_memory2: unsafe { extern "system" fn bind_buffer_memory2( _device: Device, _bind_info_count: u32, _p_bind_infos: *const BindBufferMemoryInfo, ) -> Result { panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2))) } let raw_name = stringify!(vkBindBufferMemory2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { bind_buffer_memory2 } else { ::std::mem::transmute(val) } }, bind_image_memory2: unsafe { extern "system" fn bind_image_memory2( _device: Device, _bind_info_count: u32, _p_bind_infos: *const BindImageMemoryInfo, ) -> Result { panic!(concat!("Unable to load ", stringify!(bind_image_memory2))) } let raw_name = stringify!(vkBindImageMemory2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { bind_image_memory2 } else { ::std::mem::transmute(val) } }, get_device_group_peer_memory_features: unsafe { extern "system" fn get_device_group_peer_memory_features( _device: Device, _heap_index: u32, _local_device_index: u32, _remote_device_index: u32, _p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_device_group_peer_memory_features) )) } let raw_name = stringify!(vkGetDeviceGroupPeerMemoryFeatures); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_device_group_peer_memory_features } else { ::std::mem::transmute(val) } }, cmd_set_device_mask: unsafe { extern "system" fn cmd_set_device_mask( _command_buffer: CommandBuffer, _device_mask: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask))) } let raw_name = stringify!(vkCmdSetDeviceMask); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_set_device_mask } else { ::std::mem::transmute(val) } }, cmd_dispatch_base: unsafe { extern "system" fn cmd_dispatch_base( _command_buffer: CommandBuffer, _base_group_x: u32, _base_group_y: u32, _base_group_z: u32, _group_count_x: u32, _group_count_y: u32, _group_count_z: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base))) } let raw_name = stringify!(vkCmdDispatchBase); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_dispatch_base } else { ::std::mem::transmute(val) } }, get_image_memory_requirements2: unsafe { extern "system" fn get_image_memory_requirements2( _device: Device, _p_info: *const ImageMemoryRequirementsInfo2, _p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_image_memory_requirements2) )) } let raw_name = stringify!(vkGetImageMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_image_memory_requirements2 } else { ::std::mem::transmute(val) } }, get_buffer_memory_requirements2: unsafe { extern "system" fn get_buffer_memory_requirements2( _device: Device, _p_info: *const BufferMemoryRequirementsInfo2, _p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_buffer_memory_requirements2) )) } let raw_name = stringify!(vkGetBufferMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_buffer_memory_requirements2 } else { ::std::mem::transmute(val) } }, get_image_sparse_memory_requirements2: unsafe { extern "system" fn get_image_sparse_memory_requirements2( _device: Device, _p_info: *const ImageSparseMemoryRequirementsInfo2, _p_sparse_memory_requirement_count: *mut u32, _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_image_sparse_memory_requirements2) )) } let raw_name = stringify!(vkGetImageSparseMemoryRequirements2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_image_sparse_memory_requirements2 } else { ::std::mem::transmute(val) } }, trim_command_pool: unsafe { extern "system" fn trim_command_pool( _device: Device, _command_pool: CommandPool, _flags: CommandPoolTrimFlags, ) -> c_void { panic!(concat!("Unable to load ", stringify!(trim_command_pool))) } let raw_name = stringify!(vkTrimCommandPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { trim_command_pool } else { ::std::mem::transmute(val) } }, get_device_queue2: unsafe { extern "system" fn get_device_queue2( _device: Device, _p_queue_info: *const DeviceQueueInfo2, _p_queue: *mut Queue, ) -> c_void { panic!(concat!("Unable to load ", stringify!(get_device_queue2))) } let raw_name = stringify!(vkGetDeviceQueue2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_device_queue2 } else { ::std::mem::transmute(val) } }, create_sampler_ycbcr_conversion: unsafe { extern "system" fn create_sampler_ycbcr_conversion( _device: Device, _p_create_info: *const SamplerYcbcrConversionCreateInfo, _p_allocator: *const AllocationCallbacks, _p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_sampler_ycbcr_conversion) )) } let raw_name = stringify!(vkCreateSamplerYcbcrConversion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_sampler_ycbcr_conversion } else { ::std::mem::transmute(val) } }, destroy_sampler_ycbcr_conversion: unsafe { extern "system" fn destroy_sampler_ycbcr_conversion( _device: Device, _ycbcr_conversion: SamplerYcbcrConversion, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(destroy_sampler_ycbcr_conversion) )) } let raw_name = stringify!(vkDestroySamplerYcbcrConversion); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_sampler_ycbcr_conversion } else { ::std::mem::transmute(val) } }, create_descriptor_update_template: unsafe { extern "system" fn create_descriptor_update_template( _device: Device, _p_create_info: *const DescriptorUpdateTemplateCreateInfo, _p_allocator: *const AllocationCallbacks, _p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result { panic!(concat!( "Unable to load ", stringify!(create_descriptor_update_template) )) } let raw_name = stringify!(vkCreateDescriptorUpdateTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_descriptor_update_template } else { ::std::mem::transmute(val) } }, destroy_descriptor_update_template: unsafe { extern "system" fn destroy_descriptor_update_template( _device: Device, _descriptor_update_template: DescriptorUpdateTemplate, _p_allocator: *const AllocationCallbacks, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(destroy_descriptor_update_template) )) } let raw_name = stringify!(vkDestroyDescriptorUpdateTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { destroy_descriptor_update_template } else { ::std::mem::transmute(val) } }, update_descriptor_set_with_template: unsafe { extern "system" fn update_descriptor_set_with_template( _device: Device, _descriptor_set: DescriptorSet, _descriptor_update_template: DescriptorUpdateTemplate, _p_data: *const c_void, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(update_descriptor_set_with_template) )) } let raw_name = stringify!(vkUpdateDescriptorSetWithTemplate); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { update_descriptor_set_with_template } else { ::std::mem::transmute(val) } }, get_descriptor_set_layout_support: unsafe { extern "system" fn get_descriptor_set_layout_support( _device: Device, _p_create_info: *const DescriptorSetLayoutCreateInfo, _p_support: *mut DescriptorSetLayoutSupport, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(get_descriptor_set_layout_support) )) } let raw_name = stringify!(vkGetDescriptorSetLayoutSupport); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_descriptor_set_layout_support } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn bind_buffer_memory2( &self, device: Device, bind_info_count: u32, p_bind_infos: *const BindBufferMemoryInfo, ) -> Result { (self.bind_buffer_memory2)(device, bind_info_count, p_bind_infos) } #[doc = ""] pub unsafe fn bind_image_memory2( &self, device: Device, bind_info_count: u32, p_bind_infos: *const BindImageMemoryInfo, ) -> Result { (self.bind_image_memory2)(device, bind_info_count, p_bind_infos) } #[doc = ""] pub unsafe fn get_device_group_peer_memory_features( &self, device: Device, heap_index: u32, local_device_index: u32, remote_device_index: u32, p_peer_memory_features: *mut PeerMemoryFeatureFlags, ) -> c_void { (self.get_device_group_peer_memory_features)( device, heap_index, local_device_index, remote_device_index, p_peer_memory_features, ) } #[doc = ""] pub unsafe fn cmd_set_device_mask( &self, command_buffer: CommandBuffer, device_mask: u32, ) -> c_void { (self.cmd_set_device_mask)(command_buffer, device_mask) } #[doc = ""] pub unsafe fn cmd_dispatch_base( &self, command_buffer: CommandBuffer, base_group_x: u32, base_group_y: u32, base_group_z: u32, group_count_x: u32, group_count_y: u32, group_count_z: u32, ) -> c_void { (self.cmd_dispatch_base)( command_buffer, base_group_x, base_group_y, base_group_z, group_count_x, group_count_y, group_count_z, ) } #[doc = ""] pub unsafe fn get_image_memory_requirements2( &self, device: Device, p_info: *const ImageMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { (self.get_image_memory_requirements2)(device, p_info, p_memory_requirements) } #[doc = ""] pub unsafe fn get_buffer_memory_requirements2( &self, device: Device, p_info: *const BufferMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, ) -> c_void { (self.get_buffer_memory_requirements2)(device, p_info, p_memory_requirements) } #[doc = ""] pub unsafe fn get_image_sparse_memory_requirements2( &self, device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, ) -> c_void { (self.get_image_sparse_memory_requirements2)( device, p_info, p_sparse_memory_requirement_count, p_sparse_memory_requirements, ) } #[doc = ""] pub unsafe fn trim_command_pool( &self, device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags, ) -> c_void { (self.trim_command_pool)(device, command_pool, flags) } #[doc = ""] pub unsafe fn get_device_queue2( &self, device: Device, p_queue_info: *const DeviceQueueInfo2, p_queue: *mut Queue, ) -> c_void { (self.get_device_queue2)(device, p_queue_info, p_queue) } #[doc = ""] pub unsafe fn create_sampler_ycbcr_conversion( &self, device: Device, p_create_info: *const SamplerYcbcrConversionCreateInfo, p_allocator: *const AllocationCallbacks, p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result { (self.create_sampler_ycbcr_conversion)( device, p_create_info, p_allocator, p_ycbcr_conversion, ) } #[doc = ""] pub unsafe fn destroy_sampler_ycbcr_conversion( &self, device: Device, ycbcr_conversion: SamplerYcbcrConversion, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_sampler_ycbcr_conversion)(device, ycbcr_conversion, p_allocator) } #[doc = ""] pub unsafe fn create_descriptor_update_template( &self, device: Device, p_create_info: *const DescriptorUpdateTemplateCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result { (self.create_descriptor_update_template)( device, p_create_info, p_allocator, p_descriptor_update_template, ) } #[doc = ""] pub unsafe fn destroy_descriptor_update_template( &self, device: Device, descriptor_update_template: DescriptorUpdateTemplate, p_allocator: *const AllocationCallbacks, ) -> c_void { (self.destroy_descriptor_update_template)(device, descriptor_update_template, p_allocator) } #[doc = ""] pub unsafe fn update_descriptor_set_with_template( &self, device: Device, descriptor_set: DescriptorSet, descriptor_update_template: DescriptorUpdateTemplate, p_data: *const c_void, ) -> c_void { (self.update_descriptor_set_with_template)( device, descriptor_set, descriptor_update_template, p_data, ) } #[doc = ""] pub unsafe fn get_descriptor_set_layout_support( &self, device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_support: *mut DescriptorSetLayoutSupport, ) -> c_void { (self.get_descriptor_set_layout_support)(device, p_create_info, p_support) } } pub struct EntryFnV1_2 {} unsafe impl Send for EntryFnV1_2 {} unsafe impl Sync for EntryFnV1_2 {} impl ::std::clone::Clone for EntryFnV1_2 { fn clone(&self) -> Self { EntryFnV1_2 {} } } impl EntryFnV1_2 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { EntryFnV1_2 {} } } pub struct InstanceFnV1_2 {} unsafe impl Send for InstanceFnV1_2 {} unsafe impl Sync for InstanceFnV1_2 {} impl ::std::clone::Clone for InstanceFnV1_2 { fn clone(&self) -> Self { InstanceFnV1_2 {} } } impl InstanceFnV1_2 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { InstanceFnV1_2 {} } } pub struct DeviceFnV1_2 { pub cmd_draw_indirect_count: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, ) -> c_void, pub cmd_draw_indexed_indirect_count: extern "system" fn( command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, ) -> c_void, pub create_render_pass2: extern "system" fn( device: Device, p_create_info: *const RenderPassCreateInfo2, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result, pub cmd_begin_render_pass2: extern "system" fn( command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, p_subpass_begin_info: *const SubpassBeginInfo, ) -> c_void, pub cmd_next_subpass2: extern "system" fn( command_buffer: CommandBuffer, p_subpass_begin_info: *const SubpassBeginInfo, p_subpass_end_info: *const SubpassEndInfo, ) -> c_void, pub cmd_end_render_pass2: extern "system" fn( command_buffer: CommandBuffer, p_subpass_end_info: *const SubpassEndInfo, ) -> c_void, pub reset_query_pool: extern "system" fn( device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, ) -> c_void, pub get_semaphore_counter_value: extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result, pub wait_semaphores: extern "system" fn( device: Device, p_wait_info: *const SemaphoreWaitInfo, timeout: u64, ) -> Result, pub signal_semaphore: extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result, pub get_buffer_device_address: extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress, pub get_buffer_opaque_capture_address: extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64, pub get_device_memory_opaque_capture_address: extern "system" fn( device: Device, p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, ) -> u64, } unsafe impl Send for DeviceFnV1_2 {} unsafe impl Sync for DeviceFnV1_2 {} impl ::std::clone::Clone for DeviceFnV1_2 { fn clone(&self) -> Self { DeviceFnV1_2 { cmd_draw_indirect_count: self.cmd_draw_indirect_count, cmd_draw_indexed_indirect_count: self.cmd_draw_indexed_indirect_count, create_render_pass2: self.create_render_pass2, cmd_begin_render_pass2: self.cmd_begin_render_pass2, cmd_next_subpass2: self.cmd_next_subpass2, cmd_end_render_pass2: self.cmd_end_render_pass2, reset_query_pool: self.reset_query_pool, get_semaphore_counter_value: self.get_semaphore_counter_value, wait_semaphores: self.wait_semaphores, signal_semaphore: self.signal_semaphore, get_buffer_device_address: self.get_buffer_device_address, get_buffer_opaque_capture_address: self.get_buffer_opaque_capture_address, get_device_memory_opaque_capture_address: self.get_device_memory_opaque_capture_address, } } } impl DeviceFnV1_2 { pub fn load(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void, { DeviceFnV1_2 { cmd_draw_indirect_count: unsafe { extern "system" fn cmd_draw_indirect_count( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, _count_buffer: Buffer, _count_buffer_offset: DeviceSize, _max_draw_count: u32, _stride: u32, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_draw_indirect_count) )) } let raw_name = stringify!(vkCmdDrawIndirectCount); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_draw_indirect_count } else { ::std::mem::transmute(val) } }, cmd_draw_indexed_indirect_count: unsafe { extern "system" fn cmd_draw_indexed_indirect_count( _command_buffer: CommandBuffer, _buffer: Buffer, _offset: DeviceSize, _count_buffer: Buffer, _count_buffer_offset: DeviceSize, _max_draw_count: u32, _stride: u32, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_draw_indexed_indirect_count) )) } let raw_name = stringify!(vkCmdDrawIndexedIndirectCount); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_draw_indexed_indirect_count } else { ::std::mem::transmute(val) } }, create_render_pass2: unsafe { extern "system" fn create_render_pass2( _device: Device, _p_create_info: *const RenderPassCreateInfo2, _p_allocator: *const AllocationCallbacks, _p_render_pass: *mut RenderPass, ) -> Result { panic!(concat!("Unable to load ", stringify!(create_render_pass2))) } let raw_name = stringify!(vkCreateRenderPass2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { create_render_pass2 } else { ::std::mem::transmute(val) } }, cmd_begin_render_pass2: unsafe { extern "system" fn cmd_begin_render_pass2( _command_buffer: CommandBuffer, _p_render_pass_begin: *const RenderPassBeginInfo, _p_subpass_begin_info: *const SubpassBeginInfo, ) -> c_void { panic!(concat!( "Unable to load ", stringify!(cmd_begin_render_pass2) )) } let raw_name = stringify!(vkCmdBeginRenderPass2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_begin_render_pass2 } else { ::std::mem::transmute(val) } }, cmd_next_subpass2: unsafe { extern "system" fn cmd_next_subpass2( _command_buffer: CommandBuffer, _p_subpass_begin_info: *const SubpassBeginInfo, _p_subpass_end_info: *const SubpassEndInfo, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_next_subpass2))) } let raw_name = stringify!(vkCmdNextSubpass2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_next_subpass2 } else { ::std::mem::transmute(val) } }, cmd_end_render_pass2: unsafe { extern "system" fn cmd_end_render_pass2( _command_buffer: CommandBuffer, _p_subpass_end_info: *const SubpassEndInfo, ) -> c_void { panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass2))) } let raw_name = stringify!(vkCmdEndRenderPass2); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { cmd_end_render_pass2 } else { ::std::mem::transmute(val) } }, reset_query_pool: unsafe { extern "system" fn reset_query_pool( _device: Device, _query_pool: QueryPool, _first_query: u32, _query_count: u32, ) -> c_void { panic!(concat!("Unable to load ", stringify!(reset_query_pool))) } let raw_name = stringify!(vkResetQueryPool); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { reset_query_pool } else { ::std::mem::transmute(val) } }, get_semaphore_counter_value: unsafe { extern "system" fn get_semaphore_counter_value( _device: Device, _semaphore: Semaphore, _p_value: *mut u64, ) -> Result { panic!(concat!( "Unable to load ", stringify!(get_semaphore_counter_value) )) } let raw_name = stringify!(vkGetSemaphoreCounterValue); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_semaphore_counter_value } else { ::std::mem::transmute(val) } }, wait_semaphores: unsafe { extern "system" fn wait_semaphores( _device: Device, _p_wait_info: *const SemaphoreWaitInfo, _timeout: u64, ) -> Result { panic!(concat!("Unable to load ", stringify!(wait_semaphores))) } let raw_name = stringify!(vkWaitSemaphores); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { wait_semaphores } else { ::std::mem::transmute(val) } }, signal_semaphore: unsafe { extern "system" fn signal_semaphore( _device: Device, _p_signal_info: *const SemaphoreSignalInfo, ) -> Result { panic!(concat!("Unable to load ", stringify!(signal_semaphore))) } let raw_name = stringify!(vkSignalSemaphore); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { signal_semaphore } else { ::std::mem::transmute(val) } }, get_buffer_device_address: unsafe { extern "system" fn get_buffer_device_address( _device: Device, _p_info: *const BufferDeviceAddressInfo, ) -> DeviceAddress { panic!(concat!( "Unable to load ", stringify!(get_buffer_device_address) )) } let raw_name = stringify!(vkGetBufferDeviceAddress); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_buffer_device_address } else { ::std::mem::transmute(val) } }, get_buffer_opaque_capture_address: unsafe { extern "system" fn get_buffer_opaque_capture_address( _device: Device, _p_info: *const BufferDeviceAddressInfo, ) -> u64 { panic!(concat!( "Unable to load ", stringify!(get_buffer_opaque_capture_address) )) } let raw_name = stringify!(vkGetBufferOpaqueCaptureAddress); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_buffer_opaque_capture_address } else { ::std::mem::transmute(val) } }, get_device_memory_opaque_capture_address: unsafe { extern "system" fn get_device_memory_opaque_capture_address( _device: Device, _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, ) -> u64 { panic!(concat!( "Unable to load ", stringify!(get_device_memory_opaque_capture_address) )) } let raw_name = stringify!(vkGetDeviceMemoryOpaqueCaptureAddress); let cname = ::std::ffi::CString::new(raw_name).unwrap(); let val = _f(&cname); if val.is_null() { get_device_memory_opaque_capture_address } else { ::std::mem::transmute(val) } }, } } #[doc = ""] pub unsafe fn cmd_draw_indirect_count( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, ) -> c_void { (self.cmd_draw_indirect_count)( command_buffer, buffer, offset, count_buffer, count_buffer_offset, max_draw_count, stride, ) } #[doc = ""] pub unsafe fn cmd_draw_indexed_indirect_count( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, ) -> c_void { (self.cmd_draw_indexed_indirect_count)( command_buffer, buffer, offset, count_buffer, count_buffer_offset, max_draw_count, stride, ) } #[doc = ""] pub unsafe fn create_render_pass2( &self, device: Device, p_create_info: *const RenderPassCreateInfo2, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result { (self.create_render_pass2)(device, p_create_info, p_allocator, p_render_pass) } #[doc = ""] pub unsafe fn cmd_begin_render_pass2( &self, command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, p_subpass_begin_info: *const SubpassBeginInfo, ) -> c_void { (self.cmd_begin_render_pass2)(command_buffer, p_render_pass_begin, p_subpass_begin_info) } #[doc = ""] pub unsafe fn cmd_next_subpass2( &self, command_buffer: CommandBuffer, p_subpass_begin_info: *const SubpassBeginInfo, p_subpass_end_info: *const SubpassEndInfo, ) -> c_void { (self.cmd_next_subpass2)(command_buffer, p_subpass_begin_info, p_subpass_end_info) } #[doc = ""] pub unsafe fn cmd_end_render_pass2( &self, command_buffer: CommandBuffer, p_subpass_end_info: *const SubpassEndInfo, ) -> c_void { (self.cmd_end_render_pass2)(command_buffer, p_subpass_end_info) } #[doc = ""] pub unsafe fn reset_query_pool( &self, device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, ) -> c_void { (self.reset_query_pool)(device, query_pool, first_query, query_count) } #[doc = ""] pub unsafe fn get_semaphore_counter_value( &self, device: Device, semaphore: Semaphore, p_value: *mut u64, ) -> Result { (self.get_semaphore_counter_value)(device, semaphore, p_value) } #[doc = ""] pub unsafe fn wait_semaphores( &self, device: Device, p_wait_info: *const SemaphoreWaitInfo, timeout: u64, ) -> Result { (self.wait_semaphores)(device, p_wait_info, timeout) } #[doc = ""] pub unsafe fn signal_semaphore( &self, device: Device, p_signal_info: *const SemaphoreSignalInfo, ) -> Result { (self.signal_semaphore)(device, p_signal_info) } #[doc = ""] pub unsafe fn get_buffer_device_address( &self, device: Device, p_info: *const BufferDeviceAddressInfo, ) -> DeviceAddress { (self.get_buffer_device_address)(device, p_info) } #[doc = ""] pub unsafe fn get_buffer_opaque_capture_address( &self, device: Device, p_info: *const BufferDeviceAddressInfo, ) -> u64 { (self.get_buffer_opaque_capture_address)(device, p_info) } #[doc = ""] pub unsafe fn get_device_memory_opaque_capture_address( &self, device: Device, p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, ) -> u64 { (self.get_device_memory_opaque_capture_address)(device, p_info) } }