1 use crate::vk::bitflags::*; 2 use crate::vk::definitions::*; 3 use crate::vk::enums::*; 4 use std::os::raw::*; 5 #[allow(non_camel_case_types)] 6 pub type PFN_vkGetInstanceProcAddr = 7 unsafe extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction; 8 #[derive(Clone)] 9 pub struct StaticFn { 10 pub get_instance_proc_addr: PFN_vkGetInstanceProcAddr, 11 } 12 unsafe impl Send for StaticFn {} 13 unsafe impl Sync for StaticFn {} 14 impl StaticFn { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,15 pub fn load<F>(mut _f: F) -> Self 16 where 17 F: FnMut(&::std::ffi::CStr) -> *const c_void, 18 { 19 Self { 20 get_instance_proc_addr: unsafe { 21 unsafe extern "system" fn get_instance_proc_addr( 22 _instance: Instance, 23 _p_name: *const c_char, 24 ) -> PFN_vkVoidFunction { 25 panic!(concat!( 26 "Unable to load ", 27 stringify!(get_instance_proc_addr) 28 )) 29 } 30 let cname = 31 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetInstanceProcAddr\0"); 32 let val = _f(cname); 33 if val.is_null() { 34 get_instance_proc_addr 35 } else { 36 ::std::mem::transmute(val) 37 } 38 }, 39 } 40 } 41 } 42 #[allow(non_camel_case_types)] 43 pub type PFN_vkCreateInstance = unsafe extern "system" fn( 44 p_create_info: *const InstanceCreateInfo, 45 p_allocator: *const AllocationCallbacks, 46 p_instance: *mut Instance, 47 ) -> Result; 48 #[allow(non_camel_case_types)] 49 pub type PFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn( 50 p_layer_name: *const c_char, 51 p_property_count: *mut u32, 52 p_properties: *mut ExtensionProperties, 53 ) -> Result; 54 #[allow(non_camel_case_types)] 55 pub type PFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn( 56 p_property_count: *mut u32, 57 p_properties: *mut LayerProperties, 58 ) -> Result; 59 #[derive(Clone)] 60 pub struct EntryFnV1_0 { 61 pub create_instance: PFN_vkCreateInstance, 62 pub enumerate_instance_extension_properties: PFN_vkEnumerateInstanceExtensionProperties, 63 pub enumerate_instance_layer_properties: PFN_vkEnumerateInstanceLayerProperties, 64 } 65 unsafe impl Send for EntryFnV1_0 {} 66 unsafe impl Sync for EntryFnV1_0 {} 67 impl EntryFnV1_0 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,68 pub fn load<F>(mut _f: F) -> Self 69 where 70 F: FnMut(&::std::ffi::CStr) -> *const c_void, 71 { 72 Self { 73 create_instance: unsafe { 74 unsafe extern "system" fn create_instance( 75 _p_create_info: *const InstanceCreateInfo, 76 _p_allocator: *const AllocationCallbacks, 77 _p_instance: *mut Instance, 78 ) -> Result { 79 panic!(concat!("Unable to load ", stringify!(create_instance))) 80 } 81 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateInstance\0"); 82 let val = _f(cname); 83 if val.is_null() { 84 create_instance 85 } else { 86 ::std::mem::transmute(val) 87 } 88 }, 89 enumerate_instance_extension_properties: unsafe { 90 unsafe extern "system" fn enumerate_instance_extension_properties( 91 _p_layer_name: *const c_char, 92 _p_property_count: *mut u32, 93 _p_properties: *mut ExtensionProperties, 94 ) -> Result { 95 panic!(concat!( 96 "Unable to load ", 97 stringify!(enumerate_instance_extension_properties) 98 )) 99 } 100 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 101 b"vkEnumerateInstanceExtensionProperties\0", 102 ); 103 let val = _f(cname); 104 if val.is_null() { 105 enumerate_instance_extension_properties 106 } else { 107 ::std::mem::transmute(val) 108 } 109 }, 110 enumerate_instance_layer_properties: unsafe { 111 unsafe extern "system" fn enumerate_instance_layer_properties( 112 _p_property_count: *mut u32, 113 _p_properties: *mut LayerProperties, 114 ) -> Result { 115 panic!(concat!( 116 "Unable to load ", 117 stringify!(enumerate_instance_layer_properties) 118 )) 119 } 120 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 121 b"vkEnumerateInstanceLayerProperties\0", 122 ); 123 let val = _f(cname); 124 if val.is_null() { 125 enumerate_instance_layer_properties 126 } else { 127 ::std::mem::transmute(val) 128 } 129 }, 130 } 131 } 132 } 133 #[allow(non_camel_case_types)] 134 pub type PFN_vkDestroyInstance = 135 unsafe extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks); 136 #[allow(non_camel_case_types)] 137 pub type PFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn( 138 instance: Instance, 139 p_physical_device_count: *mut u32, 140 p_physical_devices: *mut PhysicalDevice, 141 ) -> Result; 142 #[allow(non_camel_case_types)] 143 pub type PFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn( 144 physical_device: PhysicalDevice, 145 p_features: *mut PhysicalDeviceFeatures, 146 ); 147 #[allow(non_camel_case_types)] 148 pub type PFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn( 149 physical_device: PhysicalDevice, 150 format: Format, 151 p_format_properties: *mut FormatProperties, 152 ); 153 #[allow(non_camel_case_types)] 154 pub type PFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn( 155 physical_device: PhysicalDevice, 156 format: Format, 157 ty: ImageType, 158 tiling: ImageTiling, 159 usage: ImageUsageFlags, 160 flags: ImageCreateFlags, 161 p_image_format_properties: *mut ImageFormatProperties, 162 ) -> Result; 163 #[allow(non_camel_case_types)] 164 pub type PFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn( 165 physical_device: PhysicalDevice, 166 p_properties: *mut PhysicalDeviceProperties, 167 ); 168 #[allow(non_camel_case_types)] 169 pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn( 170 physical_device: PhysicalDevice, 171 p_queue_family_property_count: *mut u32, 172 p_queue_family_properties: *mut QueueFamilyProperties, 173 ); 174 #[allow(non_camel_case_types)] 175 pub type PFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn( 176 physical_device: PhysicalDevice, 177 p_memory_properties: *mut PhysicalDeviceMemoryProperties, 178 ); 179 #[allow(non_camel_case_types)] 180 pub type PFN_vkGetDeviceProcAddr = 181 unsafe extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction; 182 #[allow(non_camel_case_types)] 183 pub type PFN_vkCreateDevice = unsafe extern "system" fn( 184 physical_device: PhysicalDevice, 185 p_create_info: *const DeviceCreateInfo, 186 p_allocator: *const AllocationCallbacks, 187 p_device: *mut Device, 188 ) -> Result; 189 #[allow(non_camel_case_types)] 190 pub type PFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn( 191 physical_device: PhysicalDevice, 192 p_layer_name: *const c_char, 193 p_property_count: *mut u32, 194 p_properties: *mut ExtensionProperties, 195 ) -> Result; 196 #[allow(non_camel_case_types)] 197 pub type PFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn( 198 physical_device: PhysicalDevice, 199 p_property_count: *mut u32, 200 p_properties: *mut LayerProperties, 201 ) -> Result; 202 #[allow(non_camel_case_types)] 203 pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn( 204 physical_device: PhysicalDevice, 205 format: Format, 206 ty: ImageType, 207 samples: SampleCountFlags, 208 usage: ImageUsageFlags, 209 tiling: ImageTiling, 210 p_property_count: *mut u32, 211 p_properties: *mut SparseImageFormatProperties, 212 ); 213 #[derive(Clone)] 214 pub struct InstanceFnV1_0 { 215 pub destroy_instance: PFN_vkDestroyInstance, 216 pub enumerate_physical_devices: PFN_vkEnumeratePhysicalDevices, 217 pub get_physical_device_features: PFN_vkGetPhysicalDeviceFeatures, 218 pub get_physical_device_format_properties: PFN_vkGetPhysicalDeviceFormatProperties, 219 pub get_physical_device_image_format_properties: PFN_vkGetPhysicalDeviceImageFormatProperties, 220 pub get_physical_device_properties: PFN_vkGetPhysicalDeviceProperties, 221 pub get_physical_device_queue_family_properties: PFN_vkGetPhysicalDeviceQueueFamilyProperties, 222 pub get_physical_device_memory_properties: PFN_vkGetPhysicalDeviceMemoryProperties, 223 pub get_device_proc_addr: PFN_vkGetDeviceProcAddr, 224 pub create_device: PFN_vkCreateDevice, 225 pub enumerate_device_extension_properties: PFN_vkEnumerateDeviceExtensionProperties, 226 pub enumerate_device_layer_properties: PFN_vkEnumerateDeviceLayerProperties, 227 pub get_physical_device_sparse_image_format_properties: 228 PFN_vkGetPhysicalDeviceSparseImageFormatProperties, 229 } 230 unsafe impl Send for InstanceFnV1_0 {} 231 unsafe impl Sync for InstanceFnV1_0 {} 232 impl InstanceFnV1_0 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,233 pub fn load<F>(mut _f: F) -> Self 234 where 235 F: FnMut(&::std::ffi::CStr) -> *const c_void, 236 { 237 Self { 238 destroy_instance: unsafe { 239 unsafe extern "system" fn destroy_instance( 240 _instance: Instance, 241 _p_allocator: *const AllocationCallbacks, 242 ) { 243 panic!(concat!("Unable to load ", stringify!(destroy_instance))) 244 } 245 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyInstance\0"); 246 let val = _f(cname); 247 if val.is_null() { 248 destroy_instance 249 } else { 250 ::std::mem::transmute(val) 251 } 252 }, 253 enumerate_physical_devices: unsafe { 254 unsafe extern "system" fn enumerate_physical_devices( 255 _instance: Instance, 256 _p_physical_device_count: *mut u32, 257 _p_physical_devices: *mut PhysicalDevice, 258 ) -> Result { 259 panic!(concat!( 260 "Unable to load ", 261 stringify!(enumerate_physical_devices) 262 )) 263 } 264 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 265 b"vkEnumeratePhysicalDevices\0", 266 ); 267 let val = _f(cname); 268 if val.is_null() { 269 enumerate_physical_devices 270 } else { 271 ::std::mem::transmute(val) 272 } 273 }, 274 get_physical_device_features: unsafe { 275 unsafe extern "system" fn get_physical_device_features( 276 _physical_device: PhysicalDevice, 277 _p_features: *mut PhysicalDeviceFeatures, 278 ) { 279 panic!(concat!( 280 "Unable to load ", 281 stringify!(get_physical_device_features) 282 )) 283 } 284 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 285 b"vkGetPhysicalDeviceFeatures\0", 286 ); 287 let val = _f(cname); 288 if val.is_null() { 289 get_physical_device_features 290 } else { 291 ::std::mem::transmute(val) 292 } 293 }, 294 get_physical_device_format_properties: unsafe { 295 unsafe extern "system" fn get_physical_device_format_properties( 296 _physical_device: PhysicalDevice, 297 _format: Format, 298 _p_format_properties: *mut FormatProperties, 299 ) { 300 panic!(concat!( 301 "Unable to load ", 302 stringify!(get_physical_device_format_properties) 303 )) 304 } 305 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 306 b"vkGetPhysicalDeviceFormatProperties\0", 307 ); 308 let val = _f(cname); 309 if val.is_null() { 310 get_physical_device_format_properties 311 } else { 312 ::std::mem::transmute(val) 313 } 314 }, 315 get_physical_device_image_format_properties: unsafe { 316 unsafe extern "system" fn get_physical_device_image_format_properties( 317 _physical_device: PhysicalDevice, 318 _format: Format, 319 _ty: ImageType, 320 _tiling: ImageTiling, 321 _usage: ImageUsageFlags, 322 _flags: ImageCreateFlags, 323 _p_image_format_properties: *mut ImageFormatProperties, 324 ) -> Result { 325 panic!(concat!( 326 "Unable to load ", 327 stringify!(get_physical_device_image_format_properties) 328 )) 329 } 330 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 331 b"vkGetPhysicalDeviceImageFormatProperties\0", 332 ); 333 let val = _f(cname); 334 if val.is_null() { 335 get_physical_device_image_format_properties 336 } else { 337 ::std::mem::transmute(val) 338 } 339 }, 340 get_physical_device_properties: unsafe { 341 unsafe extern "system" fn get_physical_device_properties( 342 _physical_device: PhysicalDevice, 343 _p_properties: *mut PhysicalDeviceProperties, 344 ) { 345 panic!(concat!( 346 "Unable to load ", 347 stringify!(get_physical_device_properties) 348 )) 349 } 350 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 351 b"vkGetPhysicalDeviceProperties\0", 352 ); 353 let val = _f(cname); 354 if val.is_null() { 355 get_physical_device_properties 356 } else { 357 ::std::mem::transmute(val) 358 } 359 }, 360 get_physical_device_queue_family_properties: unsafe { 361 unsafe extern "system" fn get_physical_device_queue_family_properties( 362 _physical_device: PhysicalDevice, 363 _p_queue_family_property_count: *mut u32, 364 _p_queue_family_properties: *mut QueueFamilyProperties, 365 ) { 366 panic!(concat!( 367 "Unable to load ", 368 stringify!(get_physical_device_queue_family_properties) 369 )) 370 } 371 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 372 b"vkGetPhysicalDeviceQueueFamilyProperties\0", 373 ); 374 let val = _f(cname); 375 if val.is_null() { 376 get_physical_device_queue_family_properties 377 } else { 378 ::std::mem::transmute(val) 379 } 380 }, 381 get_physical_device_memory_properties: unsafe { 382 unsafe extern "system" fn get_physical_device_memory_properties( 383 _physical_device: PhysicalDevice, 384 _p_memory_properties: *mut PhysicalDeviceMemoryProperties, 385 ) { 386 panic!(concat!( 387 "Unable to load ", 388 stringify!(get_physical_device_memory_properties) 389 )) 390 } 391 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 392 b"vkGetPhysicalDeviceMemoryProperties\0", 393 ); 394 let val = _f(cname); 395 if val.is_null() { 396 get_physical_device_memory_properties 397 } else { 398 ::std::mem::transmute(val) 399 } 400 }, 401 get_device_proc_addr: unsafe { 402 unsafe extern "system" fn get_device_proc_addr( 403 _device: Device, 404 _p_name: *const c_char, 405 ) -> PFN_vkVoidFunction { 406 panic!(concat!("Unable to load ", stringify!(get_device_proc_addr))) 407 } 408 let cname = 409 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceProcAddr\0"); 410 let val = _f(cname); 411 if val.is_null() { 412 get_device_proc_addr 413 } else { 414 ::std::mem::transmute(val) 415 } 416 }, 417 create_device: unsafe { 418 unsafe extern "system" fn create_device( 419 _physical_device: PhysicalDevice, 420 _p_create_info: *const DeviceCreateInfo, 421 _p_allocator: *const AllocationCallbacks, 422 _p_device: *mut Device, 423 ) -> Result { 424 panic!(concat!("Unable to load ", stringify!(create_device))) 425 } 426 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDevice\0"); 427 let val = _f(cname); 428 if val.is_null() { 429 create_device 430 } else { 431 ::std::mem::transmute(val) 432 } 433 }, 434 enumerate_device_extension_properties: unsafe { 435 unsafe extern "system" fn enumerate_device_extension_properties( 436 _physical_device: PhysicalDevice, 437 _p_layer_name: *const c_char, 438 _p_property_count: *mut u32, 439 _p_properties: *mut ExtensionProperties, 440 ) -> Result { 441 panic!(concat!( 442 "Unable to load ", 443 stringify!(enumerate_device_extension_properties) 444 )) 445 } 446 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 447 b"vkEnumerateDeviceExtensionProperties\0", 448 ); 449 let val = _f(cname); 450 if val.is_null() { 451 enumerate_device_extension_properties 452 } else { 453 ::std::mem::transmute(val) 454 } 455 }, 456 enumerate_device_layer_properties: unsafe { 457 unsafe extern "system" fn enumerate_device_layer_properties( 458 _physical_device: PhysicalDevice, 459 _p_property_count: *mut u32, 460 _p_properties: *mut LayerProperties, 461 ) -> Result { 462 panic!(concat!( 463 "Unable to load ", 464 stringify!(enumerate_device_layer_properties) 465 )) 466 } 467 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 468 b"vkEnumerateDeviceLayerProperties\0", 469 ); 470 let val = _f(cname); 471 if val.is_null() { 472 enumerate_device_layer_properties 473 } else { 474 ::std::mem::transmute(val) 475 } 476 }, 477 get_physical_device_sparse_image_format_properties: unsafe { 478 unsafe extern "system" fn get_physical_device_sparse_image_format_properties( 479 _physical_device: PhysicalDevice, 480 _format: Format, 481 _ty: ImageType, 482 _samples: SampleCountFlags, 483 _usage: ImageUsageFlags, 484 _tiling: ImageTiling, 485 _p_property_count: *mut u32, 486 _p_properties: *mut SparseImageFormatProperties, 487 ) { 488 panic!(concat!( 489 "Unable to load ", 490 stringify!(get_physical_device_sparse_image_format_properties) 491 )) 492 } 493 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 494 b"vkGetPhysicalDeviceSparseImageFormatProperties\0", 495 ); 496 let val = _f(cname); 497 if val.is_null() { 498 get_physical_device_sparse_image_format_properties 499 } else { 500 ::std::mem::transmute(val) 501 } 502 }, 503 } 504 } 505 } 506 #[allow(non_camel_case_types)] 507 pub type PFN_vkDestroyDevice = 508 unsafe extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks); 509 #[allow(non_camel_case_types)] 510 pub type PFN_vkGetDeviceQueue = unsafe extern "system" fn( 511 device: Device, 512 queue_family_index: u32, 513 queue_index: u32, 514 p_queue: *mut Queue, 515 ); 516 #[allow(non_camel_case_types)] 517 pub type PFN_vkQueueSubmit = unsafe extern "system" fn( 518 queue: Queue, 519 submit_count: u32, 520 p_submits: *const SubmitInfo, 521 fence: Fence, 522 ) -> Result; 523 #[allow(non_camel_case_types)] 524 pub type PFN_vkQueueWaitIdle = unsafe extern "system" fn(queue: Queue) -> Result; 525 #[allow(non_camel_case_types)] 526 pub type PFN_vkDeviceWaitIdle = unsafe extern "system" fn(device: Device) -> Result; 527 #[allow(non_camel_case_types)] 528 pub type PFN_vkAllocateMemory = unsafe extern "system" fn( 529 device: Device, 530 p_allocate_info: *const MemoryAllocateInfo, 531 p_allocator: *const AllocationCallbacks, 532 p_memory: *mut DeviceMemory, 533 ) -> Result; 534 #[allow(non_camel_case_types)] 535 pub type PFN_vkFreeMemory = unsafe extern "system" fn( 536 device: Device, 537 memory: DeviceMemory, 538 p_allocator: *const AllocationCallbacks, 539 ); 540 #[allow(non_camel_case_types)] 541 pub type PFN_vkMapMemory = unsafe extern "system" fn( 542 device: Device, 543 memory: DeviceMemory, 544 offset: DeviceSize, 545 size: DeviceSize, 546 flags: MemoryMapFlags, 547 pp_data: *mut *mut c_void, 548 ) -> Result; 549 #[allow(non_camel_case_types)] 550 pub type PFN_vkUnmapMemory = unsafe extern "system" fn(device: Device, memory: DeviceMemory); 551 #[allow(non_camel_case_types)] 552 pub type PFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn( 553 device: Device, 554 memory_range_count: u32, 555 p_memory_ranges: *const MappedMemoryRange, 556 ) -> Result; 557 #[allow(non_camel_case_types)] 558 pub type PFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn( 559 device: Device, 560 memory_range_count: u32, 561 p_memory_ranges: *const MappedMemoryRange, 562 ) -> Result; 563 #[allow(non_camel_case_types)] 564 pub type PFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn( 565 device: Device, 566 memory: DeviceMemory, 567 p_committed_memory_in_bytes: *mut DeviceSize, 568 ); 569 #[allow(non_camel_case_types)] 570 pub type PFN_vkBindBufferMemory = unsafe extern "system" fn( 571 device: Device, 572 buffer: Buffer, 573 memory: DeviceMemory, 574 memory_offset: DeviceSize, 575 ) -> Result; 576 #[allow(non_camel_case_types)] 577 pub type PFN_vkBindImageMemory = unsafe extern "system" fn( 578 device: Device, 579 image: Image, 580 memory: DeviceMemory, 581 memory_offset: DeviceSize, 582 ) -> Result; 583 #[allow(non_camel_case_types)] 584 pub type PFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn( 585 device: Device, 586 buffer: Buffer, 587 p_memory_requirements: *mut MemoryRequirements, 588 ); 589 #[allow(non_camel_case_types)] 590 pub type PFN_vkGetImageMemoryRequirements = unsafe extern "system" fn( 591 device: Device, 592 image: Image, 593 p_memory_requirements: *mut MemoryRequirements, 594 ); 595 #[allow(non_camel_case_types)] 596 pub type PFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn( 597 device: Device, 598 image: Image, 599 p_sparse_memory_requirement_count: *mut u32, 600 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, 601 ); 602 #[allow(non_camel_case_types)] 603 pub type PFN_vkQueueBindSparse = unsafe extern "system" fn( 604 queue: Queue, 605 bind_info_count: u32, 606 p_bind_info: *const BindSparseInfo, 607 fence: Fence, 608 ) -> Result; 609 #[allow(non_camel_case_types)] 610 pub type PFN_vkCreateFence = unsafe extern "system" fn( 611 device: Device, 612 p_create_info: *const FenceCreateInfo, 613 p_allocator: *const AllocationCallbacks, 614 p_fence: *mut Fence, 615 ) -> Result; 616 #[allow(non_camel_case_types)] 617 pub type PFN_vkDestroyFence = unsafe extern "system" fn( 618 device: Device, 619 fence: Fence, 620 p_allocator: *const AllocationCallbacks, 621 ); 622 #[allow(non_camel_case_types)] 623 pub type PFN_vkResetFences = 624 unsafe extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result; 625 #[allow(non_camel_case_types)] 626 pub type PFN_vkGetFenceStatus = unsafe extern "system" fn(device: Device, fence: Fence) -> Result; 627 #[allow(non_camel_case_types)] 628 pub type PFN_vkWaitForFences = unsafe extern "system" fn( 629 device: Device, 630 fence_count: u32, 631 p_fences: *const Fence, 632 wait_all: Bool32, 633 timeout: u64, 634 ) -> Result; 635 #[allow(non_camel_case_types)] 636 pub type PFN_vkCreateSemaphore = unsafe extern "system" fn( 637 device: Device, 638 p_create_info: *const SemaphoreCreateInfo, 639 p_allocator: *const AllocationCallbacks, 640 p_semaphore: *mut Semaphore, 641 ) -> Result; 642 #[allow(non_camel_case_types)] 643 pub type PFN_vkDestroySemaphore = unsafe extern "system" fn( 644 device: Device, 645 semaphore: Semaphore, 646 p_allocator: *const AllocationCallbacks, 647 ); 648 #[allow(non_camel_case_types)] 649 pub type PFN_vkCreateEvent = unsafe extern "system" fn( 650 device: Device, 651 p_create_info: *const EventCreateInfo, 652 p_allocator: *const AllocationCallbacks, 653 p_event: *mut Event, 654 ) -> Result; 655 #[allow(non_camel_case_types)] 656 pub type PFN_vkDestroyEvent = unsafe extern "system" fn( 657 device: Device, 658 event: Event, 659 p_allocator: *const AllocationCallbacks, 660 ); 661 #[allow(non_camel_case_types)] 662 pub type PFN_vkGetEventStatus = unsafe extern "system" fn(device: Device, event: Event) -> Result; 663 #[allow(non_camel_case_types)] 664 pub type PFN_vkSetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result; 665 #[allow(non_camel_case_types)] 666 pub type PFN_vkResetEvent = unsafe extern "system" fn(device: Device, event: Event) -> Result; 667 #[allow(non_camel_case_types)] 668 pub type PFN_vkCreateQueryPool = unsafe extern "system" fn( 669 device: Device, 670 p_create_info: *const QueryPoolCreateInfo, 671 p_allocator: *const AllocationCallbacks, 672 p_query_pool: *mut QueryPool, 673 ) -> Result; 674 #[allow(non_camel_case_types)] 675 pub type PFN_vkDestroyQueryPool = unsafe extern "system" fn( 676 device: Device, 677 query_pool: QueryPool, 678 p_allocator: *const AllocationCallbacks, 679 ); 680 #[allow(non_camel_case_types)] 681 pub type PFN_vkGetQueryPoolResults = unsafe extern "system" fn( 682 device: Device, 683 query_pool: QueryPool, 684 first_query: u32, 685 query_count: u32, 686 data_size: usize, 687 p_data: *mut c_void, 688 stride: DeviceSize, 689 flags: QueryResultFlags, 690 ) -> Result; 691 #[allow(non_camel_case_types)] 692 pub type PFN_vkCreateBuffer = unsafe extern "system" fn( 693 device: Device, 694 p_create_info: *const BufferCreateInfo, 695 p_allocator: *const AllocationCallbacks, 696 p_buffer: *mut Buffer, 697 ) -> Result; 698 #[allow(non_camel_case_types)] 699 pub type PFN_vkDestroyBuffer = unsafe extern "system" fn( 700 device: Device, 701 buffer: Buffer, 702 p_allocator: *const AllocationCallbacks, 703 ); 704 #[allow(non_camel_case_types)] 705 pub type PFN_vkCreateBufferView = unsafe extern "system" fn( 706 device: Device, 707 p_create_info: *const BufferViewCreateInfo, 708 p_allocator: *const AllocationCallbacks, 709 p_view: *mut BufferView, 710 ) -> Result; 711 #[allow(non_camel_case_types)] 712 pub type PFN_vkDestroyBufferView = unsafe extern "system" fn( 713 device: Device, 714 buffer_view: BufferView, 715 p_allocator: *const AllocationCallbacks, 716 ); 717 #[allow(non_camel_case_types)] 718 pub type PFN_vkCreateImage = unsafe extern "system" fn( 719 device: Device, 720 p_create_info: *const ImageCreateInfo, 721 p_allocator: *const AllocationCallbacks, 722 p_image: *mut Image, 723 ) -> Result; 724 #[allow(non_camel_case_types)] 725 pub type PFN_vkDestroyImage = unsafe extern "system" fn( 726 device: Device, 727 image: Image, 728 p_allocator: *const AllocationCallbacks, 729 ); 730 #[allow(non_camel_case_types)] 731 pub type PFN_vkGetImageSubresourceLayout = unsafe extern "system" fn( 732 device: Device, 733 image: Image, 734 p_subresource: *const ImageSubresource, 735 p_layout: *mut SubresourceLayout, 736 ); 737 #[allow(non_camel_case_types)] 738 pub type PFN_vkCreateImageView = unsafe extern "system" fn( 739 device: Device, 740 p_create_info: *const ImageViewCreateInfo, 741 p_allocator: *const AllocationCallbacks, 742 p_view: *mut ImageView, 743 ) -> Result; 744 #[allow(non_camel_case_types)] 745 pub type PFN_vkDestroyImageView = unsafe extern "system" fn( 746 device: Device, 747 image_view: ImageView, 748 p_allocator: *const AllocationCallbacks, 749 ); 750 #[allow(non_camel_case_types)] 751 pub type PFN_vkCreateShaderModule = unsafe extern "system" fn( 752 device: Device, 753 p_create_info: *const ShaderModuleCreateInfo, 754 p_allocator: *const AllocationCallbacks, 755 p_shader_module: *mut ShaderModule, 756 ) -> Result; 757 #[allow(non_camel_case_types)] 758 pub type PFN_vkDestroyShaderModule = unsafe extern "system" fn( 759 device: Device, 760 shader_module: ShaderModule, 761 p_allocator: *const AllocationCallbacks, 762 ); 763 #[allow(non_camel_case_types)] 764 pub type PFN_vkCreatePipelineCache = unsafe extern "system" fn( 765 device: Device, 766 p_create_info: *const PipelineCacheCreateInfo, 767 p_allocator: *const AllocationCallbacks, 768 p_pipeline_cache: *mut PipelineCache, 769 ) -> Result; 770 #[allow(non_camel_case_types)] 771 pub type PFN_vkDestroyPipelineCache = unsafe extern "system" fn( 772 device: Device, 773 pipeline_cache: PipelineCache, 774 p_allocator: *const AllocationCallbacks, 775 ); 776 #[allow(non_camel_case_types)] 777 pub type PFN_vkGetPipelineCacheData = unsafe extern "system" fn( 778 device: Device, 779 pipeline_cache: PipelineCache, 780 p_data_size: *mut usize, 781 p_data: *mut c_void, 782 ) -> Result; 783 #[allow(non_camel_case_types)] 784 pub type PFN_vkMergePipelineCaches = unsafe extern "system" fn( 785 device: Device, 786 dst_cache: PipelineCache, 787 src_cache_count: u32, 788 p_src_caches: *const PipelineCache, 789 ) -> Result; 790 #[allow(non_camel_case_types)] 791 pub type PFN_vkCreateGraphicsPipelines = unsafe extern "system" fn( 792 device: Device, 793 pipeline_cache: PipelineCache, 794 create_info_count: u32, 795 p_create_infos: *const GraphicsPipelineCreateInfo, 796 p_allocator: *const AllocationCallbacks, 797 p_pipelines: *mut Pipeline, 798 ) -> Result; 799 #[allow(non_camel_case_types)] 800 pub type PFN_vkCreateComputePipelines = unsafe extern "system" fn( 801 device: Device, 802 pipeline_cache: PipelineCache, 803 create_info_count: u32, 804 p_create_infos: *const ComputePipelineCreateInfo, 805 p_allocator: *const AllocationCallbacks, 806 p_pipelines: *mut Pipeline, 807 ) -> Result; 808 #[allow(non_camel_case_types)] 809 pub type PFN_vkDestroyPipeline = unsafe extern "system" fn( 810 device: Device, 811 pipeline: Pipeline, 812 p_allocator: *const AllocationCallbacks, 813 ); 814 #[allow(non_camel_case_types)] 815 pub type PFN_vkCreatePipelineLayout = unsafe extern "system" fn( 816 device: Device, 817 p_create_info: *const PipelineLayoutCreateInfo, 818 p_allocator: *const AllocationCallbacks, 819 p_pipeline_layout: *mut PipelineLayout, 820 ) -> Result; 821 #[allow(non_camel_case_types)] 822 pub type PFN_vkDestroyPipelineLayout = unsafe extern "system" fn( 823 device: Device, 824 pipeline_layout: PipelineLayout, 825 p_allocator: *const AllocationCallbacks, 826 ); 827 #[allow(non_camel_case_types)] 828 pub type PFN_vkCreateSampler = unsafe extern "system" fn( 829 device: Device, 830 p_create_info: *const SamplerCreateInfo, 831 p_allocator: *const AllocationCallbacks, 832 p_sampler: *mut Sampler, 833 ) -> Result; 834 #[allow(non_camel_case_types)] 835 pub type PFN_vkDestroySampler = unsafe extern "system" fn( 836 device: Device, 837 sampler: Sampler, 838 p_allocator: *const AllocationCallbacks, 839 ); 840 #[allow(non_camel_case_types)] 841 pub type PFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn( 842 device: Device, 843 p_create_info: *const DescriptorSetLayoutCreateInfo, 844 p_allocator: *const AllocationCallbacks, 845 p_set_layout: *mut DescriptorSetLayout, 846 ) -> Result; 847 #[allow(non_camel_case_types)] 848 pub type PFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn( 849 device: Device, 850 descriptor_set_layout: DescriptorSetLayout, 851 p_allocator: *const AllocationCallbacks, 852 ); 853 #[allow(non_camel_case_types)] 854 pub type PFN_vkCreateDescriptorPool = unsafe extern "system" fn( 855 device: Device, 856 p_create_info: *const DescriptorPoolCreateInfo, 857 p_allocator: *const AllocationCallbacks, 858 p_descriptor_pool: *mut DescriptorPool, 859 ) -> Result; 860 #[allow(non_camel_case_types)] 861 pub type PFN_vkDestroyDescriptorPool = unsafe extern "system" fn( 862 device: Device, 863 descriptor_pool: DescriptorPool, 864 p_allocator: *const AllocationCallbacks, 865 ); 866 #[allow(non_camel_case_types)] 867 pub type PFN_vkResetDescriptorPool = unsafe extern "system" fn( 868 device: Device, 869 descriptor_pool: DescriptorPool, 870 flags: DescriptorPoolResetFlags, 871 ) -> Result; 872 #[allow(non_camel_case_types)] 873 pub type PFN_vkAllocateDescriptorSets = unsafe extern "system" fn( 874 device: Device, 875 p_allocate_info: *const DescriptorSetAllocateInfo, 876 p_descriptor_sets: *mut DescriptorSet, 877 ) -> Result; 878 #[allow(non_camel_case_types)] 879 pub type PFN_vkFreeDescriptorSets = unsafe extern "system" fn( 880 device: Device, 881 descriptor_pool: DescriptorPool, 882 descriptor_set_count: u32, 883 p_descriptor_sets: *const DescriptorSet, 884 ) -> Result; 885 #[allow(non_camel_case_types)] 886 pub type PFN_vkUpdateDescriptorSets = unsafe extern "system" fn( 887 device: Device, 888 descriptor_write_count: u32, 889 p_descriptor_writes: *const WriteDescriptorSet, 890 descriptor_copy_count: u32, 891 p_descriptor_copies: *const CopyDescriptorSet, 892 ); 893 #[allow(non_camel_case_types)] 894 pub type PFN_vkCreateFramebuffer = unsafe extern "system" fn( 895 device: Device, 896 p_create_info: *const FramebufferCreateInfo, 897 p_allocator: *const AllocationCallbacks, 898 p_framebuffer: *mut Framebuffer, 899 ) -> Result; 900 #[allow(non_camel_case_types)] 901 pub type PFN_vkDestroyFramebuffer = unsafe extern "system" fn( 902 device: Device, 903 framebuffer: Framebuffer, 904 p_allocator: *const AllocationCallbacks, 905 ); 906 #[allow(non_camel_case_types)] 907 pub type PFN_vkCreateRenderPass = unsafe extern "system" fn( 908 device: Device, 909 p_create_info: *const RenderPassCreateInfo, 910 p_allocator: *const AllocationCallbacks, 911 p_render_pass: *mut RenderPass, 912 ) -> Result; 913 #[allow(non_camel_case_types)] 914 pub type PFN_vkDestroyRenderPass = unsafe extern "system" fn( 915 device: Device, 916 render_pass: RenderPass, 917 p_allocator: *const AllocationCallbacks, 918 ); 919 #[allow(non_camel_case_types)] 920 pub type PFN_vkGetRenderAreaGranularity = unsafe extern "system" fn( 921 device: Device, 922 render_pass: RenderPass, 923 p_granularity: *mut Extent2D, 924 ); 925 #[allow(non_camel_case_types)] 926 pub type PFN_vkCreateCommandPool = unsafe extern "system" fn( 927 device: Device, 928 p_create_info: *const CommandPoolCreateInfo, 929 p_allocator: *const AllocationCallbacks, 930 p_command_pool: *mut CommandPool, 931 ) -> Result; 932 #[allow(non_camel_case_types)] 933 pub type PFN_vkDestroyCommandPool = unsafe extern "system" fn( 934 device: Device, 935 command_pool: CommandPool, 936 p_allocator: *const AllocationCallbacks, 937 ); 938 #[allow(non_camel_case_types)] 939 pub type PFN_vkResetCommandPool = unsafe extern "system" fn( 940 device: Device, 941 command_pool: CommandPool, 942 flags: CommandPoolResetFlags, 943 ) -> Result; 944 #[allow(non_camel_case_types)] 945 pub type PFN_vkAllocateCommandBuffers = unsafe extern "system" fn( 946 device: Device, 947 p_allocate_info: *const CommandBufferAllocateInfo, 948 p_command_buffers: *mut CommandBuffer, 949 ) -> Result; 950 #[allow(non_camel_case_types)] 951 pub type PFN_vkFreeCommandBuffers = unsafe extern "system" fn( 952 device: Device, 953 command_pool: CommandPool, 954 command_buffer_count: u32, 955 p_command_buffers: *const CommandBuffer, 956 ); 957 #[allow(non_camel_case_types)] 958 pub type PFN_vkBeginCommandBuffer = unsafe extern "system" fn( 959 command_buffer: CommandBuffer, 960 p_begin_info: *const CommandBufferBeginInfo, 961 ) -> Result; 962 #[allow(non_camel_case_types)] 963 pub type PFN_vkEndCommandBuffer = 964 unsafe extern "system" fn(command_buffer: CommandBuffer) -> Result; 965 #[allow(non_camel_case_types)] 966 pub type PFN_vkResetCommandBuffer = unsafe extern "system" fn( 967 command_buffer: CommandBuffer, 968 flags: CommandBufferResetFlags, 969 ) -> Result; 970 #[allow(non_camel_case_types)] 971 pub type PFN_vkCmdBindPipeline = unsafe extern "system" fn( 972 command_buffer: CommandBuffer, 973 pipeline_bind_point: PipelineBindPoint, 974 pipeline: Pipeline, 975 ); 976 #[allow(non_camel_case_types)] 977 pub type PFN_vkCmdSetViewport = unsafe extern "system" fn( 978 command_buffer: CommandBuffer, 979 first_viewport: u32, 980 viewport_count: u32, 981 p_viewports: *const Viewport, 982 ); 983 #[allow(non_camel_case_types)] 984 pub type PFN_vkCmdSetScissor = unsafe extern "system" fn( 985 command_buffer: CommandBuffer, 986 first_scissor: u32, 987 scissor_count: u32, 988 p_scissors: *const Rect2D, 989 ); 990 #[allow(non_camel_case_types)] 991 pub type PFN_vkCmdSetLineWidth = 992 unsafe extern "system" fn(command_buffer: CommandBuffer, line_width: f32); 993 #[allow(non_camel_case_types)] 994 pub type PFN_vkCmdSetDepthBias = unsafe extern "system" fn( 995 command_buffer: CommandBuffer, 996 depth_bias_constant_factor: f32, 997 depth_bias_clamp: f32, 998 depth_bias_slope_factor: f32, 999 ); 1000 #[allow(non_camel_case_types)] 1001 pub type PFN_vkCmdSetBlendConstants = 1002 unsafe extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4usize]); 1003 #[allow(non_camel_case_types)] 1004 pub type PFN_vkCmdSetDepthBounds = unsafe extern "system" fn( 1005 command_buffer: CommandBuffer, 1006 min_depth_bounds: f32, 1007 max_depth_bounds: f32, 1008 ); 1009 #[allow(non_camel_case_types)] 1010 pub type PFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn( 1011 command_buffer: CommandBuffer, 1012 face_mask: StencilFaceFlags, 1013 compare_mask: u32, 1014 ); 1015 #[allow(non_camel_case_types)] 1016 pub type PFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn( 1017 command_buffer: CommandBuffer, 1018 face_mask: StencilFaceFlags, 1019 write_mask: u32, 1020 ); 1021 #[allow(non_camel_case_types)] 1022 pub type PFN_vkCmdSetStencilReference = unsafe extern "system" fn( 1023 command_buffer: CommandBuffer, 1024 face_mask: StencilFaceFlags, 1025 reference: u32, 1026 ); 1027 #[allow(non_camel_case_types)] 1028 pub type PFN_vkCmdBindDescriptorSets = unsafe extern "system" fn( 1029 command_buffer: CommandBuffer, 1030 pipeline_bind_point: PipelineBindPoint, 1031 layout: PipelineLayout, 1032 first_set: u32, 1033 descriptor_set_count: u32, 1034 p_descriptor_sets: *const DescriptorSet, 1035 dynamic_offset_count: u32, 1036 p_dynamic_offsets: *const u32, 1037 ); 1038 #[allow(non_camel_case_types)] 1039 pub type PFN_vkCmdBindIndexBuffer = unsafe extern "system" fn( 1040 command_buffer: CommandBuffer, 1041 buffer: Buffer, 1042 offset: DeviceSize, 1043 index_type: IndexType, 1044 ); 1045 #[allow(non_camel_case_types)] 1046 pub type PFN_vkCmdBindVertexBuffers = unsafe extern "system" fn( 1047 command_buffer: CommandBuffer, 1048 first_binding: u32, 1049 binding_count: u32, 1050 p_buffers: *const Buffer, 1051 p_offsets: *const DeviceSize, 1052 ); 1053 #[allow(non_camel_case_types)] 1054 pub type PFN_vkCmdDraw = unsafe extern "system" fn( 1055 command_buffer: CommandBuffer, 1056 vertex_count: u32, 1057 instance_count: u32, 1058 first_vertex: u32, 1059 first_instance: u32, 1060 ); 1061 #[allow(non_camel_case_types)] 1062 pub type PFN_vkCmdDrawIndexed = unsafe extern "system" fn( 1063 command_buffer: CommandBuffer, 1064 index_count: u32, 1065 instance_count: u32, 1066 first_index: u32, 1067 vertex_offset: i32, 1068 first_instance: u32, 1069 ); 1070 #[allow(non_camel_case_types)] 1071 pub type PFN_vkCmdDrawIndirect = unsafe extern "system" fn( 1072 command_buffer: CommandBuffer, 1073 buffer: Buffer, 1074 offset: DeviceSize, 1075 draw_count: u32, 1076 stride: u32, 1077 ); 1078 #[allow(non_camel_case_types)] 1079 pub type PFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn( 1080 command_buffer: CommandBuffer, 1081 buffer: Buffer, 1082 offset: DeviceSize, 1083 draw_count: u32, 1084 stride: u32, 1085 ); 1086 #[allow(non_camel_case_types)] 1087 pub type PFN_vkCmdDispatch = unsafe extern "system" fn( 1088 command_buffer: CommandBuffer, 1089 group_count_x: u32, 1090 group_count_y: u32, 1091 group_count_z: u32, 1092 ); 1093 #[allow(non_camel_case_types)] 1094 pub type PFN_vkCmdDispatchIndirect = 1095 unsafe extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize); 1096 #[allow(non_camel_case_types)] 1097 pub type PFN_vkCmdCopyBuffer = unsafe extern "system" fn( 1098 command_buffer: CommandBuffer, 1099 src_buffer: Buffer, 1100 dst_buffer: Buffer, 1101 region_count: u32, 1102 p_regions: *const BufferCopy, 1103 ); 1104 #[allow(non_camel_case_types)] 1105 pub type PFN_vkCmdCopyImage = unsafe extern "system" fn( 1106 command_buffer: CommandBuffer, 1107 src_image: Image, 1108 src_image_layout: ImageLayout, 1109 dst_image: Image, 1110 dst_image_layout: ImageLayout, 1111 region_count: u32, 1112 p_regions: *const ImageCopy, 1113 ); 1114 #[allow(non_camel_case_types)] 1115 pub type PFN_vkCmdBlitImage = unsafe extern "system" fn( 1116 command_buffer: CommandBuffer, 1117 src_image: Image, 1118 src_image_layout: ImageLayout, 1119 dst_image: Image, 1120 dst_image_layout: ImageLayout, 1121 region_count: u32, 1122 p_regions: *const ImageBlit, 1123 filter: Filter, 1124 ); 1125 #[allow(non_camel_case_types)] 1126 pub type PFN_vkCmdCopyBufferToImage = unsafe extern "system" fn( 1127 command_buffer: CommandBuffer, 1128 src_buffer: Buffer, 1129 dst_image: Image, 1130 dst_image_layout: ImageLayout, 1131 region_count: u32, 1132 p_regions: *const BufferImageCopy, 1133 ); 1134 #[allow(non_camel_case_types)] 1135 pub type PFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn( 1136 command_buffer: CommandBuffer, 1137 src_image: Image, 1138 src_image_layout: ImageLayout, 1139 dst_buffer: Buffer, 1140 region_count: u32, 1141 p_regions: *const BufferImageCopy, 1142 ); 1143 #[allow(non_camel_case_types)] 1144 pub type PFN_vkCmdUpdateBuffer = unsafe extern "system" fn( 1145 command_buffer: CommandBuffer, 1146 dst_buffer: Buffer, 1147 dst_offset: DeviceSize, 1148 data_size: DeviceSize, 1149 p_data: *const c_void, 1150 ); 1151 #[allow(non_camel_case_types)] 1152 pub type PFN_vkCmdFillBuffer = unsafe extern "system" fn( 1153 command_buffer: CommandBuffer, 1154 dst_buffer: Buffer, 1155 dst_offset: DeviceSize, 1156 size: DeviceSize, 1157 data: u32, 1158 ); 1159 #[allow(non_camel_case_types)] 1160 pub type PFN_vkCmdClearColorImage = unsafe extern "system" fn( 1161 command_buffer: CommandBuffer, 1162 image: Image, 1163 image_layout: ImageLayout, 1164 p_color: *const ClearColorValue, 1165 range_count: u32, 1166 p_ranges: *const ImageSubresourceRange, 1167 ); 1168 #[allow(non_camel_case_types)] 1169 pub type PFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn( 1170 command_buffer: CommandBuffer, 1171 image: Image, 1172 image_layout: ImageLayout, 1173 p_depth_stencil: *const ClearDepthStencilValue, 1174 range_count: u32, 1175 p_ranges: *const ImageSubresourceRange, 1176 ); 1177 #[allow(non_camel_case_types)] 1178 pub type PFN_vkCmdClearAttachments = unsafe extern "system" fn( 1179 command_buffer: CommandBuffer, 1180 attachment_count: u32, 1181 p_attachments: *const ClearAttachment, 1182 rect_count: u32, 1183 p_rects: *const ClearRect, 1184 ); 1185 #[allow(non_camel_case_types)] 1186 pub type PFN_vkCmdResolveImage = unsafe extern "system" fn( 1187 command_buffer: CommandBuffer, 1188 src_image: Image, 1189 src_image_layout: ImageLayout, 1190 dst_image: Image, 1191 dst_image_layout: ImageLayout, 1192 region_count: u32, 1193 p_regions: *const ImageResolve, 1194 ); 1195 #[allow(non_camel_case_types)] 1196 pub type PFN_vkCmdSetEvent = unsafe extern "system" fn( 1197 command_buffer: CommandBuffer, 1198 event: Event, 1199 stage_mask: PipelineStageFlags, 1200 ); 1201 #[allow(non_camel_case_types)] 1202 pub type PFN_vkCmdResetEvent = unsafe extern "system" fn( 1203 command_buffer: CommandBuffer, 1204 event: Event, 1205 stage_mask: PipelineStageFlags, 1206 ); 1207 #[allow(non_camel_case_types)] 1208 pub type PFN_vkCmdWaitEvents = unsafe extern "system" fn( 1209 command_buffer: CommandBuffer, 1210 event_count: u32, 1211 p_events: *const Event, 1212 src_stage_mask: PipelineStageFlags, 1213 dst_stage_mask: PipelineStageFlags, 1214 memory_barrier_count: u32, 1215 p_memory_barriers: *const MemoryBarrier, 1216 buffer_memory_barrier_count: u32, 1217 p_buffer_memory_barriers: *const BufferMemoryBarrier, 1218 image_memory_barrier_count: u32, 1219 p_image_memory_barriers: *const ImageMemoryBarrier, 1220 ); 1221 #[allow(non_camel_case_types)] 1222 pub type PFN_vkCmdPipelineBarrier = unsafe extern "system" fn( 1223 command_buffer: CommandBuffer, 1224 src_stage_mask: PipelineStageFlags, 1225 dst_stage_mask: PipelineStageFlags, 1226 dependency_flags: DependencyFlags, 1227 memory_barrier_count: u32, 1228 p_memory_barriers: *const MemoryBarrier, 1229 buffer_memory_barrier_count: u32, 1230 p_buffer_memory_barriers: *const BufferMemoryBarrier, 1231 image_memory_barrier_count: u32, 1232 p_image_memory_barriers: *const ImageMemoryBarrier, 1233 ); 1234 #[allow(non_camel_case_types)] 1235 pub type PFN_vkCmdBeginQuery = unsafe extern "system" fn( 1236 command_buffer: CommandBuffer, 1237 query_pool: QueryPool, 1238 query: u32, 1239 flags: QueryControlFlags, 1240 ); 1241 #[allow(non_camel_case_types)] 1242 pub type PFN_vkCmdEndQuery = 1243 unsafe extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32); 1244 #[allow(non_camel_case_types)] 1245 pub type PFN_vkCmdResetQueryPool = unsafe extern "system" fn( 1246 command_buffer: CommandBuffer, 1247 query_pool: QueryPool, 1248 first_query: u32, 1249 query_count: u32, 1250 ); 1251 #[allow(non_camel_case_types)] 1252 pub type PFN_vkCmdWriteTimestamp = unsafe extern "system" fn( 1253 command_buffer: CommandBuffer, 1254 pipeline_stage: PipelineStageFlags, 1255 query_pool: QueryPool, 1256 query: u32, 1257 ); 1258 #[allow(non_camel_case_types)] 1259 pub type PFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn( 1260 command_buffer: CommandBuffer, 1261 query_pool: QueryPool, 1262 first_query: u32, 1263 query_count: u32, 1264 dst_buffer: Buffer, 1265 dst_offset: DeviceSize, 1266 stride: DeviceSize, 1267 flags: QueryResultFlags, 1268 ); 1269 #[allow(non_camel_case_types)] 1270 pub type PFN_vkCmdPushConstants = unsafe extern "system" fn( 1271 command_buffer: CommandBuffer, 1272 layout: PipelineLayout, 1273 stage_flags: ShaderStageFlags, 1274 offset: u32, 1275 size: u32, 1276 p_values: *const c_void, 1277 ); 1278 #[allow(non_camel_case_types)] 1279 pub type PFN_vkCmdBeginRenderPass = unsafe extern "system" fn( 1280 command_buffer: CommandBuffer, 1281 p_render_pass_begin: *const RenderPassBeginInfo, 1282 contents: SubpassContents, 1283 ); 1284 #[allow(non_camel_case_types)] 1285 pub type PFN_vkCmdNextSubpass = 1286 unsafe extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents); 1287 #[allow(non_camel_case_types)] 1288 pub type PFN_vkCmdEndRenderPass = unsafe extern "system" fn(command_buffer: CommandBuffer); 1289 #[allow(non_camel_case_types)] 1290 pub type PFN_vkCmdExecuteCommands = unsafe extern "system" fn( 1291 command_buffer: CommandBuffer, 1292 command_buffer_count: u32, 1293 p_command_buffers: *const CommandBuffer, 1294 ); 1295 #[derive(Clone)] 1296 pub struct DeviceFnV1_0 { 1297 pub destroy_device: PFN_vkDestroyDevice, 1298 pub get_device_queue: PFN_vkGetDeviceQueue, 1299 pub queue_submit: PFN_vkQueueSubmit, 1300 pub queue_wait_idle: PFN_vkQueueWaitIdle, 1301 pub device_wait_idle: PFN_vkDeviceWaitIdle, 1302 pub allocate_memory: PFN_vkAllocateMemory, 1303 pub free_memory: PFN_vkFreeMemory, 1304 pub map_memory: PFN_vkMapMemory, 1305 pub unmap_memory: PFN_vkUnmapMemory, 1306 pub flush_mapped_memory_ranges: PFN_vkFlushMappedMemoryRanges, 1307 pub invalidate_mapped_memory_ranges: PFN_vkInvalidateMappedMemoryRanges, 1308 pub get_device_memory_commitment: PFN_vkGetDeviceMemoryCommitment, 1309 pub bind_buffer_memory: PFN_vkBindBufferMemory, 1310 pub bind_image_memory: PFN_vkBindImageMemory, 1311 pub get_buffer_memory_requirements: PFN_vkGetBufferMemoryRequirements, 1312 pub get_image_memory_requirements: PFN_vkGetImageMemoryRequirements, 1313 pub get_image_sparse_memory_requirements: PFN_vkGetImageSparseMemoryRequirements, 1314 pub queue_bind_sparse: PFN_vkQueueBindSparse, 1315 pub create_fence: PFN_vkCreateFence, 1316 pub destroy_fence: PFN_vkDestroyFence, 1317 pub reset_fences: PFN_vkResetFences, 1318 pub get_fence_status: PFN_vkGetFenceStatus, 1319 pub wait_for_fences: PFN_vkWaitForFences, 1320 pub create_semaphore: PFN_vkCreateSemaphore, 1321 pub destroy_semaphore: PFN_vkDestroySemaphore, 1322 pub create_event: PFN_vkCreateEvent, 1323 pub destroy_event: PFN_vkDestroyEvent, 1324 pub get_event_status: PFN_vkGetEventStatus, 1325 pub set_event: PFN_vkSetEvent, 1326 pub reset_event: PFN_vkResetEvent, 1327 pub create_query_pool: PFN_vkCreateQueryPool, 1328 pub destroy_query_pool: PFN_vkDestroyQueryPool, 1329 pub get_query_pool_results: PFN_vkGetQueryPoolResults, 1330 pub create_buffer: PFN_vkCreateBuffer, 1331 pub destroy_buffer: PFN_vkDestroyBuffer, 1332 pub create_buffer_view: PFN_vkCreateBufferView, 1333 pub destroy_buffer_view: PFN_vkDestroyBufferView, 1334 pub create_image: PFN_vkCreateImage, 1335 pub destroy_image: PFN_vkDestroyImage, 1336 pub get_image_subresource_layout: PFN_vkGetImageSubresourceLayout, 1337 pub create_image_view: PFN_vkCreateImageView, 1338 pub destroy_image_view: PFN_vkDestroyImageView, 1339 pub create_shader_module: PFN_vkCreateShaderModule, 1340 pub destroy_shader_module: PFN_vkDestroyShaderModule, 1341 pub create_pipeline_cache: PFN_vkCreatePipelineCache, 1342 pub destroy_pipeline_cache: PFN_vkDestroyPipelineCache, 1343 pub get_pipeline_cache_data: PFN_vkGetPipelineCacheData, 1344 pub merge_pipeline_caches: PFN_vkMergePipelineCaches, 1345 pub create_graphics_pipelines: PFN_vkCreateGraphicsPipelines, 1346 pub create_compute_pipelines: PFN_vkCreateComputePipelines, 1347 pub destroy_pipeline: PFN_vkDestroyPipeline, 1348 pub create_pipeline_layout: PFN_vkCreatePipelineLayout, 1349 pub destroy_pipeline_layout: PFN_vkDestroyPipelineLayout, 1350 pub create_sampler: PFN_vkCreateSampler, 1351 pub destroy_sampler: PFN_vkDestroySampler, 1352 pub create_descriptor_set_layout: PFN_vkCreateDescriptorSetLayout, 1353 pub destroy_descriptor_set_layout: PFN_vkDestroyDescriptorSetLayout, 1354 pub create_descriptor_pool: PFN_vkCreateDescriptorPool, 1355 pub destroy_descriptor_pool: PFN_vkDestroyDescriptorPool, 1356 pub reset_descriptor_pool: PFN_vkResetDescriptorPool, 1357 pub allocate_descriptor_sets: PFN_vkAllocateDescriptorSets, 1358 pub free_descriptor_sets: PFN_vkFreeDescriptorSets, 1359 pub update_descriptor_sets: PFN_vkUpdateDescriptorSets, 1360 pub create_framebuffer: PFN_vkCreateFramebuffer, 1361 pub destroy_framebuffer: PFN_vkDestroyFramebuffer, 1362 pub create_render_pass: PFN_vkCreateRenderPass, 1363 pub destroy_render_pass: PFN_vkDestroyRenderPass, 1364 pub get_render_area_granularity: PFN_vkGetRenderAreaGranularity, 1365 pub create_command_pool: PFN_vkCreateCommandPool, 1366 pub destroy_command_pool: PFN_vkDestroyCommandPool, 1367 pub reset_command_pool: PFN_vkResetCommandPool, 1368 pub allocate_command_buffers: PFN_vkAllocateCommandBuffers, 1369 pub free_command_buffers: PFN_vkFreeCommandBuffers, 1370 pub begin_command_buffer: PFN_vkBeginCommandBuffer, 1371 pub end_command_buffer: PFN_vkEndCommandBuffer, 1372 pub reset_command_buffer: PFN_vkResetCommandBuffer, 1373 pub cmd_bind_pipeline: PFN_vkCmdBindPipeline, 1374 pub cmd_set_viewport: PFN_vkCmdSetViewport, 1375 pub cmd_set_scissor: PFN_vkCmdSetScissor, 1376 pub cmd_set_line_width: PFN_vkCmdSetLineWidth, 1377 pub cmd_set_depth_bias: PFN_vkCmdSetDepthBias, 1378 pub cmd_set_blend_constants: PFN_vkCmdSetBlendConstants, 1379 pub cmd_set_depth_bounds: PFN_vkCmdSetDepthBounds, 1380 pub cmd_set_stencil_compare_mask: PFN_vkCmdSetStencilCompareMask, 1381 pub cmd_set_stencil_write_mask: PFN_vkCmdSetStencilWriteMask, 1382 pub cmd_set_stencil_reference: PFN_vkCmdSetStencilReference, 1383 pub cmd_bind_descriptor_sets: PFN_vkCmdBindDescriptorSets, 1384 pub cmd_bind_index_buffer: PFN_vkCmdBindIndexBuffer, 1385 pub cmd_bind_vertex_buffers: PFN_vkCmdBindVertexBuffers, 1386 pub cmd_draw: PFN_vkCmdDraw, 1387 pub cmd_draw_indexed: PFN_vkCmdDrawIndexed, 1388 pub cmd_draw_indirect: PFN_vkCmdDrawIndirect, 1389 pub cmd_draw_indexed_indirect: PFN_vkCmdDrawIndexedIndirect, 1390 pub cmd_dispatch: PFN_vkCmdDispatch, 1391 pub cmd_dispatch_indirect: PFN_vkCmdDispatchIndirect, 1392 pub cmd_copy_buffer: PFN_vkCmdCopyBuffer, 1393 pub cmd_copy_image: PFN_vkCmdCopyImage, 1394 pub cmd_blit_image: PFN_vkCmdBlitImage, 1395 pub cmd_copy_buffer_to_image: PFN_vkCmdCopyBufferToImage, 1396 pub cmd_copy_image_to_buffer: PFN_vkCmdCopyImageToBuffer, 1397 pub cmd_update_buffer: PFN_vkCmdUpdateBuffer, 1398 pub cmd_fill_buffer: PFN_vkCmdFillBuffer, 1399 pub cmd_clear_color_image: PFN_vkCmdClearColorImage, 1400 pub cmd_clear_depth_stencil_image: PFN_vkCmdClearDepthStencilImage, 1401 pub cmd_clear_attachments: PFN_vkCmdClearAttachments, 1402 pub cmd_resolve_image: PFN_vkCmdResolveImage, 1403 pub cmd_set_event: PFN_vkCmdSetEvent, 1404 pub cmd_reset_event: PFN_vkCmdResetEvent, 1405 pub cmd_wait_events: PFN_vkCmdWaitEvents, 1406 pub cmd_pipeline_barrier: PFN_vkCmdPipelineBarrier, 1407 pub cmd_begin_query: PFN_vkCmdBeginQuery, 1408 pub cmd_end_query: PFN_vkCmdEndQuery, 1409 pub cmd_reset_query_pool: PFN_vkCmdResetQueryPool, 1410 pub cmd_write_timestamp: PFN_vkCmdWriteTimestamp, 1411 pub cmd_copy_query_pool_results: PFN_vkCmdCopyQueryPoolResults, 1412 pub cmd_push_constants: PFN_vkCmdPushConstants, 1413 pub cmd_begin_render_pass: PFN_vkCmdBeginRenderPass, 1414 pub cmd_next_subpass: PFN_vkCmdNextSubpass, 1415 pub cmd_end_render_pass: PFN_vkCmdEndRenderPass, 1416 pub cmd_execute_commands: PFN_vkCmdExecuteCommands, 1417 } 1418 unsafe impl Send for DeviceFnV1_0 {} 1419 unsafe impl Sync for DeviceFnV1_0 {} 1420 impl DeviceFnV1_0 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,1421 pub fn load<F>(mut _f: F) -> Self 1422 where 1423 F: FnMut(&::std::ffi::CStr) -> *const c_void, 1424 { 1425 Self { 1426 destroy_device: unsafe { 1427 unsafe extern "system" fn destroy_device( 1428 _device: Device, 1429 _p_allocator: *const AllocationCallbacks, 1430 ) { 1431 panic!(concat!("Unable to load ", stringify!(destroy_device))) 1432 } 1433 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDevice\0"); 1434 let val = _f(cname); 1435 if val.is_null() { 1436 destroy_device 1437 } else { 1438 ::std::mem::transmute(val) 1439 } 1440 }, 1441 get_device_queue: unsafe { 1442 unsafe extern "system" fn get_device_queue( 1443 _device: Device, 1444 _queue_family_index: u32, 1445 _queue_index: u32, 1446 _p_queue: *mut Queue, 1447 ) { 1448 panic!(concat!("Unable to load ", stringify!(get_device_queue))) 1449 } 1450 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue\0"); 1451 let val = _f(cname); 1452 if val.is_null() { 1453 get_device_queue 1454 } else { 1455 ::std::mem::transmute(val) 1456 } 1457 }, 1458 queue_submit: unsafe { 1459 unsafe extern "system" fn queue_submit( 1460 _queue: Queue, 1461 _submit_count: u32, 1462 _p_submits: *const SubmitInfo, 1463 _fence: Fence, 1464 ) -> Result { 1465 panic!(concat!("Unable to load ", stringify!(queue_submit))) 1466 } 1467 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit\0"); 1468 let val = _f(cname); 1469 if val.is_null() { 1470 queue_submit 1471 } else { 1472 ::std::mem::transmute(val) 1473 } 1474 }, 1475 queue_wait_idle: unsafe { 1476 unsafe extern "system" fn queue_wait_idle(_queue: Queue) -> Result { 1477 panic!(concat!("Unable to load ", stringify!(queue_wait_idle))) 1478 } 1479 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueWaitIdle\0"); 1480 let val = _f(cname); 1481 if val.is_null() { 1482 queue_wait_idle 1483 } else { 1484 ::std::mem::transmute(val) 1485 } 1486 }, 1487 device_wait_idle: unsafe { 1488 unsafe extern "system" fn device_wait_idle(_device: Device) -> Result { 1489 panic!(concat!("Unable to load ", stringify!(device_wait_idle))) 1490 } 1491 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDeviceWaitIdle\0"); 1492 let val = _f(cname); 1493 if val.is_null() { 1494 device_wait_idle 1495 } else { 1496 ::std::mem::transmute(val) 1497 } 1498 }, 1499 allocate_memory: unsafe { 1500 unsafe extern "system" fn allocate_memory( 1501 _device: Device, 1502 _p_allocate_info: *const MemoryAllocateInfo, 1503 _p_allocator: *const AllocationCallbacks, 1504 _p_memory: *mut DeviceMemory, 1505 ) -> Result { 1506 panic!(concat!("Unable to load ", stringify!(allocate_memory))) 1507 } 1508 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateMemory\0"); 1509 let val = _f(cname); 1510 if val.is_null() { 1511 allocate_memory 1512 } else { 1513 ::std::mem::transmute(val) 1514 } 1515 }, 1516 free_memory: unsafe { 1517 unsafe extern "system" fn free_memory( 1518 _device: Device, 1519 _memory: DeviceMemory, 1520 _p_allocator: *const AllocationCallbacks, 1521 ) { 1522 panic!(concat!("Unable to load ", stringify!(free_memory))) 1523 } 1524 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeMemory\0"); 1525 let val = _f(cname); 1526 if val.is_null() { 1527 free_memory 1528 } else { 1529 ::std::mem::transmute(val) 1530 } 1531 }, 1532 map_memory: unsafe { 1533 unsafe extern "system" fn map_memory( 1534 _device: Device, 1535 _memory: DeviceMemory, 1536 _offset: DeviceSize, 1537 _size: DeviceSize, 1538 _flags: MemoryMapFlags, 1539 _pp_data: *mut *mut c_void, 1540 ) -> Result { 1541 panic!(concat!("Unable to load ", stringify!(map_memory))) 1542 } 1543 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory\0"); 1544 let val = _f(cname); 1545 if val.is_null() { 1546 map_memory 1547 } else { 1548 ::std::mem::transmute(val) 1549 } 1550 }, 1551 unmap_memory: unsafe { 1552 unsafe extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) { 1553 panic!(concat!("Unable to load ", stringify!(unmap_memory))) 1554 } 1555 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory\0"); 1556 let val = _f(cname); 1557 if val.is_null() { 1558 unmap_memory 1559 } else { 1560 ::std::mem::transmute(val) 1561 } 1562 }, 1563 flush_mapped_memory_ranges: unsafe { 1564 unsafe extern "system" fn flush_mapped_memory_ranges( 1565 _device: Device, 1566 _memory_range_count: u32, 1567 _p_memory_ranges: *const MappedMemoryRange, 1568 ) -> Result { 1569 panic!(concat!( 1570 "Unable to load ", 1571 stringify!(flush_mapped_memory_ranges) 1572 )) 1573 } 1574 let cname = 1575 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFlushMappedMemoryRanges\0"); 1576 let val = _f(cname); 1577 if val.is_null() { 1578 flush_mapped_memory_ranges 1579 } else { 1580 ::std::mem::transmute(val) 1581 } 1582 }, 1583 invalidate_mapped_memory_ranges: unsafe { 1584 unsafe extern "system" fn invalidate_mapped_memory_ranges( 1585 _device: Device, 1586 _memory_range_count: u32, 1587 _p_memory_ranges: *const MappedMemoryRange, 1588 ) -> Result { 1589 panic!(concat!( 1590 "Unable to load ", 1591 stringify!(invalidate_mapped_memory_ranges) 1592 )) 1593 } 1594 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 1595 b"vkInvalidateMappedMemoryRanges\0", 1596 ); 1597 let val = _f(cname); 1598 if val.is_null() { 1599 invalidate_mapped_memory_ranges 1600 } else { 1601 ::std::mem::transmute(val) 1602 } 1603 }, 1604 get_device_memory_commitment: unsafe { 1605 unsafe extern "system" fn get_device_memory_commitment( 1606 _device: Device, 1607 _memory: DeviceMemory, 1608 _p_committed_memory_in_bytes: *mut DeviceSize, 1609 ) { 1610 panic!(concat!( 1611 "Unable to load ", 1612 stringify!(get_device_memory_commitment) 1613 )) 1614 } 1615 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 1616 b"vkGetDeviceMemoryCommitment\0", 1617 ); 1618 let val = _f(cname); 1619 if val.is_null() { 1620 get_device_memory_commitment 1621 } else { 1622 ::std::mem::transmute(val) 1623 } 1624 }, 1625 bind_buffer_memory: unsafe { 1626 unsafe extern "system" fn bind_buffer_memory( 1627 _device: Device, 1628 _buffer: Buffer, 1629 _memory: DeviceMemory, 1630 _memory_offset: DeviceSize, 1631 ) -> Result { 1632 panic!(concat!("Unable to load ", stringify!(bind_buffer_memory))) 1633 } 1634 let cname = 1635 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory\0"); 1636 let val = _f(cname); 1637 if val.is_null() { 1638 bind_buffer_memory 1639 } else { 1640 ::std::mem::transmute(val) 1641 } 1642 }, 1643 bind_image_memory: unsafe { 1644 unsafe extern "system" fn bind_image_memory( 1645 _device: Device, 1646 _image: Image, 1647 _memory: DeviceMemory, 1648 _memory_offset: DeviceSize, 1649 ) -> Result { 1650 panic!(concat!("Unable to load ", stringify!(bind_image_memory))) 1651 } 1652 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory\0"); 1653 let val = _f(cname); 1654 if val.is_null() { 1655 bind_image_memory 1656 } else { 1657 ::std::mem::transmute(val) 1658 } 1659 }, 1660 get_buffer_memory_requirements: unsafe { 1661 unsafe extern "system" fn get_buffer_memory_requirements( 1662 _device: Device, 1663 _buffer: Buffer, 1664 _p_memory_requirements: *mut MemoryRequirements, 1665 ) { 1666 panic!(concat!( 1667 "Unable to load ", 1668 stringify!(get_buffer_memory_requirements) 1669 )) 1670 } 1671 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 1672 b"vkGetBufferMemoryRequirements\0", 1673 ); 1674 let val = _f(cname); 1675 if val.is_null() { 1676 get_buffer_memory_requirements 1677 } else { 1678 ::std::mem::transmute(val) 1679 } 1680 }, 1681 get_image_memory_requirements: unsafe { 1682 unsafe extern "system" fn get_image_memory_requirements( 1683 _device: Device, 1684 _image: Image, 1685 _p_memory_requirements: *mut MemoryRequirements, 1686 ) { 1687 panic!(concat!( 1688 "Unable to load ", 1689 stringify!(get_image_memory_requirements) 1690 )) 1691 } 1692 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 1693 b"vkGetImageMemoryRequirements\0", 1694 ); 1695 let val = _f(cname); 1696 if val.is_null() { 1697 get_image_memory_requirements 1698 } else { 1699 ::std::mem::transmute(val) 1700 } 1701 }, 1702 get_image_sparse_memory_requirements: unsafe { 1703 unsafe extern "system" fn get_image_sparse_memory_requirements( 1704 _device: Device, 1705 _image: Image, 1706 _p_sparse_memory_requirement_count: *mut u32, 1707 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, 1708 ) { 1709 panic!(concat!( 1710 "Unable to load ", 1711 stringify!(get_image_sparse_memory_requirements) 1712 )) 1713 } 1714 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 1715 b"vkGetImageSparseMemoryRequirements\0", 1716 ); 1717 let val = _f(cname); 1718 if val.is_null() { 1719 get_image_sparse_memory_requirements 1720 } else { 1721 ::std::mem::transmute(val) 1722 } 1723 }, 1724 queue_bind_sparse: unsafe { 1725 unsafe extern "system" fn queue_bind_sparse( 1726 _queue: Queue, 1727 _bind_info_count: u32, 1728 _p_bind_info: *const BindSparseInfo, 1729 _fence: Fence, 1730 ) -> Result { 1731 panic!(concat!("Unable to load ", stringify!(queue_bind_sparse))) 1732 } 1733 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueBindSparse\0"); 1734 let val = _f(cname); 1735 if val.is_null() { 1736 queue_bind_sparse 1737 } else { 1738 ::std::mem::transmute(val) 1739 } 1740 }, 1741 create_fence: unsafe { 1742 unsafe extern "system" fn create_fence( 1743 _device: Device, 1744 _p_create_info: *const FenceCreateInfo, 1745 _p_allocator: *const AllocationCallbacks, 1746 _p_fence: *mut Fence, 1747 ) -> Result { 1748 panic!(concat!("Unable to load ", stringify!(create_fence))) 1749 } 1750 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFence\0"); 1751 let val = _f(cname); 1752 if val.is_null() { 1753 create_fence 1754 } else { 1755 ::std::mem::transmute(val) 1756 } 1757 }, 1758 destroy_fence: unsafe { 1759 unsafe extern "system" fn destroy_fence( 1760 _device: Device, 1761 _fence: Fence, 1762 _p_allocator: *const AllocationCallbacks, 1763 ) { 1764 panic!(concat!("Unable to load ", stringify!(destroy_fence))) 1765 } 1766 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFence\0"); 1767 let val = _f(cname); 1768 if val.is_null() { 1769 destroy_fence 1770 } else { 1771 ::std::mem::transmute(val) 1772 } 1773 }, 1774 reset_fences: unsafe { 1775 unsafe extern "system" fn reset_fences( 1776 _device: Device, 1777 _fence_count: u32, 1778 _p_fences: *const Fence, 1779 ) -> Result { 1780 panic!(concat!("Unable to load ", stringify!(reset_fences))) 1781 } 1782 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetFences\0"); 1783 let val = _f(cname); 1784 if val.is_null() { 1785 reset_fences 1786 } else { 1787 ::std::mem::transmute(val) 1788 } 1789 }, 1790 get_fence_status: unsafe { 1791 unsafe extern "system" fn get_fence_status( 1792 _device: Device, 1793 _fence: Fence, 1794 ) -> Result { 1795 panic!(concat!("Unable to load ", stringify!(get_fence_status))) 1796 } 1797 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceStatus\0"); 1798 let val = _f(cname); 1799 if val.is_null() { 1800 get_fence_status 1801 } else { 1802 ::std::mem::transmute(val) 1803 } 1804 }, 1805 wait_for_fences: unsafe { 1806 unsafe extern "system" fn wait_for_fences( 1807 _device: Device, 1808 _fence_count: u32, 1809 _p_fences: *const Fence, 1810 _wait_all: Bool32, 1811 _timeout: u64, 1812 ) -> Result { 1813 panic!(concat!("Unable to load ", stringify!(wait_for_fences))) 1814 } 1815 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForFences\0"); 1816 let val = _f(cname); 1817 if val.is_null() { 1818 wait_for_fences 1819 } else { 1820 ::std::mem::transmute(val) 1821 } 1822 }, 1823 create_semaphore: unsafe { 1824 unsafe extern "system" fn create_semaphore( 1825 _device: Device, 1826 _p_create_info: *const SemaphoreCreateInfo, 1827 _p_allocator: *const AllocationCallbacks, 1828 _p_semaphore: *mut Semaphore, 1829 ) -> Result { 1830 panic!(concat!("Unable to load ", stringify!(create_semaphore))) 1831 } 1832 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSemaphore\0"); 1833 let val = _f(cname); 1834 if val.is_null() { 1835 create_semaphore 1836 } else { 1837 ::std::mem::transmute(val) 1838 } 1839 }, 1840 destroy_semaphore: unsafe { 1841 unsafe extern "system" fn destroy_semaphore( 1842 _device: Device, 1843 _semaphore: Semaphore, 1844 _p_allocator: *const AllocationCallbacks, 1845 ) { 1846 panic!(concat!("Unable to load ", stringify!(destroy_semaphore))) 1847 } 1848 let cname = 1849 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySemaphore\0"); 1850 let val = _f(cname); 1851 if val.is_null() { 1852 destroy_semaphore 1853 } else { 1854 ::std::mem::transmute(val) 1855 } 1856 }, 1857 create_event: unsafe { 1858 unsafe extern "system" fn create_event( 1859 _device: Device, 1860 _p_create_info: *const EventCreateInfo, 1861 _p_allocator: *const AllocationCallbacks, 1862 _p_event: *mut Event, 1863 ) -> Result { 1864 panic!(concat!("Unable to load ", stringify!(create_event))) 1865 } 1866 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateEvent\0"); 1867 let val = _f(cname); 1868 if val.is_null() { 1869 create_event 1870 } else { 1871 ::std::mem::transmute(val) 1872 } 1873 }, 1874 destroy_event: unsafe { 1875 unsafe extern "system" fn destroy_event( 1876 _device: Device, 1877 _event: Event, 1878 _p_allocator: *const AllocationCallbacks, 1879 ) { 1880 panic!(concat!("Unable to load ", stringify!(destroy_event))) 1881 } 1882 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyEvent\0"); 1883 let val = _f(cname); 1884 if val.is_null() { 1885 destroy_event 1886 } else { 1887 ::std::mem::transmute(val) 1888 } 1889 }, 1890 get_event_status: unsafe { 1891 unsafe extern "system" fn get_event_status( 1892 _device: Device, 1893 _event: Event, 1894 ) -> Result { 1895 panic!(concat!("Unable to load ", stringify!(get_event_status))) 1896 } 1897 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetEventStatus\0"); 1898 let val = _f(cname); 1899 if val.is_null() { 1900 get_event_status 1901 } else { 1902 ::std::mem::transmute(val) 1903 } 1904 }, 1905 set_event: unsafe { 1906 unsafe extern "system" fn set_event(_device: Device, _event: Event) -> Result { 1907 panic!(concat!("Unable to load ", stringify!(set_event))) 1908 } 1909 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetEvent\0"); 1910 let val = _f(cname); 1911 if val.is_null() { 1912 set_event 1913 } else { 1914 ::std::mem::transmute(val) 1915 } 1916 }, 1917 reset_event: unsafe { 1918 unsafe extern "system" fn reset_event(_device: Device, _event: Event) -> Result { 1919 panic!(concat!("Unable to load ", stringify!(reset_event))) 1920 } 1921 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetEvent\0"); 1922 let val = _f(cname); 1923 if val.is_null() { 1924 reset_event 1925 } else { 1926 ::std::mem::transmute(val) 1927 } 1928 }, 1929 create_query_pool: unsafe { 1930 unsafe extern "system" fn create_query_pool( 1931 _device: Device, 1932 _p_create_info: *const QueryPoolCreateInfo, 1933 _p_allocator: *const AllocationCallbacks, 1934 _p_query_pool: *mut QueryPool, 1935 ) -> Result { 1936 panic!(concat!("Unable to load ", stringify!(create_query_pool))) 1937 } 1938 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateQueryPool\0"); 1939 let val = _f(cname); 1940 if val.is_null() { 1941 create_query_pool 1942 } else { 1943 ::std::mem::transmute(val) 1944 } 1945 }, 1946 destroy_query_pool: unsafe { 1947 unsafe extern "system" fn destroy_query_pool( 1948 _device: Device, 1949 _query_pool: QueryPool, 1950 _p_allocator: *const AllocationCallbacks, 1951 ) { 1952 panic!(concat!("Unable to load ", stringify!(destroy_query_pool))) 1953 } 1954 let cname = 1955 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyQueryPool\0"); 1956 let val = _f(cname); 1957 if val.is_null() { 1958 destroy_query_pool 1959 } else { 1960 ::std::mem::transmute(val) 1961 } 1962 }, 1963 get_query_pool_results: unsafe { 1964 unsafe extern "system" fn get_query_pool_results( 1965 _device: Device, 1966 _query_pool: QueryPool, 1967 _first_query: u32, 1968 _query_count: u32, 1969 _data_size: usize, 1970 _p_data: *mut c_void, 1971 _stride: DeviceSize, 1972 _flags: QueryResultFlags, 1973 ) -> Result { 1974 panic!(concat!( 1975 "Unable to load ", 1976 stringify!(get_query_pool_results) 1977 )) 1978 } 1979 let cname = 1980 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetQueryPoolResults\0"); 1981 let val = _f(cname); 1982 if val.is_null() { 1983 get_query_pool_results 1984 } else { 1985 ::std::mem::transmute(val) 1986 } 1987 }, 1988 create_buffer: unsafe { 1989 unsafe extern "system" fn create_buffer( 1990 _device: Device, 1991 _p_create_info: *const BufferCreateInfo, 1992 _p_allocator: *const AllocationCallbacks, 1993 _p_buffer: *mut Buffer, 1994 ) -> Result { 1995 panic!(concat!("Unable to load ", stringify!(create_buffer))) 1996 } 1997 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBuffer\0"); 1998 let val = _f(cname); 1999 if val.is_null() { 2000 create_buffer 2001 } else { 2002 ::std::mem::transmute(val) 2003 } 2004 }, 2005 destroy_buffer: unsafe { 2006 unsafe extern "system" fn destroy_buffer( 2007 _device: Device, 2008 _buffer: Buffer, 2009 _p_allocator: *const AllocationCallbacks, 2010 ) { 2011 panic!(concat!("Unable to load ", stringify!(destroy_buffer))) 2012 } 2013 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBuffer\0"); 2014 let val = _f(cname); 2015 if val.is_null() { 2016 destroy_buffer 2017 } else { 2018 ::std::mem::transmute(val) 2019 } 2020 }, 2021 create_buffer_view: unsafe { 2022 unsafe extern "system" fn create_buffer_view( 2023 _device: Device, 2024 _p_create_info: *const BufferViewCreateInfo, 2025 _p_allocator: *const AllocationCallbacks, 2026 _p_view: *mut BufferView, 2027 ) -> Result { 2028 panic!(concat!("Unable to load ", stringify!(create_buffer_view))) 2029 } 2030 let cname = 2031 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBufferView\0"); 2032 let val = _f(cname); 2033 if val.is_null() { 2034 create_buffer_view 2035 } else { 2036 ::std::mem::transmute(val) 2037 } 2038 }, 2039 destroy_buffer_view: unsafe { 2040 unsafe extern "system" fn destroy_buffer_view( 2041 _device: Device, 2042 _buffer_view: BufferView, 2043 _p_allocator: *const AllocationCallbacks, 2044 ) { 2045 panic!(concat!("Unable to load ", stringify!(destroy_buffer_view))) 2046 } 2047 let cname = 2048 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBufferView\0"); 2049 let val = _f(cname); 2050 if val.is_null() { 2051 destroy_buffer_view 2052 } else { 2053 ::std::mem::transmute(val) 2054 } 2055 }, 2056 create_image: unsafe { 2057 unsafe extern "system" fn create_image( 2058 _device: Device, 2059 _p_create_info: *const ImageCreateInfo, 2060 _p_allocator: *const AllocationCallbacks, 2061 _p_image: *mut Image, 2062 ) -> Result { 2063 panic!(concat!("Unable to load ", stringify!(create_image))) 2064 } 2065 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImage\0"); 2066 let val = _f(cname); 2067 if val.is_null() { 2068 create_image 2069 } else { 2070 ::std::mem::transmute(val) 2071 } 2072 }, 2073 destroy_image: unsafe { 2074 unsafe extern "system" fn destroy_image( 2075 _device: Device, 2076 _image: Image, 2077 _p_allocator: *const AllocationCallbacks, 2078 ) { 2079 panic!(concat!("Unable to load ", stringify!(destroy_image))) 2080 } 2081 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImage\0"); 2082 let val = _f(cname); 2083 if val.is_null() { 2084 destroy_image 2085 } else { 2086 ::std::mem::transmute(val) 2087 } 2088 }, 2089 get_image_subresource_layout: unsafe { 2090 unsafe extern "system" fn get_image_subresource_layout( 2091 _device: Device, 2092 _image: Image, 2093 _p_subresource: *const ImageSubresource, 2094 _p_layout: *mut SubresourceLayout, 2095 ) { 2096 panic!(concat!( 2097 "Unable to load ", 2098 stringify!(get_image_subresource_layout) 2099 )) 2100 } 2101 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2102 b"vkGetImageSubresourceLayout\0", 2103 ); 2104 let val = _f(cname); 2105 if val.is_null() { 2106 get_image_subresource_layout 2107 } else { 2108 ::std::mem::transmute(val) 2109 } 2110 }, 2111 create_image_view: unsafe { 2112 unsafe extern "system" fn create_image_view( 2113 _device: Device, 2114 _p_create_info: *const ImageViewCreateInfo, 2115 _p_allocator: *const AllocationCallbacks, 2116 _p_view: *mut ImageView, 2117 ) -> Result { 2118 panic!(concat!("Unable to load ", stringify!(create_image_view))) 2119 } 2120 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImageView\0"); 2121 let val = _f(cname); 2122 if val.is_null() { 2123 create_image_view 2124 } else { 2125 ::std::mem::transmute(val) 2126 } 2127 }, 2128 destroy_image_view: unsafe { 2129 unsafe extern "system" fn destroy_image_view( 2130 _device: Device, 2131 _image_view: ImageView, 2132 _p_allocator: *const AllocationCallbacks, 2133 ) { 2134 panic!(concat!("Unable to load ", stringify!(destroy_image_view))) 2135 } 2136 let cname = 2137 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImageView\0"); 2138 let val = _f(cname); 2139 if val.is_null() { 2140 destroy_image_view 2141 } else { 2142 ::std::mem::transmute(val) 2143 } 2144 }, 2145 create_shader_module: unsafe { 2146 unsafe extern "system" fn create_shader_module( 2147 _device: Device, 2148 _p_create_info: *const ShaderModuleCreateInfo, 2149 _p_allocator: *const AllocationCallbacks, 2150 _p_shader_module: *mut ShaderModule, 2151 ) -> Result { 2152 panic!(concat!("Unable to load ", stringify!(create_shader_module))) 2153 } 2154 let cname = 2155 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShaderModule\0"); 2156 let val = _f(cname); 2157 if val.is_null() { 2158 create_shader_module 2159 } else { 2160 ::std::mem::transmute(val) 2161 } 2162 }, 2163 destroy_shader_module: unsafe { 2164 unsafe extern "system" fn destroy_shader_module( 2165 _device: Device, 2166 _shader_module: ShaderModule, 2167 _p_allocator: *const AllocationCallbacks, 2168 ) { 2169 panic!(concat!( 2170 "Unable to load ", 2171 stringify!(destroy_shader_module) 2172 )) 2173 } 2174 let cname = 2175 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderModule\0"); 2176 let val = _f(cname); 2177 if val.is_null() { 2178 destroy_shader_module 2179 } else { 2180 ::std::mem::transmute(val) 2181 } 2182 }, 2183 create_pipeline_cache: unsafe { 2184 unsafe extern "system" fn create_pipeline_cache( 2185 _device: Device, 2186 _p_create_info: *const PipelineCacheCreateInfo, 2187 _p_allocator: *const AllocationCallbacks, 2188 _p_pipeline_cache: *mut PipelineCache, 2189 ) -> Result { 2190 panic!(concat!( 2191 "Unable to load ", 2192 stringify!(create_pipeline_cache) 2193 )) 2194 } 2195 let cname = 2196 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineCache\0"); 2197 let val = _f(cname); 2198 if val.is_null() { 2199 create_pipeline_cache 2200 } else { 2201 ::std::mem::transmute(val) 2202 } 2203 }, 2204 destroy_pipeline_cache: unsafe { 2205 unsafe extern "system" fn destroy_pipeline_cache( 2206 _device: Device, 2207 _pipeline_cache: PipelineCache, 2208 _p_allocator: *const AllocationCallbacks, 2209 ) { 2210 panic!(concat!( 2211 "Unable to load ", 2212 stringify!(destroy_pipeline_cache) 2213 )) 2214 } 2215 let cname = 2216 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineCache\0"); 2217 let val = _f(cname); 2218 if val.is_null() { 2219 destroy_pipeline_cache 2220 } else { 2221 ::std::mem::transmute(val) 2222 } 2223 }, 2224 get_pipeline_cache_data: unsafe { 2225 unsafe extern "system" fn get_pipeline_cache_data( 2226 _device: Device, 2227 _pipeline_cache: PipelineCache, 2228 _p_data_size: *mut usize, 2229 _p_data: *mut c_void, 2230 ) -> Result { 2231 panic!(concat!( 2232 "Unable to load ", 2233 stringify!(get_pipeline_cache_data) 2234 )) 2235 } 2236 let cname = 2237 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPipelineCacheData\0"); 2238 let val = _f(cname); 2239 if val.is_null() { 2240 get_pipeline_cache_data 2241 } else { 2242 ::std::mem::transmute(val) 2243 } 2244 }, 2245 merge_pipeline_caches: unsafe { 2246 unsafe extern "system" fn merge_pipeline_caches( 2247 _device: Device, 2248 _dst_cache: PipelineCache, 2249 _src_cache_count: u32, 2250 _p_src_caches: *const PipelineCache, 2251 ) -> Result { 2252 panic!(concat!( 2253 "Unable to load ", 2254 stringify!(merge_pipeline_caches) 2255 )) 2256 } 2257 let cname = 2258 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMergePipelineCaches\0"); 2259 let val = _f(cname); 2260 if val.is_null() { 2261 merge_pipeline_caches 2262 } else { 2263 ::std::mem::transmute(val) 2264 } 2265 }, 2266 create_graphics_pipelines: unsafe { 2267 unsafe extern "system" fn create_graphics_pipelines( 2268 _device: Device, 2269 _pipeline_cache: PipelineCache, 2270 _create_info_count: u32, 2271 _p_create_infos: *const GraphicsPipelineCreateInfo, 2272 _p_allocator: *const AllocationCallbacks, 2273 _p_pipelines: *mut Pipeline, 2274 ) -> Result { 2275 panic!(concat!( 2276 "Unable to load ", 2277 stringify!(create_graphics_pipelines) 2278 )) 2279 } 2280 let cname = 2281 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGraphicsPipelines\0"); 2282 let val = _f(cname); 2283 if val.is_null() { 2284 create_graphics_pipelines 2285 } else { 2286 ::std::mem::transmute(val) 2287 } 2288 }, 2289 create_compute_pipelines: unsafe { 2290 unsafe extern "system" fn create_compute_pipelines( 2291 _device: Device, 2292 _pipeline_cache: PipelineCache, 2293 _create_info_count: u32, 2294 _p_create_infos: *const ComputePipelineCreateInfo, 2295 _p_allocator: *const AllocationCallbacks, 2296 _p_pipelines: *mut Pipeline, 2297 ) -> Result { 2298 panic!(concat!( 2299 "Unable to load ", 2300 stringify!(create_compute_pipelines) 2301 )) 2302 } 2303 let cname = 2304 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateComputePipelines\0"); 2305 let val = _f(cname); 2306 if val.is_null() { 2307 create_compute_pipelines 2308 } else { 2309 ::std::mem::transmute(val) 2310 } 2311 }, 2312 destroy_pipeline: unsafe { 2313 unsafe extern "system" fn destroy_pipeline( 2314 _device: Device, 2315 _pipeline: Pipeline, 2316 _p_allocator: *const AllocationCallbacks, 2317 ) { 2318 panic!(concat!("Unable to load ", stringify!(destroy_pipeline))) 2319 } 2320 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipeline\0"); 2321 let val = _f(cname); 2322 if val.is_null() { 2323 destroy_pipeline 2324 } else { 2325 ::std::mem::transmute(val) 2326 } 2327 }, 2328 create_pipeline_layout: unsafe { 2329 unsafe extern "system" fn create_pipeline_layout( 2330 _device: Device, 2331 _p_create_info: *const PipelineLayoutCreateInfo, 2332 _p_allocator: *const AllocationCallbacks, 2333 _p_pipeline_layout: *mut PipelineLayout, 2334 ) -> Result { 2335 panic!(concat!( 2336 "Unable to load ", 2337 stringify!(create_pipeline_layout) 2338 )) 2339 } 2340 let cname = 2341 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineLayout\0"); 2342 let val = _f(cname); 2343 if val.is_null() { 2344 create_pipeline_layout 2345 } else { 2346 ::std::mem::transmute(val) 2347 } 2348 }, 2349 destroy_pipeline_layout: unsafe { 2350 unsafe extern "system" fn destroy_pipeline_layout( 2351 _device: Device, 2352 _pipeline_layout: PipelineLayout, 2353 _p_allocator: *const AllocationCallbacks, 2354 ) { 2355 panic!(concat!( 2356 "Unable to load ", 2357 stringify!(destroy_pipeline_layout) 2358 )) 2359 } 2360 let cname = 2361 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineLayout\0"); 2362 let val = _f(cname); 2363 if val.is_null() { 2364 destroy_pipeline_layout 2365 } else { 2366 ::std::mem::transmute(val) 2367 } 2368 }, 2369 create_sampler: unsafe { 2370 unsafe extern "system" fn create_sampler( 2371 _device: Device, 2372 _p_create_info: *const SamplerCreateInfo, 2373 _p_allocator: *const AllocationCallbacks, 2374 _p_sampler: *mut Sampler, 2375 ) -> Result { 2376 panic!(concat!("Unable to load ", stringify!(create_sampler))) 2377 } 2378 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSampler\0"); 2379 let val = _f(cname); 2380 if val.is_null() { 2381 create_sampler 2382 } else { 2383 ::std::mem::transmute(val) 2384 } 2385 }, 2386 destroy_sampler: unsafe { 2387 unsafe extern "system" fn destroy_sampler( 2388 _device: Device, 2389 _sampler: Sampler, 2390 _p_allocator: *const AllocationCallbacks, 2391 ) { 2392 panic!(concat!("Unable to load ", stringify!(destroy_sampler))) 2393 } 2394 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySampler\0"); 2395 let val = _f(cname); 2396 if val.is_null() { 2397 destroy_sampler 2398 } else { 2399 ::std::mem::transmute(val) 2400 } 2401 }, 2402 create_descriptor_set_layout: unsafe { 2403 unsafe extern "system" fn create_descriptor_set_layout( 2404 _device: Device, 2405 _p_create_info: *const DescriptorSetLayoutCreateInfo, 2406 _p_allocator: *const AllocationCallbacks, 2407 _p_set_layout: *mut DescriptorSetLayout, 2408 ) -> Result { 2409 panic!(concat!( 2410 "Unable to load ", 2411 stringify!(create_descriptor_set_layout) 2412 )) 2413 } 2414 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2415 b"vkCreateDescriptorSetLayout\0", 2416 ); 2417 let val = _f(cname); 2418 if val.is_null() { 2419 create_descriptor_set_layout 2420 } else { 2421 ::std::mem::transmute(val) 2422 } 2423 }, 2424 destroy_descriptor_set_layout: unsafe { 2425 unsafe extern "system" fn destroy_descriptor_set_layout( 2426 _device: Device, 2427 _descriptor_set_layout: DescriptorSetLayout, 2428 _p_allocator: *const AllocationCallbacks, 2429 ) { 2430 panic!(concat!( 2431 "Unable to load ", 2432 stringify!(destroy_descriptor_set_layout) 2433 )) 2434 } 2435 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2436 b"vkDestroyDescriptorSetLayout\0", 2437 ); 2438 let val = _f(cname); 2439 if val.is_null() { 2440 destroy_descriptor_set_layout 2441 } else { 2442 ::std::mem::transmute(val) 2443 } 2444 }, 2445 create_descriptor_pool: unsafe { 2446 unsafe extern "system" fn create_descriptor_pool( 2447 _device: Device, 2448 _p_create_info: *const DescriptorPoolCreateInfo, 2449 _p_allocator: *const AllocationCallbacks, 2450 _p_descriptor_pool: *mut DescriptorPool, 2451 ) -> Result { 2452 panic!(concat!( 2453 "Unable to load ", 2454 stringify!(create_descriptor_pool) 2455 )) 2456 } 2457 let cname = 2458 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDescriptorPool\0"); 2459 let val = _f(cname); 2460 if val.is_null() { 2461 create_descriptor_pool 2462 } else { 2463 ::std::mem::transmute(val) 2464 } 2465 }, 2466 destroy_descriptor_pool: unsafe { 2467 unsafe extern "system" fn destroy_descriptor_pool( 2468 _device: Device, 2469 _descriptor_pool: DescriptorPool, 2470 _p_allocator: *const AllocationCallbacks, 2471 ) { 2472 panic!(concat!( 2473 "Unable to load ", 2474 stringify!(destroy_descriptor_pool) 2475 )) 2476 } 2477 let cname = 2478 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDescriptorPool\0"); 2479 let val = _f(cname); 2480 if val.is_null() { 2481 destroy_descriptor_pool 2482 } else { 2483 ::std::mem::transmute(val) 2484 } 2485 }, 2486 reset_descriptor_pool: unsafe { 2487 unsafe extern "system" fn reset_descriptor_pool( 2488 _device: Device, 2489 _descriptor_pool: DescriptorPool, 2490 _flags: DescriptorPoolResetFlags, 2491 ) -> Result { 2492 panic!(concat!( 2493 "Unable to load ", 2494 stringify!(reset_descriptor_pool) 2495 )) 2496 } 2497 let cname = 2498 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetDescriptorPool\0"); 2499 let val = _f(cname); 2500 if val.is_null() { 2501 reset_descriptor_pool 2502 } else { 2503 ::std::mem::transmute(val) 2504 } 2505 }, 2506 allocate_descriptor_sets: unsafe { 2507 unsafe extern "system" fn allocate_descriptor_sets( 2508 _device: Device, 2509 _p_allocate_info: *const DescriptorSetAllocateInfo, 2510 _p_descriptor_sets: *mut DescriptorSet, 2511 ) -> Result { 2512 panic!(concat!( 2513 "Unable to load ", 2514 stringify!(allocate_descriptor_sets) 2515 )) 2516 } 2517 let cname = 2518 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateDescriptorSets\0"); 2519 let val = _f(cname); 2520 if val.is_null() { 2521 allocate_descriptor_sets 2522 } else { 2523 ::std::mem::transmute(val) 2524 } 2525 }, 2526 free_descriptor_sets: unsafe { 2527 unsafe extern "system" fn free_descriptor_sets( 2528 _device: Device, 2529 _descriptor_pool: DescriptorPool, 2530 _descriptor_set_count: u32, 2531 _p_descriptor_sets: *const DescriptorSet, 2532 ) -> Result { 2533 panic!(concat!("Unable to load ", stringify!(free_descriptor_sets))) 2534 } 2535 let cname = 2536 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeDescriptorSets\0"); 2537 let val = _f(cname); 2538 if val.is_null() { 2539 free_descriptor_sets 2540 } else { 2541 ::std::mem::transmute(val) 2542 } 2543 }, 2544 update_descriptor_sets: unsafe { 2545 unsafe extern "system" fn update_descriptor_sets( 2546 _device: Device, 2547 _descriptor_write_count: u32, 2548 _p_descriptor_writes: *const WriteDescriptorSet, 2549 _descriptor_copy_count: u32, 2550 _p_descriptor_copies: *const CopyDescriptorSet, 2551 ) { 2552 panic!(concat!( 2553 "Unable to load ", 2554 stringify!(update_descriptor_sets) 2555 )) 2556 } 2557 let cname = 2558 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUpdateDescriptorSets\0"); 2559 let val = _f(cname); 2560 if val.is_null() { 2561 update_descriptor_sets 2562 } else { 2563 ::std::mem::transmute(val) 2564 } 2565 }, 2566 create_framebuffer: unsafe { 2567 unsafe extern "system" fn create_framebuffer( 2568 _device: Device, 2569 _p_create_info: *const FramebufferCreateInfo, 2570 _p_allocator: *const AllocationCallbacks, 2571 _p_framebuffer: *mut Framebuffer, 2572 ) -> Result { 2573 panic!(concat!("Unable to load ", stringify!(create_framebuffer))) 2574 } 2575 let cname = 2576 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFramebuffer\0"); 2577 let val = _f(cname); 2578 if val.is_null() { 2579 create_framebuffer 2580 } else { 2581 ::std::mem::transmute(val) 2582 } 2583 }, 2584 destroy_framebuffer: unsafe { 2585 unsafe extern "system" fn destroy_framebuffer( 2586 _device: Device, 2587 _framebuffer: Framebuffer, 2588 _p_allocator: *const AllocationCallbacks, 2589 ) { 2590 panic!(concat!("Unable to load ", stringify!(destroy_framebuffer))) 2591 } 2592 let cname = 2593 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFramebuffer\0"); 2594 let val = _f(cname); 2595 if val.is_null() { 2596 destroy_framebuffer 2597 } else { 2598 ::std::mem::transmute(val) 2599 } 2600 }, 2601 create_render_pass: unsafe { 2602 unsafe extern "system" fn create_render_pass( 2603 _device: Device, 2604 _p_create_info: *const RenderPassCreateInfo, 2605 _p_allocator: *const AllocationCallbacks, 2606 _p_render_pass: *mut RenderPass, 2607 ) -> Result { 2608 panic!(concat!("Unable to load ", stringify!(create_render_pass))) 2609 } 2610 let cname = 2611 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass\0"); 2612 let val = _f(cname); 2613 if val.is_null() { 2614 create_render_pass 2615 } else { 2616 ::std::mem::transmute(val) 2617 } 2618 }, 2619 destroy_render_pass: unsafe { 2620 unsafe extern "system" fn destroy_render_pass( 2621 _device: Device, 2622 _render_pass: RenderPass, 2623 _p_allocator: *const AllocationCallbacks, 2624 ) { 2625 panic!(concat!("Unable to load ", stringify!(destroy_render_pass))) 2626 } 2627 let cname = 2628 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyRenderPass\0"); 2629 let val = _f(cname); 2630 if val.is_null() { 2631 destroy_render_pass 2632 } else { 2633 ::std::mem::transmute(val) 2634 } 2635 }, 2636 get_render_area_granularity: unsafe { 2637 unsafe extern "system" fn get_render_area_granularity( 2638 _device: Device, 2639 _render_pass: RenderPass, 2640 _p_granularity: *mut Extent2D, 2641 ) { 2642 panic!(concat!( 2643 "Unable to load ", 2644 stringify!(get_render_area_granularity) 2645 )) 2646 } 2647 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2648 b"vkGetRenderAreaGranularity\0", 2649 ); 2650 let val = _f(cname); 2651 if val.is_null() { 2652 get_render_area_granularity 2653 } else { 2654 ::std::mem::transmute(val) 2655 } 2656 }, 2657 create_command_pool: unsafe { 2658 unsafe extern "system" fn create_command_pool( 2659 _device: Device, 2660 _p_create_info: *const CommandPoolCreateInfo, 2661 _p_allocator: *const AllocationCallbacks, 2662 _p_command_pool: *mut CommandPool, 2663 ) -> Result { 2664 panic!(concat!("Unable to load ", stringify!(create_command_pool))) 2665 } 2666 let cname = 2667 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCommandPool\0"); 2668 let val = _f(cname); 2669 if val.is_null() { 2670 create_command_pool 2671 } else { 2672 ::std::mem::transmute(val) 2673 } 2674 }, 2675 destroy_command_pool: unsafe { 2676 unsafe extern "system" fn destroy_command_pool( 2677 _device: Device, 2678 _command_pool: CommandPool, 2679 _p_allocator: *const AllocationCallbacks, 2680 ) { 2681 panic!(concat!("Unable to load ", stringify!(destroy_command_pool))) 2682 } 2683 let cname = 2684 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCommandPool\0"); 2685 let val = _f(cname); 2686 if val.is_null() { 2687 destroy_command_pool 2688 } else { 2689 ::std::mem::transmute(val) 2690 } 2691 }, 2692 reset_command_pool: unsafe { 2693 unsafe extern "system" fn reset_command_pool( 2694 _device: Device, 2695 _command_pool: CommandPool, 2696 _flags: CommandPoolResetFlags, 2697 ) -> Result { 2698 panic!(concat!("Unable to load ", stringify!(reset_command_pool))) 2699 } 2700 let cname = 2701 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandPool\0"); 2702 let val = _f(cname); 2703 if val.is_null() { 2704 reset_command_pool 2705 } else { 2706 ::std::mem::transmute(val) 2707 } 2708 }, 2709 allocate_command_buffers: unsafe { 2710 unsafe extern "system" fn allocate_command_buffers( 2711 _device: Device, 2712 _p_allocate_info: *const CommandBufferAllocateInfo, 2713 _p_command_buffers: *mut CommandBuffer, 2714 ) -> Result { 2715 panic!(concat!( 2716 "Unable to load ", 2717 stringify!(allocate_command_buffers) 2718 )) 2719 } 2720 let cname = 2721 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateCommandBuffers\0"); 2722 let val = _f(cname); 2723 if val.is_null() { 2724 allocate_command_buffers 2725 } else { 2726 ::std::mem::transmute(val) 2727 } 2728 }, 2729 free_command_buffers: unsafe { 2730 unsafe extern "system" fn free_command_buffers( 2731 _device: Device, 2732 _command_pool: CommandPool, 2733 _command_buffer_count: u32, 2734 _p_command_buffers: *const CommandBuffer, 2735 ) { 2736 panic!(concat!("Unable to load ", stringify!(free_command_buffers))) 2737 } 2738 let cname = 2739 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeCommandBuffers\0"); 2740 let val = _f(cname); 2741 if val.is_null() { 2742 free_command_buffers 2743 } else { 2744 ::std::mem::transmute(val) 2745 } 2746 }, 2747 begin_command_buffer: unsafe { 2748 unsafe extern "system" fn begin_command_buffer( 2749 _command_buffer: CommandBuffer, 2750 _p_begin_info: *const CommandBufferBeginInfo, 2751 ) -> Result { 2752 panic!(concat!("Unable to load ", stringify!(begin_command_buffer))) 2753 } 2754 let cname = 2755 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBeginCommandBuffer\0"); 2756 let val = _f(cname); 2757 if val.is_null() { 2758 begin_command_buffer 2759 } else { 2760 ::std::mem::transmute(val) 2761 } 2762 }, 2763 end_command_buffer: unsafe { 2764 unsafe extern "system" fn end_command_buffer( 2765 _command_buffer: CommandBuffer, 2766 ) -> Result { 2767 panic!(concat!("Unable to load ", stringify!(end_command_buffer))) 2768 } 2769 let cname = 2770 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkEndCommandBuffer\0"); 2771 let val = _f(cname); 2772 if val.is_null() { 2773 end_command_buffer 2774 } else { 2775 ::std::mem::transmute(val) 2776 } 2777 }, 2778 reset_command_buffer: unsafe { 2779 unsafe extern "system" fn reset_command_buffer( 2780 _command_buffer: CommandBuffer, 2781 _flags: CommandBufferResetFlags, 2782 ) -> Result { 2783 panic!(concat!("Unable to load ", stringify!(reset_command_buffer))) 2784 } 2785 let cname = 2786 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandBuffer\0"); 2787 let val = _f(cname); 2788 if val.is_null() { 2789 reset_command_buffer 2790 } else { 2791 ::std::mem::transmute(val) 2792 } 2793 }, 2794 cmd_bind_pipeline: unsafe { 2795 unsafe extern "system" fn cmd_bind_pipeline( 2796 _command_buffer: CommandBuffer, 2797 _pipeline_bind_point: PipelineBindPoint, 2798 _pipeline: Pipeline, 2799 ) { 2800 panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline))) 2801 } 2802 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindPipeline\0"); 2803 let val = _f(cname); 2804 if val.is_null() { 2805 cmd_bind_pipeline 2806 } else { 2807 ::std::mem::transmute(val) 2808 } 2809 }, 2810 cmd_set_viewport: unsafe { 2811 unsafe extern "system" fn cmd_set_viewport( 2812 _command_buffer: CommandBuffer, 2813 _first_viewport: u32, 2814 _viewport_count: u32, 2815 _p_viewports: *const Viewport, 2816 ) { 2817 panic!(concat!("Unable to load ", stringify!(cmd_set_viewport))) 2818 } 2819 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewport\0"); 2820 let val = _f(cname); 2821 if val.is_null() { 2822 cmd_set_viewport 2823 } else { 2824 ::std::mem::transmute(val) 2825 } 2826 }, 2827 cmd_set_scissor: unsafe { 2828 unsafe extern "system" fn cmd_set_scissor( 2829 _command_buffer: CommandBuffer, 2830 _first_scissor: u32, 2831 _scissor_count: u32, 2832 _p_scissors: *const Rect2D, 2833 ) { 2834 panic!(concat!("Unable to load ", stringify!(cmd_set_scissor))) 2835 } 2836 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissor\0"); 2837 let val = _f(cname); 2838 if val.is_null() { 2839 cmd_set_scissor 2840 } else { 2841 ::std::mem::transmute(val) 2842 } 2843 }, 2844 cmd_set_line_width: unsafe { 2845 unsafe extern "system" fn cmd_set_line_width( 2846 _command_buffer: CommandBuffer, 2847 _line_width: f32, 2848 ) { 2849 panic!(concat!("Unable to load ", stringify!(cmd_set_line_width))) 2850 } 2851 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineWidth\0"); 2852 let val = _f(cname); 2853 if val.is_null() { 2854 cmd_set_line_width 2855 } else { 2856 ::std::mem::transmute(val) 2857 } 2858 }, 2859 cmd_set_depth_bias: unsafe { 2860 unsafe extern "system" fn cmd_set_depth_bias( 2861 _command_buffer: CommandBuffer, 2862 _depth_bias_constant_factor: f32, 2863 _depth_bias_clamp: f32, 2864 _depth_bias_slope_factor: f32, 2865 ) { 2866 panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias))) 2867 } 2868 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias\0"); 2869 let val = _f(cname); 2870 if val.is_null() { 2871 cmd_set_depth_bias 2872 } else { 2873 ::std::mem::transmute(val) 2874 } 2875 }, 2876 cmd_set_blend_constants: unsafe { 2877 unsafe extern "system" fn cmd_set_blend_constants( 2878 _command_buffer: CommandBuffer, 2879 _blend_constants: *const [f32; 4usize], 2880 ) { 2881 panic!(concat!( 2882 "Unable to load ", 2883 stringify!(cmd_set_blend_constants) 2884 )) 2885 } 2886 let cname = 2887 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetBlendConstants\0"); 2888 let val = _f(cname); 2889 if val.is_null() { 2890 cmd_set_blend_constants 2891 } else { 2892 ::std::mem::transmute(val) 2893 } 2894 }, 2895 cmd_set_depth_bounds: unsafe { 2896 unsafe extern "system" fn cmd_set_depth_bounds( 2897 _command_buffer: CommandBuffer, 2898 _min_depth_bounds: f32, 2899 _max_depth_bounds: f32, 2900 ) { 2901 panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds))) 2902 } 2903 let cname = 2904 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBounds\0"); 2905 let val = _f(cname); 2906 if val.is_null() { 2907 cmd_set_depth_bounds 2908 } else { 2909 ::std::mem::transmute(val) 2910 } 2911 }, 2912 cmd_set_stencil_compare_mask: unsafe { 2913 unsafe extern "system" fn cmd_set_stencil_compare_mask( 2914 _command_buffer: CommandBuffer, 2915 _face_mask: StencilFaceFlags, 2916 _compare_mask: u32, 2917 ) { 2918 panic!(concat!( 2919 "Unable to load ", 2920 stringify!(cmd_set_stencil_compare_mask) 2921 )) 2922 } 2923 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2924 b"vkCmdSetStencilCompareMask\0", 2925 ); 2926 let val = _f(cname); 2927 if val.is_null() { 2928 cmd_set_stencil_compare_mask 2929 } else { 2930 ::std::mem::transmute(val) 2931 } 2932 }, 2933 cmd_set_stencil_write_mask: unsafe { 2934 unsafe extern "system" fn cmd_set_stencil_write_mask( 2935 _command_buffer: CommandBuffer, 2936 _face_mask: StencilFaceFlags, 2937 _write_mask: u32, 2938 ) { 2939 panic!(concat!( 2940 "Unable to load ", 2941 stringify!(cmd_set_stencil_write_mask) 2942 )) 2943 } 2944 let cname = 2945 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilWriteMask\0"); 2946 let val = _f(cname); 2947 if val.is_null() { 2948 cmd_set_stencil_write_mask 2949 } else { 2950 ::std::mem::transmute(val) 2951 } 2952 }, 2953 cmd_set_stencil_reference: unsafe { 2954 unsafe extern "system" fn cmd_set_stencil_reference( 2955 _command_buffer: CommandBuffer, 2956 _face_mask: StencilFaceFlags, 2957 _reference: u32, 2958 ) { 2959 panic!(concat!( 2960 "Unable to load ", 2961 stringify!(cmd_set_stencil_reference) 2962 )) 2963 } 2964 let cname = 2965 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilReference\0"); 2966 let val = _f(cname); 2967 if val.is_null() { 2968 cmd_set_stencil_reference 2969 } else { 2970 ::std::mem::transmute(val) 2971 } 2972 }, 2973 cmd_bind_descriptor_sets: unsafe { 2974 unsafe extern "system" fn cmd_bind_descriptor_sets( 2975 _command_buffer: CommandBuffer, 2976 _pipeline_bind_point: PipelineBindPoint, 2977 _layout: PipelineLayout, 2978 _first_set: u32, 2979 _descriptor_set_count: u32, 2980 _p_descriptor_sets: *const DescriptorSet, 2981 _dynamic_offset_count: u32, 2982 _p_dynamic_offsets: *const u32, 2983 ) { 2984 panic!(concat!( 2985 "Unable to load ", 2986 stringify!(cmd_bind_descriptor_sets) 2987 )) 2988 } 2989 let cname = 2990 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorSets\0"); 2991 let val = _f(cname); 2992 if val.is_null() { 2993 cmd_bind_descriptor_sets 2994 } else { 2995 ::std::mem::transmute(val) 2996 } 2997 }, 2998 cmd_bind_index_buffer: unsafe { 2999 unsafe extern "system" fn cmd_bind_index_buffer( 3000 _command_buffer: CommandBuffer, 3001 _buffer: Buffer, 3002 _offset: DeviceSize, 3003 _index_type: IndexType, 3004 ) { 3005 panic!(concat!( 3006 "Unable to load ", 3007 stringify!(cmd_bind_index_buffer) 3008 )) 3009 } 3010 let cname = 3011 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer\0"); 3012 let val = _f(cname); 3013 if val.is_null() { 3014 cmd_bind_index_buffer 3015 } else { 3016 ::std::mem::transmute(val) 3017 } 3018 }, 3019 cmd_bind_vertex_buffers: unsafe { 3020 unsafe extern "system" fn cmd_bind_vertex_buffers( 3021 _command_buffer: CommandBuffer, 3022 _first_binding: u32, 3023 _binding_count: u32, 3024 _p_buffers: *const Buffer, 3025 _p_offsets: *const DeviceSize, 3026 ) { 3027 panic!(concat!( 3028 "Unable to load ", 3029 stringify!(cmd_bind_vertex_buffers) 3030 )) 3031 } 3032 let cname = 3033 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers\0"); 3034 let val = _f(cname); 3035 if val.is_null() { 3036 cmd_bind_vertex_buffers 3037 } else { 3038 ::std::mem::transmute(val) 3039 } 3040 }, 3041 cmd_draw: unsafe { 3042 unsafe extern "system" fn cmd_draw( 3043 _command_buffer: CommandBuffer, 3044 _vertex_count: u32, 3045 _instance_count: u32, 3046 _first_vertex: u32, 3047 _first_instance: u32, 3048 ) { 3049 panic!(concat!("Unable to load ", stringify!(cmd_draw))) 3050 } 3051 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDraw\0"); 3052 let val = _f(cname); 3053 if val.is_null() { 3054 cmd_draw 3055 } else { 3056 ::std::mem::transmute(val) 3057 } 3058 }, 3059 cmd_draw_indexed: unsafe { 3060 unsafe extern "system" fn cmd_draw_indexed( 3061 _command_buffer: CommandBuffer, 3062 _index_count: u32, 3063 _instance_count: u32, 3064 _first_index: u32, 3065 _vertex_offset: i32, 3066 _first_instance: u32, 3067 ) { 3068 panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed))) 3069 } 3070 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexed\0"); 3071 let val = _f(cname); 3072 if val.is_null() { 3073 cmd_draw_indexed 3074 } else { 3075 ::std::mem::transmute(val) 3076 } 3077 }, 3078 cmd_draw_indirect: unsafe { 3079 unsafe extern "system" fn cmd_draw_indirect( 3080 _command_buffer: CommandBuffer, 3081 _buffer: Buffer, 3082 _offset: DeviceSize, 3083 _draw_count: u32, 3084 _stride: u32, 3085 ) { 3086 panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect))) 3087 } 3088 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirect\0"); 3089 let val = _f(cname); 3090 if val.is_null() { 3091 cmd_draw_indirect 3092 } else { 3093 ::std::mem::transmute(val) 3094 } 3095 }, 3096 cmd_draw_indexed_indirect: unsafe { 3097 unsafe extern "system" fn cmd_draw_indexed_indirect( 3098 _command_buffer: CommandBuffer, 3099 _buffer: Buffer, 3100 _offset: DeviceSize, 3101 _draw_count: u32, 3102 _stride: u32, 3103 ) { 3104 panic!(concat!( 3105 "Unable to load ", 3106 stringify!(cmd_draw_indexed_indirect) 3107 )) 3108 } 3109 let cname = 3110 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexedIndirect\0"); 3111 let val = _f(cname); 3112 if val.is_null() { 3113 cmd_draw_indexed_indirect 3114 } else { 3115 ::std::mem::transmute(val) 3116 } 3117 }, 3118 cmd_dispatch: unsafe { 3119 unsafe extern "system" fn cmd_dispatch( 3120 _command_buffer: CommandBuffer, 3121 _group_count_x: u32, 3122 _group_count_y: u32, 3123 _group_count_z: u32, 3124 ) { 3125 panic!(concat!("Unable to load ", stringify!(cmd_dispatch))) 3126 } 3127 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatch\0"); 3128 let val = _f(cname); 3129 if val.is_null() { 3130 cmd_dispatch 3131 } else { 3132 ::std::mem::transmute(val) 3133 } 3134 }, 3135 cmd_dispatch_indirect: unsafe { 3136 unsafe extern "system" fn cmd_dispatch_indirect( 3137 _command_buffer: CommandBuffer, 3138 _buffer: Buffer, 3139 _offset: DeviceSize, 3140 ) { 3141 panic!(concat!( 3142 "Unable to load ", 3143 stringify!(cmd_dispatch_indirect) 3144 )) 3145 } 3146 let cname = 3147 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchIndirect\0"); 3148 let val = _f(cname); 3149 if val.is_null() { 3150 cmd_dispatch_indirect 3151 } else { 3152 ::std::mem::transmute(val) 3153 } 3154 }, 3155 cmd_copy_buffer: unsafe { 3156 unsafe extern "system" fn cmd_copy_buffer( 3157 _command_buffer: CommandBuffer, 3158 _src_buffer: Buffer, 3159 _dst_buffer: Buffer, 3160 _region_count: u32, 3161 _p_regions: *const BufferCopy, 3162 ) { 3163 panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer))) 3164 } 3165 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer\0"); 3166 let val = _f(cname); 3167 if val.is_null() { 3168 cmd_copy_buffer 3169 } else { 3170 ::std::mem::transmute(val) 3171 } 3172 }, 3173 cmd_copy_image: unsafe { 3174 unsafe extern "system" fn cmd_copy_image( 3175 _command_buffer: CommandBuffer, 3176 _src_image: Image, 3177 _src_image_layout: ImageLayout, 3178 _dst_image: Image, 3179 _dst_image_layout: ImageLayout, 3180 _region_count: u32, 3181 _p_regions: *const ImageCopy, 3182 ) { 3183 panic!(concat!("Unable to load ", stringify!(cmd_copy_image))) 3184 } 3185 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage\0"); 3186 let val = _f(cname); 3187 if val.is_null() { 3188 cmd_copy_image 3189 } else { 3190 ::std::mem::transmute(val) 3191 } 3192 }, 3193 cmd_blit_image: unsafe { 3194 unsafe extern "system" fn cmd_blit_image( 3195 _command_buffer: CommandBuffer, 3196 _src_image: Image, 3197 _src_image_layout: ImageLayout, 3198 _dst_image: Image, 3199 _dst_image_layout: ImageLayout, 3200 _region_count: u32, 3201 _p_regions: *const ImageBlit, 3202 _filter: Filter, 3203 ) { 3204 panic!(concat!("Unable to load ", stringify!(cmd_blit_image))) 3205 } 3206 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage\0"); 3207 let val = _f(cname); 3208 if val.is_null() { 3209 cmd_blit_image 3210 } else { 3211 ::std::mem::transmute(val) 3212 } 3213 }, 3214 cmd_copy_buffer_to_image: unsafe { 3215 unsafe extern "system" fn cmd_copy_buffer_to_image( 3216 _command_buffer: CommandBuffer, 3217 _src_buffer: Buffer, 3218 _dst_image: Image, 3219 _dst_image_layout: ImageLayout, 3220 _region_count: u32, 3221 _p_regions: *const BufferImageCopy, 3222 ) { 3223 panic!(concat!( 3224 "Unable to load ", 3225 stringify!(cmd_copy_buffer_to_image) 3226 )) 3227 } 3228 let cname = 3229 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage\0"); 3230 let val = _f(cname); 3231 if val.is_null() { 3232 cmd_copy_buffer_to_image 3233 } else { 3234 ::std::mem::transmute(val) 3235 } 3236 }, 3237 cmd_copy_image_to_buffer: unsafe { 3238 unsafe extern "system" fn cmd_copy_image_to_buffer( 3239 _command_buffer: CommandBuffer, 3240 _src_image: Image, 3241 _src_image_layout: ImageLayout, 3242 _dst_buffer: Buffer, 3243 _region_count: u32, 3244 _p_regions: *const BufferImageCopy, 3245 ) { 3246 panic!(concat!( 3247 "Unable to load ", 3248 stringify!(cmd_copy_image_to_buffer) 3249 )) 3250 } 3251 let cname = 3252 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer\0"); 3253 let val = _f(cname); 3254 if val.is_null() { 3255 cmd_copy_image_to_buffer 3256 } else { 3257 ::std::mem::transmute(val) 3258 } 3259 }, 3260 cmd_update_buffer: unsafe { 3261 unsafe extern "system" fn cmd_update_buffer( 3262 _command_buffer: CommandBuffer, 3263 _dst_buffer: Buffer, 3264 _dst_offset: DeviceSize, 3265 _data_size: DeviceSize, 3266 _p_data: *const c_void, 3267 ) { 3268 panic!(concat!("Unable to load ", stringify!(cmd_update_buffer))) 3269 } 3270 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdUpdateBuffer\0"); 3271 let val = _f(cname); 3272 if val.is_null() { 3273 cmd_update_buffer 3274 } else { 3275 ::std::mem::transmute(val) 3276 } 3277 }, 3278 cmd_fill_buffer: unsafe { 3279 unsafe extern "system" fn cmd_fill_buffer( 3280 _command_buffer: CommandBuffer, 3281 _dst_buffer: Buffer, 3282 _dst_offset: DeviceSize, 3283 _size: DeviceSize, 3284 _data: u32, 3285 ) { 3286 panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer))) 3287 } 3288 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdFillBuffer\0"); 3289 let val = _f(cname); 3290 if val.is_null() { 3291 cmd_fill_buffer 3292 } else { 3293 ::std::mem::transmute(val) 3294 } 3295 }, 3296 cmd_clear_color_image: unsafe { 3297 unsafe extern "system" fn cmd_clear_color_image( 3298 _command_buffer: CommandBuffer, 3299 _image: Image, 3300 _image_layout: ImageLayout, 3301 _p_color: *const ClearColorValue, 3302 _range_count: u32, 3303 _p_ranges: *const ImageSubresourceRange, 3304 ) { 3305 panic!(concat!( 3306 "Unable to load ", 3307 stringify!(cmd_clear_color_image) 3308 )) 3309 } 3310 let cname = 3311 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearColorImage\0"); 3312 let val = _f(cname); 3313 if val.is_null() { 3314 cmd_clear_color_image 3315 } else { 3316 ::std::mem::transmute(val) 3317 } 3318 }, 3319 cmd_clear_depth_stencil_image: unsafe { 3320 unsafe extern "system" fn cmd_clear_depth_stencil_image( 3321 _command_buffer: CommandBuffer, 3322 _image: Image, 3323 _image_layout: ImageLayout, 3324 _p_depth_stencil: *const ClearDepthStencilValue, 3325 _range_count: u32, 3326 _p_ranges: *const ImageSubresourceRange, 3327 ) { 3328 panic!(concat!( 3329 "Unable to load ", 3330 stringify!(cmd_clear_depth_stencil_image) 3331 )) 3332 } 3333 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3334 b"vkCmdClearDepthStencilImage\0", 3335 ); 3336 let val = _f(cname); 3337 if val.is_null() { 3338 cmd_clear_depth_stencil_image 3339 } else { 3340 ::std::mem::transmute(val) 3341 } 3342 }, 3343 cmd_clear_attachments: unsafe { 3344 unsafe extern "system" fn cmd_clear_attachments( 3345 _command_buffer: CommandBuffer, 3346 _attachment_count: u32, 3347 _p_attachments: *const ClearAttachment, 3348 _rect_count: u32, 3349 _p_rects: *const ClearRect, 3350 ) { 3351 panic!(concat!( 3352 "Unable to load ", 3353 stringify!(cmd_clear_attachments) 3354 )) 3355 } 3356 let cname = 3357 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearAttachments\0"); 3358 let val = _f(cname); 3359 if val.is_null() { 3360 cmd_clear_attachments 3361 } else { 3362 ::std::mem::transmute(val) 3363 } 3364 }, 3365 cmd_resolve_image: unsafe { 3366 unsafe extern "system" fn cmd_resolve_image( 3367 _command_buffer: CommandBuffer, 3368 _src_image: Image, 3369 _src_image_layout: ImageLayout, 3370 _dst_image: Image, 3371 _dst_image_layout: ImageLayout, 3372 _region_count: u32, 3373 _p_regions: *const ImageResolve, 3374 ) { 3375 panic!(concat!("Unable to load ", stringify!(cmd_resolve_image))) 3376 } 3377 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage\0"); 3378 let val = _f(cname); 3379 if val.is_null() { 3380 cmd_resolve_image 3381 } else { 3382 ::std::mem::transmute(val) 3383 } 3384 }, 3385 cmd_set_event: unsafe { 3386 unsafe extern "system" fn cmd_set_event( 3387 _command_buffer: CommandBuffer, 3388 _event: Event, 3389 _stage_mask: PipelineStageFlags, 3390 ) { 3391 panic!(concat!("Unable to load ", stringify!(cmd_set_event))) 3392 } 3393 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent\0"); 3394 let val = _f(cname); 3395 if val.is_null() { 3396 cmd_set_event 3397 } else { 3398 ::std::mem::transmute(val) 3399 } 3400 }, 3401 cmd_reset_event: unsafe { 3402 unsafe extern "system" fn cmd_reset_event( 3403 _command_buffer: CommandBuffer, 3404 _event: Event, 3405 _stage_mask: PipelineStageFlags, 3406 ) { 3407 panic!(concat!("Unable to load ", stringify!(cmd_reset_event))) 3408 } 3409 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent\0"); 3410 let val = _f(cname); 3411 if val.is_null() { 3412 cmd_reset_event 3413 } else { 3414 ::std::mem::transmute(val) 3415 } 3416 }, 3417 cmd_wait_events: unsafe { 3418 unsafe extern "system" fn cmd_wait_events( 3419 _command_buffer: CommandBuffer, 3420 _event_count: u32, 3421 _p_events: *const Event, 3422 _src_stage_mask: PipelineStageFlags, 3423 _dst_stage_mask: PipelineStageFlags, 3424 _memory_barrier_count: u32, 3425 _p_memory_barriers: *const MemoryBarrier, 3426 _buffer_memory_barrier_count: u32, 3427 _p_buffer_memory_barriers: *const BufferMemoryBarrier, 3428 _image_memory_barrier_count: u32, 3429 _p_image_memory_barriers: *const ImageMemoryBarrier, 3430 ) { 3431 panic!(concat!("Unable to load ", stringify!(cmd_wait_events))) 3432 } 3433 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents\0"); 3434 let val = _f(cname); 3435 if val.is_null() { 3436 cmd_wait_events 3437 } else { 3438 ::std::mem::transmute(val) 3439 } 3440 }, 3441 cmd_pipeline_barrier: unsafe { 3442 unsafe extern "system" fn cmd_pipeline_barrier( 3443 _command_buffer: CommandBuffer, 3444 _src_stage_mask: PipelineStageFlags, 3445 _dst_stage_mask: PipelineStageFlags, 3446 _dependency_flags: DependencyFlags, 3447 _memory_barrier_count: u32, 3448 _p_memory_barriers: *const MemoryBarrier, 3449 _buffer_memory_barrier_count: u32, 3450 _p_buffer_memory_barriers: *const BufferMemoryBarrier, 3451 _image_memory_barrier_count: u32, 3452 _p_image_memory_barriers: *const ImageMemoryBarrier, 3453 ) { 3454 panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier))) 3455 } 3456 let cname = 3457 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier\0"); 3458 let val = _f(cname); 3459 if val.is_null() { 3460 cmd_pipeline_barrier 3461 } else { 3462 ::std::mem::transmute(val) 3463 } 3464 }, 3465 cmd_begin_query: unsafe { 3466 unsafe extern "system" fn cmd_begin_query( 3467 _command_buffer: CommandBuffer, 3468 _query_pool: QueryPool, 3469 _query: u32, 3470 _flags: QueryControlFlags, 3471 ) { 3472 panic!(concat!("Unable to load ", stringify!(cmd_begin_query))) 3473 } 3474 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQuery\0"); 3475 let val = _f(cname); 3476 if val.is_null() { 3477 cmd_begin_query 3478 } else { 3479 ::std::mem::transmute(val) 3480 } 3481 }, 3482 cmd_end_query: unsafe { 3483 unsafe extern "system" fn cmd_end_query( 3484 _command_buffer: CommandBuffer, 3485 _query_pool: QueryPool, 3486 _query: u32, 3487 ) { 3488 panic!(concat!("Unable to load ", stringify!(cmd_end_query))) 3489 } 3490 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQuery\0"); 3491 let val = _f(cname); 3492 if val.is_null() { 3493 cmd_end_query 3494 } else { 3495 ::std::mem::transmute(val) 3496 } 3497 }, 3498 cmd_reset_query_pool: unsafe { 3499 unsafe extern "system" fn cmd_reset_query_pool( 3500 _command_buffer: CommandBuffer, 3501 _query_pool: QueryPool, 3502 _first_query: u32, 3503 _query_count: u32, 3504 ) { 3505 panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool))) 3506 } 3507 let cname = 3508 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetQueryPool\0"); 3509 let val = _f(cname); 3510 if val.is_null() { 3511 cmd_reset_query_pool 3512 } else { 3513 ::std::mem::transmute(val) 3514 } 3515 }, 3516 cmd_write_timestamp: unsafe { 3517 unsafe extern "system" fn cmd_write_timestamp( 3518 _command_buffer: CommandBuffer, 3519 _pipeline_stage: PipelineStageFlags, 3520 _query_pool: QueryPool, 3521 _query: u32, 3522 ) { 3523 panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp))) 3524 } 3525 let cname = 3526 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp\0"); 3527 let val = _f(cname); 3528 if val.is_null() { 3529 cmd_write_timestamp 3530 } else { 3531 ::std::mem::transmute(val) 3532 } 3533 }, 3534 cmd_copy_query_pool_results: unsafe { 3535 unsafe extern "system" fn cmd_copy_query_pool_results( 3536 _command_buffer: CommandBuffer, 3537 _query_pool: QueryPool, 3538 _first_query: u32, 3539 _query_count: u32, 3540 _dst_buffer: Buffer, 3541 _dst_offset: DeviceSize, 3542 _stride: DeviceSize, 3543 _flags: QueryResultFlags, 3544 ) { 3545 panic!(concat!( 3546 "Unable to load ", 3547 stringify!(cmd_copy_query_pool_results) 3548 )) 3549 } 3550 let cname = 3551 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyQueryPoolResults\0"); 3552 let val = _f(cname); 3553 if val.is_null() { 3554 cmd_copy_query_pool_results 3555 } else { 3556 ::std::mem::transmute(val) 3557 } 3558 }, 3559 cmd_push_constants: unsafe { 3560 unsafe extern "system" fn cmd_push_constants( 3561 _command_buffer: CommandBuffer, 3562 _layout: PipelineLayout, 3563 _stage_flags: ShaderStageFlags, 3564 _offset: u32, 3565 _size: u32, 3566 _p_values: *const c_void, 3567 ) { 3568 panic!(concat!("Unable to load ", stringify!(cmd_push_constants))) 3569 } 3570 let cname = 3571 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushConstants\0"); 3572 let val = _f(cname); 3573 if val.is_null() { 3574 cmd_push_constants 3575 } else { 3576 ::std::mem::transmute(val) 3577 } 3578 }, 3579 cmd_begin_render_pass: unsafe { 3580 unsafe extern "system" fn cmd_begin_render_pass( 3581 _command_buffer: CommandBuffer, 3582 _p_render_pass_begin: *const RenderPassBeginInfo, 3583 _contents: SubpassContents, 3584 ) { 3585 panic!(concat!( 3586 "Unable to load ", 3587 stringify!(cmd_begin_render_pass) 3588 )) 3589 } 3590 let cname = 3591 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass\0"); 3592 let val = _f(cname); 3593 if val.is_null() { 3594 cmd_begin_render_pass 3595 } else { 3596 ::std::mem::transmute(val) 3597 } 3598 }, 3599 cmd_next_subpass: unsafe { 3600 unsafe extern "system" fn cmd_next_subpass( 3601 _command_buffer: CommandBuffer, 3602 _contents: SubpassContents, 3603 ) { 3604 panic!(concat!("Unable to load ", stringify!(cmd_next_subpass))) 3605 } 3606 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass\0"); 3607 let val = _f(cname); 3608 if val.is_null() { 3609 cmd_next_subpass 3610 } else { 3611 ::std::mem::transmute(val) 3612 } 3613 }, 3614 cmd_end_render_pass: unsafe { 3615 unsafe extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) { 3616 panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass))) 3617 } 3618 let cname = 3619 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass\0"); 3620 let val = _f(cname); 3621 if val.is_null() { 3622 cmd_end_render_pass 3623 } else { 3624 ::std::mem::transmute(val) 3625 } 3626 }, 3627 cmd_execute_commands: unsafe { 3628 unsafe extern "system" fn cmd_execute_commands( 3629 _command_buffer: CommandBuffer, 3630 _command_buffer_count: u32, 3631 _p_command_buffers: *const CommandBuffer, 3632 ) { 3633 panic!(concat!("Unable to load ", stringify!(cmd_execute_commands))) 3634 } 3635 let cname = 3636 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdExecuteCommands\0"); 3637 let val = _f(cname); 3638 if val.is_null() { 3639 cmd_execute_commands 3640 } else { 3641 ::std::mem::transmute(val) 3642 } 3643 }, 3644 } 3645 } 3646 } 3647 #[allow(non_camel_case_types)] 3648 pub type PFN_vkEnumerateInstanceVersion = 3649 unsafe extern "system" fn(p_api_version: *mut u32) -> Result; 3650 #[derive(Clone)] 3651 pub struct EntryFnV1_1 { 3652 pub enumerate_instance_version: PFN_vkEnumerateInstanceVersion, 3653 } 3654 unsafe impl Send for EntryFnV1_1 {} 3655 unsafe impl Sync for EntryFnV1_1 {} 3656 impl EntryFnV1_1 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,3657 pub fn load<F>(mut _f: F) -> Self 3658 where 3659 F: FnMut(&::std::ffi::CStr) -> *const c_void, 3660 { 3661 Self { 3662 enumerate_instance_version: unsafe { 3663 unsafe extern "system" fn enumerate_instance_version( 3664 _p_api_version: *mut u32, 3665 ) -> Result { 3666 panic!(concat!( 3667 "Unable to load ", 3668 stringify!(enumerate_instance_version) 3669 )) 3670 } 3671 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3672 b"vkEnumerateInstanceVersion\0", 3673 ); 3674 let val = _f(cname); 3675 if val.is_null() { 3676 enumerate_instance_version 3677 } else { 3678 ::std::mem::transmute(val) 3679 } 3680 }, 3681 } 3682 } 3683 } 3684 #[derive(Clone)] 3685 pub struct InstanceFnV1_1 { 3686 pub enumerate_physical_device_groups: crate::vk::PFN_vkEnumeratePhysicalDeviceGroups, 3687 pub get_physical_device_features2: crate::vk::PFN_vkGetPhysicalDeviceFeatures2, 3688 pub get_physical_device_properties2: crate::vk::PFN_vkGetPhysicalDeviceProperties2, 3689 pub get_physical_device_format_properties2: crate::vk::PFN_vkGetPhysicalDeviceFormatProperties2, 3690 pub get_physical_device_image_format_properties2: 3691 crate::vk::PFN_vkGetPhysicalDeviceImageFormatProperties2, 3692 pub get_physical_device_queue_family_properties2: 3693 crate::vk::PFN_vkGetPhysicalDeviceQueueFamilyProperties2, 3694 pub get_physical_device_memory_properties2: crate::vk::PFN_vkGetPhysicalDeviceMemoryProperties2, 3695 pub get_physical_device_sparse_image_format_properties2: 3696 crate::vk::PFN_vkGetPhysicalDeviceSparseImageFormatProperties2, 3697 pub get_physical_device_external_buffer_properties: 3698 crate::vk::PFN_vkGetPhysicalDeviceExternalBufferProperties, 3699 pub get_physical_device_external_fence_properties: 3700 crate::vk::PFN_vkGetPhysicalDeviceExternalFenceProperties, 3701 pub get_physical_device_external_semaphore_properties: 3702 crate::vk::PFN_vkGetPhysicalDeviceExternalSemaphoreProperties, 3703 } 3704 unsafe impl Send for InstanceFnV1_1 {} 3705 unsafe impl Sync for InstanceFnV1_1 {} 3706 impl InstanceFnV1_1 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,3707 pub fn load<F>(mut _f: F) -> Self 3708 where 3709 F: FnMut(&::std::ffi::CStr) -> *const c_void, 3710 { 3711 Self { 3712 enumerate_physical_device_groups: unsafe { 3713 unsafe extern "system" fn enumerate_physical_device_groups( 3714 _instance: Instance, 3715 _p_physical_device_group_count: *mut u32, 3716 _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, 3717 ) -> Result { 3718 panic!(concat!( 3719 "Unable to load ", 3720 stringify!(enumerate_physical_device_groups) 3721 )) 3722 } 3723 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3724 b"vkEnumeratePhysicalDeviceGroups\0", 3725 ); 3726 let val = _f(cname); 3727 if val.is_null() { 3728 enumerate_physical_device_groups 3729 } else { 3730 ::std::mem::transmute(val) 3731 } 3732 }, 3733 get_physical_device_features2: unsafe { 3734 unsafe extern "system" fn get_physical_device_features2( 3735 _physical_device: PhysicalDevice, 3736 _p_features: *mut PhysicalDeviceFeatures2, 3737 ) { 3738 panic!(concat!( 3739 "Unable to load ", 3740 stringify!(get_physical_device_features2) 3741 )) 3742 } 3743 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3744 b"vkGetPhysicalDeviceFeatures2\0", 3745 ); 3746 let val = _f(cname); 3747 if val.is_null() { 3748 get_physical_device_features2 3749 } else { 3750 ::std::mem::transmute(val) 3751 } 3752 }, 3753 get_physical_device_properties2: unsafe { 3754 unsafe extern "system" fn get_physical_device_properties2( 3755 _physical_device: PhysicalDevice, 3756 _p_properties: *mut PhysicalDeviceProperties2, 3757 ) { 3758 panic!(concat!( 3759 "Unable to load ", 3760 stringify!(get_physical_device_properties2) 3761 )) 3762 } 3763 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3764 b"vkGetPhysicalDeviceProperties2\0", 3765 ); 3766 let val = _f(cname); 3767 if val.is_null() { 3768 get_physical_device_properties2 3769 } else { 3770 ::std::mem::transmute(val) 3771 } 3772 }, 3773 get_physical_device_format_properties2: unsafe { 3774 unsafe extern "system" fn get_physical_device_format_properties2( 3775 _physical_device: PhysicalDevice, 3776 _format: Format, 3777 _p_format_properties: *mut FormatProperties2, 3778 ) { 3779 panic!(concat!( 3780 "Unable to load ", 3781 stringify!(get_physical_device_format_properties2) 3782 )) 3783 } 3784 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3785 b"vkGetPhysicalDeviceFormatProperties2\0", 3786 ); 3787 let val = _f(cname); 3788 if val.is_null() { 3789 get_physical_device_format_properties2 3790 } else { 3791 ::std::mem::transmute(val) 3792 } 3793 }, 3794 get_physical_device_image_format_properties2: unsafe { 3795 unsafe extern "system" fn get_physical_device_image_format_properties2( 3796 _physical_device: PhysicalDevice, 3797 _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, 3798 _p_image_format_properties: *mut ImageFormatProperties2, 3799 ) -> Result { 3800 panic!(concat!( 3801 "Unable to load ", 3802 stringify!(get_physical_device_image_format_properties2) 3803 )) 3804 } 3805 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3806 b"vkGetPhysicalDeviceImageFormatProperties2\0", 3807 ); 3808 let val = _f(cname); 3809 if val.is_null() { 3810 get_physical_device_image_format_properties2 3811 } else { 3812 ::std::mem::transmute(val) 3813 } 3814 }, 3815 get_physical_device_queue_family_properties2: unsafe { 3816 unsafe extern "system" fn get_physical_device_queue_family_properties2( 3817 _physical_device: PhysicalDevice, 3818 _p_queue_family_property_count: *mut u32, 3819 _p_queue_family_properties: *mut QueueFamilyProperties2, 3820 ) { 3821 panic!(concat!( 3822 "Unable to load ", 3823 stringify!(get_physical_device_queue_family_properties2) 3824 )) 3825 } 3826 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3827 b"vkGetPhysicalDeviceQueueFamilyProperties2\0", 3828 ); 3829 let val = _f(cname); 3830 if val.is_null() { 3831 get_physical_device_queue_family_properties2 3832 } else { 3833 ::std::mem::transmute(val) 3834 } 3835 }, 3836 get_physical_device_memory_properties2: unsafe { 3837 unsafe extern "system" fn get_physical_device_memory_properties2( 3838 _physical_device: PhysicalDevice, 3839 _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, 3840 ) { 3841 panic!(concat!( 3842 "Unable to load ", 3843 stringify!(get_physical_device_memory_properties2) 3844 )) 3845 } 3846 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3847 b"vkGetPhysicalDeviceMemoryProperties2\0", 3848 ); 3849 let val = _f(cname); 3850 if val.is_null() { 3851 get_physical_device_memory_properties2 3852 } else { 3853 ::std::mem::transmute(val) 3854 } 3855 }, 3856 get_physical_device_sparse_image_format_properties2: unsafe { 3857 unsafe extern "system" fn get_physical_device_sparse_image_format_properties2( 3858 _physical_device: PhysicalDevice, 3859 _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, 3860 _p_property_count: *mut u32, 3861 _p_properties: *mut SparseImageFormatProperties2, 3862 ) { 3863 panic!(concat!( 3864 "Unable to load ", 3865 stringify!(get_physical_device_sparse_image_format_properties2) 3866 )) 3867 } 3868 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3869 b"vkGetPhysicalDeviceSparseImageFormatProperties2\0", 3870 ); 3871 let val = _f(cname); 3872 if val.is_null() { 3873 get_physical_device_sparse_image_format_properties2 3874 } else { 3875 ::std::mem::transmute(val) 3876 } 3877 }, 3878 get_physical_device_external_buffer_properties: unsafe { 3879 unsafe extern "system" fn get_physical_device_external_buffer_properties( 3880 _physical_device: PhysicalDevice, 3881 _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, 3882 _p_external_buffer_properties: *mut ExternalBufferProperties, 3883 ) { 3884 panic!(concat!( 3885 "Unable to load ", 3886 stringify!(get_physical_device_external_buffer_properties) 3887 )) 3888 } 3889 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3890 b"vkGetPhysicalDeviceExternalBufferProperties\0", 3891 ); 3892 let val = _f(cname); 3893 if val.is_null() { 3894 get_physical_device_external_buffer_properties 3895 } else { 3896 ::std::mem::transmute(val) 3897 } 3898 }, 3899 get_physical_device_external_fence_properties: unsafe { 3900 unsafe extern "system" fn get_physical_device_external_fence_properties( 3901 _physical_device: PhysicalDevice, 3902 _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, 3903 _p_external_fence_properties: *mut ExternalFenceProperties, 3904 ) { 3905 panic!(concat!( 3906 "Unable to load ", 3907 stringify!(get_physical_device_external_fence_properties) 3908 )) 3909 } 3910 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3911 b"vkGetPhysicalDeviceExternalFenceProperties\0", 3912 ); 3913 let val = _f(cname); 3914 if val.is_null() { 3915 get_physical_device_external_fence_properties 3916 } else { 3917 ::std::mem::transmute(val) 3918 } 3919 }, 3920 get_physical_device_external_semaphore_properties: unsafe { 3921 unsafe extern "system" fn get_physical_device_external_semaphore_properties( 3922 _physical_device: PhysicalDevice, 3923 _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, 3924 _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, 3925 ) { 3926 panic!(concat!( 3927 "Unable to load ", 3928 stringify!(get_physical_device_external_semaphore_properties) 3929 )) 3930 } 3931 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3932 b"vkGetPhysicalDeviceExternalSemaphoreProperties\0", 3933 ); 3934 let val = _f(cname); 3935 if val.is_null() { 3936 get_physical_device_external_semaphore_properties 3937 } else { 3938 ::std::mem::transmute(val) 3939 } 3940 }, 3941 } 3942 } 3943 } 3944 #[allow(non_camel_case_types)] 3945 pub type PFN_vkGetDeviceQueue2 = unsafe extern "system" fn( 3946 device: Device, 3947 p_queue_info: *const DeviceQueueInfo2, 3948 p_queue: *mut Queue, 3949 ); 3950 #[derive(Clone)] 3951 pub struct DeviceFnV1_1 { 3952 pub bind_buffer_memory2: crate::vk::PFN_vkBindBufferMemory2, 3953 pub bind_image_memory2: crate::vk::PFN_vkBindImageMemory2, 3954 pub get_device_group_peer_memory_features: crate::vk::PFN_vkGetDeviceGroupPeerMemoryFeatures, 3955 pub cmd_set_device_mask: crate::vk::PFN_vkCmdSetDeviceMask, 3956 pub cmd_dispatch_base: crate::vk::PFN_vkCmdDispatchBase, 3957 pub get_image_memory_requirements2: crate::vk::PFN_vkGetImageMemoryRequirements2, 3958 pub get_buffer_memory_requirements2: crate::vk::PFN_vkGetBufferMemoryRequirements2, 3959 pub get_image_sparse_memory_requirements2: crate::vk::PFN_vkGetImageSparseMemoryRequirements2, 3960 pub trim_command_pool: crate::vk::PFN_vkTrimCommandPool, 3961 pub get_device_queue2: PFN_vkGetDeviceQueue2, 3962 pub create_sampler_ycbcr_conversion: crate::vk::PFN_vkCreateSamplerYcbcrConversion, 3963 pub destroy_sampler_ycbcr_conversion: crate::vk::PFN_vkDestroySamplerYcbcrConversion, 3964 pub create_descriptor_update_template: crate::vk::PFN_vkCreateDescriptorUpdateTemplate, 3965 pub destroy_descriptor_update_template: crate::vk::PFN_vkDestroyDescriptorUpdateTemplate, 3966 pub update_descriptor_set_with_template: crate::vk::PFN_vkUpdateDescriptorSetWithTemplate, 3967 pub get_descriptor_set_layout_support: crate::vk::PFN_vkGetDescriptorSetLayoutSupport, 3968 } 3969 unsafe impl Send for DeviceFnV1_1 {} 3970 unsafe impl Sync for DeviceFnV1_1 {} 3971 impl DeviceFnV1_1 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,3972 pub fn load<F>(mut _f: F) -> Self 3973 where 3974 F: FnMut(&::std::ffi::CStr) -> *const c_void, 3975 { 3976 Self { 3977 bind_buffer_memory2: unsafe { 3978 unsafe extern "system" fn bind_buffer_memory2( 3979 _device: Device, 3980 _bind_info_count: u32, 3981 _p_bind_infos: *const BindBufferMemoryInfo, 3982 ) -> Result { 3983 panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2))) 3984 } 3985 let cname = 3986 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2\0"); 3987 let val = _f(cname); 3988 if val.is_null() { 3989 bind_buffer_memory2 3990 } else { 3991 ::std::mem::transmute(val) 3992 } 3993 }, 3994 bind_image_memory2: unsafe { 3995 unsafe extern "system" fn bind_image_memory2( 3996 _device: Device, 3997 _bind_info_count: u32, 3998 _p_bind_infos: *const BindImageMemoryInfo, 3999 ) -> Result { 4000 panic!(concat!("Unable to load ", stringify!(bind_image_memory2))) 4001 } 4002 let cname = 4003 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2\0"); 4004 let val = _f(cname); 4005 if val.is_null() { 4006 bind_image_memory2 4007 } else { 4008 ::std::mem::transmute(val) 4009 } 4010 }, 4011 get_device_group_peer_memory_features: unsafe { 4012 unsafe extern "system" fn get_device_group_peer_memory_features( 4013 _device: Device, 4014 _heap_index: u32, 4015 _local_device_index: u32, 4016 _remote_device_index: u32, 4017 _p_peer_memory_features: *mut PeerMemoryFeatureFlags, 4018 ) { 4019 panic!(concat!( 4020 "Unable to load ", 4021 stringify!(get_device_group_peer_memory_features) 4022 )) 4023 } 4024 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4025 b"vkGetDeviceGroupPeerMemoryFeatures\0", 4026 ); 4027 let val = _f(cname); 4028 if val.is_null() { 4029 get_device_group_peer_memory_features 4030 } else { 4031 ::std::mem::transmute(val) 4032 } 4033 }, 4034 cmd_set_device_mask: unsafe { 4035 unsafe extern "system" fn cmd_set_device_mask( 4036 _command_buffer: CommandBuffer, 4037 _device_mask: u32, 4038 ) { 4039 panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask))) 4040 } 4041 let cname = 4042 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMask\0"); 4043 let val = _f(cname); 4044 if val.is_null() { 4045 cmd_set_device_mask 4046 } else { 4047 ::std::mem::transmute(val) 4048 } 4049 }, 4050 cmd_dispatch_base: unsafe { 4051 unsafe extern "system" fn cmd_dispatch_base( 4052 _command_buffer: CommandBuffer, 4053 _base_group_x: u32, 4054 _base_group_y: u32, 4055 _base_group_z: u32, 4056 _group_count_x: u32, 4057 _group_count_y: u32, 4058 _group_count_z: u32, 4059 ) { 4060 panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base))) 4061 } 4062 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBase\0"); 4063 let val = _f(cname); 4064 if val.is_null() { 4065 cmd_dispatch_base 4066 } else { 4067 ::std::mem::transmute(val) 4068 } 4069 }, 4070 get_image_memory_requirements2: unsafe { 4071 unsafe extern "system" fn get_image_memory_requirements2( 4072 _device: Device, 4073 _p_info: *const ImageMemoryRequirementsInfo2, 4074 _p_memory_requirements: *mut MemoryRequirements2, 4075 ) { 4076 panic!(concat!( 4077 "Unable to load ", 4078 stringify!(get_image_memory_requirements2) 4079 )) 4080 } 4081 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4082 b"vkGetImageMemoryRequirements2\0", 4083 ); 4084 let val = _f(cname); 4085 if val.is_null() { 4086 get_image_memory_requirements2 4087 } else { 4088 ::std::mem::transmute(val) 4089 } 4090 }, 4091 get_buffer_memory_requirements2: unsafe { 4092 unsafe extern "system" fn get_buffer_memory_requirements2( 4093 _device: Device, 4094 _p_info: *const BufferMemoryRequirementsInfo2, 4095 _p_memory_requirements: *mut MemoryRequirements2, 4096 ) { 4097 panic!(concat!( 4098 "Unable to load ", 4099 stringify!(get_buffer_memory_requirements2) 4100 )) 4101 } 4102 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4103 b"vkGetBufferMemoryRequirements2\0", 4104 ); 4105 let val = _f(cname); 4106 if val.is_null() { 4107 get_buffer_memory_requirements2 4108 } else { 4109 ::std::mem::transmute(val) 4110 } 4111 }, 4112 get_image_sparse_memory_requirements2: unsafe { 4113 unsafe extern "system" fn get_image_sparse_memory_requirements2( 4114 _device: Device, 4115 _p_info: *const ImageSparseMemoryRequirementsInfo2, 4116 _p_sparse_memory_requirement_count: *mut u32, 4117 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, 4118 ) { 4119 panic!(concat!( 4120 "Unable to load ", 4121 stringify!(get_image_sparse_memory_requirements2) 4122 )) 4123 } 4124 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4125 b"vkGetImageSparseMemoryRequirements2\0", 4126 ); 4127 let val = _f(cname); 4128 if val.is_null() { 4129 get_image_sparse_memory_requirements2 4130 } else { 4131 ::std::mem::transmute(val) 4132 } 4133 }, 4134 trim_command_pool: unsafe { 4135 unsafe extern "system" fn trim_command_pool( 4136 _device: Device, 4137 _command_pool: CommandPool, 4138 _flags: CommandPoolTrimFlags, 4139 ) { 4140 panic!(concat!("Unable to load ", stringify!(trim_command_pool))) 4141 } 4142 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPool\0"); 4143 let val = _f(cname); 4144 if val.is_null() { 4145 trim_command_pool 4146 } else { 4147 ::std::mem::transmute(val) 4148 } 4149 }, 4150 get_device_queue2: unsafe { 4151 unsafe extern "system" fn get_device_queue2( 4152 _device: Device, 4153 _p_queue_info: *const DeviceQueueInfo2, 4154 _p_queue: *mut Queue, 4155 ) { 4156 panic!(concat!("Unable to load ", stringify!(get_device_queue2))) 4157 } 4158 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue2\0"); 4159 let val = _f(cname); 4160 if val.is_null() { 4161 get_device_queue2 4162 } else { 4163 ::std::mem::transmute(val) 4164 } 4165 }, 4166 create_sampler_ycbcr_conversion: unsafe { 4167 unsafe extern "system" fn create_sampler_ycbcr_conversion( 4168 _device: Device, 4169 _p_create_info: *const SamplerYcbcrConversionCreateInfo, 4170 _p_allocator: *const AllocationCallbacks, 4171 _p_ycbcr_conversion: *mut SamplerYcbcrConversion, 4172 ) -> Result { 4173 panic!(concat!( 4174 "Unable to load ", 4175 stringify!(create_sampler_ycbcr_conversion) 4176 )) 4177 } 4178 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4179 b"vkCreateSamplerYcbcrConversion\0", 4180 ); 4181 let val = _f(cname); 4182 if val.is_null() { 4183 create_sampler_ycbcr_conversion 4184 } else { 4185 ::std::mem::transmute(val) 4186 } 4187 }, 4188 destroy_sampler_ycbcr_conversion: unsafe { 4189 unsafe extern "system" fn destroy_sampler_ycbcr_conversion( 4190 _device: Device, 4191 _ycbcr_conversion: SamplerYcbcrConversion, 4192 _p_allocator: *const AllocationCallbacks, 4193 ) { 4194 panic!(concat!( 4195 "Unable to load ", 4196 stringify!(destroy_sampler_ycbcr_conversion) 4197 )) 4198 } 4199 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4200 b"vkDestroySamplerYcbcrConversion\0", 4201 ); 4202 let val = _f(cname); 4203 if val.is_null() { 4204 destroy_sampler_ycbcr_conversion 4205 } else { 4206 ::std::mem::transmute(val) 4207 } 4208 }, 4209 create_descriptor_update_template: unsafe { 4210 unsafe extern "system" fn create_descriptor_update_template( 4211 _device: Device, 4212 _p_create_info: *const DescriptorUpdateTemplateCreateInfo, 4213 _p_allocator: *const AllocationCallbacks, 4214 _p_descriptor_update_template: *mut DescriptorUpdateTemplate, 4215 ) -> Result { 4216 panic!(concat!( 4217 "Unable to load ", 4218 stringify!(create_descriptor_update_template) 4219 )) 4220 } 4221 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4222 b"vkCreateDescriptorUpdateTemplate\0", 4223 ); 4224 let val = _f(cname); 4225 if val.is_null() { 4226 create_descriptor_update_template 4227 } else { 4228 ::std::mem::transmute(val) 4229 } 4230 }, 4231 destroy_descriptor_update_template: unsafe { 4232 unsafe extern "system" fn destroy_descriptor_update_template( 4233 _device: Device, 4234 _descriptor_update_template: DescriptorUpdateTemplate, 4235 _p_allocator: *const AllocationCallbacks, 4236 ) { 4237 panic!(concat!( 4238 "Unable to load ", 4239 stringify!(destroy_descriptor_update_template) 4240 )) 4241 } 4242 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4243 b"vkDestroyDescriptorUpdateTemplate\0", 4244 ); 4245 let val = _f(cname); 4246 if val.is_null() { 4247 destroy_descriptor_update_template 4248 } else { 4249 ::std::mem::transmute(val) 4250 } 4251 }, 4252 update_descriptor_set_with_template: unsafe { 4253 unsafe extern "system" fn update_descriptor_set_with_template( 4254 _device: Device, 4255 _descriptor_set: DescriptorSet, 4256 _descriptor_update_template: DescriptorUpdateTemplate, 4257 _p_data: *const c_void, 4258 ) { 4259 panic!(concat!( 4260 "Unable to load ", 4261 stringify!(update_descriptor_set_with_template) 4262 )) 4263 } 4264 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4265 b"vkUpdateDescriptorSetWithTemplate\0", 4266 ); 4267 let val = _f(cname); 4268 if val.is_null() { 4269 update_descriptor_set_with_template 4270 } else { 4271 ::std::mem::transmute(val) 4272 } 4273 }, 4274 get_descriptor_set_layout_support: unsafe { 4275 unsafe extern "system" fn get_descriptor_set_layout_support( 4276 _device: Device, 4277 _p_create_info: *const DescriptorSetLayoutCreateInfo, 4278 _p_support: *mut DescriptorSetLayoutSupport, 4279 ) { 4280 panic!(concat!( 4281 "Unable to load ", 4282 stringify!(get_descriptor_set_layout_support) 4283 )) 4284 } 4285 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4286 b"vkGetDescriptorSetLayoutSupport\0", 4287 ); 4288 let val = _f(cname); 4289 if val.is_null() { 4290 get_descriptor_set_layout_support 4291 } else { 4292 ::std::mem::transmute(val) 4293 } 4294 }, 4295 } 4296 } 4297 } 4298 #[derive(Clone)] 4299 pub struct EntryFnV1_2 {} 4300 unsafe impl Send for EntryFnV1_2 {} 4301 unsafe impl Sync for EntryFnV1_2 {} 4302 impl EntryFnV1_2 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,4303 pub fn load<F>(mut _f: F) -> Self 4304 where 4305 F: FnMut(&::std::ffi::CStr) -> *const c_void, 4306 { 4307 Self {} 4308 } 4309 } 4310 #[derive(Clone)] 4311 pub struct InstanceFnV1_2 {} 4312 unsafe impl Send for InstanceFnV1_2 {} 4313 unsafe impl Sync for InstanceFnV1_2 {} 4314 impl InstanceFnV1_2 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,4315 pub fn load<F>(mut _f: F) -> Self 4316 where 4317 F: FnMut(&::std::ffi::CStr) -> *const c_void, 4318 { 4319 Self {} 4320 } 4321 } 4322 #[derive(Clone)] 4323 pub struct DeviceFnV1_2 { 4324 pub cmd_draw_indirect_count: crate::vk::PFN_vkCmdDrawIndirectCount, 4325 pub cmd_draw_indexed_indirect_count: crate::vk::PFN_vkCmdDrawIndexedIndirectCount, 4326 pub create_render_pass2: crate::vk::PFN_vkCreateRenderPass2, 4327 pub cmd_begin_render_pass2: crate::vk::PFN_vkCmdBeginRenderPass2, 4328 pub cmd_next_subpass2: crate::vk::PFN_vkCmdNextSubpass2, 4329 pub cmd_end_render_pass2: crate::vk::PFN_vkCmdEndRenderPass2, 4330 pub reset_query_pool: crate::vk::PFN_vkResetQueryPool, 4331 pub get_semaphore_counter_value: crate::vk::PFN_vkGetSemaphoreCounterValue, 4332 pub wait_semaphores: crate::vk::PFN_vkWaitSemaphores, 4333 pub signal_semaphore: crate::vk::PFN_vkSignalSemaphore, 4334 pub get_buffer_device_address: crate::vk::PFN_vkGetBufferDeviceAddress, 4335 pub get_buffer_opaque_capture_address: crate::vk::PFN_vkGetBufferOpaqueCaptureAddress, 4336 pub get_device_memory_opaque_capture_address: 4337 crate::vk::PFN_vkGetDeviceMemoryOpaqueCaptureAddress, 4338 } 4339 unsafe impl Send for DeviceFnV1_2 {} 4340 unsafe impl Sync for DeviceFnV1_2 {} 4341 impl DeviceFnV1_2 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,4342 pub fn load<F>(mut _f: F) -> Self 4343 where 4344 F: FnMut(&::std::ffi::CStr) -> *const c_void, 4345 { 4346 Self { 4347 cmd_draw_indirect_count: unsafe { 4348 unsafe extern "system" fn cmd_draw_indirect_count( 4349 _command_buffer: CommandBuffer, 4350 _buffer: Buffer, 4351 _offset: DeviceSize, 4352 _count_buffer: Buffer, 4353 _count_buffer_offset: DeviceSize, 4354 _max_draw_count: u32, 4355 _stride: u32, 4356 ) { 4357 panic!(concat!( 4358 "Unable to load ", 4359 stringify!(cmd_draw_indirect_count) 4360 )) 4361 } 4362 let cname = 4363 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCount\0"); 4364 let val = _f(cname); 4365 if val.is_null() { 4366 cmd_draw_indirect_count 4367 } else { 4368 ::std::mem::transmute(val) 4369 } 4370 }, 4371 cmd_draw_indexed_indirect_count: unsafe { 4372 unsafe extern "system" fn cmd_draw_indexed_indirect_count( 4373 _command_buffer: CommandBuffer, 4374 _buffer: Buffer, 4375 _offset: DeviceSize, 4376 _count_buffer: Buffer, 4377 _count_buffer_offset: DeviceSize, 4378 _max_draw_count: u32, 4379 _stride: u32, 4380 ) { 4381 panic!(concat!( 4382 "Unable to load ", 4383 stringify!(cmd_draw_indexed_indirect_count) 4384 )) 4385 } 4386 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4387 b"vkCmdDrawIndexedIndirectCount\0", 4388 ); 4389 let val = _f(cname); 4390 if val.is_null() { 4391 cmd_draw_indexed_indirect_count 4392 } else { 4393 ::std::mem::transmute(val) 4394 } 4395 }, 4396 create_render_pass2: unsafe { 4397 unsafe extern "system" fn create_render_pass2( 4398 _device: Device, 4399 _p_create_info: *const RenderPassCreateInfo2, 4400 _p_allocator: *const AllocationCallbacks, 4401 _p_render_pass: *mut RenderPass, 4402 ) -> Result { 4403 panic!(concat!("Unable to load ", stringify!(create_render_pass2))) 4404 } 4405 let cname = 4406 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2\0"); 4407 let val = _f(cname); 4408 if val.is_null() { 4409 create_render_pass2 4410 } else { 4411 ::std::mem::transmute(val) 4412 } 4413 }, 4414 cmd_begin_render_pass2: unsafe { 4415 unsafe extern "system" fn cmd_begin_render_pass2( 4416 _command_buffer: CommandBuffer, 4417 _p_render_pass_begin: *const RenderPassBeginInfo, 4418 _p_subpass_begin_info: *const SubpassBeginInfo, 4419 ) { 4420 panic!(concat!( 4421 "Unable to load ", 4422 stringify!(cmd_begin_render_pass2) 4423 )) 4424 } 4425 let cname = 4426 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2\0"); 4427 let val = _f(cname); 4428 if val.is_null() { 4429 cmd_begin_render_pass2 4430 } else { 4431 ::std::mem::transmute(val) 4432 } 4433 }, 4434 cmd_next_subpass2: unsafe { 4435 unsafe extern "system" fn cmd_next_subpass2( 4436 _command_buffer: CommandBuffer, 4437 _p_subpass_begin_info: *const SubpassBeginInfo, 4438 _p_subpass_end_info: *const SubpassEndInfo, 4439 ) { 4440 panic!(concat!("Unable to load ", stringify!(cmd_next_subpass2))) 4441 } 4442 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2\0"); 4443 let val = _f(cname); 4444 if val.is_null() { 4445 cmd_next_subpass2 4446 } else { 4447 ::std::mem::transmute(val) 4448 } 4449 }, 4450 cmd_end_render_pass2: unsafe { 4451 unsafe extern "system" fn cmd_end_render_pass2( 4452 _command_buffer: CommandBuffer, 4453 _p_subpass_end_info: *const SubpassEndInfo, 4454 ) { 4455 panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass2))) 4456 } 4457 let cname = 4458 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2\0"); 4459 let val = _f(cname); 4460 if val.is_null() { 4461 cmd_end_render_pass2 4462 } else { 4463 ::std::mem::transmute(val) 4464 } 4465 }, 4466 reset_query_pool: unsafe { 4467 unsafe extern "system" fn reset_query_pool( 4468 _device: Device, 4469 _query_pool: QueryPool, 4470 _first_query: u32, 4471 _query_count: u32, 4472 ) { 4473 panic!(concat!("Unable to load ", stringify!(reset_query_pool))) 4474 } 4475 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPool\0"); 4476 let val = _f(cname); 4477 if val.is_null() { 4478 reset_query_pool 4479 } else { 4480 ::std::mem::transmute(val) 4481 } 4482 }, 4483 get_semaphore_counter_value: unsafe { 4484 unsafe extern "system" fn get_semaphore_counter_value( 4485 _device: Device, 4486 _semaphore: Semaphore, 4487 _p_value: *mut u64, 4488 ) -> Result { 4489 panic!(concat!( 4490 "Unable to load ", 4491 stringify!(get_semaphore_counter_value) 4492 )) 4493 } 4494 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4495 b"vkGetSemaphoreCounterValue\0", 4496 ); 4497 let val = _f(cname); 4498 if val.is_null() { 4499 get_semaphore_counter_value 4500 } else { 4501 ::std::mem::transmute(val) 4502 } 4503 }, 4504 wait_semaphores: unsafe { 4505 unsafe extern "system" fn wait_semaphores( 4506 _device: Device, 4507 _p_wait_info: *const SemaphoreWaitInfo, 4508 _timeout: u64, 4509 ) -> Result { 4510 panic!(concat!("Unable to load ", stringify!(wait_semaphores))) 4511 } 4512 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphores\0"); 4513 let val = _f(cname); 4514 if val.is_null() { 4515 wait_semaphores 4516 } else { 4517 ::std::mem::transmute(val) 4518 } 4519 }, 4520 signal_semaphore: unsafe { 4521 unsafe extern "system" fn signal_semaphore( 4522 _device: Device, 4523 _p_signal_info: *const SemaphoreSignalInfo, 4524 ) -> Result { 4525 panic!(concat!("Unable to load ", stringify!(signal_semaphore))) 4526 } 4527 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphore\0"); 4528 let val = _f(cname); 4529 if val.is_null() { 4530 signal_semaphore 4531 } else { 4532 ::std::mem::transmute(val) 4533 } 4534 }, 4535 get_buffer_device_address: unsafe { 4536 unsafe extern "system" fn get_buffer_device_address( 4537 _device: Device, 4538 _p_info: *const BufferDeviceAddressInfo, 4539 ) -> DeviceAddress { 4540 panic!(concat!( 4541 "Unable to load ", 4542 stringify!(get_buffer_device_address) 4543 )) 4544 } 4545 let cname = 4546 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddress\0"); 4547 let val = _f(cname); 4548 if val.is_null() { 4549 get_buffer_device_address 4550 } else { 4551 ::std::mem::transmute(val) 4552 } 4553 }, 4554 get_buffer_opaque_capture_address: unsafe { 4555 unsafe extern "system" fn get_buffer_opaque_capture_address( 4556 _device: Device, 4557 _p_info: *const BufferDeviceAddressInfo, 4558 ) -> u64 { 4559 panic!(concat!( 4560 "Unable to load ", 4561 stringify!(get_buffer_opaque_capture_address) 4562 )) 4563 } 4564 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4565 b"vkGetBufferOpaqueCaptureAddress\0", 4566 ); 4567 let val = _f(cname); 4568 if val.is_null() { 4569 get_buffer_opaque_capture_address 4570 } else { 4571 ::std::mem::transmute(val) 4572 } 4573 }, 4574 get_device_memory_opaque_capture_address: unsafe { 4575 unsafe extern "system" fn get_device_memory_opaque_capture_address( 4576 _device: Device, 4577 _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, 4578 ) -> u64 { 4579 panic!(concat!( 4580 "Unable to load ", 4581 stringify!(get_device_memory_opaque_capture_address) 4582 )) 4583 } 4584 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4585 b"vkGetDeviceMemoryOpaqueCaptureAddress\0", 4586 ); 4587 let val = _f(cname); 4588 if val.is_null() { 4589 get_device_memory_opaque_capture_address 4590 } else { 4591 ::std::mem::transmute(val) 4592 } 4593 }, 4594 } 4595 } 4596 } 4597 #[derive(Clone)] 4598 pub struct EntryFnV1_3 {} 4599 unsafe impl Send for EntryFnV1_3 {} 4600 unsafe impl Sync for EntryFnV1_3 {} 4601 impl EntryFnV1_3 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,4602 pub fn load<F>(mut _f: F) -> Self 4603 where 4604 F: FnMut(&::std::ffi::CStr) -> *const c_void, 4605 { 4606 Self {} 4607 } 4608 } 4609 #[derive(Clone)] 4610 pub struct InstanceFnV1_3 { 4611 pub get_physical_device_tool_properties: crate::vk::PFN_vkGetPhysicalDeviceToolProperties, 4612 } 4613 unsafe impl Send for InstanceFnV1_3 {} 4614 unsafe impl Sync for InstanceFnV1_3 {} 4615 impl InstanceFnV1_3 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,4616 pub fn load<F>(mut _f: F) -> Self 4617 where 4618 F: FnMut(&::std::ffi::CStr) -> *const c_void, 4619 { 4620 Self { 4621 get_physical_device_tool_properties: unsafe { 4622 unsafe extern "system" fn get_physical_device_tool_properties( 4623 _physical_device: PhysicalDevice, 4624 _p_tool_count: *mut u32, 4625 _p_tool_properties: *mut PhysicalDeviceToolProperties, 4626 ) -> Result { 4627 panic!(concat!( 4628 "Unable to load ", 4629 stringify!(get_physical_device_tool_properties) 4630 )) 4631 } 4632 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4633 b"vkGetPhysicalDeviceToolProperties\0", 4634 ); 4635 let val = _f(cname); 4636 if val.is_null() { 4637 get_physical_device_tool_properties 4638 } else { 4639 ::std::mem::transmute(val) 4640 } 4641 }, 4642 } 4643 } 4644 } 4645 #[derive(Clone)] 4646 pub struct DeviceFnV1_3 { 4647 pub create_private_data_slot: crate::vk::PFN_vkCreatePrivateDataSlot, 4648 pub destroy_private_data_slot: crate::vk::PFN_vkDestroyPrivateDataSlot, 4649 pub set_private_data: crate::vk::PFN_vkSetPrivateData, 4650 pub get_private_data: crate::vk::PFN_vkGetPrivateData, 4651 pub cmd_set_event2: crate::vk::PFN_vkCmdSetEvent2, 4652 pub cmd_reset_event2: crate::vk::PFN_vkCmdResetEvent2, 4653 pub cmd_wait_events2: crate::vk::PFN_vkCmdWaitEvents2, 4654 pub cmd_pipeline_barrier2: crate::vk::PFN_vkCmdPipelineBarrier2, 4655 pub cmd_write_timestamp2: crate::vk::PFN_vkCmdWriteTimestamp2, 4656 pub queue_submit2: crate::vk::PFN_vkQueueSubmit2, 4657 pub cmd_copy_buffer2: crate::vk::PFN_vkCmdCopyBuffer2, 4658 pub cmd_copy_image2: crate::vk::PFN_vkCmdCopyImage2, 4659 pub cmd_copy_buffer_to_image2: crate::vk::PFN_vkCmdCopyBufferToImage2, 4660 pub cmd_copy_image_to_buffer2: crate::vk::PFN_vkCmdCopyImageToBuffer2, 4661 pub cmd_blit_image2: crate::vk::PFN_vkCmdBlitImage2, 4662 pub cmd_resolve_image2: crate::vk::PFN_vkCmdResolveImage2, 4663 pub cmd_begin_rendering: crate::vk::PFN_vkCmdBeginRendering, 4664 pub cmd_end_rendering: crate::vk::PFN_vkCmdEndRendering, 4665 pub cmd_set_cull_mode: crate::vk::PFN_vkCmdSetCullMode, 4666 pub cmd_set_front_face: crate::vk::PFN_vkCmdSetFrontFace, 4667 pub cmd_set_primitive_topology: crate::vk::PFN_vkCmdSetPrimitiveTopology, 4668 pub cmd_set_viewport_with_count: crate::vk::PFN_vkCmdSetViewportWithCount, 4669 pub cmd_set_scissor_with_count: crate::vk::PFN_vkCmdSetScissorWithCount, 4670 pub cmd_bind_vertex_buffers2: crate::vk::PFN_vkCmdBindVertexBuffers2, 4671 pub cmd_set_depth_test_enable: crate::vk::PFN_vkCmdSetDepthTestEnable, 4672 pub cmd_set_depth_write_enable: crate::vk::PFN_vkCmdSetDepthWriteEnable, 4673 pub cmd_set_depth_compare_op: crate::vk::PFN_vkCmdSetDepthCompareOp, 4674 pub cmd_set_depth_bounds_test_enable: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable, 4675 pub cmd_set_stencil_test_enable: crate::vk::PFN_vkCmdSetStencilTestEnable, 4676 pub cmd_set_stencil_op: crate::vk::PFN_vkCmdSetStencilOp, 4677 pub cmd_set_rasterizer_discard_enable: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable, 4678 pub cmd_set_depth_bias_enable: crate::vk::PFN_vkCmdSetDepthBiasEnable, 4679 pub cmd_set_primitive_restart_enable: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable, 4680 pub get_device_buffer_memory_requirements: crate::vk::PFN_vkGetDeviceBufferMemoryRequirements, 4681 pub get_device_image_memory_requirements: crate::vk::PFN_vkGetDeviceImageMemoryRequirements, 4682 pub get_device_image_sparse_memory_requirements: 4683 crate::vk::PFN_vkGetDeviceImageSparseMemoryRequirements, 4684 } 4685 unsafe impl Send for DeviceFnV1_3 {} 4686 unsafe impl Sync for DeviceFnV1_3 {} 4687 impl DeviceFnV1_3 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,4688 pub fn load<F>(mut _f: F) -> Self 4689 where 4690 F: FnMut(&::std::ffi::CStr) -> *const c_void, 4691 { 4692 Self { 4693 create_private_data_slot: unsafe { 4694 unsafe extern "system" fn create_private_data_slot( 4695 _device: Device, 4696 _p_create_info: *const PrivateDataSlotCreateInfo, 4697 _p_allocator: *const AllocationCallbacks, 4698 _p_private_data_slot: *mut PrivateDataSlot, 4699 ) -> Result { 4700 panic!(concat!( 4701 "Unable to load ", 4702 stringify!(create_private_data_slot) 4703 )) 4704 } 4705 let cname = 4706 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePrivateDataSlot\0"); 4707 let val = _f(cname); 4708 if val.is_null() { 4709 create_private_data_slot 4710 } else { 4711 ::std::mem::transmute(val) 4712 } 4713 }, 4714 destroy_private_data_slot: unsafe { 4715 unsafe extern "system" fn destroy_private_data_slot( 4716 _device: Device, 4717 _private_data_slot: PrivateDataSlot, 4718 _p_allocator: *const AllocationCallbacks, 4719 ) { 4720 panic!(concat!( 4721 "Unable to load ", 4722 stringify!(destroy_private_data_slot) 4723 )) 4724 } 4725 let cname = 4726 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPrivateDataSlot\0"); 4727 let val = _f(cname); 4728 if val.is_null() { 4729 destroy_private_data_slot 4730 } else { 4731 ::std::mem::transmute(val) 4732 } 4733 }, 4734 set_private_data: unsafe { 4735 unsafe extern "system" fn set_private_data( 4736 _device: Device, 4737 _object_type: ObjectType, 4738 _object_handle: u64, 4739 _private_data_slot: PrivateDataSlot, 4740 _data: u64, 4741 ) -> Result { 4742 panic!(concat!("Unable to load ", stringify!(set_private_data))) 4743 } 4744 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateData\0"); 4745 let val = _f(cname); 4746 if val.is_null() { 4747 set_private_data 4748 } else { 4749 ::std::mem::transmute(val) 4750 } 4751 }, 4752 get_private_data: unsafe { 4753 unsafe extern "system" fn get_private_data( 4754 _device: Device, 4755 _object_type: ObjectType, 4756 _object_handle: u64, 4757 _private_data_slot: PrivateDataSlot, 4758 _p_data: *mut u64, 4759 ) { 4760 panic!(concat!("Unable to load ", stringify!(get_private_data))) 4761 } 4762 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateData\0"); 4763 let val = _f(cname); 4764 if val.is_null() { 4765 get_private_data 4766 } else { 4767 ::std::mem::transmute(val) 4768 } 4769 }, 4770 cmd_set_event2: unsafe { 4771 unsafe extern "system" fn cmd_set_event2( 4772 _command_buffer: CommandBuffer, 4773 _event: Event, 4774 _p_dependency_info: *const DependencyInfo, 4775 ) { 4776 panic!(concat!("Unable to load ", stringify!(cmd_set_event2))) 4777 } 4778 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2\0"); 4779 let val = _f(cname); 4780 if val.is_null() { 4781 cmd_set_event2 4782 } else { 4783 ::std::mem::transmute(val) 4784 } 4785 }, 4786 cmd_reset_event2: unsafe { 4787 unsafe extern "system" fn cmd_reset_event2( 4788 _command_buffer: CommandBuffer, 4789 _event: Event, 4790 _stage_mask: PipelineStageFlags2, 4791 ) { 4792 panic!(concat!("Unable to load ", stringify!(cmd_reset_event2))) 4793 } 4794 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2\0"); 4795 let val = _f(cname); 4796 if val.is_null() { 4797 cmd_reset_event2 4798 } else { 4799 ::std::mem::transmute(val) 4800 } 4801 }, 4802 cmd_wait_events2: unsafe { 4803 unsafe extern "system" fn cmd_wait_events2( 4804 _command_buffer: CommandBuffer, 4805 _event_count: u32, 4806 _p_events: *const Event, 4807 _p_dependency_infos: *const DependencyInfo, 4808 ) { 4809 panic!(concat!("Unable to load ", stringify!(cmd_wait_events2))) 4810 } 4811 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2\0"); 4812 let val = _f(cname); 4813 if val.is_null() { 4814 cmd_wait_events2 4815 } else { 4816 ::std::mem::transmute(val) 4817 } 4818 }, 4819 cmd_pipeline_barrier2: unsafe { 4820 unsafe extern "system" fn cmd_pipeline_barrier2( 4821 _command_buffer: CommandBuffer, 4822 _p_dependency_info: *const DependencyInfo, 4823 ) { 4824 panic!(concat!( 4825 "Unable to load ", 4826 stringify!(cmd_pipeline_barrier2) 4827 )) 4828 } 4829 let cname = 4830 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2\0"); 4831 let val = _f(cname); 4832 if val.is_null() { 4833 cmd_pipeline_barrier2 4834 } else { 4835 ::std::mem::transmute(val) 4836 } 4837 }, 4838 cmd_write_timestamp2: unsafe { 4839 unsafe extern "system" fn cmd_write_timestamp2( 4840 _command_buffer: CommandBuffer, 4841 _stage: PipelineStageFlags2, 4842 _query_pool: QueryPool, 4843 _query: u32, 4844 ) { 4845 panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp2))) 4846 } 4847 let cname = 4848 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2\0"); 4849 let val = _f(cname); 4850 if val.is_null() { 4851 cmd_write_timestamp2 4852 } else { 4853 ::std::mem::transmute(val) 4854 } 4855 }, 4856 queue_submit2: unsafe { 4857 unsafe extern "system" fn queue_submit2( 4858 _queue: Queue, 4859 _submit_count: u32, 4860 _p_submits: *const SubmitInfo2, 4861 _fence: Fence, 4862 ) -> Result { 4863 panic!(concat!("Unable to load ", stringify!(queue_submit2))) 4864 } 4865 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2\0"); 4866 let val = _f(cname); 4867 if val.is_null() { 4868 queue_submit2 4869 } else { 4870 ::std::mem::transmute(val) 4871 } 4872 }, 4873 cmd_copy_buffer2: unsafe { 4874 unsafe extern "system" fn cmd_copy_buffer2( 4875 _command_buffer: CommandBuffer, 4876 _p_copy_buffer_info: *const CopyBufferInfo2, 4877 ) { 4878 panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2))) 4879 } 4880 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2\0"); 4881 let val = _f(cname); 4882 if val.is_null() { 4883 cmd_copy_buffer2 4884 } else { 4885 ::std::mem::transmute(val) 4886 } 4887 }, 4888 cmd_copy_image2: unsafe { 4889 unsafe extern "system" fn cmd_copy_image2( 4890 _command_buffer: CommandBuffer, 4891 _p_copy_image_info: *const CopyImageInfo2, 4892 ) { 4893 panic!(concat!("Unable to load ", stringify!(cmd_copy_image2))) 4894 } 4895 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2\0"); 4896 let val = _f(cname); 4897 if val.is_null() { 4898 cmd_copy_image2 4899 } else { 4900 ::std::mem::transmute(val) 4901 } 4902 }, 4903 cmd_copy_buffer_to_image2: unsafe { 4904 unsafe extern "system" fn cmd_copy_buffer_to_image2( 4905 _command_buffer: CommandBuffer, 4906 _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2, 4907 ) { 4908 panic!(concat!( 4909 "Unable to load ", 4910 stringify!(cmd_copy_buffer_to_image2) 4911 )) 4912 } 4913 let cname = 4914 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage2\0"); 4915 let val = _f(cname); 4916 if val.is_null() { 4917 cmd_copy_buffer_to_image2 4918 } else { 4919 ::std::mem::transmute(val) 4920 } 4921 }, 4922 cmd_copy_image_to_buffer2: unsafe { 4923 unsafe extern "system" fn cmd_copy_image_to_buffer2( 4924 _command_buffer: CommandBuffer, 4925 _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2, 4926 ) { 4927 panic!(concat!( 4928 "Unable to load ", 4929 stringify!(cmd_copy_image_to_buffer2) 4930 )) 4931 } 4932 let cname = 4933 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer2\0"); 4934 let val = _f(cname); 4935 if val.is_null() { 4936 cmd_copy_image_to_buffer2 4937 } else { 4938 ::std::mem::transmute(val) 4939 } 4940 }, 4941 cmd_blit_image2: unsafe { 4942 unsafe extern "system" fn cmd_blit_image2( 4943 _command_buffer: CommandBuffer, 4944 _p_blit_image_info: *const BlitImageInfo2, 4945 ) { 4946 panic!(concat!("Unable to load ", stringify!(cmd_blit_image2))) 4947 } 4948 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2\0"); 4949 let val = _f(cname); 4950 if val.is_null() { 4951 cmd_blit_image2 4952 } else { 4953 ::std::mem::transmute(val) 4954 } 4955 }, 4956 cmd_resolve_image2: unsafe { 4957 unsafe extern "system" fn cmd_resolve_image2( 4958 _command_buffer: CommandBuffer, 4959 _p_resolve_image_info: *const ResolveImageInfo2, 4960 ) { 4961 panic!(concat!("Unable to load ", stringify!(cmd_resolve_image2))) 4962 } 4963 let cname = 4964 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2\0"); 4965 let val = _f(cname); 4966 if val.is_null() { 4967 cmd_resolve_image2 4968 } else { 4969 ::std::mem::transmute(val) 4970 } 4971 }, 4972 cmd_begin_rendering: unsafe { 4973 unsafe extern "system" fn cmd_begin_rendering( 4974 _command_buffer: CommandBuffer, 4975 _p_rendering_info: *const RenderingInfo, 4976 ) { 4977 panic!(concat!("Unable to load ", stringify!(cmd_begin_rendering))) 4978 } 4979 let cname = 4980 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRendering\0"); 4981 let val = _f(cname); 4982 if val.is_null() { 4983 cmd_begin_rendering 4984 } else { 4985 ::std::mem::transmute(val) 4986 } 4987 }, 4988 cmd_end_rendering: unsafe { 4989 unsafe extern "system" fn cmd_end_rendering(_command_buffer: CommandBuffer) { 4990 panic!(concat!("Unable to load ", stringify!(cmd_end_rendering))) 4991 } 4992 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRendering\0"); 4993 let val = _f(cname); 4994 if val.is_null() { 4995 cmd_end_rendering 4996 } else { 4997 ::std::mem::transmute(val) 4998 } 4999 }, 5000 cmd_set_cull_mode: unsafe { 5001 unsafe extern "system" fn cmd_set_cull_mode( 5002 _command_buffer: CommandBuffer, 5003 _cull_mode: CullModeFlags, 5004 ) { 5005 panic!(concat!("Unable to load ", stringify!(cmd_set_cull_mode))) 5006 } 5007 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullMode\0"); 5008 let val = _f(cname); 5009 if val.is_null() { 5010 cmd_set_cull_mode 5011 } else { 5012 ::std::mem::transmute(val) 5013 } 5014 }, 5015 cmd_set_front_face: unsafe { 5016 unsafe extern "system" fn cmd_set_front_face( 5017 _command_buffer: CommandBuffer, 5018 _front_face: FrontFace, 5019 ) { 5020 panic!(concat!("Unable to load ", stringify!(cmd_set_front_face))) 5021 } 5022 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFace\0"); 5023 let val = _f(cname); 5024 if val.is_null() { 5025 cmd_set_front_face 5026 } else { 5027 ::std::mem::transmute(val) 5028 } 5029 }, 5030 cmd_set_primitive_topology: unsafe { 5031 unsafe extern "system" fn cmd_set_primitive_topology( 5032 _command_buffer: CommandBuffer, 5033 _primitive_topology: PrimitiveTopology, 5034 ) { 5035 panic!(concat!( 5036 "Unable to load ", 5037 stringify!(cmd_set_primitive_topology) 5038 )) 5039 } 5040 let cname = 5041 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPrimitiveTopology\0"); 5042 let val = _f(cname); 5043 if val.is_null() { 5044 cmd_set_primitive_topology 5045 } else { 5046 ::std::mem::transmute(val) 5047 } 5048 }, 5049 cmd_set_viewport_with_count: unsafe { 5050 unsafe extern "system" fn cmd_set_viewport_with_count( 5051 _command_buffer: CommandBuffer, 5052 _viewport_count: u32, 5053 _p_viewports: *const Viewport, 5054 ) { 5055 panic!(concat!( 5056 "Unable to load ", 5057 stringify!(cmd_set_viewport_with_count) 5058 )) 5059 } 5060 let cname = 5061 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportWithCount\0"); 5062 let val = _f(cname); 5063 if val.is_null() { 5064 cmd_set_viewport_with_count 5065 } else { 5066 ::std::mem::transmute(val) 5067 } 5068 }, 5069 cmd_set_scissor_with_count: unsafe { 5070 unsafe extern "system" fn cmd_set_scissor_with_count( 5071 _command_buffer: CommandBuffer, 5072 _scissor_count: u32, 5073 _p_scissors: *const Rect2D, 5074 ) { 5075 panic!(concat!( 5076 "Unable to load ", 5077 stringify!(cmd_set_scissor_with_count) 5078 )) 5079 } 5080 let cname = 5081 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissorWithCount\0"); 5082 let val = _f(cname); 5083 if val.is_null() { 5084 cmd_set_scissor_with_count 5085 } else { 5086 ::std::mem::transmute(val) 5087 } 5088 }, 5089 cmd_bind_vertex_buffers2: unsafe { 5090 unsafe extern "system" fn cmd_bind_vertex_buffers2( 5091 _command_buffer: CommandBuffer, 5092 _first_binding: u32, 5093 _binding_count: u32, 5094 _p_buffers: *const Buffer, 5095 _p_offsets: *const DeviceSize, 5096 _p_sizes: *const DeviceSize, 5097 _p_strides: *const DeviceSize, 5098 ) { 5099 panic!(concat!( 5100 "Unable to load ", 5101 stringify!(cmd_bind_vertex_buffers2) 5102 )) 5103 } 5104 let cname = 5105 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers2\0"); 5106 let val = _f(cname); 5107 if val.is_null() { 5108 cmd_bind_vertex_buffers2 5109 } else { 5110 ::std::mem::transmute(val) 5111 } 5112 }, 5113 cmd_set_depth_test_enable: unsafe { 5114 unsafe extern "system" fn cmd_set_depth_test_enable( 5115 _command_buffer: CommandBuffer, 5116 _depth_test_enable: Bool32, 5117 ) { 5118 panic!(concat!( 5119 "Unable to load ", 5120 stringify!(cmd_set_depth_test_enable) 5121 )) 5122 } 5123 let cname = 5124 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthTestEnable\0"); 5125 let val = _f(cname); 5126 if val.is_null() { 5127 cmd_set_depth_test_enable 5128 } else { 5129 ::std::mem::transmute(val) 5130 } 5131 }, 5132 cmd_set_depth_write_enable: unsafe { 5133 unsafe extern "system" fn cmd_set_depth_write_enable( 5134 _command_buffer: CommandBuffer, 5135 _depth_write_enable: Bool32, 5136 ) { 5137 panic!(concat!( 5138 "Unable to load ", 5139 stringify!(cmd_set_depth_write_enable) 5140 )) 5141 } 5142 let cname = 5143 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthWriteEnable\0"); 5144 let val = _f(cname); 5145 if val.is_null() { 5146 cmd_set_depth_write_enable 5147 } else { 5148 ::std::mem::transmute(val) 5149 } 5150 }, 5151 cmd_set_depth_compare_op: unsafe { 5152 unsafe extern "system" fn cmd_set_depth_compare_op( 5153 _command_buffer: CommandBuffer, 5154 _depth_compare_op: CompareOp, 5155 ) { 5156 panic!(concat!( 5157 "Unable to load ", 5158 stringify!(cmd_set_depth_compare_op) 5159 )) 5160 } 5161 let cname = 5162 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOp\0"); 5163 let val = _f(cname); 5164 if val.is_null() { 5165 cmd_set_depth_compare_op 5166 } else { 5167 ::std::mem::transmute(val) 5168 } 5169 }, 5170 cmd_set_depth_bounds_test_enable: unsafe { 5171 unsafe extern "system" fn cmd_set_depth_bounds_test_enable( 5172 _command_buffer: CommandBuffer, 5173 _depth_bounds_test_enable: Bool32, 5174 ) { 5175 panic!(concat!( 5176 "Unable to load ", 5177 stringify!(cmd_set_depth_bounds_test_enable) 5178 )) 5179 } 5180 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5181 b"vkCmdSetDepthBoundsTestEnable\0", 5182 ); 5183 let val = _f(cname); 5184 if val.is_null() { 5185 cmd_set_depth_bounds_test_enable 5186 } else { 5187 ::std::mem::transmute(val) 5188 } 5189 }, 5190 cmd_set_stencil_test_enable: unsafe { 5191 unsafe extern "system" fn cmd_set_stencil_test_enable( 5192 _command_buffer: CommandBuffer, 5193 _stencil_test_enable: Bool32, 5194 ) { 5195 panic!(concat!( 5196 "Unable to load ", 5197 stringify!(cmd_set_stencil_test_enable) 5198 )) 5199 } 5200 let cname = 5201 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilTestEnable\0"); 5202 let val = _f(cname); 5203 if val.is_null() { 5204 cmd_set_stencil_test_enable 5205 } else { 5206 ::std::mem::transmute(val) 5207 } 5208 }, 5209 cmd_set_stencil_op: unsafe { 5210 unsafe extern "system" fn cmd_set_stencil_op( 5211 _command_buffer: CommandBuffer, 5212 _face_mask: StencilFaceFlags, 5213 _fail_op: StencilOp, 5214 _pass_op: StencilOp, 5215 _depth_fail_op: StencilOp, 5216 _compare_op: CompareOp, 5217 ) { 5218 panic!(concat!("Unable to load ", stringify!(cmd_set_stencil_op))) 5219 } 5220 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOp\0"); 5221 let val = _f(cname); 5222 if val.is_null() { 5223 cmd_set_stencil_op 5224 } else { 5225 ::std::mem::transmute(val) 5226 } 5227 }, 5228 cmd_set_rasterizer_discard_enable: unsafe { 5229 unsafe extern "system" fn cmd_set_rasterizer_discard_enable( 5230 _command_buffer: CommandBuffer, 5231 _rasterizer_discard_enable: Bool32, 5232 ) { 5233 panic!(concat!( 5234 "Unable to load ", 5235 stringify!(cmd_set_rasterizer_discard_enable) 5236 )) 5237 } 5238 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5239 b"vkCmdSetRasterizerDiscardEnable\0", 5240 ); 5241 let val = _f(cname); 5242 if val.is_null() { 5243 cmd_set_rasterizer_discard_enable 5244 } else { 5245 ::std::mem::transmute(val) 5246 } 5247 }, 5248 cmd_set_depth_bias_enable: unsafe { 5249 unsafe extern "system" fn cmd_set_depth_bias_enable( 5250 _command_buffer: CommandBuffer, 5251 _depth_bias_enable: Bool32, 5252 ) { 5253 panic!(concat!( 5254 "Unable to load ", 5255 stringify!(cmd_set_depth_bias_enable) 5256 )) 5257 } 5258 let cname = 5259 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBiasEnable\0"); 5260 let val = _f(cname); 5261 if val.is_null() { 5262 cmd_set_depth_bias_enable 5263 } else { 5264 ::std::mem::transmute(val) 5265 } 5266 }, 5267 cmd_set_primitive_restart_enable: unsafe { 5268 unsafe extern "system" fn cmd_set_primitive_restart_enable( 5269 _command_buffer: CommandBuffer, 5270 _primitive_restart_enable: Bool32, 5271 ) { 5272 panic!(concat!( 5273 "Unable to load ", 5274 stringify!(cmd_set_primitive_restart_enable) 5275 )) 5276 } 5277 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5278 b"vkCmdSetPrimitiveRestartEnable\0", 5279 ); 5280 let val = _f(cname); 5281 if val.is_null() { 5282 cmd_set_primitive_restart_enable 5283 } else { 5284 ::std::mem::transmute(val) 5285 } 5286 }, 5287 get_device_buffer_memory_requirements: unsafe { 5288 unsafe extern "system" fn get_device_buffer_memory_requirements( 5289 _device: Device, 5290 _p_info: *const DeviceBufferMemoryRequirements, 5291 _p_memory_requirements: *mut MemoryRequirements2, 5292 ) { 5293 panic!(concat!( 5294 "Unable to load ", 5295 stringify!(get_device_buffer_memory_requirements) 5296 )) 5297 } 5298 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5299 b"vkGetDeviceBufferMemoryRequirements\0", 5300 ); 5301 let val = _f(cname); 5302 if val.is_null() { 5303 get_device_buffer_memory_requirements 5304 } else { 5305 ::std::mem::transmute(val) 5306 } 5307 }, 5308 get_device_image_memory_requirements: unsafe { 5309 unsafe extern "system" fn get_device_image_memory_requirements( 5310 _device: Device, 5311 _p_info: *const DeviceImageMemoryRequirements, 5312 _p_memory_requirements: *mut MemoryRequirements2, 5313 ) { 5314 panic!(concat!( 5315 "Unable to load ", 5316 stringify!(get_device_image_memory_requirements) 5317 )) 5318 } 5319 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5320 b"vkGetDeviceImageMemoryRequirements\0", 5321 ); 5322 let val = _f(cname); 5323 if val.is_null() { 5324 get_device_image_memory_requirements 5325 } else { 5326 ::std::mem::transmute(val) 5327 } 5328 }, 5329 get_device_image_sparse_memory_requirements: unsafe { 5330 unsafe extern "system" fn get_device_image_sparse_memory_requirements( 5331 _device: Device, 5332 _p_info: *const DeviceImageMemoryRequirements, 5333 _p_sparse_memory_requirement_count: *mut u32, 5334 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, 5335 ) { 5336 panic!(concat!( 5337 "Unable to load ", 5338 stringify!(get_device_image_sparse_memory_requirements) 5339 )) 5340 } 5341 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5342 b"vkGetDeviceImageSparseMemoryRequirements\0", 5343 ); 5344 let val = _f(cname); 5345 if val.is_null() { 5346 get_device_image_sparse_memory_requirements 5347 } else { 5348 ::std::mem::transmute(val) 5349 } 5350 }, 5351 } 5352 } 5353 } 5354