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 extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction; 8 pub struct StaticFn { 9 pub get_instance_proc_addr: 10 extern "system" fn(instance: Instance, p_name: *const c_char) -> PFN_vkVoidFunction, 11 } 12 unsafe impl Send for StaticFn {} 13 unsafe impl Sync for StaticFn {} 14 impl ::std::clone::Clone for StaticFn { clone(&self) -> Self15 fn clone(&self) -> Self { 16 StaticFn { 17 get_instance_proc_addr: self.get_instance_proc_addr, 18 } 19 } 20 } 21 impl StaticFn { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,22 pub fn load<F>(mut _f: F) -> Self 23 where 24 F: FnMut(&::std::ffi::CStr) -> *const c_void, 25 { 26 StaticFn { 27 get_instance_proc_addr: unsafe { 28 extern "system" fn get_instance_proc_addr( 29 _instance: Instance, 30 _p_name: *const c_char, 31 ) -> PFN_vkVoidFunction { 32 panic!(concat!( 33 "Unable to load ", 34 stringify!(get_instance_proc_addr) 35 )) 36 } 37 let cname = 38 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetInstanceProcAddr\0"); 39 let val = _f(cname); 40 if val.is_null() { 41 get_instance_proc_addr 42 } else { 43 ::std::mem::transmute(val) 44 } 45 }, 46 } 47 } 48 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetInstanceProcAddr.html>"] get_instance_proc_addr( &self, instance: Instance, p_name: *const c_char, ) -> PFN_vkVoidFunction49 pub unsafe fn get_instance_proc_addr( 50 &self, 51 instance: Instance, 52 p_name: *const c_char, 53 ) -> PFN_vkVoidFunction { 54 (self.get_instance_proc_addr)(instance, p_name) 55 } 56 } 57 #[allow(non_camel_case_types)] 58 pub type PFN_vkCreateInstance = extern "system" fn( 59 p_create_info: *const InstanceCreateInfo, 60 p_allocator: *const AllocationCallbacks, 61 p_instance: *mut Instance, 62 ) -> Result; 63 #[allow(non_camel_case_types)] 64 pub type PFN_vkEnumerateInstanceExtensionProperties = extern "system" fn( 65 p_layer_name: *const c_char, 66 p_property_count: *mut u32, 67 p_properties: *mut ExtensionProperties, 68 ) -> Result; 69 #[allow(non_camel_case_types)] 70 pub type PFN_vkEnumerateInstanceLayerProperties = 71 extern "system" fn(p_property_count: *mut u32, p_properties: *mut LayerProperties) -> Result; 72 pub struct EntryFnV1_0 { 73 pub create_instance: extern "system" fn( 74 p_create_info: *const InstanceCreateInfo, 75 p_allocator: *const AllocationCallbacks, 76 p_instance: *mut Instance, 77 ) -> Result, 78 pub enumerate_instance_extension_properties: extern "system" fn( 79 p_layer_name: *const c_char, 80 p_property_count: *mut u32, 81 p_properties: *mut ExtensionProperties, 82 ) -> Result, 83 pub enumerate_instance_layer_properties: extern "system" fn( 84 p_property_count: *mut u32, 85 p_properties: *mut LayerProperties, 86 ) -> Result, 87 } 88 unsafe impl Send for EntryFnV1_0 {} 89 unsafe impl Sync for EntryFnV1_0 {} 90 impl ::std::clone::Clone for EntryFnV1_0 { clone(&self) -> Self91 fn clone(&self) -> Self { 92 EntryFnV1_0 { 93 create_instance: self.create_instance, 94 enumerate_instance_extension_properties: self.enumerate_instance_extension_properties, 95 enumerate_instance_layer_properties: self.enumerate_instance_layer_properties, 96 } 97 } 98 } 99 impl EntryFnV1_0 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,100 pub fn load<F>(mut _f: F) -> Self 101 where 102 F: FnMut(&::std::ffi::CStr) -> *const c_void, 103 { 104 EntryFnV1_0 { 105 create_instance: unsafe { 106 extern "system" fn create_instance( 107 _p_create_info: *const InstanceCreateInfo, 108 _p_allocator: *const AllocationCallbacks, 109 _p_instance: *mut Instance, 110 ) -> Result { 111 panic!(concat!("Unable to load ", stringify!(create_instance))) 112 } 113 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateInstance\0"); 114 let val = _f(cname); 115 if val.is_null() { 116 create_instance 117 } else { 118 ::std::mem::transmute(val) 119 } 120 }, 121 enumerate_instance_extension_properties: unsafe { 122 extern "system" fn enumerate_instance_extension_properties( 123 _p_layer_name: *const c_char, 124 _p_property_count: *mut u32, 125 _p_properties: *mut ExtensionProperties, 126 ) -> Result { 127 panic!(concat!( 128 "Unable to load ", 129 stringify!(enumerate_instance_extension_properties) 130 )) 131 } 132 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 133 b"vkEnumerateInstanceExtensionProperties\0", 134 ); 135 let val = _f(cname); 136 if val.is_null() { 137 enumerate_instance_extension_properties 138 } else { 139 ::std::mem::transmute(val) 140 } 141 }, 142 enumerate_instance_layer_properties: unsafe { 143 extern "system" fn enumerate_instance_layer_properties( 144 _p_property_count: *mut u32, 145 _p_properties: *mut LayerProperties, 146 ) -> Result { 147 panic!(concat!( 148 "Unable to load ", 149 stringify!(enumerate_instance_layer_properties) 150 )) 151 } 152 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 153 b"vkEnumerateInstanceLayerProperties\0", 154 ); 155 let val = _f(cname); 156 if val.is_null() { 157 enumerate_instance_layer_properties 158 } else { 159 ::std::mem::transmute(val) 160 } 161 }, 162 } 163 } 164 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateInstance.html>"] create_instance( &self, p_create_info: *const InstanceCreateInfo, p_allocator: *const AllocationCallbacks, p_instance: *mut Instance, ) -> Result165 pub unsafe fn create_instance( 166 &self, 167 p_create_info: *const InstanceCreateInfo, 168 p_allocator: *const AllocationCallbacks, 169 p_instance: *mut Instance, 170 ) -> Result { 171 (self.create_instance)(p_create_info, p_allocator, p_instance) 172 } 173 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceExtensionProperties.html>"] enumerate_instance_extension_properties( &self, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result174 pub unsafe fn enumerate_instance_extension_properties( 175 &self, 176 p_layer_name: *const c_char, 177 p_property_count: *mut u32, 178 p_properties: *mut ExtensionProperties, 179 ) -> Result { 180 (self.enumerate_instance_extension_properties)(p_layer_name, p_property_count, p_properties) 181 } 182 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceLayerProperties.html>"] enumerate_instance_layer_properties( &self, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result183 pub unsafe fn enumerate_instance_layer_properties( 184 &self, 185 p_property_count: *mut u32, 186 p_properties: *mut LayerProperties, 187 ) -> Result { 188 (self.enumerate_instance_layer_properties)(p_property_count, p_properties) 189 } 190 } 191 #[allow(non_camel_case_types)] 192 pub type PFN_vkDestroyInstance = 193 extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks); 194 #[allow(non_camel_case_types)] 195 pub type PFN_vkEnumeratePhysicalDevices = extern "system" fn( 196 instance: Instance, 197 p_physical_device_count: *mut u32, 198 p_physical_devices: *mut PhysicalDevice, 199 ) -> Result; 200 #[allow(non_camel_case_types)] 201 pub type PFN_vkGetPhysicalDeviceFeatures = 202 extern "system" fn(physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures); 203 #[allow(non_camel_case_types)] 204 pub type PFN_vkGetPhysicalDeviceFormatProperties = extern "system" fn( 205 physical_device: PhysicalDevice, 206 format: Format, 207 p_format_properties: *mut FormatProperties, 208 ); 209 #[allow(non_camel_case_types)] 210 pub type PFN_vkGetPhysicalDeviceImageFormatProperties = extern "system" fn( 211 physical_device: PhysicalDevice, 212 format: Format, 213 ty: ImageType, 214 tiling: ImageTiling, 215 usage: ImageUsageFlags, 216 flags: ImageCreateFlags, 217 p_image_format_properties: *mut ImageFormatProperties, 218 ) -> Result; 219 #[allow(non_camel_case_types)] 220 pub type PFN_vkGetPhysicalDeviceProperties = extern "system" fn( 221 physical_device: PhysicalDevice, 222 p_properties: *mut PhysicalDeviceProperties, 223 ); 224 #[allow(non_camel_case_types)] 225 pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = extern "system" fn( 226 physical_device: PhysicalDevice, 227 p_queue_family_property_count: *mut u32, 228 p_queue_family_properties: *mut QueueFamilyProperties, 229 ); 230 #[allow(non_camel_case_types)] 231 pub type PFN_vkGetPhysicalDeviceMemoryProperties = extern "system" fn( 232 physical_device: PhysicalDevice, 233 p_memory_properties: *mut PhysicalDeviceMemoryProperties, 234 ); 235 #[allow(non_camel_case_types)] 236 pub type PFN_vkGetDeviceProcAddr = 237 extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction; 238 #[allow(non_camel_case_types)] 239 pub type PFN_vkCreateDevice = extern "system" fn( 240 physical_device: PhysicalDevice, 241 p_create_info: *const DeviceCreateInfo, 242 p_allocator: *const AllocationCallbacks, 243 p_device: *mut Device, 244 ) -> Result; 245 #[allow(non_camel_case_types)] 246 pub type PFN_vkEnumerateDeviceExtensionProperties = extern "system" fn( 247 physical_device: PhysicalDevice, 248 p_layer_name: *const c_char, 249 p_property_count: *mut u32, 250 p_properties: *mut ExtensionProperties, 251 ) -> Result; 252 #[allow(non_camel_case_types)] 253 pub type PFN_vkEnumerateDeviceLayerProperties = extern "system" fn( 254 physical_device: PhysicalDevice, 255 p_property_count: *mut u32, 256 p_properties: *mut LayerProperties, 257 ) -> Result; 258 #[allow(non_camel_case_types)] 259 pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = extern "system" fn( 260 physical_device: PhysicalDevice, 261 format: Format, 262 ty: ImageType, 263 samples: SampleCountFlags, 264 usage: ImageUsageFlags, 265 tiling: ImageTiling, 266 p_property_count: *mut u32, 267 p_properties: *mut SparseImageFormatProperties, 268 ); 269 pub struct InstanceFnV1_0 { 270 pub destroy_instance: 271 extern "system" fn(instance: Instance, p_allocator: *const AllocationCallbacks), 272 pub enumerate_physical_devices: extern "system" fn( 273 instance: Instance, 274 p_physical_device_count: *mut u32, 275 p_physical_devices: *mut PhysicalDevice, 276 ) -> Result, 277 pub get_physical_device_features: extern "system" fn( 278 physical_device: PhysicalDevice, 279 p_features: *mut PhysicalDeviceFeatures, 280 ), 281 pub get_physical_device_format_properties: extern "system" fn( 282 physical_device: PhysicalDevice, 283 format: Format, 284 p_format_properties: *mut FormatProperties, 285 ), 286 pub get_physical_device_image_format_properties: extern "system" fn( 287 physical_device: PhysicalDevice, 288 format: Format, 289 ty: ImageType, 290 tiling: ImageTiling, 291 usage: ImageUsageFlags, 292 flags: ImageCreateFlags, 293 p_image_format_properties: *mut ImageFormatProperties, 294 ) -> Result, 295 pub get_physical_device_properties: extern "system" fn( 296 physical_device: PhysicalDevice, 297 p_properties: *mut PhysicalDeviceProperties, 298 ), 299 pub get_physical_device_queue_family_properties: extern "system" fn( 300 physical_device: PhysicalDevice, 301 p_queue_family_property_count: *mut u32, 302 p_queue_family_properties: *mut QueueFamilyProperties, 303 ), 304 pub get_physical_device_memory_properties: extern "system" fn( 305 physical_device: PhysicalDevice, 306 p_memory_properties: *mut PhysicalDeviceMemoryProperties, 307 ), 308 pub get_device_proc_addr: 309 extern "system" fn(device: Device, p_name: *const c_char) -> PFN_vkVoidFunction, 310 pub create_device: extern "system" fn( 311 physical_device: PhysicalDevice, 312 p_create_info: *const DeviceCreateInfo, 313 p_allocator: *const AllocationCallbacks, 314 p_device: *mut Device, 315 ) -> Result, 316 pub enumerate_device_extension_properties: extern "system" fn( 317 physical_device: PhysicalDevice, 318 p_layer_name: *const c_char, 319 p_property_count: *mut u32, 320 p_properties: *mut ExtensionProperties, 321 ) -> Result, 322 pub enumerate_device_layer_properties: extern "system" fn( 323 physical_device: PhysicalDevice, 324 p_property_count: *mut u32, 325 p_properties: *mut LayerProperties, 326 ) -> Result, 327 pub get_physical_device_sparse_image_format_properties: extern "system" fn( 328 physical_device: PhysicalDevice, 329 format: Format, 330 ty: ImageType, 331 samples: SampleCountFlags, 332 usage: ImageUsageFlags, 333 tiling: ImageTiling, 334 p_property_count: *mut u32, 335 p_properties: *mut SparseImageFormatProperties, 336 ), 337 } 338 unsafe impl Send for InstanceFnV1_0 {} 339 unsafe impl Sync for InstanceFnV1_0 {} 340 impl ::std::clone::Clone for InstanceFnV1_0 { clone(&self) -> Self341 fn clone(&self) -> Self { 342 InstanceFnV1_0 { 343 destroy_instance: self.destroy_instance, 344 enumerate_physical_devices: self.enumerate_physical_devices, 345 get_physical_device_features: self.get_physical_device_features, 346 get_physical_device_format_properties: self.get_physical_device_format_properties, 347 get_physical_device_image_format_properties: self 348 .get_physical_device_image_format_properties, 349 get_physical_device_properties: self.get_physical_device_properties, 350 get_physical_device_queue_family_properties: self 351 .get_physical_device_queue_family_properties, 352 get_physical_device_memory_properties: self.get_physical_device_memory_properties, 353 get_device_proc_addr: self.get_device_proc_addr, 354 create_device: self.create_device, 355 enumerate_device_extension_properties: self.enumerate_device_extension_properties, 356 enumerate_device_layer_properties: self.enumerate_device_layer_properties, 357 get_physical_device_sparse_image_format_properties: self 358 .get_physical_device_sparse_image_format_properties, 359 } 360 } 361 } 362 impl InstanceFnV1_0 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,363 pub fn load<F>(mut _f: F) -> Self 364 where 365 F: FnMut(&::std::ffi::CStr) -> *const c_void, 366 { 367 InstanceFnV1_0 { 368 destroy_instance: unsafe { 369 extern "system" fn destroy_instance( 370 _instance: Instance, 371 _p_allocator: *const AllocationCallbacks, 372 ) { 373 panic!(concat!("Unable to load ", stringify!(destroy_instance))) 374 } 375 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyInstance\0"); 376 let val = _f(cname); 377 if val.is_null() { 378 destroy_instance 379 } else { 380 ::std::mem::transmute(val) 381 } 382 }, 383 enumerate_physical_devices: unsafe { 384 extern "system" fn enumerate_physical_devices( 385 _instance: Instance, 386 _p_physical_device_count: *mut u32, 387 _p_physical_devices: *mut PhysicalDevice, 388 ) -> Result { 389 panic!(concat!( 390 "Unable to load ", 391 stringify!(enumerate_physical_devices) 392 )) 393 } 394 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 395 b"vkEnumeratePhysicalDevices\0", 396 ); 397 let val = _f(cname); 398 if val.is_null() { 399 enumerate_physical_devices 400 } else { 401 ::std::mem::transmute(val) 402 } 403 }, 404 get_physical_device_features: unsafe { 405 extern "system" fn get_physical_device_features( 406 _physical_device: PhysicalDevice, 407 _p_features: *mut PhysicalDeviceFeatures, 408 ) { 409 panic!(concat!( 410 "Unable to load ", 411 stringify!(get_physical_device_features) 412 )) 413 } 414 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 415 b"vkGetPhysicalDeviceFeatures\0", 416 ); 417 let val = _f(cname); 418 if val.is_null() { 419 get_physical_device_features 420 } else { 421 ::std::mem::transmute(val) 422 } 423 }, 424 get_physical_device_format_properties: unsafe { 425 extern "system" fn get_physical_device_format_properties( 426 _physical_device: PhysicalDevice, 427 _format: Format, 428 _p_format_properties: *mut FormatProperties, 429 ) { 430 panic!(concat!( 431 "Unable to load ", 432 stringify!(get_physical_device_format_properties) 433 )) 434 } 435 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 436 b"vkGetPhysicalDeviceFormatProperties\0", 437 ); 438 let val = _f(cname); 439 if val.is_null() { 440 get_physical_device_format_properties 441 } else { 442 ::std::mem::transmute(val) 443 } 444 }, 445 get_physical_device_image_format_properties: unsafe { 446 extern "system" fn get_physical_device_image_format_properties( 447 _physical_device: PhysicalDevice, 448 _format: Format, 449 _ty: ImageType, 450 _tiling: ImageTiling, 451 _usage: ImageUsageFlags, 452 _flags: ImageCreateFlags, 453 _p_image_format_properties: *mut ImageFormatProperties, 454 ) -> Result { 455 panic!(concat!( 456 "Unable to load ", 457 stringify!(get_physical_device_image_format_properties) 458 )) 459 } 460 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 461 b"vkGetPhysicalDeviceImageFormatProperties\0", 462 ); 463 let val = _f(cname); 464 if val.is_null() { 465 get_physical_device_image_format_properties 466 } else { 467 ::std::mem::transmute(val) 468 } 469 }, 470 get_physical_device_properties: unsafe { 471 extern "system" fn get_physical_device_properties( 472 _physical_device: PhysicalDevice, 473 _p_properties: *mut PhysicalDeviceProperties, 474 ) { 475 panic!(concat!( 476 "Unable to load ", 477 stringify!(get_physical_device_properties) 478 )) 479 } 480 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 481 b"vkGetPhysicalDeviceProperties\0", 482 ); 483 let val = _f(cname); 484 if val.is_null() { 485 get_physical_device_properties 486 } else { 487 ::std::mem::transmute(val) 488 } 489 }, 490 get_physical_device_queue_family_properties: unsafe { 491 extern "system" fn get_physical_device_queue_family_properties( 492 _physical_device: PhysicalDevice, 493 _p_queue_family_property_count: *mut u32, 494 _p_queue_family_properties: *mut QueueFamilyProperties, 495 ) { 496 panic!(concat!( 497 "Unable to load ", 498 stringify!(get_physical_device_queue_family_properties) 499 )) 500 } 501 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 502 b"vkGetPhysicalDeviceQueueFamilyProperties\0", 503 ); 504 let val = _f(cname); 505 if val.is_null() { 506 get_physical_device_queue_family_properties 507 } else { 508 ::std::mem::transmute(val) 509 } 510 }, 511 get_physical_device_memory_properties: unsafe { 512 extern "system" fn get_physical_device_memory_properties( 513 _physical_device: PhysicalDevice, 514 _p_memory_properties: *mut PhysicalDeviceMemoryProperties, 515 ) { 516 panic!(concat!( 517 "Unable to load ", 518 stringify!(get_physical_device_memory_properties) 519 )) 520 } 521 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 522 b"vkGetPhysicalDeviceMemoryProperties\0", 523 ); 524 let val = _f(cname); 525 if val.is_null() { 526 get_physical_device_memory_properties 527 } else { 528 ::std::mem::transmute(val) 529 } 530 }, 531 get_device_proc_addr: unsafe { 532 extern "system" fn get_device_proc_addr( 533 _device: Device, 534 _p_name: *const c_char, 535 ) -> PFN_vkVoidFunction { 536 panic!(concat!("Unable to load ", stringify!(get_device_proc_addr))) 537 } 538 let cname = 539 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceProcAddr\0"); 540 let val = _f(cname); 541 if val.is_null() { 542 get_device_proc_addr 543 } else { 544 ::std::mem::transmute(val) 545 } 546 }, 547 create_device: unsafe { 548 extern "system" fn create_device( 549 _physical_device: PhysicalDevice, 550 _p_create_info: *const DeviceCreateInfo, 551 _p_allocator: *const AllocationCallbacks, 552 _p_device: *mut Device, 553 ) -> Result { 554 panic!(concat!("Unable to load ", stringify!(create_device))) 555 } 556 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDevice\0"); 557 let val = _f(cname); 558 if val.is_null() { 559 create_device 560 } else { 561 ::std::mem::transmute(val) 562 } 563 }, 564 enumerate_device_extension_properties: unsafe { 565 extern "system" fn enumerate_device_extension_properties( 566 _physical_device: PhysicalDevice, 567 _p_layer_name: *const c_char, 568 _p_property_count: *mut u32, 569 _p_properties: *mut ExtensionProperties, 570 ) -> Result { 571 panic!(concat!( 572 "Unable to load ", 573 stringify!(enumerate_device_extension_properties) 574 )) 575 } 576 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 577 b"vkEnumerateDeviceExtensionProperties\0", 578 ); 579 let val = _f(cname); 580 if val.is_null() { 581 enumerate_device_extension_properties 582 } else { 583 ::std::mem::transmute(val) 584 } 585 }, 586 enumerate_device_layer_properties: unsafe { 587 extern "system" fn enumerate_device_layer_properties( 588 _physical_device: PhysicalDevice, 589 _p_property_count: *mut u32, 590 _p_properties: *mut LayerProperties, 591 ) -> Result { 592 panic!(concat!( 593 "Unable to load ", 594 stringify!(enumerate_device_layer_properties) 595 )) 596 } 597 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 598 b"vkEnumerateDeviceLayerProperties\0", 599 ); 600 let val = _f(cname); 601 if val.is_null() { 602 enumerate_device_layer_properties 603 } else { 604 ::std::mem::transmute(val) 605 } 606 }, 607 get_physical_device_sparse_image_format_properties: unsafe { 608 extern "system" fn get_physical_device_sparse_image_format_properties( 609 _physical_device: PhysicalDevice, 610 _format: Format, 611 _ty: ImageType, 612 _samples: SampleCountFlags, 613 _usage: ImageUsageFlags, 614 _tiling: ImageTiling, 615 _p_property_count: *mut u32, 616 _p_properties: *mut SparseImageFormatProperties, 617 ) { 618 panic!(concat!( 619 "Unable to load ", 620 stringify!(get_physical_device_sparse_image_format_properties) 621 )) 622 } 623 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 624 b"vkGetPhysicalDeviceSparseImageFormatProperties\0", 625 ); 626 let val = _f(cname); 627 if val.is_null() { 628 get_physical_device_sparse_image_format_properties 629 } else { 630 ::std::mem::transmute(val) 631 } 632 }, 633 } 634 } 635 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyInstance.html>"] destroy_instance( &self, instance: Instance, p_allocator: *const AllocationCallbacks, )636 pub unsafe fn destroy_instance( 637 &self, 638 instance: Instance, 639 p_allocator: *const AllocationCallbacks, 640 ) { 641 (self.destroy_instance)(instance, p_allocator) 642 } 643 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDevices.html>"] enumerate_physical_devices( &self, instance: Instance, p_physical_device_count: *mut u32, p_physical_devices: *mut PhysicalDevice, ) -> Result644 pub unsafe fn enumerate_physical_devices( 645 &self, 646 instance: Instance, 647 p_physical_device_count: *mut u32, 648 p_physical_devices: *mut PhysicalDevice, 649 ) -> Result { 650 (self.enumerate_physical_devices)(instance, p_physical_device_count, p_physical_devices) 651 } 652 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures.html>"] get_physical_device_features( &self, physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures, )653 pub unsafe fn get_physical_device_features( 654 &self, 655 physical_device: PhysicalDevice, 656 p_features: *mut PhysicalDeviceFeatures, 657 ) { 658 (self.get_physical_device_features)(physical_device, p_features) 659 } 660 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties.html>"] get_physical_device_format_properties( &self, physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties, )661 pub unsafe fn get_physical_device_format_properties( 662 &self, 663 physical_device: PhysicalDevice, 664 format: Format, 665 p_format_properties: *mut FormatProperties, 666 ) { 667 (self.get_physical_device_format_properties)(physical_device, format, p_format_properties) 668 } 669 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties.html>"] get_physical_device_image_format_properties( &self, physical_device: PhysicalDevice, format: Format, ty: ImageType, tiling: ImageTiling, usage: ImageUsageFlags, flags: ImageCreateFlags, p_image_format_properties: *mut ImageFormatProperties, ) -> Result670 pub unsafe fn get_physical_device_image_format_properties( 671 &self, 672 physical_device: PhysicalDevice, 673 format: Format, 674 ty: ImageType, 675 tiling: ImageTiling, 676 usage: ImageUsageFlags, 677 flags: ImageCreateFlags, 678 p_image_format_properties: *mut ImageFormatProperties, 679 ) -> Result { 680 (self.get_physical_device_image_format_properties)( 681 physical_device, 682 format, 683 ty, 684 tiling, 685 usage, 686 flags, 687 p_image_format_properties, 688 ) 689 } 690 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties.html>"] get_physical_device_properties( &self, physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties, )691 pub unsafe fn get_physical_device_properties( 692 &self, 693 physical_device: PhysicalDevice, 694 p_properties: *mut PhysicalDeviceProperties, 695 ) { 696 (self.get_physical_device_properties)(physical_device, p_properties) 697 } 698 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties.html>"] get_physical_device_queue_family_properties( &self, physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties, )699 pub unsafe fn get_physical_device_queue_family_properties( 700 &self, 701 physical_device: PhysicalDevice, 702 p_queue_family_property_count: *mut u32, 703 p_queue_family_properties: *mut QueueFamilyProperties, 704 ) { 705 (self.get_physical_device_queue_family_properties)( 706 physical_device, 707 p_queue_family_property_count, 708 p_queue_family_properties, 709 ) 710 } 711 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties.html>"] get_physical_device_memory_properties( &self, physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties, )712 pub unsafe fn get_physical_device_memory_properties( 713 &self, 714 physical_device: PhysicalDevice, 715 p_memory_properties: *mut PhysicalDeviceMemoryProperties, 716 ) { 717 (self.get_physical_device_memory_properties)(physical_device, p_memory_properties) 718 } 719 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceProcAddr.html>"] get_device_proc_addr( &self, device: Device, p_name: *const c_char, ) -> PFN_vkVoidFunction720 pub unsafe fn get_device_proc_addr( 721 &self, 722 device: Device, 723 p_name: *const c_char, 724 ) -> PFN_vkVoidFunction { 725 (self.get_device_proc_addr)(device, p_name) 726 } 727 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDevice.html>"] create_device( &self, physical_device: PhysicalDevice, p_create_info: *const DeviceCreateInfo, p_allocator: *const AllocationCallbacks, p_device: *mut Device, ) -> Result728 pub unsafe fn create_device( 729 &self, 730 physical_device: PhysicalDevice, 731 p_create_info: *const DeviceCreateInfo, 732 p_allocator: *const AllocationCallbacks, 733 p_device: *mut Device, 734 ) -> Result { 735 (self.create_device)(physical_device, p_create_info, p_allocator, p_device) 736 } 737 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceExtensionProperties.html>"] enumerate_device_extension_properties( &self, physical_device: PhysicalDevice, p_layer_name: *const c_char, p_property_count: *mut u32, p_properties: *mut ExtensionProperties, ) -> Result738 pub unsafe fn enumerate_device_extension_properties( 739 &self, 740 physical_device: PhysicalDevice, 741 p_layer_name: *const c_char, 742 p_property_count: *mut u32, 743 p_properties: *mut ExtensionProperties, 744 ) -> Result { 745 (self.enumerate_device_extension_properties)( 746 physical_device, 747 p_layer_name, 748 p_property_count, 749 p_properties, 750 ) 751 } 752 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateDeviceLayerProperties.html>"] enumerate_device_layer_properties( &self, physical_device: PhysicalDevice, p_property_count: *mut u32, p_properties: *mut LayerProperties, ) -> Result753 pub unsafe fn enumerate_device_layer_properties( 754 &self, 755 physical_device: PhysicalDevice, 756 p_property_count: *mut u32, 757 p_properties: *mut LayerProperties, 758 ) -> Result { 759 (self.enumerate_device_layer_properties)(physical_device, p_property_count, p_properties) 760 } 761 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties.html>"] get_physical_device_sparse_image_format_properties( &self, physical_device: PhysicalDevice, format: Format, ty: ImageType, samples: SampleCountFlags, usage: ImageUsageFlags, tiling: ImageTiling, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties, )762 pub unsafe fn get_physical_device_sparse_image_format_properties( 763 &self, 764 physical_device: PhysicalDevice, 765 format: Format, 766 ty: ImageType, 767 samples: SampleCountFlags, 768 usage: ImageUsageFlags, 769 tiling: ImageTiling, 770 p_property_count: *mut u32, 771 p_properties: *mut SparseImageFormatProperties, 772 ) { 773 (self.get_physical_device_sparse_image_format_properties)( 774 physical_device, 775 format, 776 ty, 777 samples, 778 usage, 779 tiling, 780 p_property_count, 781 p_properties, 782 ) 783 } 784 } 785 #[allow(non_camel_case_types)] 786 pub type PFN_vkDestroyDevice = 787 extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks); 788 #[allow(non_camel_case_types)] 789 pub type PFN_vkGetDeviceQueue = extern "system" fn( 790 device: Device, 791 queue_family_index: u32, 792 queue_index: u32, 793 p_queue: *mut Queue, 794 ); 795 #[allow(non_camel_case_types)] 796 pub type PFN_vkQueueSubmit = extern "system" fn( 797 queue: Queue, 798 submit_count: u32, 799 p_submits: *const SubmitInfo, 800 fence: Fence, 801 ) -> Result; 802 #[allow(non_camel_case_types)] 803 pub type PFN_vkQueueWaitIdle = extern "system" fn(queue: Queue) -> Result; 804 #[allow(non_camel_case_types)] 805 pub type PFN_vkDeviceWaitIdle = extern "system" fn(device: Device) -> Result; 806 #[allow(non_camel_case_types)] 807 pub type PFN_vkAllocateMemory = extern "system" fn( 808 device: Device, 809 p_allocate_info: *const MemoryAllocateInfo, 810 p_allocator: *const AllocationCallbacks, 811 p_memory: *mut DeviceMemory, 812 ) -> Result; 813 #[allow(non_camel_case_types)] 814 pub type PFN_vkFreeMemory = extern "system" fn( 815 device: Device, 816 memory: DeviceMemory, 817 p_allocator: *const AllocationCallbacks, 818 ); 819 #[allow(non_camel_case_types)] 820 pub type PFN_vkMapMemory = extern "system" fn( 821 device: Device, 822 memory: DeviceMemory, 823 offset: DeviceSize, 824 size: DeviceSize, 825 flags: MemoryMapFlags, 826 pp_data: *mut *mut c_void, 827 ) -> Result; 828 #[allow(non_camel_case_types)] 829 pub type PFN_vkUnmapMemory = extern "system" fn(device: Device, memory: DeviceMemory); 830 #[allow(non_camel_case_types)] 831 pub type PFN_vkFlushMappedMemoryRanges = extern "system" fn( 832 device: Device, 833 memory_range_count: u32, 834 p_memory_ranges: *const MappedMemoryRange, 835 ) -> Result; 836 #[allow(non_camel_case_types)] 837 pub type PFN_vkInvalidateMappedMemoryRanges = extern "system" fn( 838 device: Device, 839 memory_range_count: u32, 840 p_memory_ranges: *const MappedMemoryRange, 841 ) -> Result; 842 #[allow(non_camel_case_types)] 843 pub type PFN_vkGetDeviceMemoryCommitment = extern "system" fn( 844 device: Device, 845 memory: DeviceMemory, 846 p_committed_memory_in_bytes: *mut DeviceSize, 847 ); 848 #[allow(non_camel_case_types)] 849 pub type PFN_vkBindBufferMemory = extern "system" fn( 850 device: Device, 851 buffer: Buffer, 852 memory: DeviceMemory, 853 memory_offset: DeviceSize, 854 ) -> Result; 855 #[allow(non_camel_case_types)] 856 pub type PFN_vkBindImageMemory = extern "system" fn( 857 device: Device, 858 image: Image, 859 memory: DeviceMemory, 860 memory_offset: DeviceSize, 861 ) -> Result; 862 #[allow(non_camel_case_types)] 863 pub type PFN_vkGetBufferMemoryRequirements = extern "system" fn( 864 device: Device, 865 buffer: Buffer, 866 p_memory_requirements: *mut MemoryRequirements, 867 ); 868 #[allow(non_camel_case_types)] 869 pub type PFN_vkGetImageMemoryRequirements = extern "system" fn( 870 device: Device, 871 image: Image, 872 p_memory_requirements: *mut MemoryRequirements, 873 ); 874 #[allow(non_camel_case_types)] 875 pub type PFN_vkGetImageSparseMemoryRequirements = extern "system" fn( 876 device: Device, 877 image: Image, 878 p_sparse_memory_requirement_count: *mut u32, 879 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, 880 ); 881 #[allow(non_camel_case_types)] 882 pub type PFN_vkQueueBindSparse = extern "system" fn( 883 queue: Queue, 884 bind_info_count: u32, 885 p_bind_info: *const BindSparseInfo, 886 fence: Fence, 887 ) -> Result; 888 #[allow(non_camel_case_types)] 889 pub type PFN_vkCreateFence = extern "system" fn( 890 device: Device, 891 p_create_info: *const FenceCreateInfo, 892 p_allocator: *const AllocationCallbacks, 893 p_fence: *mut Fence, 894 ) -> Result; 895 #[allow(non_camel_case_types)] 896 pub type PFN_vkDestroyFence = 897 extern "system" fn(device: Device, fence: Fence, p_allocator: *const AllocationCallbacks); 898 #[allow(non_camel_case_types)] 899 pub type PFN_vkResetFences = 900 extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result; 901 #[allow(non_camel_case_types)] 902 pub type PFN_vkGetFenceStatus = extern "system" fn(device: Device, fence: Fence) -> Result; 903 #[allow(non_camel_case_types)] 904 pub type PFN_vkWaitForFences = extern "system" fn( 905 device: Device, 906 fence_count: u32, 907 p_fences: *const Fence, 908 wait_all: Bool32, 909 timeout: u64, 910 ) -> Result; 911 #[allow(non_camel_case_types)] 912 pub type PFN_vkCreateSemaphore = extern "system" fn( 913 device: Device, 914 p_create_info: *const SemaphoreCreateInfo, 915 p_allocator: *const AllocationCallbacks, 916 p_semaphore: *mut Semaphore, 917 ) -> Result; 918 #[allow(non_camel_case_types)] 919 pub type PFN_vkDestroySemaphore = extern "system" fn( 920 device: Device, 921 semaphore: Semaphore, 922 p_allocator: *const AllocationCallbacks, 923 ); 924 #[allow(non_camel_case_types)] 925 pub type PFN_vkCreateEvent = extern "system" fn( 926 device: Device, 927 p_create_info: *const EventCreateInfo, 928 p_allocator: *const AllocationCallbacks, 929 p_event: *mut Event, 930 ) -> Result; 931 #[allow(non_camel_case_types)] 932 pub type PFN_vkDestroyEvent = 933 extern "system" fn(device: Device, event: Event, p_allocator: *const AllocationCallbacks); 934 #[allow(non_camel_case_types)] 935 pub type PFN_vkGetEventStatus = extern "system" fn(device: Device, event: Event) -> Result; 936 #[allow(non_camel_case_types)] 937 pub type PFN_vkSetEvent = extern "system" fn(device: Device, event: Event) -> Result; 938 #[allow(non_camel_case_types)] 939 pub type PFN_vkResetEvent = extern "system" fn(device: Device, event: Event) -> Result; 940 #[allow(non_camel_case_types)] 941 pub type PFN_vkCreateQueryPool = extern "system" fn( 942 device: Device, 943 p_create_info: *const QueryPoolCreateInfo, 944 p_allocator: *const AllocationCallbacks, 945 p_query_pool: *mut QueryPool, 946 ) -> Result; 947 #[allow(non_camel_case_types)] 948 pub type PFN_vkDestroyQueryPool = extern "system" fn( 949 device: Device, 950 query_pool: QueryPool, 951 p_allocator: *const AllocationCallbacks, 952 ); 953 #[allow(non_camel_case_types)] 954 pub type PFN_vkGetQueryPoolResults = extern "system" fn( 955 device: Device, 956 query_pool: QueryPool, 957 first_query: u32, 958 query_count: u32, 959 data_size: usize, 960 p_data: *mut c_void, 961 stride: DeviceSize, 962 flags: QueryResultFlags, 963 ) -> Result; 964 #[allow(non_camel_case_types)] 965 pub type PFN_vkCreateBuffer = extern "system" fn( 966 device: Device, 967 p_create_info: *const BufferCreateInfo, 968 p_allocator: *const AllocationCallbacks, 969 p_buffer: *mut Buffer, 970 ) -> Result; 971 #[allow(non_camel_case_types)] 972 pub type PFN_vkDestroyBuffer = 973 extern "system" fn(device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks); 974 #[allow(non_camel_case_types)] 975 pub type PFN_vkCreateBufferView = extern "system" fn( 976 device: Device, 977 p_create_info: *const BufferViewCreateInfo, 978 p_allocator: *const AllocationCallbacks, 979 p_view: *mut BufferView, 980 ) -> Result; 981 #[allow(non_camel_case_types)] 982 pub type PFN_vkDestroyBufferView = extern "system" fn( 983 device: Device, 984 buffer_view: BufferView, 985 p_allocator: *const AllocationCallbacks, 986 ); 987 #[allow(non_camel_case_types)] 988 pub type PFN_vkCreateImage = extern "system" fn( 989 device: Device, 990 p_create_info: *const ImageCreateInfo, 991 p_allocator: *const AllocationCallbacks, 992 p_image: *mut Image, 993 ) -> Result; 994 #[allow(non_camel_case_types)] 995 pub type PFN_vkDestroyImage = 996 extern "system" fn(device: Device, image: Image, p_allocator: *const AllocationCallbacks); 997 #[allow(non_camel_case_types)] 998 pub type PFN_vkGetImageSubresourceLayout = extern "system" fn( 999 device: Device, 1000 image: Image, 1001 p_subresource: *const ImageSubresource, 1002 p_layout: *mut SubresourceLayout, 1003 ); 1004 #[allow(non_camel_case_types)] 1005 pub type PFN_vkCreateImageView = extern "system" fn( 1006 device: Device, 1007 p_create_info: *const ImageViewCreateInfo, 1008 p_allocator: *const AllocationCallbacks, 1009 p_view: *mut ImageView, 1010 ) -> Result; 1011 #[allow(non_camel_case_types)] 1012 pub type PFN_vkDestroyImageView = extern "system" fn( 1013 device: Device, 1014 image_view: ImageView, 1015 p_allocator: *const AllocationCallbacks, 1016 ); 1017 #[allow(non_camel_case_types)] 1018 pub type PFN_vkCreateShaderModule = extern "system" fn( 1019 device: Device, 1020 p_create_info: *const ShaderModuleCreateInfo, 1021 p_allocator: *const AllocationCallbacks, 1022 p_shader_module: *mut ShaderModule, 1023 ) -> Result; 1024 #[allow(non_camel_case_types)] 1025 pub type PFN_vkDestroyShaderModule = extern "system" fn( 1026 device: Device, 1027 shader_module: ShaderModule, 1028 p_allocator: *const AllocationCallbacks, 1029 ); 1030 #[allow(non_camel_case_types)] 1031 pub type PFN_vkCreatePipelineCache = extern "system" fn( 1032 device: Device, 1033 p_create_info: *const PipelineCacheCreateInfo, 1034 p_allocator: *const AllocationCallbacks, 1035 p_pipeline_cache: *mut PipelineCache, 1036 ) -> Result; 1037 #[allow(non_camel_case_types)] 1038 pub type PFN_vkDestroyPipelineCache = extern "system" fn( 1039 device: Device, 1040 pipeline_cache: PipelineCache, 1041 p_allocator: *const AllocationCallbacks, 1042 ); 1043 #[allow(non_camel_case_types)] 1044 pub type PFN_vkGetPipelineCacheData = extern "system" fn( 1045 device: Device, 1046 pipeline_cache: PipelineCache, 1047 p_data_size: *mut usize, 1048 p_data: *mut c_void, 1049 ) -> Result; 1050 #[allow(non_camel_case_types)] 1051 pub type PFN_vkMergePipelineCaches = extern "system" fn( 1052 device: Device, 1053 dst_cache: PipelineCache, 1054 src_cache_count: u32, 1055 p_src_caches: *const PipelineCache, 1056 ) -> Result; 1057 #[allow(non_camel_case_types)] 1058 pub type PFN_vkCreateGraphicsPipelines = extern "system" fn( 1059 device: Device, 1060 pipeline_cache: PipelineCache, 1061 create_info_count: u32, 1062 p_create_infos: *const GraphicsPipelineCreateInfo, 1063 p_allocator: *const AllocationCallbacks, 1064 p_pipelines: *mut Pipeline, 1065 ) -> Result; 1066 #[allow(non_camel_case_types)] 1067 pub type PFN_vkCreateComputePipelines = extern "system" fn( 1068 device: Device, 1069 pipeline_cache: PipelineCache, 1070 create_info_count: u32, 1071 p_create_infos: *const ComputePipelineCreateInfo, 1072 p_allocator: *const AllocationCallbacks, 1073 p_pipelines: *mut Pipeline, 1074 ) -> Result; 1075 #[allow(non_camel_case_types)] 1076 pub type PFN_vkDestroyPipeline = 1077 extern "system" fn(device: Device, pipeline: Pipeline, p_allocator: *const AllocationCallbacks); 1078 #[allow(non_camel_case_types)] 1079 pub type PFN_vkCreatePipelineLayout = extern "system" fn( 1080 device: Device, 1081 p_create_info: *const PipelineLayoutCreateInfo, 1082 p_allocator: *const AllocationCallbacks, 1083 p_pipeline_layout: *mut PipelineLayout, 1084 ) -> Result; 1085 #[allow(non_camel_case_types)] 1086 pub type PFN_vkDestroyPipelineLayout = extern "system" fn( 1087 device: Device, 1088 pipeline_layout: PipelineLayout, 1089 p_allocator: *const AllocationCallbacks, 1090 ); 1091 #[allow(non_camel_case_types)] 1092 pub type PFN_vkCreateSampler = extern "system" fn( 1093 device: Device, 1094 p_create_info: *const SamplerCreateInfo, 1095 p_allocator: *const AllocationCallbacks, 1096 p_sampler: *mut Sampler, 1097 ) -> Result; 1098 #[allow(non_camel_case_types)] 1099 pub type PFN_vkDestroySampler = 1100 extern "system" fn(device: Device, sampler: Sampler, p_allocator: *const AllocationCallbacks); 1101 #[allow(non_camel_case_types)] 1102 pub type PFN_vkCreateDescriptorSetLayout = extern "system" fn( 1103 device: Device, 1104 p_create_info: *const DescriptorSetLayoutCreateInfo, 1105 p_allocator: *const AllocationCallbacks, 1106 p_set_layout: *mut DescriptorSetLayout, 1107 ) -> Result; 1108 #[allow(non_camel_case_types)] 1109 pub type PFN_vkDestroyDescriptorSetLayout = extern "system" fn( 1110 device: Device, 1111 descriptor_set_layout: DescriptorSetLayout, 1112 p_allocator: *const AllocationCallbacks, 1113 ); 1114 #[allow(non_camel_case_types)] 1115 pub type PFN_vkCreateDescriptorPool = extern "system" fn( 1116 device: Device, 1117 p_create_info: *const DescriptorPoolCreateInfo, 1118 p_allocator: *const AllocationCallbacks, 1119 p_descriptor_pool: *mut DescriptorPool, 1120 ) -> Result; 1121 #[allow(non_camel_case_types)] 1122 pub type PFN_vkDestroyDescriptorPool = extern "system" fn( 1123 device: Device, 1124 descriptor_pool: DescriptorPool, 1125 p_allocator: *const AllocationCallbacks, 1126 ); 1127 #[allow(non_camel_case_types)] 1128 pub type PFN_vkResetDescriptorPool = extern "system" fn( 1129 device: Device, 1130 descriptor_pool: DescriptorPool, 1131 flags: DescriptorPoolResetFlags, 1132 ) -> Result; 1133 #[allow(non_camel_case_types)] 1134 pub type PFN_vkAllocateDescriptorSets = extern "system" fn( 1135 device: Device, 1136 p_allocate_info: *const DescriptorSetAllocateInfo, 1137 p_descriptor_sets: *mut DescriptorSet, 1138 ) -> Result; 1139 #[allow(non_camel_case_types)] 1140 pub type PFN_vkFreeDescriptorSets = extern "system" fn( 1141 device: Device, 1142 descriptor_pool: DescriptorPool, 1143 descriptor_set_count: u32, 1144 p_descriptor_sets: *const DescriptorSet, 1145 ) -> Result; 1146 #[allow(non_camel_case_types)] 1147 pub type PFN_vkUpdateDescriptorSets = extern "system" fn( 1148 device: Device, 1149 descriptor_write_count: u32, 1150 p_descriptor_writes: *const WriteDescriptorSet, 1151 descriptor_copy_count: u32, 1152 p_descriptor_copies: *const CopyDescriptorSet, 1153 ); 1154 #[allow(non_camel_case_types)] 1155 pub type PFN_vkCreateFramebuffer = extern "system" fn( 1156 device: Device, 1157 p_create_info: *const FramebufferCreateInfo, 1158 p_allocator: *const AllocationCallbacks, 1159 p_framebuffer: *mut Framebuffer, 1160 ) -> Result; 1161 #[allow(non_camel_case_types)] 1162 pub type PFN_vkDestroyFramebuffer = extern "system" fn( 1163 device: Device, 1164 framebuffer: Framebuffer, 1165 p_allocator: *const AllocationCallbacks, 1166 ); 1167 #[allow(non_camel_case_types)] 1168 pub type PFN_vkCreateRenderPass = extern "system" fn( 1169 device: Device, 1170 p_create_info: *const RenderPassCreateInfo, 1171 p_allocator: *const AllocationCallbacks, 1172 p_render_pass: *mut RenderPass, 1173 ) -> Result; 1174 #[allow(non_camel_case_types)] 1175 pub type PFN_vkDestroyRenderPass = extern "system" fn( 1176 device: Device, 1177 render_pass: RenderPass, 1178 p_allocator: *const AllocationCallbacks, 1179 ); 1180 #[allow(non_camel_case_types)] 1181 pub type PFN_vkGetRenderAreaGranularity = 1182 extern "system" fn(device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D); 1183 #[allow(non_camel_case_types)] 1184 pub type PFN_vkCreateCommandPool = extern "system" fn( 1185 device: Device, 1186 p_create_info: *const CommandPoolCreateInfo, 1187 p_allocator: *const AllocationCallbacks, 1188 p_command_pool: *mut CommandPool, 1189 ) -> Result; 1190 #[allow(non_camel_case_types)] 1191 pub type PFN_vkDestroyCommandPool = extern "system" fn( 1192 device: Device, 1193 command_pool: CommandPool, 1194 p_allocator: *const AllocationCallbacks, 1195 ); 1196 #[allow(non_camel_case_types)] 1197 pub type PFN_vkResetCommandPool = extern "system" fn( 1198 device: Device, 1199 command_pool: CommandPool, 1200 flags: CommandPoolResetFlags, 1201 ) -> Result; 1202 #[allow(non_camel_case_types)] 1203 pub type PFN_vkAllocateCommandBuffers = extern "system" fn( 1204 device: Device, 1205 p_allocate_info: *const CommandBufferAllocateInfo, 1206 p_command_buffers: *mut CommandBuffer, 1207 ) -> Result; 1208 #[allow(non_camel_case_types)] 1209 pub type PFN_vkFreeCommandBuffers = extern "system" fn( 1210 device: Device, 1211 command_pool: CommandPool, 1212 command_buffer_count: u32, 1213 p_command_buffers: *const CommandBuffer, 1214 ); 1215 #[allow(non_camel_case_types)] 1216 pub type PFN_vkBeginCommandBuffer = extern "system" fn( 1217 command_buffer: CommandBuffer, 1218 p_begin_info: *const CommandBufferBeginInfo, 1219 ) -> Result; 1220 #[allow(non_camel_case_types)] 1221 pub type PFN_vkEndCommandBuffer = extern "system" fn(command_buffer: CommandBuffer) -> Result; 1222 #[allow(non_camel_case_types)] 1223 pub type PFN_vkResetCommandBuffer = 1224 extern "system" fn(command_buffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result; 1225 #[allow(non_camel_case_types)] 1226 pub type PFN_vkCmdBindPipeline = extern "system" fn( 1227 command_buffer: CommandBuffer, 1228 pipeline_bind_point: PipelineBindPoint, 1229 pipeline: Pipeline, 1230 ); 1231 #[allow(non_camel_case_types)] 1232 pub type PFN_vkCmdSetViewport = extern "system" fn( 1233 command_buffer: CommandBuffer, 1234 first_viewport: u32, 1235 viewport_count: u32, 1236 p_viewports: *const Viewport, 1237 ); 1238 #[allow(non_camel_case_types)] 1239 pub type PFN_vkCmdSetScissor = extern "system" fn( 1240 command_buffer: CommandBuffer, 1241 first_scissor: u32, 1242 scissor_count: u32, 1243 p_scissors: *const Rect2D, 1244 ); 1245 #[allow(non_camel_case_types)] 1246 pub type PFN_vkCmdSetLineWidth = extern "system" fn(command_buffer: CommandBuffer, line_width: f32); 1247 #[allow(non_camel_case_types)] 1248 pub type PFN_vkCmdSetDepthBias = extern "system" fn( 1249 command_buffer: CommandBuffer, 1250 depth_bias_constant_factor: f32, 1251 depth_bias_clamp: f32, 1252 depth_bias_slope_factor: f32, 1253 ); 1254 #[allow(non_camel_case_types)] 1255 pub type PFN_vkCmdSetBlendConstants = 1256 extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4]); 1257 #[allow(non_camel_case_types)] 1258 pub type PFN_vkCmdSetDepthBounds = 1259 extern "system" fn(command_buffer: CommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32); 1260 #[allow(non_camel_case_types)] 1261 pub type PFN_vkCmdSetStencilCompareMask = extern "system" fn( 1262 command_buffer: CommandBuffer, 1263 face_mask: StencilFaceFlags, 1264 compare_mask: u32, 1265 ); 1266 #[allow(non_camel_case_types)] 1267 pub type PFN_vkCmdSetStencilWriteMask = 1268 extern "system" fn(command_buffer: CommandBuffer, face_mask: StencilFaceFlags, write_mask: u32); 1269 #[allow(non_camel_case_types)] 1270 pub type PFN_vkCmdSetStencilReference = 1271 extern "system" fn(command_buffer: CommandBuffer, face_mask: StencilFaceFlags, reference: u32); 1272 #[allow(non_camel_case_types)] 1273 pub type PFN_vkCmdBindDescriptorSets = extern "system" fn( 1274 command_buffer: CommandBuffer, 1275 pipeline_bind_point: PipelineBindPoint, 1276 layout: PipelineLayout, 1277 first_set: u32, 1278 descriptor_set_count: u32, 1279 p_descriptor_sets: *const DescriptorSet, 1280 dynamic_offset_count: u32, 1281 p_dynamic_offsets: *const u32, 1282 ); 1283 #[allow(non_camel_case_types)] 1284 pub type PFN_vkCmdBindIndexBuffer = extern "system" fn( 1285 command_buffer: CommandBuffer, 1286 buffer: Buffer, 1287 offset: DeviceSize, 1288 index_type: IndexType, 1289 ); 1290 #[allow(non_camel_case_types)] 1291 pub type PFN_vkCmdBindVertexBuffers = extern "system" fn( 1292 command_buffer: CommandBuffer, 1293 first_binding: u32, 1294 binding_count: u32, 1295 p_buffers: *const Buffer, 1296 p_offsets: *const DeviceSize, 1297 ); 1298 #[allow(non_camel_case_types)] 1299 pub type PFN_vkCmdDraw = extern "system" fn( 1300 command_buffer: CommandBuffer, 1301 vertex_count: u32, 1302 instance_count: u32, 1303 first_vertex: u32, 1304 first_instance: u32, 1305 ); 1306 #[allow(non_camel_case_types)] 1307 pub type PFN_vkCmdDrawIndexed = extern "system" fn( 1308 command_buffer: CommandBuffer, 1309 index_count: u32, 1310 instance_count: u32, 1311 first_index: u32, 1312 vertex_offset: i32, 1313 first_instance: u32, 1314 ); 1315 #[allow(non_camel_case_types)] 1316 pub type PFN_vkCmdDrawIndirect = extern "system" fn( 1317 command_buffer: CommandBuffer, 1318 buffer: Buffer, 1319 offset: DeviceSize, 1320 draw_count: u32, 1321 stride: u32, 1322 ); 1323 #[allow(non_camel_case_types)] 1324 pub type PFN_vkCmdDrawIndexedIndirect = extern "system" fn( 1325 command_buffer: CommandBuffer, 1326 buffer: Buffer, 1327 offset: DeviceSize, 1328 draw_count: u32, 1329 stride: u32, 1330 ); 1331 #[allow(non_camel_case_types)] 1332 pub type PFN_vkCmdDispatch = extern "system" fn( 1333 command_buffer: CommandBuffer, 1334 group_count_x: u32, 1335 group_count_y: u32, 1336 group_count_z: u32, 1337 ); 1338 #[allow(non_camel_case_types)] 1339 pub type PFN_vkCmdDispatchIndirect = 1340 extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize); 1341 #[allow(non_camel_case_types)] 1342 pub type PFN_vkCmdCopyBuffer = extern "system" fn( 1343 command_buffer: CommandBuffer, 1344 src_buffer: Buffer, 1345 dst_buffer: Buffer, 1346 region_count: u32, 1347 p_regions: *const BufferCopy, 1348 ); 1349 #[allow(non_camel_case_types)] 1350 pub type PFN_vkCmdCopyImage = extern "system" fn( 1351 command_buffer: CommandBuffer, 1352 src_image: Image, 1353 src_image_layout: ImageLayout, 1354 dst_image: Image, 1355 dst_image_layout: ImageLayout, 1356 region_count: u32, 1357 p_regions: *const ImageCopy, 1358 ); 1359 #[allow(non_camel_case_types)] 1360 pub type PFN_vkCmdBlitImage = extern "system" fn( 1361 command_buffer: CommandBuffer, 1362 src_image: Image, 1363 src_image_layout: ImageLayout, 1364 dst_image: Image, 1365 dst_image_layout: ImageLayout, 1366 region_count: u32, 1367 p_regions: *const ImageBlit, 1368 filter: Filter, 1369 ); 1370 #[allow(non_camel_case_types)] 1371 pub type PFN_vkCmdCopyBufferToImage = extern "system" fn( 1372 command_buffer: CommandBuffer, 1373 src_buffer: Buffer, 1374 dst_image: Image, 1375 dst_image_layout: ImageLayout, 1376 region_count: u32, 1377 p_regions: *const BufferImageCopy, 1378 ); 1379 #[allow(non_camel_case_types)] 1380 pub type PFN_vkCmdCopyImageToBuffer = extern "system" fn( 1381 command_buffer: CommandBuffer, 1382 src_image: Image, 1383 src_image_layout: ImageLayout, 1384 dst_buffer: Buffer, 1385 region_count: u32, 1386 p_regions: *const BufferImageCopy, 1387 ); 1388 #[allow(non_camel_case_types)] 1389 pub type PFN_vkCmdUpdateBuffer = extern "system" fn( 1390 command_buffer: CommandBuffer, 1391 dst_buffer: Buffer, 1392 dst_offset: DeviceSize, 1393 data_size: DeviceSize, 1394 p_data: *const c_void, 1395 ); 1396 #[allow(non_camel_case_types)] 1397 pub type PFN_vkCmdFillBuffer = extern "system" fn( 1398 command_buffer: CommandBuffer, 1399 dst_buffer: Buffer, 1400 dst_offset: DeviceSize, 1401 size: DeviceSize, 1402 data: u32, 1403 ); 1404 #[allow(non_camel_case_types)] 1405 pub type PFN_vkCmdClearColorImage = extern "system" fn( 1406 command_buffer: CommandBuffer, 1407 image: Image, 1408 image_layout: ImageLayout, 1409 p_color: *const ClearColorValue, 1410 range_count: u32, 1411 p_ranges: *const ImageSubresourceRange, 1412 ); 1413 #[allow(non_camel_case_types)] 1414 pub type PFN_vkCmdClearDepthStencilImage = extern "system" fn( 1415 command_buffer: CommandBuffer, 1416 image: Image, 1417 image_layout: ImageLayout, 1418 p_depth_stencil: *const ClearDepthStencilValue, 1419 range_count: u32, 1420 p_ranges: *const ImageSubresourceRange, 1421 ); 1422 #[allow(non_camel_case_types)] 1423 pub type PFN_vkCmdClearAttachments = extern "system" fn( 1424 command_buffer: CommandBuffer, 1425 attachment_count: u32, 1426 p_attachments: *const ClearAttachment, 1427 rect_count: u32, 1428 p_rects: *const ClearRect, 1429 ); 1430 #[allow(non_camel_case_types)] 1431 pub type PFN_vkCmdResolveImage = extern "system" fn( 1432 command_buffer: CommandBuffer, 1433 src_image: Image, 1434 src_image_layout: ImageLayout, 1435 dst_image: Image, 1436 dst_image_layout: ImageLayout, 1437 region_count: u32, 1438 p_regions: *const ImageResolve, 1439 ); 1440 #[allow(non_camel_case_types)] 1441 pub type PFN_vkCmdSetEvent = 1442 extern "system" fn(command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags); 1443 #[allow(non_camel_case_types)] 1444 pub type PFN_vkCmdResetEvent = 1445 extern "system" fn(command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags); 1446 #[allow(non_camel_case_types)] 1447 pub type PFN_vkCmdWaitEvents = extern "system" fn( 1448 command_buffer: CommandBuffer, 1449 event_count: u32, 1450 p_events: *const Event, 1451 src_stage_mask: PipelineStageFlags, 1452 dst_stage_mask: PipelineStageFlags, 1453 memory_barrier_count: u32, 1454 p_memory_barriers: *const MemoryBarrier, 1455 buffer_memory_barrier_count: u32, 1456 p_buffer_memory_barriers: *const BufferMemoryBarrier, 1457 image_memory_barrier_count: u32, 1458 p_image_memory_barriers: *const ImageMemoryBarrier, 1459 ); 1460 #[allow(non_camel_case_types)] 1461 pub type PFN_vkCmdPipelineBarrier = extern "system" fn( 1462 command_buffer: CommandBuffer, 1463 src_stage_mask: PipelineStageFlags, 1464 dst_stage_mask: PipelineStageFlags, 1465 dependency_flags: DependencyFlags, 1466 memory_barrier_count: u32, 1467 p_memory_barriers: *const MemoryBarrier, 1468 buffer_memory_barrier_count: u32, 1469 p_buffer_memory_barriers: *const BufferMemoryBarrier, 1470 image_memory_barrier_count: u32, 1471 p_image_memory_barriers: *const ImageMemoryBarrier, 1472 ); 1473 #[allow(non_camel_case_types)] 1474 pub type PFN_vkCmdBeginQuery = extern "system" fn( 1475 command_buffer: CommandBuffer, 1476 query_pool: QueryPool, 1477 query: u32, 1478 flags: QueryControlFlags, 1479 ); 1480 #[allow(non_camel_case_types)] 1481 pub type PFN_vkCmdEndQuery = 1482 extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32); 1483 #[allow(non_camel_case_types)] 1484 pub type PFN_vkCmdResetQueryPool = extern "system" fn( 1485 command_buffer: CommandBuffer, 1486 query_pool: QueryPool, 1487 first_query: u32, 1488 query_count: u32, 1489 ); 1490 #[allow(non_camel_case_types)] 1491 pub type PFN_vkCmdWriteTimestamp = extern "system" fn( 1492 command_buffer: CommandBuffer, 1493 pipeline_stage: PipelineStageFlags, 1494 query_pool: QueryPool, 1495 query: u32, 1496 ); 1497 #[allow(non_camel_case_types)] 1498 pub type PFN_vkCmdCopyQueryPoolResults = extern "system" fn( 1499 command_buffer: CommandBuffer, 1500 query_pool: QueryPool, 1501 first_query: u32, 1502 query_count: u32, 1503 dst_buffer: Buffer, 1504 dst_offset: DeviceSize, 1505 stride: DeviceSize, 1506 flags: QueryResultFlags, 1507 ); 1508 #[allow(non_camel_case_types)] 1509 pub type PFN_vkCmdPushConstants = extern "system" fn( 1510 command_buffer: CommandBuffer, 1511 layout: PipelineLayout, 1512 stage_flags: ShaderStageFlags, 1513 offset: u32, 1514 size: u32, 1515 p_values: *const c_void, 1516 ); 1517 #[allow(non_camel_case_types)] 1518 pub type PFN_vkCmdBeginRenderPass = extern "system" fn( 1519 command_buffer: CommandBuffer, 1520 p_render_pass_begin: *const RenderPassBeginInfo, 1521 contents: SubpassContents, 1522 ); 1523 #[allow(non_camel_case_types)] 1524 pub type PFN_vkCmdNextSubpass = 1525 extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents); 1526 #[allow(non_camel_case_types)] 1527 pub type PFN_vkCmdEndRenderPass = extern "system" fn(command_buffer: CommandBuffer); 1528 #[allow(non_camel_case_types)] 1529 pub type PFN_vkCmdExecuteCommands = extern "system" fn( 1530 command_buffer: CommandBuffer, 1531 command_buffer_count: u32, 1532 p_command_buffers: *const CommandBuffer, 1533 ); 1534 pub struct DeviceFnV1_0 { 1535 pub destroy_device: extern "system" fn(device: Device, p_allocator: *const AllocationCallbacks), 1536 pub get_device_queue: extern "system" fn( 1537 device: Device, 1538 queue_family_index: u32, 1539 queue_index: u32, 1540 p_queue: *mut Queue, 1541 ), 1542 pub queue_submit: extern "system" fn( 1543 queue: Queue, 1544 submit_count: u32, 1545 p_submits: *const SubmitInfo, 1546 fence: Fence, 1547 ) -> Result, 1548 pub queue_wait_idle: extern "system" fn(queue: Queue) -> Result, 1549 pub device_wait_idle: extern "system" fn(device: Device) -> Result, 1550 pub allocate_memory: extern "system" fn( 1551 device: Device, 1552 p_allocate_info: *const MemoryAllocateInfo, 1553 p_allocator: *const AllocationCallbacks, 1554 p_memory: *mut DeviceMemory, 1555 ) -> Result, 1556 pub free_memory: extern "system" fn( 1557 device: Device, 1558 memory: DeviceMemory, 1559 p_allocator: *const AllocationCallbacks, 1560 ), 1561 pub map_memory: extern "system" fn( 1562 device: Device, 1563 memory: DeviceMemory, 1564 offset: DeviceSize, 1565 size: DeviceSize, 1566 flags: MemoryMapFlags, 1567 pp_data: *mut *mut c_void, 1568 ) -> Result, 1569 pub unmap_memory: extern "system" fn(device: Device, memory: DeviceMemory), 1570 pub flush_mapped_memory_ranges: extern "system" fn( 1571 device: Device, 1572 memory_range_count: u32, 1573 p_memory_ranges: *const MappedMemoryRange, 1574 ) -> Result, 1575 pub invalidate_mapped_memory_ranges: extern "system" fn( 1576 device: Device, 1577 memory_range_count: u32, 1578 p_memory_ranges: *const MappedMemoryRange, 1579 ) -> Result, 1580 pub get_device_memory_commitment: extern "system" fn( 1581 device: Device, 1582 memory: DeviceMemory, 1583 p_committed_memory_in_bytes: *mut DeviceSize, 1584 ), 1585 pub bind_buffer_memory: extern "system" fn( 1586 device: Device, 1587 buffer: Buffer, 1588 memory: DeviceMemory, 1589 memory_offset: DeviceSize, 1590 ) -> Result, 1591 pub bind_image_memory: extern "system" fn( 1592 device: Device, 1593 image: Image, 1594 memory: DeviceMemory, 1595 memory_offset: DeviceSize, 1596 ) -> Result, 1597 pub get_buffer_memory_requirements: extern "system" fn( 1598 device: Device, 1599 buffer: Buffer, 1600 p_memory_requirements: *mut MemoryRequirements, 1601 ), 1602 pub get_image_memory_requirements: extern "system" fn( 1603 device: Device, 1604 image: Image, 1605 p_memory_requirements: *mut MemoryRequirements, 1606 ), 1607 pub get_image_sparse_memory_requirements: extern "system" fn( 1608 device: Device, 1609 image: Image, 1610 p_sparse_memory_requirement_count: *mut u32, 1611 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, 1612 ), 1613 pub queue_bind_sparse: extern "system" fn( 1614 queue: Queue, 1615 bind_info_count: u32, 1616 p_bind_info: *const BindSparseInfo, 1617 fence: Fence, 1618 ) -> Result, 1619 pub create_fence: extern "system" fn( 1620 device: Device, 1621 p_create_info: *const FenceCreateInfo, 1622 p_allocator: *const AllocationCallbacks, 1623 p_fence: *mut Fence, 1624 ) -> Result, 1625 pub destroy_fence: 1626 extern "system" fn(device: Device, fence: Fence, p_allocator: *const AllocationCallbacks), 1627 pub reset_fences: 1628 extern "system" fn(device: Device, fence_count: u32, p_fences: *const Fence) -> Result, 1629 pub get_fence_status: extern "system" fn(device: Device, fence: Fence) -> Result, 1630 pub wait_for_fences: extern "system" fn( 1631 device: Device, 1632 fence_count: u32, 1633 p_fences: *const Fence, 1634 wait_all: Bool32, 1635 timeout: u64, 1636 ) -> Result, 1637 pub create_semaphore: extern "system" fn( 1638 device: Device, 1639 p_create_info: *const SemaphoreCreateInfo, 1640 p_allocator: *const AllocationCallbacks, 1641 p_semaphore: *mut Semaphore, 1642 ) -> Result, 1643 pub destroy_semaphore: extern "system" fn( 1644 device: Device, 1645 semaphore: Semaphore, 1646 p_allocator: *const AllocationCallbacks, 1647 ), 1648 pub create_event: extern "system" fn( 1649 device: Device, 1650 p_create_info: *const EventCreateInfo, 1651 p_allocator: *const AllocationCallbacks, 1652 p_event: *mut Event, 1653 ) -> Result, 1654 pub destroy_event: 1655 extern "system" fn(device: Device, event: Event, p_allocator: *const AllocationCallbacks), 1656 pub get_event_status: extern "system" fn(device: Device, event: Event) -> Result, 1657 pub set_event: extern "system" fn(device: Device, event: Event) -> Result, 1658 pub reset_event: extern "system" fn(device: Device, event: Event) -> Result, 1659 pub create_query_pool: extern "system" fn( 1660 device: Device, 1661 p_create_info: *const QueryPoolCreateInfo, 1662 p_allocator: *const AllocationCallbacks, 1663 p_query_pool: *mut QueryPool, 1664 ) -> Result, 1665 pub destroy_query_pool: extern "system" fn( 1666 device: Device, 1667 query_pool: QueryPool, 1668 p_allocator: *const AllocationCallbacks, 1669 ), 1670 pub get_query_pool_results: extern "system" fn( 1671 device: Device, 1672 query_pool: QueryPool, 1673 first_query: u32, 1674 query_count: u32, 1675 data_size: usize, 1676 p_data: *mut c_void, 1677 stride: DeviceSize, 1678 flags: QueryResultFlags, 1679 ) -> Result, 1680 pub create_buffer: extern "system" fn( 1681 device: Device, 1682 p_create_info: *const BufferCreateInfo, 1683 p_allocator: *const AllocationCallbacks, 1684 p_buffer: *mut Buffer, 1685 ) -> Result, 1686 pub destroy_buffer: 1687 extern "system" fn(device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks), 1688 pub create_buffer_view: extern "system" fn( 1689 device: Device, 1690 p_create_info: *const BufferViewCreateInfo, 1691 p_allocator: *const AllocationCallbacks, 1692 p_view: *mut BufferView, 1693 ) -> Result, 1694 pub destroy_buffer_view: extern "system" fn( 1695 device: Device, 1696 buffer_view: BufferView, 1697 p_allocator: *const AllocationCallbacks, 1698 ), 1699 pub create_image: extern "system" fn( 1700 device: Device, 1701 p_create_info: *const ImageCreateInfo, 1702 p_allocator: *const AllocationCallbacks, 1703 p_image: *mut Image, 1704 ) -> Result, 1705 pub destroy_image: 1706 extern "system" fn(device: Device, image: Image, p_allocator: *const AllocationCallbacks), 1707 pub get_image_subresource_layout: extern "system" fn( 1708 device: Device, 1709 image: Image, 1710 p_subresource: *const ImageSubresource, 1711 p_layout: *mut SubresourceLayout, 1712 ), 1713 pub create_image_view: extern "system" fn( 1714 device: Device, 1715 p_create_info: *const ImageViewCreateInfo, 1716 p_allocator: *const AllocationCallbacks, 1717 p_view: *mut ImageView, 1718 ) -> Result, 1719 pub destroy_image_view: extern "system" fn( 1720 device: Device, 1721 image_view: ImageView, 1722 p_allocator: *const AllocationCallbacks, 1723 ), 1724 pub create_shader_module: extern "system" fn( 1725 device: Device, 1726 p_create_info: *const ShaderModuleCreateInfo, 1727 p_allocator: *const AllocationCallbacks, 1728 p_shader_module: *mut ShaderModule, 1729 ) -> Result, 1730 pub destroy_shader_module: extern "system" fn( 1731 device: Device, 1732 shader_module: ShaderModule, 1733 p_allocator: *const AllocationCallbacks, 1734 ), 1735 pub create_pipeline_cache: extern "system" fn( 1736 device: Device, 1737 p_create_info: *const PipelineCacheCreateInfo, 1738 p_allocator: *const AllocationCallbacks, 1739 p_pipeline_cache: *mut PipelineCache, 1740 ) -> Result, 1741 pub destroy_pipeline_cache: extern "system" fn( 1742 device: Device, 1743 pipeline_cache: PipelineCache, 1744 p_allocator: *const AllocationCallbacks, 1745 ), 1746 pub get_pipeline_cache_data: extern "system" fn( 1747 device: Device, 1748 pipeline_cache: PipelineCache, 1749 p_data_size: *mut usize, 1750 p_data: *mut c_void, 1751 ) -> Result, 1752 pub merge_pipeline_caches: extern "system" fn( 1753 device: Device, 1754 dst_cache: PipelineCache, 1755 src_cache_count: u32, 1756 p_src_caches: *const PipelineCache, 1757 ) -> Result, 1758 pub create_graphics_pipelines: extern "system" fn( 1759 device: Device, 1760 pipeline_cache: PipelineCache, 1761 create_info_count: u32, 1762 p_create_infos: *const GraphicsPipelineCreateInfo, 1763 p_allocator: *const AllocationCallbacks, 1764 p_pipelines: *mut Pipeline, 1765 ) -> Result, 1766 pub create_compute_pipelines: extern "system" fn( 1767 device: Device, 1768 pipeline_cache: PipelineCache, 1769 create_info_count: u32, 1770 p_create_infos: *const ComputePipelineCreateInfo, 1771 p_allocator: *const AllocationCallbacks, 1772 p_pipelines: *mut Pipeline, 1773 ) -> Result, 1774 pub destroy_pipeline: extern "system" fn( 1775 device: Device, 1776 pipeline: Pipeline, 1777 p_allocator: *const AllocationCallbacks, 1778 ), 1779 pub create_pipeline_layout: extern "system" fn( 1780 device: Device, 1781 p_create_info: *const PipelineLayoutCreateInfo, 1782 p_allocator: *const AllocationCallbacks, 1783 p_pipeline_layout: *mut PipelineLayout, 1784 ) -> Result, 1785 pub destroy_pipeline_layout: extern "system" fn( 1786 device: Device, 1787 pipeline_layout: PipelineLayout, 1788 p_allocator: *const AllocationCallbacks, 1789 ), 1790 pub create_sampler: extern "system" fn( 1791 device: Device, 1792 p_create_info: *const SamplerCreateInfo, 1793 p_allocator: *const AllocationCallbacks, 1794 p_sampler: *mut Sampler, 1795 ) -> Result, 1796 pub destroy_sampler: extern "system" fn( 1797 device: Device, 1798 sampler: Sampler, 1799 p_allocator: *const AllocationCallbacks, 1800 ), 1801 pub create_descriptor_set_layout: extern "system" fn( 1802 device: Device, 1803 p_create_info: *const DescriptorSetLayoutCreateInfo, 1804 p_allocator: *const AllocationCallbacks, 1805 p_set_layout: *mut DescriptorSetLayout, 1806 ) -> Result, 1807 pub destroy_descriptor_set_layout: extern "system" fn( 1808 device: Device, 1809 descriptor_set_layout: DescriptorSetLayout, 1810 p_allocator: *const AllocationCallbacks, 1811 ), 1812 pub create_descriptor_pool: extern "system" fn( 1813 device: Device, 1814 p_create_info: *const DescriptorPoolCreateInfo, 1815 p_allocator: *const AllocationCallbacks, 1816 p_descriptor_pool: *mut DescriptorPool, 1817 ) -> Result, 1818 pub destroy_descriptor_pool: extern "system" fn( 1819 device: Device, 1820 descriptor_pool: DescriptorPool, 1821 p_allocator: *const AllocationCallbacks, 1822 ), 1823 pub reset_descriptor_pool: extern "system" fn( 1824 device: Device, 1825 descriptor_pool: DescriptorPool, 1826 flags: DescriptorPoolResetFlags, 1827 ) -> Result, 1828 pub allocate_descriptor_sets: extern "system" fn( 1829 device: Device, 1830 p_allocate_info: *const DescriptorSetAllocateInfo, 1831 p_descriptor_sets: *mut DescriptorSet, 1832 ) -> Result, 1833 pub free_descriptor_sets: extern "system" fn( 1834 device: Device, 1835 descriptor_pool: DescriptorPool, 1836 descriptor_set_count: u32, 1837 p_descriptor_sets: *const DescriptorSet, 1838 ) -> Result, 1839 pub update_descriptor_sets: extern "system" fn( 1840 device: Device, 1841 descriptor_write_count: u32, 1842 p_descriptor_writes: *const WriteDescriptorSet, 1843 descriptor_copy_count: u32, 1844 p_descriptor_copies: *const CopyDescriptorSet, 1845 ), 1846 pub create_framebuffer: extern "system" fn( 1847 device: Device, 1848 p_create_info: *const FramebufferCreateInfo, 1849 p_allocator: *const AllocationCallbacks, 1850 p_framebuffer: *mut Framebuffer, 1851 ) -> Result, 1852 pub destroy_framebuffer: extern "system" fn( 1853 device: Device, 1854 framebuffer: Framebuffer, 1855 p_allocator: *const AllocationCallbacks, 1856 ), 1857 pub create_render_pass: extern "system" fn( 1858 device: Device, 1859 p_create_info: *const RenderPassCreateInfo, 1860 p_allocator: *const AllocationCallbacks, 1861 p_render_pass: *mut RenderPass, 1862 ) -> Result, 1863 pub destroy_render_pass: extern "system" fn( 1864 device: Device, 1865 render_pass: RenderPass, 1866 p_allocator: *const AllocationCallbacks, 1867 ), 1868 pub get_render_area_granularity: 1869 extern "system" fn(device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D), 1870 pub create_command_pool: extern "system" fn( 1871 device: Device, 1872 p_create_info: *const CommandPoolCreateInfo, 1873 p_allocator: *const AllocationCallbacks, 1874 p_command_pool: *mut CommandPool, 1875 ) -> Result, 1876 pub destroy_command_pool: extern "system" fn( 1877 device: Device, 1878 command_pool: CommandPool, 1879 p_allocator: *const AllocationCallbacks, 1880 ), 1881 pub reset_command_pool: extern "system" fn( 1882 device: Device, 1883 command_pool: CommandPool, 1884 flags: CommandPoolResetFlags, 1885 ) -> Result, 1886 pub allocate_command_buffers: extern "system" fn( 1887 device: Device, 1888 p_allocate_info: *const CommandBufferAllocateInfo, 1889 p_command_buffers: *mut CommandBuffer, 1890 ) -> Result, 1891 pub free_command_buffers: extern "system" fn( 1892 device: Device, 1893 command_pool: CommandPool, 1894 command_buffer_count: u32, 1895 p_command_buffers: *const CommandBuffer, 1896 ), 1897 pub begin_command_buffer: extern "system" fn( 1898 command_buffer: CommandBuffer, 1899 p_begin_info: *const CommandBufferBeginInfo, 1900 ) -> Result, 1901 pub end_command_buffer: extern "system" fn(command_buffer: CommandBuffer) -> Result, 1902 pub reset_command_buffer: 1903 extern "system" fn(command_buffer: CommandBuffer, flags: CommandBufferResetFlags) -> Result, 1904 pub cmd_bind_pipeline: extern "system" fn( 1905 command_buffer: CommandBuffer, 1906 pipeline_bind_point: PipelineBindPoint, 1907 pipeline: Pipeline, 1908 ), 1909 pub cmd_set_viewport: extern "system" fn( 1910 command_buffer: CommandBuffer, 1911 first_viewport: u32, 1912 viewport_count: u32, 1913 p_viewports: *const Viewport, 1914 ), 1915 pub cmd_set_scissor: extern "system" fn( 1916 command_buffer: CommandBuffer, 1917 first_scissor: u32, 1918 scissor_count: u32, 1919 p_scissors: *const Rect2D, 1920 ), 1921 pub cmd_set_line_width: extern "system" fn(command_buffer: CommandBuffer, line_width: f32), 1922 pub cmd_set_depth_bias: extern "system" fn( 1923 command_buffer: CommandBuffer, 1924 depth_bias_constant_factor: f32, 1925 depth_bias_clamp: f32, 1926 depth_bias_slope_factor: f32, 1927 ), 1928 pub cmd_set_blend_constants: 1929 extern "system" fn(command_buffer: CommandBuffer, blend_constants: *const [f32; 4]), 1930 pub cmd_set_depth_bounds: extern "system" fn( 1931 command_buffer: CommandBuffer, 1932 min_depth_bounds: f32, 1933 max_depth_bounds: f32, 1934 ), 1935 pub cmd_set_stencil_compare_mask: extern "system" fn( 1936 command_buffer: CommandBuffer, 1937 face_mask: StencilFaceFlags, 1938 compare_mask: u32, 1939 ), 1940 pub cmd_set_stencil_write_mask: extern "system" fn( 1941 command_buffer: CommandBuffer, 1942 face_mask: StencilFaceFlags, 1943 write_mask: u32, 1944 ), 1945 pub cmd_set_stencil_reference: extern "system" fn( 1946 command_buffer: CommandBuffer, 1947 face_mask: StencilFaceFlags, 1948 reference: u32, 1949 ), 1950 pub cmd_bind_descriptor_sets: extern "system" fn( 1951 command_buffer: CommandBuffer, 1952 pipeline_bind_point: PipelineBindPoint, 1953 layout: PipelineLayout, 1954 first_set: u32, 1955 descriptor_set_count: u32, 1956 p_descriptor_sets: *const DescriptorSet, 1957 dynamic_offset_count: u32, 1958 p_dynamic_offsets: *const u32, 1959 ), 1960 pub cmd_bind_index_buffer: extern "system" fn( 1961 command_buffer: CommandBuffer, 1962 buffer: Buffer, 1963 offset: DeviceSize, 1964 index_type: IndexType, 1965 ), 1966 pub cmd_bind_vertex_buffers: extern "system" fn( 1967 command_buffer: CommandBuffer, 1968 first_binding: u32, 1969 binding_count: u32, 1970 p_buffers: *const Buffer, 1971 p_offsets: *const DeviceSize, 1972 ), 1973 pub cmd_draw: extern "system" fn( 1974 command_buffer: CommandBuffer, 1975 vertex_count: u32, 1976 instance_count: u32, 1977 first_vertex: u32, 1978 first_instance: u32, 1979 ), 1980 pub cmd_draw_indexed: extern "system" fn( 1981 command_buffer: CommandBuffer, 1982 index_count: u32, 1983 instance_count: u32, 1984 first_index: u32, 1985 vertex_offset: i32, 1986 first_instance: u32, 1987 ), 1988 pub cmd_draw_indirect: extern "system" fn( 1989 command_buffer: CommandBuffer, 1990 buffer: Buffer, 1991 offset: DeviceSize, 1992 draw_count: u32, 1993 stride: u32, 1994 ), 1995 pub cmd_draw_indexed_indirect: extern "system" fn( 1996 command_buffer: CommandBuffer, 1997 buffer: Buffer, 1998 offset: DeviceSize, 1999 draw_count: u32, 2000 stride: u32, 2001 ), 2002 pub cmd_dispatch: extern "system" fn( 2003 command_buffer: CommandBuffer, 2004 group_count_x: u32, 2005 group_count_y: u32, 2006 group_count_z: u32, 2007 ), 2008 pub cmd_dispatch_indirect: 2009 extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize), 2010 pub cmd_copy_buffer: extern "system" fn( 2011 command_buffer: CommandBuffer, 2012 src_buffer: Buffer, 2013 dst_buffer: Buffer, 2014 region_count: u32, 2015 p_regions: *const BufferCopy, 2016 ), 2017 pub cmd_copy_image: extern "system" fn( 2018 command_buffer: CommandBuffer, 2019 src_image: Image, 2020 src_image_layout: ImageLayout, 2021 dst_image: Image, 2022 dst_image_layout: ImageLayout, 2023 region_count: u32, 2024 p_regions: *const ImageCopy, 2025 ), 2026 pub cmd_blit_image: extern "system" fn( 2027 command_buffer: CommandBuffer, 2028 src_image: Image, 2029 src_image_layout: ImageLayout, 2030 dst_image: Image, 2031 dst_image_layout: ImageLayout, 2032 region_count: u32, 2033 p_regions: *const ImageBlit, 2034 filter: Filter, 2035 ), 2036 pub cmd_copy_buffer_to_image: extern "system" fn( 2037 command_buffer: CommandBuffer, 2038 src_buffer: Buffer, 2039 dst_image: Image, 2040 dst_image_layout: ImageLayout, 2041 region_count: u32, 2042 p_regions: *const BufferImageCopy, 2043 ), 2044 pub cmd_copy_image_to_buffer: extern "system" fn( 2045 command_buffer: CommandBuffer, 2046 src_image: Image, 2047 src_image_layout: ImageLayout, 2048 dst_buffer: Buffer, 2049 region_count: u32, 2050 p_regions: *const BufferImageCopy, 2051 ), 2052 pub cmd_update_buffer: extern "system" fn( 2053 command_buffer: CommandBuffer, 2054 dst_buffer: Buffer, 2055 dst_offset: DeviceSize, 2056 data_size: DeviceSize, 2057 p_data: *const c_void, 2058 ), 2059 pub cmd_fill_buffer: extern "system" fn( 2060 command_buffer: CommandBuffer, 2061 dst_buffer: Buffer, 2062 dst_offset: DeviceSize, 2063 size: DeviceSize, 2064 data: u32, 2065 ), 2066 pub cmd_clear_color_image: extern "system" fn( 2067 command_buffer: CommandBuffer, 2068 image: Image, 2069 image_layout: ImageLayout, 2070 p_color: *const ClearColorValue, 2071 range_count: u32, 2072 p_ranges: *const ImageSubresourceRange, 2073 ), 2074 pub cmd_clear_depth_stencil_image: extern "system" fn( 2075 command_buffer: CommandBuffer, 2076 image: Image, 2077 image_layout: ImageLayout, 2078 p_depth_stencil: *const ClearDepthStencilValue, 2079 range_count: u32, 2080 p_ranges: *const ImageSubresourceRange, 2081 ), 2082 pub cmd_clear_attachments: extern "system" fn( 2083 command_buffer: CommandBuffer, 2084 attachment_count: u32, 2085 p_attachments: *const ClearAttachment, 2086 rect_count: u32, 2087 p_rects: *const ClearRect, 2088 ), 2089 pub cmd_resolve_image: extern "system" fn( 2090 command_buffer: CommandBuffer, 2091 src_image: Image, 2092 src_image_layout: ImageLayout, 2093 dst_image: Image, 2094 dst_image_layout: ImageLayout, 2095 region_count: u32, 2096 p_regions: *const ImageResolve, 2097 ), 2098 pub cmd_set_event: extern "system" fn( 2099 command_buffer: CommandBuffer, 2100 event: Event, 2101 stage_mask: PipelineStageFlags, 2102 ), 2103 pub cmd_reset_event: extern "system" fn( 2104 command_buffer: CommandBuffer, 2105 event: Event, 2106 stage_mask: PipelineStageFlags, 2107 ), 2108 pub cmd_wait_events: extern "system" fn( 2109 command_buffer: CommandBuffer, 2110 event_count: u32, 2111 p_events: *const Event, 2112 src_stage_mask: PipelineStageFlags, 2113 dst_stage_mask: PipelineStageFlags, 2114 memory_barrier_count: u32, 2115 p_memory_barriers: *const MemoryBarrier, 2116 buffer_memory_barrier_count: u32, 2117 p_buffer_memory_barriers: *const BufferMemoryBarrier, 2118 image_memory_barrier_count: u32, 2119 p_image_memory_barriers: *const ImageMemoryBarrier, 2120 ), 2121 pub cmd_pipeline_barrier: extern "system" fn( 2122 command_buffer: CommandBuffer, 2123 src_stage_mask: PipelineStageFlags, 2124 dst_stage_mask: PipelineStageFlags, 2125 dependency_flags: DependencyFlags, 2126 memory_barrier_count: u32, 2127 p_memory_barriers: *const MemoryBarrier, 2128 buffer_memory_barrier_count: u32, 2129 p_buffer_memory_barriers: *const BufferMemoryBarrier, 2130 image_memory_barrier_count: u32, 2131 p_image_memory_barriers: *const ImageMemoryBarrier, 2132 ), 2133 pub cmd_begin_query: extern "system" fn( 2134 command_buffer: CommandBuffer, 2135 query_pool: QueryPool, 2136 query: u32, 2137 flags: QueryControlFlags, 2138 ), 2139 pub cmd_end_query: 2140 extern "system" fn(command_buffer: CommandBuffer, query_pool: QueryPool, query: u32), 2141 pub cmd_reset_query_pool: extern "system" fn( 2142 command_buffer: CommandBuffer, 2143 query_pool: QueryPool, 2144 first_query: u32, 2145 query_count: u32, 2146 ), 2147 pub cmd_write_timestamp: extern "system" fn( 2148 command_buffer: CommandBuffer, 2149 pipeline_stage: PipelineStageFlags, 2150 query_pool: QueryPool, 2151 query: u32, 2152 ), 2153 pub cmd_copy_query_pool_results: extern "system" fn( 2154 command_buffer: CommandBuffer, 2155 query_pool: QueryPool, 2156 first_query: u32, 2157 query_count: u32, 2158 dst_buffer: Buffer, 2159 dst_offset: DeviceSize, 2160 stride: DeviceSize, 2161 flags: QueryResultFlags, 2162 ), 2163 pub cmd_push_constants: extern "system" fn( 2164 command_buffer: CommandBuffer, 2165 layout: PipelineLayout, 2166 stage_flags: ShaderStageFlags, 2167 offset: u32, 2168 size: u32, 2169 p_values: *const c_void, 2170 ), 2171 pub cmd_begin_render_pass: extern "system" fn( 2172 command_buffer: CommandBuffer, 2173 p_render_pass_begin: *const RenderPassBeginInfo, 2174 contents: SubpassContents, 2175 ), 2176 pub cmd_next_subpass: 2177 extern "system" fn(command_buffer: CommandBuffer, contents: SubpassContents), 2178 pub cmd_end_render_pass: extern "system" fn(command_buffer: CommandBuffer), 2179 pub cmd_execute_commands: extern "system" fn( 2180 command_buffer: CommandBuffer, 2181 command_buffer_count: u32, 2182 p_command_buffers: *const CommandBuffer, 2183 ), 2184 } 2185 unsafe impl Send for DeviceFnV1_0 {} 2186 unsafe impl Sync for DeviceFnV1_0 {} 2187 impl ::std::clone::Clone for DeviceFnV1_0 { clone(&self) -> Self2188 fn clone(&self) -> Self { 2189 DeviceFnV1_0 { 2190 destroy_device: self.destroy_device, 2191 get_device_queue: self.get_device_queue, 2192 queue_submit: self.queue_submit, 2193 queue_wait_idle: self.queue_wait_idle, 2194 device_wait_idle: self.device_wait_idle, 2195 allocate_memory: self.allocate_memory, 2196 free_memory: self.free_memory, 2197 map_memory: self.map_memory, 2198 unmap_memory: self.unmap_memory, 2199 flush_mapped_memory_ranges: self.flush_mapped_memory_ranges, 2200 invalidate_mapped_memory_ranges: self.invalidate_mapped_memory_ranges, 2201 get_device_memory_commitment: self.get_device_memory_commitment, 2202 bind_buffer_memory: self.bind_buffer_memory, 2203 bind_image_memory: self.bind_image_memory, 2204 get_buffer_memory_requirements: self.get_buffer_memory_requirements, 2205 get_image_memory_requirements: self.get_image_memory_requirements, 2206 get_image_sparse_memory_requirements: self.get_image_sparse_memory_requirements, 2207 queue_bind_sparse: self.queue_bind_sparse, 2208 create_fence: self.create_fence, 2209 destroy_fence: self.destroy_fence, 2210 reset_fences: self.reset_fences, 2211 get_fence_status: self.get_fence_status, 2212 wait_for_fences: self.wait_for_fences, 2213 create_semaphore: self.create_semaphore, 2214 destroy_semaphore: self.destroy_semaphore, 2215 create_event: self.create_event, 2216 destroy_event: self.destroy_event, 2217 get_event_status: self.get_event_status, 2218 set_event: self.set_event, 2219 reset_event: self.reset_event, 2220 create_query_pool: self.create_query_pool, 2221 destroy_query_pool: self.destroy_query_pool, 2222 get_query_pool_results: self.get_query_pool_results, 2223 create_buffer: self.create_buffer, 2224 destroy_buffer: self.destroy_buffer, 2225 create_buffer_view: self.create_buffer_view, 2226 destroy_buffer_view: self.destroy_buffer_view, 2227 create_image: self.create_image, 2228 destroy_image: self.destroy_image, 2229 get_image_subresource_layout: self.get_image_subresource_layout, 2230 create_image_view: self.create_image_view, 2231 destroy_image_view: self.destroy_image_view, 2232 create_shader_module: self.create_shader_module, 2233 destroy_shader_module: self.destroy_shader_module, 2234 create_pipeline_cache: self.create_pipeline_cache, 2235 destroy_pipeline_cache: self.destroy_pipeline_cache, 2236 get_pipeline_cache_data: self.get_pipeline_cache_data, 2237 merge_pipeline_caches: self.merge_pipeline_caches, 2238 create_graphics_pipelines: self.create_graphics_pipelines, 2239 create_compute_pipelines: self.create_compute_pipelines, 2240 destroy_pipeline: self.destroy_pipeline, 2241 create_pipeline_layout: self.create_pipeline_layout, 2242 destroy_pipeline_layout: self.destroy_pipeline_layout, 2243 create_sampler: self.create_sampler, 2244 destroy_sampler: self.destroy_sampler, 2245 create_descriptor_set_layout: self.create_descriptor_set_layout, 2246 destroy_descriptor_set_layout: self.destroy_descriptor_set_layout, 2247 create_descriptor_pool: self.create_descriptor_pool, 2248 destroy_descriptor_pool: self.destroy_descriptor_pool, 2249 reset_descriptor_pool: self.reset_descriptor_pool, 2250 allocate_descriptor_sets: self.allocate_descriptor_sets, 2251 free_descriptor_sets: self.free_descriptor_sets, 2252 update_descriptor_sets: self.update_descriptor_sets, 2253 create_framebuffer: self.create_framebuffer, 2254 destroy_framebuffer: self.destroy_framebuffer, 2255 create_render_pass: self.create_render_pass, 2256 destroy_render_pass: self.destroy_render_pass, 2257 get_render_area_granularity: self.get_render_area_granularity, 2258 create_command_pool: self.create_command_pool, 2259 destroy_command_pool: self.destroy_command_pool, 2260 reset_command_pool: self.reset_command_pool, 2261 allocate_command_buffers: self.allocate_command_buffers, 2262 free_command_buffers: self.free_command_buffers, 2263 begin_command_buffer: self.begin_command_buffer, 2264 end_command_buffer: self.end_command_buffer, 2265 reset_command_buffer: self.reset_command_buffer, 2266 cmd_bind_pipeline: self.cmd_bind_pipeline, 2267 cmd_set_viewport: self.cmd_set_viewport, 2268 cmd_set_scissor: self.cmd_set_scissor, 2269 cmd_set_line_width: self.cmd_set_line_width, 2270 cmd_set_depth_bias: self.cmd_set_depth_bias, 2271 cmd_set_blend_constants: self.cmd_set_blend_constants, 2272 cmd_set_depth_bounds: self.cmd_set_depth_bounds, 2273 cmd_set_stencil_compare_mask: self.cmd_set_stencil_compare_mask, 2274 cmd_set_stencil_write_mask: self.cmd_set_stencil_write_mask, 2275 cmd_set_stencil_reference: self.cmd_set_stencil_reference, 2276 cmd_bind_descriptor_sets: self.cmd_bind_descriptor_sets, 2277 cmd_bind_index_buffer: self.cmd_bind_index_buffer, 2278 cmd_bind_vertex_buffers: self.cmd_bind_vertex_buffers, 2279 cmd_draw: self.cmd_draw, 2280 cmd_draw_indexed: self.cmd_draw_indexed, 2281 cmd_draw_indirect: self.cmd_draw_indirect, 2282 cmd_draw_indexed_indirect: self.cmd_draw_indexed_indirect, 2283 cmd_dispatch: self.cmd_dispatch, 2284 cmd_dispatch_indirect: self.cmd_dispatch_indirect, 2285 cmd_copy_buffer: self.cmd_copy_buffer, 2286 cmd_copy_image: self.cmd_copy_image, 2287 cmd_blit_image: self.cmd_blit_image, 2288 cmd_copy_buffer_to_image: self.cmd_copy_buffer_to_image, 2289 cmd_copy_image_to_buffer: self.cmd_copy_image_to_buffer, 2290 cmd_update_buffer: self.cmd_update_buffer, 2291 cmd_fill_buffer: self.cmd_fill_buffer, 2292 cmd_clear_color_image: self.cmd_clear_color_image, 2293 cmd_clear_depth_stencil_image: self.cmd_clear_depth_stencil_image, 2294 cmd_clear_attachments: self.cmd_clear_attachments, 2295 cmd_resolve_image: self.cmd_resolve_image, 2296 cmd_set_event: self.cmd_set_event, 2297 cmd_reset_event: self.cmd_reset_event, 2298 cmd_wait_events: self.cmd_wait_events, 2299 cmd_pipeline_barrier: self.cmd_pipeline_barrier, 2300 cmd_begin_query: self.cmd_begin_query, 2301 cmd_end_query: self.cmd_end_query, 2302 cmd_reset_query_pool: self.cmd_reset_query_pool, 2303 cmd_write_timestamp: self.cmd_write_timestamp, 2304 cmd_copy_query_pool_results: self.cmd_copy_query_pool_results, 2305 cmd_push_constants: self.cmd_push_constants, 2306 cmd_begin_render_pass: self.cmd_begin_render_pass, 2307 cmd_next_subpass: self.cmd_next_subpass, 2308 cmd_end_render_pass: self.cmd_end_render_pass, 2309 cmd_execute_commands: self.cmd_execute_commands, 2310 } 2311 } 2312 } 2313 impl DeviceFnV1_0 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,2314 pub fn load<F>(mut _f: F) -> Self 2315 where 2316 F: FnMut(&::std::ffi::CStr) -> *const c_void, 2317 { 2318 DeviceFnV1_0 { 2319 destroy_device: unsafe { 2320 extern "system" fn destroy_device( 2321 _device: Device, 2322 _p_allocator: *const AllocationCallbacks, 2323 ) { 2324 panic!(concat!("Unable to load ", stringify!(destroy_device))) 2325 } 2326 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDevice\0"); 2327 let val = _f(cname); 2328 if val.is_null() { 2329 destroy_device 2330 } else { 2331 ::std::mem::transmute(val) 2332 } 2333 }, 2334 get_device_queue: unsafe { 2335 extern "system" fn get_device_queue( 2336 _device: Device, 2337 _queue_family_index: u32, 2338 _queue_index: u32, 2339 _p_queue: *mut Queue, 2340 ) { 2341 panic!(concat!("Unable to load ", stringify!(get_device_queue))) 2342 } 2343 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue\0"); 2344 let val = _f(cname); 2345 if val.is_null() { 2346 get_device_queue 2347 } else { 2348 ::std::mem::transmute(val) 2349 } 2350 }, 2351 queue_submit: unsafe { 2352 extern "system" fn queue_submit( 2353 _queue: Queue, 2354 _submit_count: u32, 2355 _p_submits: *const SubmitInfo, 2356 _fence: Fence, 2357 ) -> Result { 2358 panic!(concat!("Unable to load ", stringify!(queue_submit))) 2359 } 2360 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit\0"); 2361 let val = _f(cname); 2362 if val.is_null() { 2363 queue_submit 2364 } else { 2365 ::std::mem::transmute(val) 2366 } 2367 }, 2368 queue_wait_idle: unsafe { 2369 extern "system" fn queue_wait_idle(_queue: Queue) -> Result { 2370 panic!(concat!("Unable to load ", stringify!(queue_wait_idle))) 2371 } 2372 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueWaitIdle\0"); 2373 let val = _f(cname); 2374 if val.is_null() { 2375 queue_wait_idle 2376 } else { 2377 ::std::mem::transmute(val) 2378 } 2379 }, 2380 device_wait_idle: unsafe { 2381 extern "system" fn device_wait_idle(_device: Device) -> Result { 2382 panic!(concat!("Unable to load ", stringify!(device_wait_idle))) 2383 } 2384 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDeviceWaitIdle\0"); 2385 let val = _f(cname); 2386 if val.is_null() { 2387 device_wait_idle 2388 } else { 2389 ::std::mem::transmute(val) 2390 } 2391 }, 2392 allocate_memory: unsafe { 2393 extern "system" fn allocate_memory( 2394 _device: Device, 2395 _p_allocate_info: *const MemoryAllocateInfo, 2396 _p_allocator: *const AllocationCallbacks, 2397 _p_memory: *mut DeviceMemory, 2398 ) -> Result { 2399 panic!(concat!("Unable to load ", stringify!(allocate_memory))) 2400 } 2401 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateMemory\0"); 2402 let val = _f(cname); 2403 if val.is_null() { 2404 allocate_memory 2405 } else { 2406 ::std::mem::transmute(val) 2407 } 2408 }, 2409 free_memory: unsafe { 2410 extern "system" fn free_memory( 2411 _device: Device, 2412 _memory: DeviceMemory, 2413 _p_allocator: *const AllocationCallbacks, 2414 ) { 2415 panic!(concat!("Unable to load ", stringify!(free_memory))) 2416 } 2417 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeMemory\0"); 2418 let val = _f(cname); 2419 if val.is_null() { 2420 free_memory 2421 } else { 2422 ::std::mem::transmute(val) 2423 } 2424 }, 2425 map_memory: unsafe { 2426 extern "system" fn map_memory( 2427 _device: Device, 2428 _memory: DeviceMemory, 2429 _offset: DeviceSize, 2430 _size: DeviceSize, 2431 _flags: MemoryMapFlags, 2432 _pp_data: *mut *mut c_void, 2433 ) -> Result { 2434 panic!(concat!("Unable to load ", stringify!(map_memory))) 2435 } 2436 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory\0"); 2437 let val = _f(cname); 2438 if val.is_null() { 2439 map_memory 2440 } else { 2441 ::std::mem::transmute(val) 2442 } 2443 }, 2444 unmap_memory: unsafe { 2445 extern "system" fn unmap_memory(_device: Device, _memory: DeviceMemory) { 2446 panic!(concat!("Unable to load ", stringify!(unmap_memory))) 2447 } 2448 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory\0"); 2449 let val = _f(cname); 2450 if val.is_null() { 2451 unmap_memory 2452 } else { 2453 ::std::mem::transmute(val) 2454 } 2455 }, 2456 flush_mapped_memory_ranges: unsafe { 2457 extern "system" fn flush_mapped_memory_ranges( 2458 _device: Device, 2459 _memory_range_count: u32, 2460 _p_memory_ranges: *const MappedMemoryRange, 2461 ) -> Result { 2462 panic!(concat!( 2463 "Unable to load ", 2464 stringify!(flush_mapped_memory_ranges) 2465 )) 2466 } 2467 let cname = 2468 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFlushMappedMemoryRanges\0"); 2469 let val = _f(cname); 2470 if val.is_null() { 2471 flush_mapped_memory_ranges 2472 } else { 2473 ::std::mem::transmute(val) 2474 } 2475 }, 2476 invalidate_mapped_memory_ranges: unsafe { 2477 extern "system" fn invalidate_mapped_memory_ranges( 2478 _device: Device, 2479 _memory_range_count: u32, 2480 _p_memory_ranges: *const MappedMemoryRange, 2481 ) -> Result { 2482 panic!(concat!( 2483 "Unable to load ", 2484 stringify!(invalidate_mapped_memory_ranges) 2485 )) 2486 } 2487 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2488 b"vkInvalidateMappedMemoryRanges\0", 2489 ); 2490 let val = _f(cname); 2491 if val.is_null() { 2492 invalidate_mapped_memory_ranges 2493 } else { 2494 ::std::mem::transmute(val) 2495 } 2496 }, 2497 get_device_memory_commitment: unsafe { 2498 extern "system" fn get_device_memory_commitment( 2499 _device: Device, 2500 _memory: DeviceMemory, 2501 _p_committed_memory_in_bytes: *mut DeviceSize, 2502 ) { 2503 panic!(concat!( 2504 "Unable to load ", 2505 stringify!(get_device_memory_commitment) 2506 )) 2507 } 2508 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2509 b"vkGetDeviceMemoryCommitment\0", 2510 ); 2511 let val = _f(cname); 2512 if val.is_null() { 2513 get_device_memory_commitment 2514 } else { 2515 ::std::mem::transmute(val) 2516 } 2517 }, 2518 bind_buffer_memory: unsafe { 2519 extern "system" fn bind_buffer_memory( 2520 _device: Device, 2521 _buffer: Buffer, 2522 _memory: DeviceMemory, 2523 _memory_offset: DeviceSize, 2524 ) -> Result { 2525 panic!(concat!("Unable to load ", stringify!(bind_buffer_memory))) 2526 } 2527 let cname = 2528 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory\0"); 2529 let val = _f(cname); 2530 if val.is_null() { 2531 bind_buffer_memory 2532 } else { 2533 ::std::mem::transmute(val) 2534 } 2535 }, 2536 bind_image_memory: unsafe { 2537 extern "system" fn bind_image_memory( 2538 _device: Device, 2539 _image: Image, 2540 _memory: DeviceMemory, 2541 _memory_offset: DeviceSize, 2542 ) -> Result { 2543 panic!(concat!("Unable to load ", stringify!(bind_image_memory))) 2544 } 2545 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory\0"); 2546 let val = _f(cname); 2547 if val.is_null() { 2548 bind_image_memory 2549 } else { 2550 ::std::mem::transmute(val) 2551 } 2552 }, 2553 get_buffer_memory_requirements: unsafe { 2554 extern "system" fn get_buffer_memory_requirements( 2555 _device: Device, 2556 _buffer: Buffer, 2557 _p_memory_requirements: *mut MemoryRequirements, 2558 ) { 2559 panic!(concat!( 2560 "Unable to load ", 2561 stringify!(get_buffer_memory_requirements) 2562 )) 2563 } 2564 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2565 b"vkGetBufferMemoryRequirements\0", 2566 ); 2567 let val = _f(cname); 2568 if val.is_null() { 2569 get_buffer_memory_requirements 2570 } else { 2571 ::std::mem::transmute(val) 2572 } 2573 }, 2574 get_image_memory_requirements: unsafe { 2575 extern "system" fn get_image_memory_requirements( 2576 _device: Device, 2577 _image: Image, 2578 _p_memory_requirements: *mut MemoryRequirements, 2579 ) { 2580 panic!(concat!( 2581 "Unable to load ", 2582 stringify!(get_image_memory_requirements) 2583 )) 2584 } 2585 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2586 b"vkGetImageMemoryRequirements\0", 2587 ); 2588 let val = _f(cname); 2589 if val.is_null() { 2590 get_image_memory_requirements 2591 } else { 2592 ::std::mem::transmute(val) 2593 } 2594 }, 2595 get_image_sparse_memory_requirements: unsafe { 2596 extern "system" fn get_image_sparse_memory_requirements( 2597 _device: Device, 2598 _image: Image, 2599 _p_sparse_memory_requirement_count: *mut u32, 2600 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, 2601 ) { 2602 panic!(concat!( 2603 "Unable to load ", 2604 stringify!(get_image_sparse_memory_requirements) 2605 )) 2606 } 2607 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2608 b"vkGetImageSparseMemoryRequirements\0", 2609 ); 2610 let val = _f(cname); 2611 if val.is_null() { 2612 get_image_sparse_memory_requirements 2613 } else { 2614 ::std::mem::transmute(val) 2615 } 2616 }, 2617 queue_bind_sparse: unsafe { 2618 extern "system" fn queue_bind_sparse( 2619 _queue: Queue, 2620 _bind_info_count: u32, 2621 _p_bind_info: *const BindSparseInfo, 2622 _fence: Fence, 2623 ) -> Result { 2624 panic!(concat!("Unable to load ", stringify!(queue_bind_sparse))) 2625 } 2626 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueBindSparse\0"); 2627 let val = _f(cname); 2628 if val.is_null() { 2629 queue_bind_sparse 2630 } else { 2631 ::std::mem::transmute(val) 2632 } 2633 }, 2634 create_fence: unsafe { 2635 extern "system" fn create_fence( 2636 _device: Device, 2637 _p_create_info: *const FenceCreateInfo, 2638 _p_allocator: *const AllocationCallbacks, 2639 _p_fence: *mut Fence, 2640 ) -> Result { 2641 panic!(concat!("Unable to load ", stringify!(create_fence))) 2642 } 2643 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFence\0"); 2644 let val = _f(cname); 2645 if val.is_null() { 2646 create_fence 2647 } else { 2648 ::std::mem::transmute(val) 2649 } 2650 }, 2651 destroy_fence: unsafe { 2652 extern "system" fn destroy_fence( 2653 _device: Device, 2654 _fence: Fence, 2655 _p_allocator: *const AllocationCallbacks, 2656 ) { 2657 panic!(concat!("Unable to load ", stringify!(destroy_fence))) 2658 } 2659 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFence\0"); 2660 let val = _f(cname); 2661 if val.is_null() { 2662 destroy_fence 2663 } else { 2664 ::std::mem::transmute(val) 2665 } 2666 }, 2667 reset_fences: unsafe { 2668 extern "system" fn reset_fences( 2669 _device: Device, 2670 _fence_count: u32, 2671 _p_fences: *const Fence, 2672 ) -> Result { 2673 panic!(concat!("Unable to load ", stringify!(reset_fences))) 2674 } 2675 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetFences\0"); 2676 let val = _f(cname); 2677 if val.is_null() { 2678 reset_fences 2679 } else { 2680 ::std::mem::transmute(val) 2681 } 2682 }, 2683 get_fence_status: unsafe { 2684 extern "system" fn get_fence_status(_device: Device, _fence: Fence) -> Result { 2685 panic!(concat!("Unable to load ", stringify!(get_fence_status))) 2686 } 2687 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceStatus\0"); 2688 let val = _f(cname); 2689 if val.is_null() { 2690 get_fence_status 2691 } else { 2692 ::std::mem::transmute(val) 2693 } 2694 }, 2695 wait_for_fences: unsafe { 2696 extern "system" fn wait_for_fences( 2697 _device: Device, 2698 _fence_count: u32, 2699 _p_fences: *const Fence, 2700 _wait_all: Bool32, 2701 _timeout: u64, 2702 ) -> Result { 2703 panic!(concat!("Unable to load ", stringify!(wait_for_fences))) 2704 } 2705 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForFences\0"); 2706 let val = _f(cname); 2707 if val.is_null() { 2708 wait_for_fences 2709 } else { 2710 ::std::mem::transmute(val) 2711 } 2712 }, 2713 create_semaphore: unsafe { 2714 extern "system" fn create_semaphore( 2715 _device: Device, 2716 _p_create_info: *const SemaphoreCreateInfo, 2717 _p_allocator: *const AllocationCallbacks, 2718 _p_semaphore: *mut Semaphore, 2719 ) -> Result { 2720 panic!(concat!("Unable to load ", stringify!(create_semaphore))) 2721 } 2722 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSemaphore\0"); 2723 let val = _f(cname); 2724 if val.is_null() { 2725 create_semaphore 2726 } else { 2727 ::std::mem::transmute(val) 2728 } 2729 }, 2730 destroy_semaphore: unsafe { 2731 extern "system" fn destroy_semaphore( 2732 _device: Device, 2733 _semaphore: Semaphore, 2734 _p_allocator: *const AllocationCallbacks, 2735 ) { 2736 panic!(concat!("Unable to load ", stringify!(destroy_semaphore))) 2737 } 2738 let cname = 2739 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySemaphore\0"); 2740 let val = _f(cname); 2741 if val.is_null() { 2742 destroy_semaphore 2743 } else { 2744 ::std::mem::transmute(val) 2745 } 2746 }, 2747 create_event: unsafe { 2748 extern "system" fn create_event( 2749 _device: Device, 2750 _p_create_info: *const EventCreateInfo, 2751 _p_allocator: *const AllocationCallbacks, 2752 _p_event: *mut Event, 2753 ) -> Result { 2754 panic!(concat!("Unable to load ", stringify!(create_event))) 2755 } 2756 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateEvent\0"); 2757 let val = _f(cname); 2758 if val.is_null() { 2759 create_event 2760 } else { 2761 ::std::mem::transmute(val) 2762 } 2763 }, 2764 destroy_event: unsafe { 2765 extern "system" fn destroy_event( 2766 _device: Device, 2767 _event: Event, 2768 _p_allocator: *const AllocationCallbacks, 2769 ) { 2770 panic!(concat!("Unable to load ", stringify!(destroy_event))) 2771 } 2772 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyEvent\0"); 2773 let val = _f(cname); 2774 if val.is_null() { 2775 destroy_event 2776 } else { 2777 ::std::mem::transmute(val) 2778 } 2779 }, 2780 get_event_status: unsafe { 2781 extern "system" fn get_event_status(_device: Device, _event: Event) -> Result { 2782 panic!(concat!("Unable to load ", stringify!(get_event_status))) 2783 } 2784 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetEventStatus\0"); 2785 let val = _f(cname); 2786 if val.is_null() { 2787 get_event_status 2788 } else { 2789 ::std::mem::transmute(val) 2790 } 2791 }, 2792 set_event: unsafe { 2793 extern "system" fn set_event(_device: Device, _event: Event) -> Result { 2794 panic!(concat!("Unable to load ", stringify!(set_event))) 2795 } 2796 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetEvent\0"); 2797 let val = _f(cname); 2798 if val.is_null() { 2799 set_event 2800 } else { 2801 ::std::mem::transmute(val) 2802 } 2803 }, 2804 reset_event: unsafe { 2805 extern "system" fn reset_event(_device: Device, _event: Event) -> Result { 2806 panic!(concat!("Unable to load ", stringify!(reset_event))) 2807 } 2808 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetEvent\0"); 2809 let val = _f(cname); 2810 if val.is_null() { 2811 reset_event 2812 } else { 2813 ::std::mem::transmute(val) 2814 } 2815 }, 2816 create_query_pool: unsafe { 2817 extern "system" fn create_query_pool( 2818 _device: Device, 2819 _p_create_info: *const QueryPoolCreateInfo, 2820 _p_allocator: *const AllocationCallbacks, 2821 _p_query_pool: *mut QueryPool, 2822 ) -> Result { 2823 panic!(concat!("Unable to load ", stringify!(create_query_pool))) 2824 } 2825 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateQueryPool\0"); 2826 let val = _f(cname); 2827 if val.is_null() { 2828 create_query_pool 2829 } else { 2830 ::std::mem::transmute(val) 2831 } 2832 }, 2833 destroy_query_pool: unsafe { 2834 extern "system" fn destroy_query_pool( 2835 _device: Device, 2836 _query_pool: QueryPool, 2837 _p_allocator: *const AllocationCallbacks, 2838 ) { 2839 panic!(concat!("Unable to load ", stringify!(destroy_query_pool))) 2840 } 2841 let cname = 2842 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyQueryPool\0"); 2843 let val = _f(cname); 2844 if val.is_null() { 2845 destroy_query_pool 2846 } else { 2847 ::std::mem::transmute(val) 2848 } 2849 }, 2850 get_query_pool_results: unsafe { 2851 extern "system" fn get_query_pool_results( 2852 _device: Device, 2853 _query_pool: QueryPool, 2854 _first_query: u32, 2855 _query_count: u32, 2856 _data_size: usize, 2857 _p_data: *mut c_void, 2858 _stride: DeviceSize, 2859 _flags: QueryResultFlags, 2860 ) -> Result { 2861 panic!(concat!( 2862 "Unable to load ", 2863 stringify!(get_query_pool_results) 2864 )) 2865 } 2866 let cname = 2867 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetQueryPoolResults\0"); 2868 let val = _f(cname); 2869 if val.is_null() { 2870 get_query_pool_results 2871 } else { 2872 ::std::mem::transmute(val) 2873 } 2874 }, 2875 create_buffer: unsafe { 2876 extern "system" fn create_buffer( 2877 _device: Device, 2878 _p_create_info: *const BufferCreateInfo, 2879 _p_allocator: *const AllocationCallbacks, 2880 _p_buffer: *mut Buffer, 2881 ) -> Result { 2882 panic!(concat!("Unable to load ", stringify!(create_buffer))) 2883 } 2884 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBuffer\0"); 2885 let val = _f(cname); 2886 if val.is_null() { 2887 create_buffer 2888 } else { 2889 ::std::mem::transmute(val) 2890 } 2891 }, 2892 destroy_buffer: unsafe { 2893 extern "system" fn destroy_buffer( 2894 _device: Device, 2895 _buffer: Buffer, 2896 _p_allocator: *const AllocationCallbacks, 2897 ) { 2898 panic!(concat!("Unable to load ", stringify!(destroy_buffer))) 2899 } 2900 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBuffer\0"); 2901 let val = _f(cname); 2902 if val.is_null() { 2903 destroy_buffer 2904 } else { 2905 ::std::mem::transmute(val) 2906 } 2907 }, 2908 create_buffer_view: unsafe { 2909 extern "system" fn create_buffer_view( 2910 _device: Device, 2911 _p_create_info: *const BufferViewCreateInfo, 2912 _p_allocator: *const AllocationCallbacks, 2913 _p_view: *mut BufferView, 2914 ) -> Result { 2915 panic!(concat!("Unable to load ", stringify!(create_buffer_view))) 2916 } 2917 let cname = 2918 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateBufferView\0"); 2919 let val = _f(cname); 2920 if val.is_null() { 2921 create_buffer_view 2922 } else { 2923 ::std::mem::transmute(val) 2924 } 2925 }, 2926 destroy_buffer_view: unsafe { 2927 extern "system" fn destroy_buffer_view( 2928 _device: Device, 2929 _buffer_view: BufferView, 2930 _p_allocator: *const AllocationCallbacks, 2931 ) { 2932 panic!(concat!("Unable to load ", stringify!(destroy_buffer_view))) 2933 } 2934 let cname = 2935 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyBufferView\0"); 2936 let val = _f(cname); 2937 if val.is_null() { 2938 destroy_buffer_view 2939 } else { 2940 ::std::mem::transmute(val) 2941 } 2942 }, 2943 create_image: unsafe { 2944 extern "system" fn create_image( 2945 _device: Device, 2946 _p_create_info: *const ImageCreateInfo, 2947 _p_allocator: *const AllocationCallbacks, 2948 _p_image: *mut Image, 2949 ) -> Result { 2950 panic!(concat!("Unable to load ", stringify!(create_image))) 2951 } 2952 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImage\0"); 2953 let val = _f(cname); 2954 if val.is_null() { 2955 create_image 2956 } else { 2957 ::std::mem::transmute(val) 2958 } 2959 }, 2960 destroy_image: unsafe { 2961 extern "system" fn destroy_image( 2962 _device: Device, 2963 _image: Image, 2964 _p_allocator: *const AllocationCallbacks, 2965 ) { 2966 panic!(concat!("Unable to load ", stringify!(destroy_image))) 2967 } 2968 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImage\0"); 2969 let val = _f(cname); 2970 if val.is_null() { 2971 destroy_image 2972 } else { 2973 ::std::mem::transmute(val) 2974 } 2975 }, 2976 get_image_subresource_layout: unsafe { 2977 extern "system" fn get_image_subresource_layout( 2978 _device: Device, 2979 _image: Image, 2980 _p_subresource: *const ImageSubresource, 2981 _p_layout: *mut SubresourceLayout, 2982 ) { 2983 panic!(concat!( 2984 "Unable to load ", 2985 stringify!(get_image_subresource_layout) 2986 )) 2987 } 2988 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 2989 b"vkGetImageSubresourceLayout\0", 2990 ); 2991 let val = _f(cname); 2992 if val.is_null() { 2993 get_image_subresource_layout 2994 } else { 2995 ::std::mem::transmute(val) 2996 } 2997 }, 2998 create_image_view: unsafe { 2999 extern "system" fn create_image_view( 3000 _device: Device, 3001 _p_create_info: *const ImageViewCreateInfo, 3002 _p_allocator: *const AllocationCallbacks, 3003 _p_view: *mut ImageView, 3004 ) -> Result { 3005 panic!(concat!("Unable to load ", stringify!(create_image_view))) 3006 } 3007 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateImageView\0"); 3008 let val = _f(cname); 3009 if val.is_null() { 3010 create_image_view 3011 } else { 3012 ::std::mem::transmute(val) 3013 } 3014 }, 3015 destroy_image_view: unsafe { 3016 extern "system" fn destroy_image_view( 3017 _device: Device, 3018 _image_view: ImageView, 3019 _p_allocator: *const AllocationCallbacks, 3020 ) { 3021 panic!(concat!("Unable to load ", stringify!(destroy_image_view))) 3022 } 3023 let cname = 3024 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyImageView\0"); 3025 let val = _f(cname); 3026 if val.is_null() { 3027 destroy_image_view 3028 } else { 3029 ::std::mem::transmute(val) 3030 } 3031 }, 3032 create_shader_module: unsafe { 3033 extern "system" fn create_shader_module( 3034 _device: Device, 3035 _p_create_info: *const ShaderModuleCreateInfo, 3036 _p_allocator: *const AllocationCallbacks, 3037 _p_shader_module: *mut ShaderModule, 3038 ) -> Result { 3039 panic!(concat!("Unable to load ", stringify!(create_shader_module))) 3040 } 3041 let cname = 3042 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShaderModule\0"); 3043 let val = _f(cname); 3044 if val.is_null() { 3045 create_shader_module 3046 } else { 3047 ::std::mem::transmute(val) 3048 } 3049 }, 3050 destroy_shader_module: unsafe { 3051 extern "system" fn destroy_shader_module( 3052 _device: Device, 3053 _shader_module: ShaderModule, 3054 _p_allocator: *const AllocationCallbacks, 3055 ) { 3056 panic!(concat!( 3057 "Unable to load ", 3058 stringify!(destroy_shader_module) 3059 )) 3060 } 3061 let cname = 3062 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderModule\0"); 3063 let val = _f(cname); 3064 if val.is_null() { 3065 destroy_shader_module 3066 } else { 3067 ::std::mem::transmute(val) 3068 } 3069 }, 3070 create_pipeline_cache: unsafe { 3071 extern "system" fn create_pipeline_cache( 3072 _device: Device, 3073 _p_create_info: *const PipelineCacheCreateInfo, 3074 _p_allocator: *const AllocationCallbacks, 3075 _p_pipeline_cache: *mut PipelineCache, 3076 ) -> Result { 3077 panic!(concat!( 3078 "Unable to load ", 3079 stringify!(create_pipeline_cache) 3080 )) 3081 } 3082 let cname = 3083 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineCache\0"); 3084 let val = _f(cname); 3085 if val.is_null() { 3086 create_pipeline_cache 3087 } else { 3088 ::std::mem::transmute(val) 3089 } 3090 }, 3091 destroy_pipeline_cache: unsafe { 3092 extern "system" fn destroy_pipeline_cache( 3093 _device: Device, 3094 _pipeline_cache: PipelineCache, 3095 _p_allocator: *const AllocationCallbacks, 3096 ) { 3097 panic!(concat!( 3098 "Unable to load ", 3099 stringify!(destroy_pipeline_cache) 3100 )) 3101 } 3102 let cname = 3103 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineCache\0"); 3104 let val = _f(cname); 3105 if val.is_null() { 3106 destroy_pipeline_cache 3107 } else { 3108 ::std::mem::transmute(val) 3109 } 3110 }, 3111 get_pipeline_cache_data: unsafe { 3112 extern "system" fn get_pipeline_cache_data( 3113 _device: Device, 3114 _pipeline_cache: PipelineCache, 3115 _p_data_size: *mut usize, 3116 _p_data: *mut c_void, 3117 ) -> Result { 3118 panic!(concat!( 3119 "Unable to load ", 3120 stringify!(get_pipeline_cache_data) 3121 )) 3122 } 3123 let cname = 3124 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPipelineCacheData\0"); 3125 let val = _f(cname); 3126 if val.is_null() { 3127 get_pipeline_cache_data 3128 } else { 3129 ::std::mem::transmute(val) 3130 } 3131 }, 3132 merge_pipeline_caches: unsafe { 3133 extern "system" fn merge_pipeline_caches( 3134 _device: Device, 3135 _dst_cache: PipelineCache, 3136 _src_cache_count: u32, 3137 _p_src_caches: *const PipelineCache, 3138 ) -> Result { 3139 panic!(concat!( 3140 "Unable to load ", 3141 stringify!(merge_pipeline_caches) 3142 )) 3143 } 3144 let cname = 3145 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMergePipelineCaches\0"); 3146 let val = _f(cname); 3147 if val.is_null() { 3148 merge_pipeline_caches 3149 } else { 3150 ::std::mem::transmute(val) 3151 } 3152 }, 3153 create_graphics_pipelines: unsafe { 3154 extern "system" fn create_graphics_pipelines( 3155 _device: Device, 3156 _pipeline_cache: PipelineCache, 3157 _create_info_count: u32, 3158 _p_create_infos: *const GraphicsPipelineCreateInfo, 3159 _p_allocator: *const AllocationCallbacks, 3160 _p_pipelines: *mut Pipeline, 3161 ) -> Result { 3162 panic!(concat!( 3163 "Unable to load ", 3164 stringify!(create_graphics_pipelines) 3165 )) 3166 } 3167 let cname = 3168 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateGraphicsPipelines\0"); 3169 let val = _f(cname); 3170 if val.is_null() { 3171 create_graphics_pipelines 3172 } else { 3173 ::std::mem::transmute(val) 3174 } 3175 }, 3176 create_compute_pipelines: unsafe { 3177 extern "system" fn create_compute_pipelines( 3178 _device: Device, 3179 _pipeline_cache: PipelineCache, 3180 _create_info_count: u32, 3181 _p_create_infos: *const ComputePipelineCreateInfo, 3182 _p_allocator: *const AllocationCallbacks, 3183 _p_pipelines: *mut Pipeline, 3184 ) -> Result { 3185 panic!(concat!( 3186 "Unable to load ", 3187 stringify!(create_compute_pipelines) 3188 )) 3189 } 3190 let cname = 3191 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateComputePipelines\0"); 3192 let val = _f(cname); 3193 if val.is_null() { 3194 create_compute_pipelines 3195 } else { 3196 ::std::mem::transmute(val) 3197 } 3198 }, 3199 destroy_pipeline: unsafe { 3200 extern "system" fn destroy_pipeline( 3201 _device: Device, 3202 _pipeline: Pipeline, 3203 _p_allocator: *const AllocationCallbacks, 3204 ) { 3205 panic!(concat!("Unable to load ", stringify!(destroy_pipeline))) 3206 } 3207 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipeline\0"); 3208 let val = _f(cname); 3209 if val.is_null() { 3210 destroy_pipeline 3211 } else { 3212 ::std::mem::transmute(val) 3213 } 3214 }, 3215 create_pipeline_layout: unsafe { 3216 extern "system" fn create_pipeline_layout( 3217 _device: Device, 3218 _p_create_info: *const PipelineLayoutCreateInfo, 3219 _p_allocator: *const AllocationCallbacks, 3220 _p_pipeline_layout: *mut PipelineLayout, 3221 ) -> Result { 3222 panic!(concat!( 3223 "Unable to load ", 3224 stringify!(create_pipeline_layout) 3225 )) 3226 } 3227 let cname = 3228 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreatePipelineLayout\0"); 3229 let val = _f(cname); 3230 if val.is_null() { 3231 create_pipeline_layout 3232 } else { 3233 ::std::mem::transmute(val) 3234 } 3235 }, 3236 destroy_pipeline_layout: unsafe { 3237 extern "system" fn destroy_pipeline_layout( 3238 _device: Device, 3239 _pipeline_layout: PipelineLayout, 3240 _p_allocator: *const AllocationCallbacks, 3241 ) { 3242 panic!(concat!( 3243 "Unable to load ", 3244 stringify!(destroy_pipeline_layout) 3245 )) 3246 } 3247 let cname = 3248 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyPipelineLayout\0"); 3249 let val = _f(cname); 3250 if val.is_null() { 3251 destroy_pipeline_layout 3252 } else { 3253 ::std::mem::transmute(val) 3254 } 3255 }, 3256 create_sampler: unsafe { 3257 extern "system" fn create_sampler( 3258 _device: Device, 3259 _p_create_info: *const SamplerCreateInfo, 3260 _p_allocator: *const AllocationCallbacks, 3261 _p_sampler: *mut Sampler, 3262 ) -> Result { 3263 panic!(concat!("Unable to load ", stringify!(create_sampler))) 3264 } 3265 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSampler\0"); 3266 let val = _f(cname); 3267 if val.is_null() { 3268 create_sampler 3269 } else { 3270 ::std::mem::transmute(val) 3271 } 3272 }, 3273 destroy_sampler: unsafe { 3274 extern "system" fn destroy_sampler( 3275 _device: Device, 3276 _sampler: Sampler, 3277 _p_allocator: *const AllocationCallbacks, 3278 ) { 3279 panic!(concat!("Unable to load ", stringify!(destroy_sampler))) 3280 } 3281 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySampler\0"); 3282 let val = _f(cname); 3283 if val.is_null() { 3284 destroy_sampler 3285 } else { 3286 ::std::mem::transmute(val) 3287 } 3288 }, 3289 create_descriptor_set_layout: unsafe { 3290 extern "system" fn create_descriptor_set_layout( 3291 _device: Device, 3292 _p_create_info: *const DescriptorSetLayoutCreateInfo, 3293 _p_allocator: *const AllocationCallbacks, 3294 _p_set_layout: *mut DescriptorSetLayout, 3295 ) -> Result { 3296 panic!(concat!( 3297 "Unable to load ", 3298 stringify!(create_descriptor_set_layout) 3299 )) 3300 } 3301 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3302 b"vkCreateDescriptorSetLayout\0", 3303 ); 3304 let val = _f(cname); 3305 if val.is_null() { 3306 create_descriptor_set_layout 3307 } else { 3308 ::std::mem::transmute(val) 3309 } 3310 }, 3311 destroy_descriptor_set_layout: unsafe { 3312 extern "system" fn destroy_descriptor_set_layout( 3313 _device: Device, 3314 _descriptor_set_layout: DescriptorSetLayout, 3315 _p_allocator: *const AllocationCallbacks, 3316 ) { 3317 panic!(concat!( 3318 "Unable to load ", 3319 stringify!(destroy_descriptor_set_layout) 3320 )) 3321 } 3322 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3323 b"vkDestroyDescriptorSetLayout\0", 3324 ); 3325 let val = _f(cname); 3326 if val.is_null() { 3327 destroy_descriptor_set_layout 3328 } else { 3329 ::std::mem::transmute(val) 3330 } 3331 }, 3332 create_descriptor_pool: unsafe { 3333 extern "system" fn create_descriptor_pool( 3334 _device: Device, 3335 _p_create_info: *const DescriptorPoolCreateInfo, 3336 _p_allocator: *const AllocationCallbacks, 3337 _p_descriptor_pool: *mut DescriptorPool, 3338 ) -> Result { 3339 panic!(concat!( 3340 "Unable to load ", 3341 stringify!(create_descriptor_pool) 3342 )) 3343 } 3344 let cname = 3345 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDescriptorPool\0"); 3346 let val = _f(cname); 3347 if val.is_null() { 3348 create_descriptor_pool 3349 } else { 3350 ::std::mem::transmute(val) 3351 } 3352 }, 3353 destroy_descriptor_pool: unsafe { 3354 extern "system" fn destroy_descriptor_pool( 3355 _device: Device, 3356 _descriptor_pool: DescriptorPool, 3357 _p_allocator: *const AllocationCallbacks, 3358 ) { 3359 panic!(concat!( 3360 "Unable to load ", 3361 stringify!(destroy_descriptor_pool) 3362 )) 3363 } 3364 let cname = 3365 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyDescriptorPool\0"); 3366 let val = _f(cname); 3367 if val.is_null() { 3368 destroy_descriptor_pool 3369 } else { 3370 ::std::mem::transmute(val) 3371 } 3372 }, 3373 reset_descriptor_pool: unsafe { 3374 extern "system" fn reset_descriptor_pool( 3375 _device: Device, 3376 _descriptor_pool: DescriptorPool, 3377 _flags: DescriptorPoolResetFlags, 3378 ) -> Result { 3379 panic!(concat!( 3380 "Unable to load ", 3381 stringify!(reset_descriptor_pool) 3382 )) 3383 } 3384 let cname = 3385 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetDescriptorPool\0"); 3386 let val = _f(cname); 3387 if val.is_null() { 3388 reset_descriptor_pool 3389 } else { 3390 ::std::mem::transmute(val) 3391 } 3392 }, 3393 allocate_descriptor_sets: unsafe { 3394 extern "system" fn allocate_descriptor_sets( 3395 _device: Device, 3396 _p_allocate_info: *const DescriptorSetAllocateInfo, 3397 _p_descriptor_sets: *mut DescriptorSet, 3398 ) -> Result { 3399 panic!(concat!( 3400 "Unable to load ", 3401 stringify!(allocate_descriptor_sets) 3402 )) 3403 } 3404 let cname = 3405 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateDescriptorSets\0"); 3406 let val = _f(cname); 3407 if val.is_null() { 3408 allocate_descriptor_sets 3409 } else { 3410 ::std::mem::transmute(val) 3411 } 3412 }, 3413 free_descriptor_sets: unsafe { 3414 extern "system" fn free_descriptor_sets( 3415 _device: Device, 3416 _descriptor_pool: DescriptorPool, 3417 _descriptor_set_count: u32, 3418 _p_descriptor_sets: *const DescriptorSet, 3419 ) -> Result { 3420 panic!(concat!("Unable to load ", stringify!(free_descriptor_sets))) 3421 } 3422 let cname = 3423 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeDescriptorSets\0"); 3424 let val = _f(cname); 3425 if val.is_null() { 3426 free_descriptor_sets 3427 } else { 3428 ::std::mem::transmute(val) 3429 } 3430 }, 3431 update_descriptor_sets: unsafe { 3432 extern "system" fn update_descriptor_sets( 3433 _device: Device, 3434 _descriptor_write_count: u32, 3435 _p_descriptor_writes: *const WriteDescriptorSet, 3436 _descriptor_copy_count: u32, 3437 _p_descriptor_copies: *const CopyDescriptorSet, 3438 ) { 3439 panic!(concat!( 3440 "Unable to load ", 3441 stringify!(update_descriptor_sets) 3442 )) 3443 } 3444 let cname = 3445 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUpdateDescriptorSets\0"); 3446 let val = _f(cname); 3447 if val.is_null() { 3448 update_descriptor_sets 3449 } else { 3450 ::std::mem::transmute(val) 3451 } 3452 }, 3453 create_framebuffer: unsafe { 3454 extern "system" fn create_framebuffer( 3455 _device: Device, 3456 _p_create_info: *const FramebufferCreateInfo, 3457 _p_allocator: *const AllocationCallbacks, 3458 _p_framebuffer: *mut Framebuffer, 3459 ) -> Result { 3460 panic!(concat!("Unable to load ", stringify!(create_framebuffer))) 3461 } 3462 let cname = 3463 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateFramebuffer\0"); 3464 let val = _f(cname); 3465 if val.is_null() { 3466 create_framebuffer 3467 } else { 3468 ::std::mem::transmute(val) 3469 } 3470 }, 3471 destroy_framebuffer: unsafe { 3472 extern "system" fn destroy_framebuffer( 3473 _device: Device, 3474 _framebuffer: Framebuffer, 3475 _p_allocator: *const AllocationCallbacks, 3476 ) { 3477 panic!(concat!("Unable to load ", stringify!(destroy_framebuffer))) 3478 } 3479 let cname = 3480 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyFramebuffer\0"); 3481 let val = _f(cname); 3482 if val.is_null() { 3483 destroy_framebuffer 3484 } else { 3485 ::std::mem::transmute(val) 3486 } 3487 }, 3488 create_render_pass: unsafe { 3489 extern "system" fn create_render_pass( 3490 _device: Device, 3491 _p_create_info: *const RenderPassCreateInfo, 3492 _p_allocator: *const AllocationCallbacks, 3493 _p_render_pass: *mut RenderPass, 3494 ) -> Result { 3495 panic!(concat!("Unable to load ", stringify!(create_render_pass))) 3496 } 3497 let cname = 3498 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass\0"); 3499 let val = _f(cname); 3500 if val.is_null() { 3501 create_render_pass 3502 } else { 3503 ::std::mem::transmute(val) 3504 } 3505 }, 3506 destroy_render_pass: unsafe { 3507 extern "system" fn destroy_render_pass( 3508 _device: Device, 3509 _render_pass: RenderPass, 3510 _p_allocator: *const AllocationCallbacks, 3511 ) { 3512 panic!(concat!("Unable to load ", stringify!(destroy_render_pass))) 3513 } 3514 let cname = 3515 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyRenderPass\0"); 3516 let val = _f(cname); 3517 if val.is_null() { 3518 destroy_render_pass 3519 } else { 3520 ::std::mem::transmute(val) 3521 } 3522 }, 3523 get_render_area_granularity: unsafe { 3524 extern "system" fn get_render_area_granularity( 3525 _device: Device, 3526 _render_pass: RenderPass, 3527 _p_granularity: *mut Extent2D, 3528 ) { 3529 panic!(concat!( 3530 "Unable to load ", 3531 stringify!(get_render_area_granularity) 3532 )) 3533 } 3534 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3535 b"vkGetRenderAreaGranularity\0", 3536 ); 3537 let val = _f(cname); 3538 if val.is_null() { 3539 get_render_area_granularity 3540 } else { 3541 ::std::mem::transmute(val) 3542 } 3543 }, 3544 create_command_pool: unsafe { 3545 extern "system" fn create_command_pool( 3546 _device: Device, 3547 _p_create_info: *const CommandPoolCreateInfo, 3548 _p_allocator: *const AllocationCallbacks, 3549 _p_command_pool: *mut CommandPool, 3550 ) -> Result { 3551 panic!(concat!("Unable to load ", stringify!(create_command_pool))) 3552 } 3553 let cname = 3554 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCommandPool\0"); 3555 let val = _f(cname); 3556 if val.is_null() { 3557 create_command_pool 3558 } else { 3559 ::std::mem::transmute(val) 3560 } 3561 }, 3562 destroy_command_pool: unsafe { 3563 extern "system" fn destroy_command_pool( 3564 _device: Device, 3565 _command_pool: CommandPool, 3566 _p_allocator: *const AllocationCallbacks, 3567 ) { 3568 panic!(concat!("Unable to load ", stringify!(destroy_command_pool))) 3569 } 3570 let cname = 3571 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCommandPool\0"); 3572 let val = _f(cname); 3573 if val.is_null() { 3574 destroy_command_pool 3575 } else { 3576 ::std::mem::transmute(val) 3577 } 3578 }, 3579 reset_command_pool: unsafe { 3580 extern "system" fn reset_command_pool( 3581 _device: Device, 3582 _command_pool: CommandPool, 3583 _flags: CommandPoolResetFlags, 3584 ) -> Result { 3585 panic!(concat!("Unable to load ", stringify!(reset_command_pool))) 3586 } 3587 let cname = 3588 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandPool\0"); 3589 let val = _f(cname); 3590 if val.is_null() { 3591 reset_command_pool 3592 } else { 3593 ::std::mem::transmute(val) 3594 } 3595 }, 3596 allocate_command_buffers: unsafe { 3597 extern "system" fn allocate_command_buffers( 3598 _device: Device, 3599 _p_allocate_info: *const CommandBufferAllocateInfo, 3600 _p_command_buffers: *mut CommandBuffer, 3601 ) -> Result { 3602 panic!(concat!( 3603 "Unable to load ", 3604 stringify!(allocate_command_buffers) 3605 )) 3606 } 3607 let cname = 3608 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAllocateCommandBuffers\0"); 3609 let val = _f(cname); 3610 if val.is_null() { 3611 allocate_command_buffers 3612 } else { 3613 ::std::mem::transmute(val) 3614 } 3615 }, 3616 free_command_buffers: unsafe { 3617 extern "system" fn free_command_buffers( 3618 _device: Device, 3619 _command_pool: CommandPool, 3620 _command_buffer_count: u32, 3621 _p_command_buffers: *const CommandBuffer, 3622 ) { 3623 panic!(concat!("Unable to load ", stringify!(free_command_buffers))) 3624 } 3625 let cname = 3626 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkFreeCommandBuffers\0"); 3627 let val = _f(cname); 3628 if val.is_null() { 3629 free_command_buffers 3630 } else { 3631 ::std::mem::transmute(val) 3632 } 3633 }, 3634 begin_command_buffer: unsafe { 3635 extern "system" fn begin_command_buffer( 3636 _command_buffer: CommandBuffer, 3637 _p_begin_info: *const CommandBufferBeginInfo, 3638 ) -> Result { 3639 panic!(concat!("Unable to load ", stringify!(begin_command_buffer))) 3640 } 3641 let cname = 3642 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBeginCommandBuffer\0"); 3643 let val = _f(cname); 3644 if val.is_null() { 3645 begin_command_buffer 3646 } else { 3647 ::std::mem::transmute(val) 3648 } 3649 }, 3650 end_command_buffer: unsafe { 3651 extern "system" fn end_command_buffer(_command_buffer: CommandBuffer) -> Result { 3652 panic!(concat!("Unable to load ", stringify!(end_command_buffer))) 3653 } 3654 let cname = 3655 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkEndCommandBuffer\0"); 3656 let val = _f(cname); 3657 if val.is_null() { 3658 end_command_buffer 3659 } else { 3660 ::std::mem::transmute(val) 3661 } 3662 }, 3663 reset_command_buffer: unsafe { 3664 extern "system" fn reset_command_buffer( 3665 _command_buffer: CommandBuffer, 3666 _flags: CommandBufferResetFlags, 3667 ) -> Result { 3668 panic!(concat!("Unable to load ", stringify!(reset_command_buffer))) 3669 } 3670 let cname = 3671 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetCommandBuffer\0"); 3672 let val = _f(cname); 3673 if val.is_null() { 3674 reset_command_buffer 3675 } else { 3676 ::std::mem::transmute(val) 3677 } 3678 }, 3679 cmd_bind_pipeline: unsafe { 3680 extern "system" fn cmd_bind_pipeline( 3681 _command_buffer: CommandBuffer, 3682 _pipeline_bind_point: PipelineBindPoint, 3683 _pipeline: Pipeline, 3684 ) { 3685 panic!(concat!("Unable to load ", stringify!(cmd_bind_pipeline))) 3686 } 3687 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindPipeline\0"); 3688 let val = _f(cname); 3689 if val.is_null() { 3690 cmd_bind_pipeline 3691 } else { 3692 ::std::mem::transmute(val) 3693 } 3694 }, 3695 cmd_set_viewport: unsafe { 3696 extern "system" fn cmd_set_viewport( 3697 _command_buffer: CommandBuffer, 3698 _first_viewport: u32, 3699 _viewport_count: u32, 3700 _p_viewports: *const Viewport, 3701 ) { 3702 panic!(concat!("Unable to load ", stringify!(cmd_set_viewport))) 3703 } 3704 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewport\0"); 3705 let val = _f(cname); 3706 if val.is_null() { 3707 cmd_set_viewport 3708 } else { 3709 ::std::mem::transmute(val) 3710 } 3711 }, 3712 cmd_set_scissor: unsafe { 3713 extern "system" fn cmd_set_scissor( 3714 _command_buffer: CommandBuffer, 3715 _first_scissor: u32, 3716 _scissor_count: u32, 3717 _p_scissors: *const Rect2D, 3718 ) { 3719 panic!(concat!("Unable to load ", stringify!(cmd_set_scissor))) 3720 } 3721 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetScissor\0"); 3722 let val = _f(cname); 3723 if val.is_null() { 3724 cmd_set_scissor 3725 } else { 3726 ::std::mem::transmute(val) 3727 } 3728 }, 3729 cmd_set_line_width: unsafe { 3730 extern "system" fn cmd_set_line_width( 3731 _command_buffer: CommandBuffer, 3732 _line_width: f32, 3733 ) { 3734 panic!(concat!("Unable to load ", stringify!(cmd_set_line_width))) 3735 } 3736 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineWidth\0"); 3737 let val = _f(cname); 3738 if val.is_null() { 3739 cmd_set_line_width 3740 } else { 3741 ::std::mem::transmute(val) 3742 } 3743 }, 3744 cmd_set_depth_bias: unsafe { 3745 extern "system" fn cmd_set_depth_bias( 3746 _command_buffer: CommandBuffer, 3747 _depth_bias_constant_factor: f32, 3748 _depth_bias_clamp: f32, 3749 _depth_bias_slope_factor: f32, 3750 ) { 3751 panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bias))) 3752 } 3753 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBias\0"); 3754 let val = _f(cname); 3755 if val.is_null() { 3756 cmd_set_depth_bias 3757 } else { 3758 ::std::mem::transmute(val) 3759 } 3760 }, 3761 cmd_set_blend_constants: unsafe { 3762 extern "system" fn cmd_set_blend_constants( 3763 _command_buffer: CommandBuffer, 3764 _blend_constants: *const [f32; 4], 3765 ) { 3766 panic!(concat!( 3767 "Unable to load ", 3768 stringify!(cmd_set_blend_constants) 3769 )) 3770 } 3771 let cname = 3772 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetBlendConstants\0"); 3773 let val = _f(cname); 3774 if val.is_null() { 3775 cmd_set_blend_constants 3776 } else { 3777 ::std::mem::transmute(val) 3778 } 3779 }, 3780 cmd_set_depth_bounds: unsafe { 3781 extern "system" fn cmd_set_depth_bounds( 3782 _command_buffer: CommandBuffer, 3783 _min_depth_bounds: f32, 3784 _max_depth_bounds: f32, 3785 ) { 3786 panic!(concat!("Unable to load ", stringify!(cmd_set_depth_bounds))) 3787 } 3788 let cname = 3789 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthBounds\0"); 3790 let val = _f(cname); 3791 if val.is_null() { 3792 cmd_set_depth_bounds 3793 } else { 3794 ::std::mem::transmute(val) 3795 } 3796 }, 3797 cmd_set_stencil_compare_mask: unsafe { 3798 extern "system" fn cmd_set_stencil_compare_mask( 3799 _command_buffer: CommandBuffer, 3800 _face_mask: StencilFaceFlags, 3801 _compare_mask: u32, 3802 ) { 3803 panic!(concat!( 3804 "Unable to load ", 3805 stringify!(cmd_set_stencil_compare_mask) 3806 )) 3807 } 3808 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 3809 b"vkCmdSetStencilCompareMask\0", 3810 ); 3811 let val = _f(cname); 3812 if val.is_null() { 3813 cmd_set_stencil_compare_mask 3814 } else { 3815 ::std::mem::transmute(val) 3816 } 3817 }, 3818 cmd_set_stencil_write_mask: unsafe { 3819 extern "system" fn cmd_set_stencil_write_mask( 3820 _command_buffer: CommandBuffer, 3821 _face_mask: StencilFaceFlags, 3822 _write_mask: u32, 3823 ) { 3824 panic!(concat!( 3825 "Unable to load ", 3826 stringify!(cmd_set_stencil_write_mask) 3827 )) 3828 } 3829 let cname = 3830 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilWriteMask\0"); 3831 let val = _f(cname); 3832 if val.is_null() { 3833 cmd_set_stencil_write_mask 3834 } else { 3835 ::std::mem::transmute(val) 3836 } 3837 }, 3838 cmd_set_stencil_reference: unsafe { 3839 extern "system" fn cmd_set_stencil_reference( 3840 _command_buffer: CommandBuffer, 3841 _face_mask: StencilFaceFlags, 3842 _reference: u32, 3843 ) { 3844 panic!(concat!( 3845 "Unable to load ", 3846 stringify!(cmd_set_stencil_reference) 3847 )) 3848 } 3849 let cname = 3850 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilReference\0"); 3851 let val = _f(cname); 3852 if val.is_null() { 3853 cmd_set_stencil_reference 3854 } else { 3855 ::std::mem::transmute(val) 3856 } 3857 }, 3858 cmd_bind_descriptor_sets: unsafe { 3859 extern "system" fn cmd_bind_descriptor_sets( 3860 _command_buffer: CommandBuffer, 3861 _pipeline_bind_point: PipelineBindPoint, 3862 _layout: PipelineLayout, 3863 _first_set: u32, 3864 _descriptor_set_count: u32, 3865 _p_descriptor_sets: *const DescriptorSet, 3866 _dynamic_offset_count: u32, 3867 _p_dynamic_offsets: *const u32, 3868 ) { 3869 panic!(concat!( 3870 "Unable to load ", 3871 stringify!(cmd_bind_descriptor_sets) 3872 )) 3873 } 3874 let cname = 3875 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindDescriptorSets\0"); 3876 let val = _f(cname); 3877 if val.is_null() { 3878 cmd_bind_descriptor_sets 3879 } else { 3880 ::std::mem::transmute(val) 3881 } 3882 }, 3883 cmd_bind_index_buffer: unsafe { 3884 extern "system" fn cmd_bind_index_buffer( 3885 _command_buffer: CommandBuffer, 3886 _buffer: Buffer, 3887 _offset: DeviceSize, 3888 _index_type: IndexType, 3889 ) { 3890 panic!(concat!( 3891 "Unable to load ", 3892 stringify!(cmd_bind_index_buffer) 3893 )) 3894 } 3895 let cname = 3896 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindIndexBuffer\0"); 3897 let val = _f(cname); 3898 if val.is_null() { 3899 cmd_bind_index_buffer 3900 } else { 3901 ::std::mem::transmute(val) 3902 } 3903 }, 3904 cmd_bind_vertex_buffers: unsafe { 3905 extern "system" fn cmd_bind_vertex_buffers( 3906 _command_buffer: CommandBuffer, 3907 _first_binding: u32, 3908 _binding_count: u32, 3909 _p_buffers: *const Buffer, 3910 _p_offsets: *const DeviceSize, 3911 ) { 3912 panic!(concat!( 3913 "Unable to load ", 3914 stringify!(cmd_bind_vertex_buffers) 3915 )) 3916 } 3917 let cname = 3918 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindVertexBuffers\0"); 3919 let val = _f(cname); 3920 if val.is_null() { 3921 cmd_bind_vertex_buffers 3922 } else { 3923 ::std::mem::transmute(val) 3924 } 3925 }, 3926 cmd_draw: unsafe { 3927 extern "system" fn cmd_draw( 3928 _command_buffer: CommandBuffer, 3929 _vertex_count: u32, 3930 _instance_count: u32, 3931 _first_vertex: u32, 3932 _first_instance: u32, 3933 ) { 3934 panic!(concat!("Unable to load ", stringify!(cmd_draw))) 3935 } 3936 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDraw\0"); 3937 let val = _f(cname); 3938 if val.is_null() { 3939 cmd_draw 3940 } else { 3941 ::std::mem::transmute(val) 3942 } 3943 }, 3944 cmd_draw_indexed: unsafe { 3945 extern "system" fn cmd_draw_indexed( 3946 _command_buffer: CommandBuffer, 3947 _index_count: u32, 3948 _instance_count: u32, 3949 _first_index: u32, 3950 _vertex_offset: i32, 3951 _first_instance: u32, 3952 ) { 3953 panic!(concat!("Unable to load ", stringify!(cmd_draw_indexed))) 3954 } 3955 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexed\0"); 3956 let val = _f(cname); 3957 if val.is_null() { 3958 cmd_draw_indexed 3959 } else { 3960 ::std::mem::transmute(val) 3961 } 3962 }, 3963 cmd_draw_indirect: unsafe { 3964 extern "system" fn cmd_draw_indirect( 3965 _command_buffer: CommandBuffer, 3966 _buffer: Buffer, 3967 _offset: DeviceSize, 3968 _draw_count: u32, 3969 _stride: u32, 3970 ) { 3971 panic!(concat!("Unable to load ", stringify!(cmd_draw_indirect))) 3972 } 3973 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirect\0"); 3974 let val = _f(cname); 3975 if val.is_null() { 3976 cmd_draw_indirect 3977 } else { 3978 ::std::mem::transmute(val) 3979 } 3980 }, 3981 cmd_draw_indexed_indirect: unsafe { 3982 extern "system" fn cmd_draw_indexed_indirect( 3983 _command_buffer: CommandBuffer, 3984 _buffer: Buffer, 3985 _offset: DeviceSize, 3986 _draw_count: u32, 3987 _stride: u32, 3988 ) { 3989 panic!(concat!( 3990 "Unable to load ", 3991 stringify!(cmd_draw_indexed_indirect) 3992 )) 3993 } 3994 let cname = 3995 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndexedIndirect\0"); 3996 let val = _f(cname); 3997 if val.is_null() { 3998 cmd_draw_indexed_indirect 3999 } else { 4000 ::std::mem::transmute(val) 4001 } 4002 }, 4003 cmd_dispatch: unsafe { 4004 extern "system" fn cmd_dispatch( 4005 _command_buffer: CommandBuffer, 4006 _group_count_x: u32, 4007 _group_count_y: u32, 4008 _group_count_z: u32, 4009 ) { 4010 panic!(concat!("Unable to load ", stringify!(cmd_dispatch))) 4011 } 4012 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatch\0"); 4013 let val = _f(cname); 4014 if val.is_null() { 4015 cmd_dispatch 4016 } else { 4017 ::std::mem::transmute(val) 4018 } 4019 }, 4020 cmd_dispatch_indirect: unsafe { 4021 extern "system" fn cmd_dispatch_indirect( 4022 _command_buffer: CommandBuffer, 4023 _buffer: Buffer, 4024 _offset: DeviceSize, 4025 ) { 4026 panic!(concat!( 4027 "Unable to load ", 4028 stringify!(cmd_dispatch_indirect) 4029 )) 4030 } 4031 let cname = 4032 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchIndirect\0"); 4033 let val = _f(cname); 4034 if val.is_null() { 4035 cmd_dispatch_indirect 4036 } else { 4037 ::std::mem::transmute(val) 4038 } 4039 }, 4040 cmd_copy_buffer: unsafe { 4041 extern "system" fn cmd_copy_buffer( 4042 _command_buffer: CommandBuffer, 4043 _src_buffer: Buffer, 4044 _dst_buffer: Buffer, 4045 _region_count: u32, 4046 _p_regions: *const BufferCopy, 4047 ) { 4048 panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer))) 4049 } 4050 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer\0"); 4051 let val = _f(cname); 4052 if val.is_null() { 4053 cmd_copy_buffer 4054 } else { 4055 ::std::mem::transmute(val) 4056 } 4057 }, 4058 cmd_copy_image: unsafe { 4059 extern "system" fn cmd_copy_image( 4060 _command_buffer: CommandBuffer, 4061 _src_image: Image, 4062 _src_image_layout: ImageLayout, 4063 _dst_image: Image, 4064 _dst_image_layout: ImageLayout, 4065 _region_count: u32, 4066 _p_regions: *const ImageCopy, 4067 ) { 4068 panic!(concat!("Unable to load ", stringify!(cmd_copy_image))) 4069 } 4070 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage\0"); 4071 let val = _f(cname); 4072 if val.is_null() { 4073 cmd_copy_image 4074 } else { 4075 ::std::mem::transmute(val) 4076 } 4077 }, 4078 cmd_blit_image: unsafe { 4079 extern "system" fn cmd_blit_image( 4080 _command_buffer: CommandBuffer, 4081 _src_image: Image, 4082 _src_image_layout: ImageLayout, 4083 _dst_image: Image, 4084 _dst_image_layout: ImageLayout, 4085 _region_count: u32, 4086 _p_regions: *const ImageBlit, 4087 _filter: Filter, 4088 ) { 4089 panic!(concat!("Unable to load ", stringify!(cmd_blit_image))) 4090 } 4091 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage\0"); 4092 let val = _f(cname); 4093 if val.is_null() { 4094 cmd_blit_image 4095 } else { 4096 ::std::mem::transmute(val) 4097 } 4098 }, 4099 cmd_copy_buffer_to_image: unsafe { 4100 extern "system" fn cmd_copy_buffer_to_image( 4101 _command_buffer: CommandBuffer, 4102 _src_buffer: Buffer, 4103 _dst_image: Image, 4104 _dst_image_layout: ImageLayout, 4105 _region_count: u32, 4106 _p_regions: *const BufferImageCopy, 4107 ) { 4108 panic!(concat!( 4109 "Unable to load ", 4110 stringify!(cmd_copy_buffer_to_image) 4111 )) 4112 } 4113 let cname = 4114 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBufferToImage\0"); 4115 let val = _f(cname); 4116 if val.is_null() { 4117 cmd_copy_buffer_to_image 4118 } else { 4119 ::std::mem::transmute(val) 4120 } 4121 }, 4122 cmd_copy_image_to_buffer: unsafe { 4123 extern "system" fn cmd_copy_image_to_buffer( 4124 _command_buffer: CommandBuffer, 4125 _src_image: Image, 4126 _src_image_layout: ImageLayout, 4127 _dst_buffer: Buffer, 4128 _region_count: u32, 4129 _p_regions: *const BufferImageCopy, 4130 ) { 4131 panic!(concat!( 4132 "Unable to load ", 4133 stringify!(cmd_copy_image_to_buffer) 4134 )) 4135 } 4136 let cname = 4137 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImageToBuffer\0"); 4138 let val = _f(cname); 4139 if val.is_null() { 4140 cmd_copy_image_to_buffer 4141 } else { 4142 ::std::mem::transmute(val) 4143 } 4144 }, 4145 cmd_update_buffer: unsafe { 4146 extern "system" fn cmd_update_buffer( 4147 _command_buffer: CommandBuffer, 4148 _dst_buffer: Buffer, 4149 _dst_offset: DeviceSize, 4150 _data_size: DeviceSize, 4151 _p_data: *const c_void, 4152 ) { 4153 panic!(concat!("Unable to load ", stringify!(cmd_update_buffer))) 4154 } 4155 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdUpdateBuffer\0"); 4156 let val = _f(cname); 4157 if val.is_null() { 4158 cmd_update_buffer 4159 } else { 4160 ::std::mem::transmute(val) 4161 } 4162 }, 4163 cmd_fill_buffer: unsafe { 4164 extern "system" fn cmd_fill_buffer( 4165 _command_buffer: CommandBuffer, 4166 _dst_buffer: Buffer, 4167 _dst_offset: DeviceSize, 4168 _size: DeviceSize, 4169 _data: u32, 4170 ) { 4171 panic!(concat!("Unable to load ", stringify!(cmd_fill_buffer))) 4172 } 4173 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdFillBuffer\0"); 4174 let val = _f(cname); 4175 if val.is_null() { 4176 cmd_fill_buffer 4177 } else { 4178 ::std::mem::transmute(val) 4179 } 4180 }, 4181 cmd_clear_color_image: unsafe { 4182 extern "system" fn cmd_clear_color_image( 4183 _command_buffer: CommandBuffer, 4184 _image: Image, 4185 _image_layout: ImageLayout, 4186 _p_color: *const ClearColorValue, 4187 _range_count: u32, 4188 _p_ranges: *const ImageSubresourceRange, 4189 ) { 4190 panic!(concat!( 4191 "Unable to load ", 4192 stringify!(cmd_clear_color_image) 4193 )) 4194 } 4195 let cname = 4196 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearColorImage\0"); 4197 let val = _f(cname); 4198 if val.is_null() { 4199 cmd_clear_color_image 4200 } else { 4201 ::std::mem::transmute(val) 4202 } 4203 }, 4204 cmd_clear_depth_stencil_image: unsafe { 4205 extern "system" fn cmd_clear_depth_stencil_image( 4206 _command_buffer: CommandBuffer, 4207 _image: Image, 4208 _image_layout: ImageLayout, 4209 _p_depth_stencil: *const ClearDepthStencilValue, 4210 _range_count: u32, 4211 _p_ranges: *const ImageSubresourceRange, 4212 ) { 4213 panic!(concat!( 4214 "Unable to load ", 4215 stringify!(cmd_clear_depth_stencil_image) 4216 )) 4217 } 4218 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 4219 b"vkCmdClearDepthStencilImage\0", 4220 ); 4221 let val = _f(cname); 4222 if val.is_null() { 4223 cmd_clear_depth_stencil_image 4224 } else { 4225 ::std::mem::transmute(val) 4226 } 4227 }, 4228 cmd_clear_attachments: unsafe { 4229 extern "system" fn cmd_clear_attachments( 4230 _command_buffer: CommandBuffer, 4231 _attachment_count: u32, 4232 _p_attachments: *const ClearAttachment, 4233 _rect_count: u32, 4234 _p_rects: *const ClearRect, 4235 ) { 4236 panic!(concat!( 4237 "Unable to load ", 4238 stringify!(cmd_clear_attachments) 4239 )) 4240 } 4241 let cname = 4242 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdClearAttachments\0"); 4243 let val = _f(cname); 4244 if val.is_null() { 4245 cmd_clear_attachments 4246 } else { 4247 ::std::mem::transmute(val) 4248 } 4249 }, 4250 cmd_resolve_image: unsafe { 4251 extern "system" fn cmd_resolve_image( 4252 _command_buffer: CommandBuffer, 4253 _src_image: Image, 4254 _src_image_layout: ImageLayout, 4255 _dst_image: Image, 4256 _dst_image_layout: ImageLayout, 4257 _region_count: u32, 4258 _p_regions: *const ImageResolve, 4259 ) { 4260 panic!(concat!("Unable to load ", stringify!(cmd_resolve_image))) 4261 } 4262 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage\0"); 4263 let val = _f(cname); 4264 if val.is_null() { 4265 cmd_resolve_image 4266 } else { 4267 ::std::mem::transmute(val) 4268 } 4269 }, 4270 cmd_set_event: unsafe { 4271 extern "system" fn cmd_set_event( 4272 _command_buffer: CommandBuffer, 4273 _event: Event, 4274 _stage_mask: PipelineStageFlags, 4275 ) { 4276 panic!(concat!("Unable to load ", stringify!(cmd_set_event))) 4277 } 4278 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent\0"); 4279 let val = _f(cname); 4280 if val.is_null() { 4281 cmd_set_event 4282 } else { 4283 ::std::mem::transmute(val) 4284 } 4285 }, 4286 cmd_reset_event: unsafe { 4287 extern "system" fn cmd_reset_event( 4288 _command_buffer: CommandBuffer, 4289 _event: Event, 4290 _stage_mask: PipelineStageFlags, 4291 ) { 4292 panic!(concat!("Unable to load ", stringify!(cmd_reset_event))) 4293 } 4294 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent\0"); 4295 let val = _f(cname); 4296 if val.is_null() { 4297 cmd_reset_event 4298 } else { 4299 ::std::mem::transmute(val) 4300 } 4301 }, 4302 cmd_wait_events: unsafe { 4303 extern "system" fn cmd_wait_events( 4304 _command_buffer: CommandBuffer, 4305 _event_count: u32, 4306 _p_events: *const Event, 4307 _src_stage_mask: PipelineStageFlags, 4308 _dst_stage_mask: PipelineStageFlags, 4309 _memory_barrier_count: u32, 4310 _p_memory_barriers: *const MemoryBarrier, 4311 _buffer_memory_barrier_count: u32, 4312 _p_buffer_memory_barriers: *const BufferMemoryBarrier, 4313 _image_memory_barrier_count: u32, 4314 _p_image_memory_barriers: *const ImageMemoryBarrier, 4315 ) { 4316 panic!(concat!("Unable to load ", stringify!(cmd_wait_events))) 4317 } 4318 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents\0"); 4319 let val = _f(cname); 4320 if val.is_null() { 4321 cmd_wait_events 4322 } else { 4323 ::std::mem::transmute(val) 4324 } 4325 }, 4326 cmd_pipeline_barrier: unsafe { 4327 extern "system" fn cmd_pipeline_barrier( 4328 _command_buffer: CommandBuffer, 4329 _src_stage_mask: PipelineStageFlags, 4330 _dst_stage_mask: PipelineStageFlags, 4331 _dependency_flags: DependencyFlags, 4332 _memory_barrier_count: u32, 4333 _p_memory_barriers: *const MemoryBarrier, 4334 _buffer_memory_barrier_count: u32, 4335 _p_buffer_memory_barriers: *const BufferMemoryBarrier, 4336 _image_memory_barrier_count: u32, 4337 _p_image_memory_barriers: *const ImageMemoryBarrier, 4338 ) { 4339 panic!(concat!("Unable to load ", stringify!(cmd_pipeline_barrier))) 4340 } 4341 let cname = 4342 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier\0"); 4343 let val = _f(cname); 4344 if val.is_null() { 4345 cmd_pipeline_barrier 4346 } else { 4347 ::std::mem::transmute(val) 4348 } 4349 }, 4350 cmd_begin_query: unsafe { 4351 extern "system" fn cmd_begin_query( 4352 _command_buffer: CommandBuffer, 4353 _query_pool: QueryPool, 4354 _query: u32, 4355 _flags: QueryControlFlags, 4356 ) { 4357 panic!(concat!("Unable to load ", stringify!(cmd_begin_query))) 4358 } 4359 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQuery\0"); 4360 let val = _f(cname); 4361 if val.is_null() { 4362 cmd_begin_query 4363 } else { 4364 ::std::mem::transmute(val) 4365 } 4366 }, 4367 cmd_end_query: unsafe { 4368 extern "system" fn cmd_end_query( 4369 _command_buffer: CommandBuffer, 4370 _query_pool: QueryPool, 4371 _query: u32, 4372 ) { 4373 panic!(concat!("Unable to load ", stringify!(cmd_end_query))) 4374 } 4375 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQuery\0"); 4376 let val = _f(cname); 4377 if val.is_null() { 4378 cmd_end_query 4379 } else { 4380 ::std::mem::transmute(val) 4381 } 4382 }, 4383 cmd_reset_query_pool: unsafe { 4384 extern "system" fn cmd_reset_query_pool( 4385 _command_buffer: CommandBuffer, 4386 _query_pool: QueryPool, 4387 _first_query: u32, 4388 _query_count: u32, 4389 ) { 4390 panic!(concat!("Unable to load ", stringify!(cmd_reset_query_pool))) 4391 } 4392 let cname = 4393 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetQueryPool\0"); 4394 let val = _f(cname); 4395 if val.is_null() { 4396 cmd_reset_query_pool 4397 } else { 4398 ::std::mem::transmute(val) 4399 } 4400 }, 4401 cmd_write_timestamp: unsafe { 4402 extern "system" fn cmd_write_timestamp( 4403 _command_buffer: CommandBuffer, 4404 _pipeline_stage: PipelineStageFlags, 4405 _query_pool: QueryPool, 4406 _query: u32, 4407 ) { 4408 panic!(concat!("Unable to load ", stringify!(cmd_write_timestamp))) 4409 } 4410 let cname = 4411 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp\0"); 4412 let val = _f(cname); 4413 if val.is_null() { 4414 cmd_write_timestamp 4415 } else { 4416 ::std::mem::transmute(val) 4417 } 4418 }, 4419 cmd_copy_query_pool_results: unsafe { 4420 extern "system" fn cmd_copy_query_pool_results( 4421 _command_buffer: CommandBuffer, 4422 _query_pool: QueryPool, 4423 _first_query: u32, 4424 _query_count: u32, 4425 _dst_buffer: Buffer, 4426 _dst_offset: DeviceSize, 4427 _stride: DeviceSize, 4428 _flags: QueryResultFlags, 4429 ) { 4430 panic!(concat!( 4431 "Unable to load ", 4432 stringify!(cmd_copy_query_pool_results) 4433 )) 4434 } 4435 let cname = 4436 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyQueryPoolResults\0"); 4437 let val = _f(cname); 4438 if val.is_null() { 4439 cmd_copy_query_pool_results 4440 } else { 4441 ::std::mem::transmute(val) 4442 } 4443 }, 4444 cmd_push_constants: unsafe { 4445 extern "system" fn cmd_push_constants( 4446 _command_buffer: CommandBuffer, 4447 _layout: PipelineLayout, 4448 _stage_flags: ShaderStageFlags, 4449 _offset: u32, 4450 _size: u32, 4451 _p_values: *const c_void, 4452 ) { 4453 panic!(concat!("Unable to load ", stringify!(cmd_push_constants))) 4454 } 4455 let cname = 4456 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushConstants\0"); 4457 let val = _f(cname); 4458 if val.is_null() { 4459 cmd_push_constants 4460 } else { 4461 ::std::mem::transmute(val) 4462 } 4463 }, 4464 cmd_begin_render_pass: unsafe { 4465 extern "system" fn cmd_begin_render_pass( 4466 _command_buffer: CommandBuffer, 4467 _p_render_pass_begin: *const RenderPassBeginInfo, 4468 _contents: SubpassContents, 4469 ) { 4470 panic!(concat!( 4471 "Unable to load ", 4472 stringify!(cmd_begin_render_pass) 4473 )) 4474 } 4475 let cname = 4476 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass\0"); 4477 let val = _f(cname); 4478 if val.is_null() { 4479 cmd_begin_render_pass 4480 } else { 4481 ::std::mem::transmute(val) 4482 } 4483 }, 4484 cmd_next_subpass: unsafe { 4485 extern "system" fn cmd_next_subpass( 4486 _command_buffer: CommandBuffer, 4487 _contents: SubpassContents, 4488 ) { 4489 panic!(concat!("Unable to load ", stringify!(cmd_next_subpass))) 4490 } 4491 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass\0"); 4492 let val = _f(cname); 4493 if val.is_null() { 4494 cmd_next_subpass 4495 } else { 4496 ::std::mem::transmute(val) 4497 } 4498 }, 4499 cmd_end_render_pass: unsafe { 4500 extern "system" fn cmd_end_render_pass(_command_buffer: CommandBuffer) { 4501 panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass))) 4502 } 4503 let cname = 4504 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass\0"); 4505 let val = _f(cname); 4506 if val.is_null() { 4507 cmd_end_render_pass 4508 } else { 4509 ::std::mem::transmute(val) 4510 } 4511 }, 4512 cmd_execute_commands: unsafe { 4513 extern "system" fn cmd_execute_commands( 4514 _command_buffer: CommandBuffer, 4515 _command_buffer_count: u32, 4516 _p_command_buffers: *const CommandBuffer, 4517 ) { 4518 panic!(concat!("Unable to load ", stringify!(cmd_execute_commands))) 4519 } 4520 let cname = 4521 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdExecuteCommands\0"); 4522 let val = _f(cname); 4523 if val.is_null() { 4524 cmd_execute_commands 4525 } else { 4526 ::std::mem::transmute(val) 4527 } 4528 }, 4529 } 4530 } 4531 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDevice.html>"] destroy_device(&self, device: Device, p_allocator: *const AllocationCallbacks)4532 pub unsafe fn destroy_device(&self, device: Device, p_allocator: *const AllocationCallbacks) { 4533 (self.destroy_device)(device, p_allocator) 4534 } 4535 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceQueue.html>"] get_device_queue( &self, device: Device, queue_family_index: u32, queue_index: u32, p_queue: *mut Queue, )4536 pub unsafe fn get_device_queue( 4537 &self, 4538 device: Device, 4539 queue_family_index: u32, 4540 queue_index: u32, 4541 p_queue: *mut Queue, 4542 ) { 4543 (self.get_device_queue)(device, queue_family_index, queue_index, p_queue) 4544 } 4545 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueSubmit.html>"] queue_submit( &self, queue: Queue, submit_count: u32, p_submits: *const SubmitInfo, fence: Fence, ) -> Result4546 pub unsafe fn queue_submit( 4547 &self, 4548 queue: Queue, 4549 submit_count: u32, 4550 p_submits: *const SubmitInfo, 4551 fence: Fence, 4552 ) -> Result { 4553 (self.queue_submit)(queue, submit_count, p_submits, fence) 4554 } 4555 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueWaitIdle.html>"] queue_wait_idle(&self, queue: Queue) -> Result4556 pub unsafe fn queue_wait_idle(&self, queue: Queue) -> Result { 4557 (self.queue_wait_idle)(queue) 4558 } 4559 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDeviceWaitIdle.html>"] device_wait_idle(&self, device: Device) -> Result4560 pub unsafe fn device_wait_idle(&self, device: Device) -> Result { 4561 (self.device_wait_idle)(device) 4562 } 4563 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateMemory.html>"] allocate_memory( &self, device: Device, p_allocate_info: *const MemoryAllocateInfo, p_allocator: *const AllocationCallbacks, p_memory: *mut DeviceMemory, ) -> Result4564 pub unsafe fn allocate_memory( 4565 &self, 4566 device: Device, 4567 p_allocate_info: *const MemoryAllocateInfo, 4568 p_allocator: *const AllocationCallbacks, 4569 p_memory: *mut DeviceMemory, 4570 ) -> Result { 4571 (self.allocate_memory)(device, p_allocate_info, p_allocator, p_memory) 4572 } 4573 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeMemory.html>"] free_memory( &self, device: Device, memory: DeviceMemory, p_allocator: *const AllocationCallbacks, )4574 pub unsafe fn free_memory( 4575 &self, 4576 device: Device, 4577 memory: DeviceMemory, 4578 p_allocator: *const AllocationCallbacks, 4579 ) { 4580 (self.free_memory)(device, memory, p_allocator) 4581 } 4582 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMapMemory.html>"] map_memory( &self, device: Device, memory: DeviceMemory, offset: DeviceSize, size: DeviceSize, flags: MemoryMapFlags, pp_data: *mut *mut c_void, ) -> Result4583 pub unsafe fn map_memory( 4584 &self, 4585 device: Device, 4586 memory: DeviceMemory, 4587 offset: DeviceSize, 4588 size: DeviceSize, 4589 flags: MemoryMapFlags, 4590 pp_data: *mut *mut c_void, 4591 ) -> Result { 4592 (self.map_memory)(device, memory, offset, size, flags, pp_data) 4593 } 4594 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUnmapMemory.html>"] unmap_memory(&self, device: Device, memory: DeviceMemory)4595 pub unsafe fn unmap_memory(&self, device: Device, memory: DeviceMemory) { 4596 (self.unmap_memory)(device, memory) 4597 } 4598 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFlushMappedMemoryRanges.html>"] flush_mapped_memory_ranges( &self, device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result4599 pub unsafe fn flush_mapped_memory_ranges( 4600 &self, 4601 device: Device, 4602 memory_range_count: u32, 4603 p_memory_ranges: *const MappedMemoryRange, 4604 ) -> Result { 4605 (self.flush_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) 4606 } 4607 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkInvalidateMappedMemoryRanges.html>"] invalidate_mapped_memory_ranges( &self, device: Device, memory_range_count: u32, p_memory_ranges: *const MappedMemoryRange, ) -> Result4608 pub unsafe fn invalidate_mapped_memory_ranges( 4609 &self, 4610 device: Device, 4611 memory_range_count: u32, 4612 p_memory_ranges: *const MappedMemoryRange, 4613 ) -> Result { 4614 (self.invalidate_mapped_memory_ranges)(device, memory_range_count, p_memory_ranges) 4615 } 4616 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryCommitment.html>"] get_device_memory_commitment( &self, device: Device, memory: DeviceMemory, p_committed_memory_in_bytes: *mut DeviceSize, )4617 pub unsafe fn get_device_memory_commitment( 4618 &self, 4619 device: Device, 4620 memory: DeviceMemory, 4621 p_committed_memory_in_bytes: *mut DeviceSize, 4622 ) { 4623 (self.get_device_memory_commitment)(device, memory, p_committed_memory_in_bytes) 4624 } 4625 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory.html>"] bind_buffer_memory( &self, device: Device, buffer: Buffer, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result4626 pub unsafe fn bind_buffer_memory( 4627 &self, 4628 device: Device, 4629 buffer: Buffer, 4630 memory: DeviceMemory, 4631 memory_offset: DeviceSize, 4632 ) -> Result { 4633 (self.bind_buffer_memory)(device, buffer, memory, memory_offset) 4634 } 4635 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory.html>"] bind_image_memory( &self, device: Device, image: Image, memory: DeviceMemory, memory_offset: DeviceSize, ) -> Result4636 pub unsafe fn bind_image_memory( 4637 &self, 4638 device: Device, 4639 image: Image, 4640 memory: DeviceMemory, 4641 memory_offset: DeviceSize, 4642 ) -> Result { 4643 (self.bind_image_memory)(device, image, memory, memory_offset) 4644 } 4645 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements.html>"] get_buffer_memory_requirements( &self, device: Device, buffer: Buffer, p_memory_requirements: *mut MemoryRequirements, )4646 pub unsafe fn get_buffer_memory_requirements( 4647 &self, 4648 device: Device, 4649 buffer: Buffer, 4650 p_memory_requirements: *mut MemoryRequirements, 4651 ) { 4652 (self.get_buffer_memory_requirements)(device, buffer, p_memory_requirements) 4653 } 4654 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements.html>"] get_image_memory_requirements( &self, device: Device, image: Image, p_memory_requirements: *mut MemoryRequirements, )4655 pub unsafe fn get_image_memory_requirements( 4656 &self, 4657 device: Device, 4658 image: Image, 4659 p_memory_requirements: *mut MemoryRequirements, 4660 ) { 4661 (self.get_image_memory_requirements)(device, image, p_memory_requirements) 4662 } 4663 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements.html>"] get_image_sparse_memory_requirements( &self, device: Device, image: Image, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, )4664 pub unsafe fn get_image_sparse_memory_requirements( 4665 &self, 4666 device: Device, 4667 image: Image, 4668 p_sparse_memory_requirement_count: *mut u32, 4669 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements, 4670 ) { 4671 (self.get_image_sparse_memory_requirements)( 4672 device, 4673 image, 4674 p_sparse_memory_requirement_count, 4675 p_sparse_memory_requirements, 4676 ) 4677 } 4678 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkQueueBindSparse.html>"] queue_bind_sparse( &self, queue: Queue, bind_info_count: u32, p_bind_info: *const BindSparseInfo, fence: Fence, ) -> Result4679 pub unsafe fn queue_bind_sparse( 4680 &self, 4681 queue: Queue, 4682 bind_info_count: u32, 4683 p_bind_info: *const BindSparseInfo, 4684 fence: Fence, 4685 ) -> Result { 4686 (self.queue_bind_sparse)(queue, bind_info_count, p_bind_info, fence) 4687 } 4688 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFence.html>"] create_fence( &self, device: Device, p_create_info: *const FenceCreateInfo, p_allocator: *const AllocationCallbacks, p_fence: *mut Fence, ) -> Result4689 pub unsafe fn create_fence( 4690 &self, 4691 device: Device, 4692 p_create_info: *const FenceCreateInfo, 4693 p_allocator: *const AllocationCallbacks, 4694 p_fence: *mut Fence, 4695 ) -> Result { 4696 (self.create_fence)(device, p_create_info, p_allocator, p_fence) 4697 } 4698 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFence.html>"] destroy_fence( &self, device: Device, fence: Fence, p_allocator: *const AllocationCallbacks, )4699 pub unsafe fn destroy_fence( 4700 &self, 4701 device: Device, 4702 fence: Fence, 4703 p_allocator: *const AllocationCallbacks, 4704 ) { 4705 (self.destroy_fence)(device, fence, p_allocator) 4706 } 4707 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetFences.html>"] reset_fences( &self, device: Device, fence_count: u32, p_fences: *const Fence, ) -> Result4708 pub unsafe fn reset_fences( 4709 &self, 4710 device: Device, 4711 fence_count: u32, 4712 p_fences: *const Fence, 4713 ) -> Result { 4714 (self.reset_fences)(device, fence_count, p_fences) 4715 } 4716 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetFenceStatus.html>"] get_fence_status(&self, device: Device, fence: Fence) -> Result4717 pub unsafe fn get_fence_status(&self, device: Device, fence: Fence) -> Result { 4718 (self.get_fence_status)(device, fence) 4719 } 4720 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitForFences.html>"] wait_for_fences( &self, device: Device, fence_count: u32, p_fences: *const Fence, wait_all: Bool32, timeout: u64, ) -> Result4721 pub unsafe fn wait_for_fences( 4722 &self, 4723 device: Device, 4724 fence_count: u32, 4725 p_fences: *const Fence, 4726 wait_all: Bool32, 4727 timeout: u64, 4728 ) -> Result { 4729 (self.wait_for_fences)(device, fence_count, p_fences, wait_all, timeout) 4730 } 4731 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSemaphore.html>"] create_semaphore( &self, device: Device, p_create_info: *const SemaphoreCreateInfo, p_allocator: *const AllocationCallbacks, p_semaphore: *mut Semaphore, ) -> Result4732 pub unsafe fn create_semaphore( 4733 &self, 4734 device: Device, 4735 p_create_info: *const SemaphoreCreateInfo, 4736 p_allocator: *const AllocationCallbacks, 4737 p_semaphore: *mut Semaphore, 4738 ) -> Result { 4739 (self.create_semaphore)(device, p_create_info, p_allocator, p_semaphore) 4740 } 4741 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySemaphore.html>"] destroy_semaphore( &self, device: Device, semaphore: Semaphore, p_allocator: *const AllocationCallbacks, )4742 pub unsafe fn destroy_semaphore( 4743 &self, 4744 device: Device, 4745 semaphore: Semaphore, 4746 p_allocator: *const AllocationCallbacks, 4747 ) { 4748 (self.destroy_semaphore)(device, semaphore, p_allocator) 4749 } 4750 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateEvent.html>"] create_event( &self, device: Device, p_create_info: *const EventCreateInfo, p_allocator: *const AllocationCallbacks, p_event: *mut Event, ) -> Result4751 pub unsafe fn create_event( 4752 &self, 4753 device: Device, 4754 p_create_info: *const EventCreateInfo, 4755 p_allocator: *const AllocationCallbacks, 4756 p_event: *mut Event, 4757 ) -> Result { 4758 (self.create_event)(device, p_create_info, p_allocator, p_event) 4759 } 4760 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyEvent.html>"] destroy_event( &self, device: Device, event: Event, p_allocator: *const AllocationCallbacks, )4761 pub unsafe fn destroy_event( 4762 &self, 4763 device: Device, 4764 event: Event, 4765 p_allocator: *const AllocationCallbacks, 4766 ) { 4767 (self.destroy_event)(device, event, p_allocator) 4768 } 4769 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetEventStatus.html>"] get_event_status(&self, device: Device, event: Event) -> Result4770 pub unsafe fn get_event_status(&self, device: Device, event: Event) -> Result { 4771 (self.get_event_status)(device, event) 4772 } 4773 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSetEvent.html>"] set_event(&self, device: Device, event: Event) -> Result4774 pub unsafe fn set_event(&self, device: Device, event: Event) -> Result { 4775 (self.set_event)(device, event) 4776 } 4777 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetEvent.html>"] reset_event(&self, device: Device, event: Event) -> Result4778 pub unsafe fn reset_event(&self, device: Device, event: Event) -> Result { 4779 (self.reset_event)(device, event) 4780 } 4781 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateQueryPool.html>"] create_query_pool( &self, device: Device, p_create_info: *const QueryPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_query_pool: *mut QueryPool, ) -> Result4782 pub unsafe fn create_query_pool( 4783 &self, 4784 device: Device, 4785 p_create_info: *const QueryPoolCreateInfo, 4786 p_allocator: *const AllocationCallbacks, 4787 p_query_pool: *mut QueryPool, 4788 ) -> Result { 4789 (self.create_query_pool)(device, p_create_info, p_allocator, p_query_pool) 4790 } 4791 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyQueryPool.html>"] destroy_query_pool( &self, device: Device, query_pool: QueryPool, p_allocator: *const AllocationCallbacks, )4792 pub unsafe fn destroy_query_pool( 4793 &self, 4794 device: Device, 4795 query_pool: QueryPool, 4796 p_allocator: *const AllocationCallbacks, 4797 ) { 4798 (self.destroy_query_pool)(device, query_pool, p_allocator) 4799 } 4800 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetQueryPoolResults.html>"] get_query_pool_results( &self, device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, data_size: usize, p_data: *mut c_void, stride: DeviceSize, flags: QueryResultFlags, ) -> Result4801 pub unsafe fn get_query_pool_results( 4802 &self, 4803 device: Device, 4804 query_pool: QueryPool, 4805 first_query: u32, 4806 query_count: u32, 4807 data_size: usize, 4808 p_data: *mut c_void, 4809 stride: DeviceSize, 4810 flags: QueryResultFlags, 4811 ) -> Result { 4812 (self.get_query_pool_results)( 4813 device, 4814 query_pool, 4815 first_query, 4816 query_count, 4817 data_size, 4818 p_data, 4819 stride, 4820 flags, 4821 ) 4822 } 4823 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBuffer.html>"] create_buffer( &self, device: Device, p_create_info: *const BufferCreateInfo, p_allocator: *const AllocationCallbacks, p_buffer: *mut Buffer, ) -> Result4824 pub unsafe fn create_buffer( 4825 &self, 4826 device: Device, 4827 p_create_info: *const BufferCreateInfo, 4828 p_allocator: *const AllocationCallbacks, 4829 p_buffer: *mut Buffer, 4830 ) -> Result { 4831 (self.create_buffer)(device, p_create_info, p_allocator, p_buffer) 4832 } 4833 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBuffer.html>"] destroy_buffer( &self, device: Device, buffer: Buffer, p_allocator: *const AllocationCallbacks, )4834 pub unsafe fn destroy_buffer( 4835 &self, 4836 device: Device, 4837 buffer: Buffer, 4838 p_allocator: *const AllocationCallbacks, 4839 ) { 4840 (self.destroy_buffer)(device, buffer, p_allocator) 4841 } 4842 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateBufferView.html>"] create_buffer_view( &self, device: Device, p_create_info: *const BufferViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut BufferView, ) -> Result4843 pub unsafe fn create_buffer_view( 4844 &self, 4845 device: Device, 4846 p_create_info: *const BufferViewCreateInfo, 4847 p_allocator: *const AllocationCallbacks, 4848 p_view: *mut BufferView, 4849 ) -> Result { 4850 (self.create_buffer_view)(device, p_create_info, p_allocator, p_view) 4851 } 4852 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyBufferView.html>"] destroy_buffer_view( &self, device: Device, buffer_view: BufferView, p_allocator: *const AllocationCallbacks, )4853 pub unsafe fn destroy_buffer_view( 4854 &self, 4855 device: Device, 4856 buffer_view: BufferView, 4857 p_allocator: *const AllocationCallbacks, 4858 ) { 4859 (self.destroy_buffer_view)(device, buffer_view, p_allocator) 4860 } 4861 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImage.html>"] create_image( &self, device: Device, p_create_info: *const ImageCreateInfo, p_allocator: *const AllocationCallbacks, p_image: *mut Image, ) -> Result4862 pub unsafe fn create_image( 4863 &self, 4864 device: Device, 4865 p_create_info: *const ImageCreateInfo, 4866 p_allocator: *const AllocationCallbacks, 4867 p_image: *mut Image, 4868 ) -> Result { 4869 (self.create_image)(device, p_create_info, p_allocator, p_image) 4870 } 4871 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImage.html>"] destroy_image( &self, device: Device, image: Image, p_allocator: *const AllocationCallbacks, )4872 pub unsafe fn destroy_image( 4873 &self, 4874 device: Device, 4875 image: Image, 4876 p_allocator: *const AllocationCallbacks, 4877 ) { 4878 (self.destroy_image)(device, image, p_allocator) 4879 } 4880 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSubresourceLayout.html>"] get_image_subresource_layout( &self, device: Device, image: Image, p_subresource: *const ImageSubresource, p_layout: *mut SubresourceLayout, )4881 pub unsafe fn get_image_subresource_layout( 4882 &self, 4883 device: Device, 4884 image: Image, 4885 p_subresource: *const ImageSubresource, 4886 p_layout: *mut SubresourceLayout, 4887 ) { 4888 (self.get_image_subresource_layout)(device, image, p_subresource, p_layout) 4889 } 4890 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateImageView.html>"] create_image_view( &self, device: Device, p_create_info: *const ImageViewCreateInfo, p_allocator: *const AllocationCallbacks, p_view: *mut ImageView, ) -> Result4891 pub unsafe fn create_image_view( 4892 &self, 4893 device: Device, 4894 p_create_info: *const ImageViewCreateInfo, 4895 p_allocator: *const AllocationCallbacks, 4896 p_view: *mut ImageView, 4897 ) -> Result { 4898 (self.create_image_view)(device, p_create_info, p_allocator, p_view) 4899 } 4900 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyImageView.html>"] destroy_image_view( &self, device: Device, image_view: ImageView, p_allocator: *const AllocationCallbacks, )4901 pub unsafe fn destroy_image_view( 4902 &self, 4903 device: Device, 4904 image_view: ImageView, 4905 p_allocator: *const AllocationCallbacks, 4906 ) { 4907 (self.destroy_image_view)(device, image_view, p_allocator) 4908 } 4909 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateShaderModule.html>"] create_shader_module( &self, device: Device, p_create_info: *const ShaderModuleCreateInfo, p_allocator: *const AllocationCallbacks, p_shader_module: *mut ShaderModule, ) -> Result4910 pub unsafe fn create_shader_module( 4911 &self, 4912 device: Device, 4913 p_create_info: *const ShaderModuleCreateInfo, 4914 p_allocator: *const AllocationCallbacks, 4915 p_shader_module: *mut ShaderModule, 4916 ) -> Result { 4917 (self.create_shader_module)(device, p_create_info, p_allocator, p_shader_module) 4918 } 4919 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyShaderModule.html>"] destroy_shader_module( &self, device: Device, shader_module: ShaderModule, p_allocator: *const AllocationCallbacks, )4920 pub unsafe fn destroy_shader_module( 4921 &self, 4922 device: Device, 4923 shader_module: ShaderModule, 4924 p_allocator: *const AllocationCallbacks, 4925 ) { 4926 (self.destroy_shader_module)(device, shader_module, p_allocator) 4927 } 4928 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineCache.html>"] create_pipeline_cache( &self, device: Device, p_create_info: *const PipelineCacheCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_cache: *mut PipelineCache, ) -> Result4929 pub unsafe fn create_pipeline_cache( 4930 &self, 4931 device: Device, 4932 p_create_info: *const PipelineCacheCreateInfo, 4933 p_allocator: *const AllocationCallbacks, 4934 p_pipeline_cache: *mut PipelineCache, 4935 ) -> Result { 4936 (self.create_pipeline_cache)(device, p_create_info, p_allocator, p_pipeline_cache) 4937 } 4938 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineCache.html>"] destroy_pipeline_cache( &self, device: Device, pipeline_cache: PipelineCache, p_allocator: *const AllocationCallbacks, )4939 pub unsafe fn destroy_pipeline_cache( 4940 &self, 4941 device: Device, 4942 pipeline_cache: PipelineCache, 4943 p_allocator: *const AllocationCallbacks, 4944 ) { 4945 (self.destroy_pipeline_cache)(device, pipeline_cache, p_allocator) 4946 } 4947 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPipelineCacheData.html>"] get_pipeline_cache_data( &self, device: Device, pipeline_cache: PipelineCache, p_data_size: *mut usize, p_data: *mut c_void, ) -> Result4948 pub unsafe fn get_pipeline_cache_data( 4949 &self, 4950 device: Device, 4951 pipeline_cache: PipelineCache, 4952 p_data_size: *mut usize, 4953 p_data: *mut c_void, 4954 ) -> Result { 4955 (self.get_pipeline_cache_data)(device, pipeline_cache, p_data_size, p_data) 4956 } 4957 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkMergePipelineCaches.html>"] merge_pipeline_caches( &self, device: Device, dst_cache: PipelineCache, src_cache_count: u32, p_src_caches: *const PipelineCache, ) -> Result4958 pub unsafe fn merge_pipeline_caches( 4959 &self, 4960 device: Device, 4961 dst_cache: PipelineCache, 4962 src_cache_count: u32, 4963 p_src_caches: *const PipelineCache, 4964 ) -> Result { 4965 (self.merge_pipeline_caches)(device, dst_cache, src_cache_count, p_src_caches) 4966 } 4967 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateGraphicsPipelines.html>"] create_graphics_pipelines( &self, device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const GraphicsPipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result4968 pub unsafe fn create_graphics_pipelines( 4969 &self, 4970 device: Device, 4971 pipeline_cache: PipelineCache, 4972 create_info_count: u32, 4973 p_create_infos: *const GraphicsPipelineCreateInfo, 4974 p_allocator: *const AllocationCallbacks, 4975 p_pipelines: *mut Pipeline, 4976 ) -> Result { 4977 (self.create_graphics_pipelines)( 4978 device, 4979 pipeline_cache, 4980 create_info_count, 4981 p_create_infos, 4982 p_allocator, 4983 p_pipelines, 4984 ) 4985 } 4986 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateComputePipelines.html>"] create_compute_pipelines( &self, device: Device, pipeline_cache: PipelineCache, create_info_count: u32, p_create_infos: *const ComputePipelineCreateInfo, p_allocator: *const AllocationCallbacks, p_pipelines: *mut Pipeline, ) -> Result4987 pub unsafe fn create_compute_pipelines( 4988 &self, 4989 device: Device, 4990 pipeline_cache: PipelineCache, 4991 create_info_count: u32, 4992 p_create_infos: *const ComputePipelineCreateInfo, 4993 p_allocator: *const AllocationCallbacks, 4994 p_pipelines: *mut Pipeline, 4995 ) -> Result { 4996 (self.create_compute_pipelines)( 4997 device, 4998 pipeline_cache, 4999 create_info_count, 5000 p_create_infos, 5001 p_allocator, 5002 p_pipelines, 5003 ) 5004 } 5005 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipeline.html>"] destroy_pipeline( &self, device: Device, pipeline: Pipeline, p_allocator: *const AllocationCallbacks, )5006 pub unsafe fn destroy_pipeline( 5007 &self, 5008 device: Device, 5009 pipeline: Pipeline, 5010 p_allocator: *const AllocationCallbacks, 5011 ) { 5012 (self.destroy_pipeline)(device, pipeline, p_allocator) 5013 } 5014 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreatePipelineLayout.html>"] create_pipeline_layout( &self, device: Device, p_create_info: *const PipelineLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_pipeline_layout: *mut PipelineLayout, ) -> Result5015 pub unsafe fn create_pipeline_layout( 5016 &self, 5017 device: Device, 5018 p_create_info: *const PipelineLayoutCreateInfo, 5019 p_allocator: *const AllocationCallbacks, 5020 p_pipeline_layout: *mut PipelineLayout, 5021 ) -> Result { 5022 (self.create_pipeline_layout)(device, p_create_info, p_allocator, p_pipeline_layout) 5023 } 5024 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyPipelineLayout.html>"] destroy_pipeline_layout( &self, device: Device, pipeline_layout: PipelineLayout, p_allocator: *const AllocationCallbacks, )5025 pub unsafe fn destroy_pipeline_layout( 5026 &self, 5027 device: Device, 5028 pipeline_layout: PipelineLayout, 5029 p_allocator: *const AllocationCallbacks, 5030 ) { 5031 (self.destroy_pipeline_layout)(device, pipeline_layout, p_allocator) 5032 } 5033 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSampler.html>"] create_sampler( &self, device: Device, p_create_info: *const SamplerCreateInfo, p_allocator: *const AllocationCallbacks, p_sampler: *mut Sampler, ) -> Result5034 pub unsafe fn create_sampler( 5035 &self, 5036 device: Device, 5037 p_create_info: *const SamplerCreateInfo, 5038 p_allocator: *const AllocationCallbacks, 5039 p_sampler: *mut Sampler, 5040 ) -> Result { 5041 (self.create_sampler)(device, p_create_info, p_allocator, p_sampler) 5042 } 5043 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySampler.html>"] destroy_sampler( &self, device: Device, sampler: Sampler, p_allocator: *const AllocationCallbacks, )5044 pub unsafe fn destroy_sampler( 5045 &self, 5046 device: Device, 5047 sampler: Sampler, 5048 p_allocator: *const AllocationCallbacks, 5049 ) { 5050 (self.destroy_sampler)(device, sampler, p_allocator) 5051 } 5052 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorSetLayout.html>"] create_descriptor_set_layout( &self, device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_allocator: *const AllocationCallbacks, p_set_layout: *mut DescriptorSetLayout, ) -> Result5053 pub unsafe fn create_descriptor_set_layout( 5054 &self, 5055 device: Device, 5056 p_create_info: *const DescriptorSetLayoutCreateInfo, 5057 p_allocator: *const AllocationCallbacks, 5058 p_set_layout: *mut DescriptorSetLayout, 5059 ) -> Result { 5060 (self.create_descriptor_set_layout)(device, p_create_info, p_allocator, p_set_layout) 5061 } 5062 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorSetLayout.html>"] destroy_descriptor_set_layout( &self, device: Device, descriptor_set_layout: DescriptorSetLayout, p_allocator: *const AllocationCallbacks, )5063 pub unsafe fn destroy_descriptor_set_layout( 5064 &self, 5065 device: Device, 5066 descriptor_set_layout: DescriptorSetLayout, 5067 p_allocator: *const AllocationCallbacks, 5068 ) { 5069 (self.destroy_descriptor_set_layout)(device, descriptor_set_layout, p_allocator) 5070 } 5071 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorPool.html>"] create_descriptor_pool( &self, device: Device, p_create_info: *const DescriptorPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_pool: *mut DescriptorPool, ) -> Result5072 pub unsafe fn create_descriptor_pool( 5073 &self, 5074 device: Device, 5075 p_create_info: *const DescriptorPoolCreateInfo, 5076 p_allocator: *const AllocationCallbacks, 5077 p_descriptor_pool: *mut DescriptorPool, 5078 ) -> Result { 5079 (self.create_descriptor_pool)(device, p_create_info, p_allocator, p_descriptor_pool) 5080 } 5081 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorPool.html>"] destroy_descriptor_pool( &self, device: Device, descriptor_pool: DescriptorPool, p_allocator: *const AllocationCallbacks, )5082 pub unsafe fn destroy_descriptor_pool( 5083 &self, 5084 device: Device, 5085 descriptor_pool: DescriptorPool, 5086 p_allocator: *const AllocationCallbacks, 5087 ) { 5088 (self.destroy_descriptor_pool)(device, descriptor_pool, p_allocator) 5089 } 5090 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetDescriptorPool.html>"] reset_descriptor_pool( &self, device: Device, descriptor_pool: DescriptorPool, flags: DescriptorPoolResetFlags, ) -> Result5091 pub unsafe fn reset_descriptor_pool( 5092 &self, 5093 device: Device, 5094 descriptor_pool: DescriptorPool, 5095 flags: DescriptorPoolResetFlags, 5096 ) -> Result { 5097 (self.reset_descriptor_pool)(device, descriptor_pool, flags) 5098 } 5099 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateDescriptorSets.html>"] allocate_descriptor_sets( &self, device: Device, p_allocate_info: *const DescriptorSetAllocateInfo, p_descriptor_sets: *mut DescriptorSet, ) -> Result5100 pub unsafe fn allocate_descriptor_sets( 5101 &self, 5102 device: Device, 5103 p_allocate_info: *const DescriptorSetAllocateInfo, 5104 p_descriptor_sets: *mut DescriptorSet, 5105 ) -> Result { 5106 (self.allocate_descriptor_sets)(device, p_allocate_info, p_descriptor_sets) 5107 } 5108 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeDescriptorSets.html>"] free_descriptor_sets( &self, device: Device, descriptor_pool: DescriptorPool, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, ) -> Result5109 pub unsafe fn free_descriptor_sets( 5110 &self, 5111 device: Device, 5112 descriptor_pool: DescriptorPool, 5113 descriptor_set_count: u32, 5114 p_descriptor_sets: *const DescriptorSet, 5115 ) -> Result { 5116 (self.free_descriptor_sets)( 5117 device, 5118 descriptor_pool, 5119 descriptor_set_count, 5120 p_descriptor_sets, 5121 ) 5122 } 5123 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSets.html>"] update_descriptor_sets( &self, device: Device, descriptor_write_count: u32, p_descriptor_writes: *const WriteDescriptorSet, descriptor_copy_count: u32, p_descriptor_copies: *const CopyDescriptorSet, )5124 pub unsafe fn update_descriptor_sets( 5125 &self, 5126 device: Device, 5127 descriptor_write_count: u32, 5128 p_descriptor_writes: *const WriteDescriptorSet, 5129 descriptor_copy_count: u32, 5130 p_descriptor_copies: *const CopyDescriptorSet, 5131 ) { 5132 (self.update_descriptor_sets)( 5133 device, 5134 descriptor_write_count, 5135 p_descriptor_writes, 5136 descriptor_copy_count, 5137 p_descriptor_copies, 5138 ) 5139 } 5140 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateFramebuffer.html>"] create_framebuffer( &self, device: Device, p_create_info: *const FramebufferCreateInfo, p_allocator: *const AllocationCallbacks, p_framebuffer: *mut Framebuffer, ) -> Result5141 pub unsafe fn create_framebuffer( 5142 &self, 5143 device: Device, 5144 p_create_info: *const FramebufferCreateInfo, 5145 p_allocator: *const AllocationCallbacks, 5146 p_framebuffer: *mut Framebuffer, 5147 ) -> Result { 5148 (self.create_framebuffer)(device, p_create_info, p_allocator, p_framebuffer) 5149 } 5150 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyFramebuffer.html>"] destroy_framebuffer( &self, device: Device, framebuffer: Framebuffer, p_allocator: *const AllocationCallbacks, )5151 pub unsafe fn destroy_framebuffer( 5152 &self, 5153 device: Device, 5154 framebuffer: Framebuffer, 5155 p_allocator: *const AllocationCallbacks, 5156 ) { 5157 (self.destroy_framebuffer)(device, framebuffer, p_allocator) 5158 } 5159 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass.html>"] create_render_pass( &self, device: Device, p_create_info: *const RenderPassCreateInfo, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result5160 pub unsafe fn create_render_pass( 5161 &self, 5162 device: Device, 5163 p_create_info: *const RenderPassCreateInfo, 5164 p_allocator: *const AllocationCallbacks, 5165 p_render_pass: *mut RenderPass, 5166 ) -> Result { 5167 (self.create_render_pass)(device, p_create_info, p_allocator, p_render_pass) 5168 } 5169 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyRenderPass.html>"] destroy_render_pass( &self, device: Device, render_pass: RenderPass, p_allocator: *const AllocationCallbacks, )5170 pub unsafe fn destroy_render_pass( 5171 &self, 5172 device: Device, 5173 render_pass: RenderPass, 5174 p_allocator: *const AllocationCallbacks, 5175 ) { 5176 (self.destroy_render_pass)(device, render_pass, p_allocator) 5177 } 5178 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetRenderAreaGranularity.html>"] get_render_area_granularity( &self, device: Device, render_pass: RenderPass, p_granularity: *mut Extent2D, )5179 pub unsafe fn get_render_area_granularity( 5180 &self, 5181 device: Device, 5182 render_pass: RenderPass, 5183 p_granularity: *mut Extent2D, 5184 ) { 5185 (self.get_render_area_granularity)(device, render_pass, p_granularity) 5186 } 5187 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateCommandPool.html>"] create_command_pool( &self, device: Device, p_create_info: *const CommandPoolCreateInfo, p_allocator: *const AllocationCallbacks, p_command_pool: *mut CommandPool, ) -> Result5188 pub unsafe fn create_command_pool( 5189 &self, 5190 device: Device, 5191 p_create_info: *const CommandPoolCreateInfo, 5192 p_allocator: *const AllocationCallbacks, 5193 p_command_pool: *mut CommandPool, 5194 ) -> Result { 5195 (self.create_command_pool)(device, p_create_info, p_allocator, p_command_pool) 5196 } 5197 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyCommandPool.html>"] destroy_command_pool( &self, device: Device, command_pool: CommandPool, p_allocator: *const AllocationCallbacks, )5198 pub unsafe fn destroy_command_pool( 5199 &self, 5200 device: Device, 5201 command_pool: CommandPool, 5202 p_allocator: *const AllocationCallbacks, 5203 ) { 5204 (self.destroy_command_pool)(device, command_pool, p_allocator) 5205 } 5206 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandPool.html>"] reset_command_pool( &self, device: Device, command_pool: CommandPool, flags: CommandPoolResetFlags, ) -> Result5207 pub unsafe fn reset_command_pool( 5208 &self, 5209 device: Device, 5210 command_pool: CommandPool, 5211 flags: CommandPoolResetFlags, 5212 ) -> Result { 5213 (self.reset_command_pool)(device, command_pool, flags) 5214 } 5215 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkAllocateCommandBuffers.html>"] allocate_command_buffers( &self, device: Device, p_allocate_info: *const CommandBufferAllocateInfo, p_command_buffers: *mut CommandBuffer, ) -> Result5216 pub unsafe fn allocate_command_buffers( 5217 &self, 5218 device: Device, 5219 p_allocate_info: *const CommandBufferAllocateInfo, 5220 p_command_buffers: *mut CommandBuffer, 5221 ) -> Result { 5222 (self.allocate_command_buffers)(device, p_allocate_info, p_command_buffers) 5223 } 5224 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkFreeCommandBuffers.html>"] free_command_buffers( &self, device: Device, command_pool: CommandPool, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, )5225 pub unsafe fn free_command_buffers( 5226 &self, 5227 device: Device, 5228 command_pool: CommandPool, 5229 command_buffer_count: u32, 5230 p_command_buffers: *const CommandBuffer, 5231 ) { 5232 (self.free_command_buffers)( 5233 device, 5234 command_pool, 5235 command_buffer_count, 5236 p_command_buffers, 5237 ) 5238 } 5239 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBeginCommandBuffer.html>"] begin_command_buffer( &self, command_buffer: CommandBuffer, p_begin_info: *const CommandBufferBeginInfo, ) -> Result5240 pub unsafe fn begin_command_buffer( 5241 &self, 5242 command_buffer: CommandBuffer, 5243 p_begin_info: *const CommandBufferBeginInfo, 5244 ) -> Result { 5245 (self.begin_command_buffer)(command_buffer, p_begin_info) 5246 } 5247 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEndCommandBuffer.html>"] end_command_buffer(&self, command_buffer: CommandBuffer) -> Result5248 pub unsafe fn end_command_buffer(&self, command_buffer: CommandBuffer) -> Result { 5249 (self.end_command_buffer)(command_buffer) 5250 } 5251 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetCommandBuffer.html>"] reset_command_buffer( &self, command_buffer: CommandBuffer, flags: CommandBufferResetFlags, ) -> Result5252 pub unsafe fn reset_command_buffer( 5253 &self, 5254 command_buffer: CommandBuffer, 5255 flags: CommandBufferResetFlags, 5256 ) -> Result { 5257 (self.reset_command_buffer)(command_buffer, flags) 5258 } 5259 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindPipeline.html>"] cmd_bind_pipeline( &self, command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, pipeline: Pipeline, )5260 pub unsafe fn cmd_bind_pipeline( 5261 &self, 5262 command_buffer: CommandBuffer, 5263 pipeline_bind_point: PipelineBindPoint, 5264 pipeline: Pipeline, 5265 ) { 5266 (self.cmd_bind_pipeline)(command_buffer, pipeline_bind_point, pipeline) 5267 } 5268 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetViewport.html>"] cmd_set_viewport( &self, command_buffer: CommandBuffer, first_viewport: u32, viewport_count: u32, p_viewports: *const Viewport, )5269 pub unsafe fn cmd_set_viewport( 5270 &self, 5271 command_buffer: CommandBuffer, 5272 first_viewport: u32, 5273 viewport_count: u32, 5274 p_viewports: *const Viewport, 5275 ) { 5276 (self.cmd_set_viewport)(command_buffer, first_viewport, viewport_count, p_viewports) 5277 } 5278 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetScissor.html>"] cmd_set_scissor( &self, command_buffer: CommandBuffer, first_scissor: u32, scissor_count: u32, p_scissors: *const Rect2D, )5279 pub unsafe fn cmd_set_scissor( 5280 &self, 5281 command_buffer: CommandBuffer, 5282 first_scissor: u32, 5283 scissor_count: u32, 5284 p_scissors: *const Rect2D, 5285 ) { 5286 (self.cmd_set_scissor)(command_buffer, first_scissor, scissor_count, p_scissors) 5287 } 5288 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetLineWidth.html>"] cmd_set_line_width(&self, command_buffer: CommandBuffer, line_width: f32)5289 pub unsafe fn cmd_set_line_width(&self, command_buffer: CommandBuffer, line_width: f32) { 5290 (self.cmd_set_line_width)(command_buffer, line_width) 5291 } 5292 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBias.html>"] cmd_set_depth_bias( &self, command_buffer: CommandBuffer, depth_bias_constant_factor: f32, depth_bias_clamp: f32, depth_bias_slope_factor: f32, )5293 pub unsafe fn cmd_set_depth_bias( 5294 &self, 5295 command_buffer: CommandBuffer, 5296 depth_bias_constant_factor: f32, 5297 depth_bias_clamp: f32, 5298 depth_bias_slope_factor: f32, 5299 ) { 5300 (self.cmd_set_depth_bias)( 5301 command_buffer, 5302 depth_bias_constant_factor, 5303 depth_bias_clamp, 5304 depth_bias_slope_factor, 5305 ) 5306 } 5307 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetBlendConstants.html>"] cmd_set_blend_constants( &self, command_buffer: CommandBuffer, blend_constants: *const [f32; 4], )5308 pub unsafe fn cmd_set_blend_constants( 5309 &self, 5310 command_buffer: CommandBuffer, 5311 blend_constants: *const [f32; 4], 5312 ) { 5313 (self.cmd_set_blend_constants)(command_buffer, blend_constants) 5314 } 5315 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDepthBounds.html>"] cmd_set_depth_bounds( &self, command_buffer: CommandBuffer, min_depth_bounds: f32, max_depth_bounds: f32, )5316 pub unsafe fn cmd_set_depth_bounds( 5317 &self, 5318 command_buffer: CommandBuffer, 5319 min_depth_bounds: f32, 5320 max_depth_bounds: f32, 5321 ) { 5322 (self.cmd_set_depth_bounds)(command_buffer, min_depth_bounds, max_depth_bounds) 5323 } 5324 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilCompareMask.html>"] cmd_set_stencil_compare_mask( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, compare_mask: u32, )5325 pub unsafe fn cmd_set_stencil_compare_mask( 5326 &self, 5327 command_buffer: CommandBuffer, 5328 face_mask: StencilFaceFlags, 5329 compare_mask: u32, 5330 ) { 5331 (self.cmd_set_stencil_compare_mask)(command_buffer, face_mask, compare_mask) 5332 } 5333 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilWriteMask.html>"] cmd_set_stencil_write_mask( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, write_mask: u32, )5334 pub unsafe fn cmd_set_stencil_write_mask( 5335 &self, 5336 command_buffer: CommandBuffer, 5337 face_mask: StencilFaceFlags, 5338 write_mask: u32, 5339 ) { 5340 (self.cmd_set_stencil_write_mask)(command_buffer, face_mask, write_mask) 5341 } 5342 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetStencilReference.html>"] cmd_set_stencil_reference( &self, command_buffer: CommandBuffer, face_mask: StencilFaceFlags, reference: u32, )5343 pub unsafe fn cmd_set_stencil_reference( 5344 &self, 5345 command_buffer: CommandBuffer, 5346 face_mask: StencilFaceFlags, 5347 reference: u32, 5348 ) { 5349 (self.cmd_set_stencil_reference)(command_buffer, face_mask, reference) 5350 } 5351 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindDescriptorSets.html>"] cmd_bind_descriptor_sets( &self, command_buffer: CommandBuffer, pipeline_bind_point: PipelineBindPoint, layout: PipelineLayout, first_set: u32, descriptor_set_count: u32, p_descriptor_sets: *const DescriptorSet, dynamic_offset_count: u32, p_dynamic_offsets: *const u32, )5352 pub unsafe fn cmd_bind_descriptor_sets( 5353 &self, 5354 command_buffer: CommandBuffer, 5355 pipeline_bind_point: PipelineBindPoint, 5356 layout: PipelineLayout, 5357 first_set: u32, 5358 descriptor_set_count: u32, 5359 p_descriptor_sets: *const DescriptorSet, 5360 dynamic_offset_count: u32, 5361 p_dynamic_offsets: *const u32, 5362 ) { 5363 (self.cmd_bind_descriptor_sets)( 5364 command_buffer, 5365 pipeline_bind_point, 5366 layout, 5367 first_set, 5368 descriptor_set_count, 5369 p_descriptor_sets, 5370 dynamic_offset_count, 5371 p_dynamic_offsets, 5372 ) 5373 } 5374 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindIndexBuffer.html>"] cmd_bind_index_buffer( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, index_type: IndexType, )5375 pub unsafe fn cmd_bind_index_buffer( 5376 &self, 5377 command_buffer: CommandBuffer, 5378 buffer: Buffer, 5379 offset: DeviceSize, 5380 index_type: IndexType, 5381 ) { 5382 (self.cmd_bind_index_buffer)(command_buffer, buffer, offset, index_type) 5383 } 5384 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBindVertexBuffers.html>"] cmd_bind_vertex_buffers( &self, command_buffer: CommandBuffer, first_binding: u32, binding_count: u32, p_buffers: *const Buffer, p_offsets: *const DeviceSize, )5385 pub unsafe fn cmd_bind_vertex_buffers( 5386 &self, 5387 command_buffer: CommandBuffer, 5388 first_binding: u32, 5389 binding_count: u32, 5390 p_buffers: *const Buffer, 5391 p_offsets: *const DeviceSize, 5392 ) { 5393 (self.cmd_bind_vertex_buffers)( 5394 command_buffer, 5395 first_binding, 5396 binding_count, 5397 p_buffers, 5398 p_offsets, 5399 ) 5400 } 5401 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDraw.html>"] cmd_draw( &self, command_buffer: CommandBuffer, vertex_count: u32, instance_count: u32, first_vertex: u32, first_instance: u32, )5402 pub unsafe fn cmd_draw( 5403 &self, 5404 command_buffer: CommandBuffer, 5405 vertex_count: u32, 5406 instance_count: u32, 5407 first_vertex: u32, 5408 first_instance: u32, 5409 ) { 5410 (self.cmd_draw)( 5411 command_buffer, 5412 vertex_count, 5413 instance_count, 5414 first_vertex, 5415 first_instance, 5416 ) 5417 } 5418 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexed.html>"] cmd_draw_indexed( &self, command_buffer: CommandBuffer, index_count: u32, instance_count: u32, first_index: u32, vertex_offset: i32, first_instance: u32, )5419 pub unsafe fn cmd_draw_indexed( 5420 &self, 5421 command_buffer: CommandBuffer, 5422 index_count: u32, 5423 instance_count: u32, 5424 first_index: u32, 5425 vertex_offset: i32, 5426 first_instance: u32, 5427 ) { 5428 (self.cmd_draw_indexed)( 5429 command_buffer, 5430 index_count, 5431 instance_count, 5432 first_index, 5433 vertex_offset, 5434 first_instance, 5435 ) 5436 } 5437 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirect.html>"] cmd_draw_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, )5438 pub unsafe fn cmd_draw_indirect( 5439 &self, 5440 command_buffer: CommandBuffer, 5441 buffer: Buffer, 5442 offset: DeviceSize, 5443 draw_count: u32, 5444 stride: u32, 5445 ) { 5446 (self.cmd_draw_indirect)(command_buffer, buffer, offset, draw_count, stride) 5447 } 5448 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirect.html>"] cmd_draw_indexed_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, draw_count: u32, stride: u32, )5449 pub unsafe fn cmd_draw_indexed_indirect( 5450 &self, 5451 command_buffer: CommandBuffer, 5452 buffer: Buffer, 5453 offset: DeviceSize, 5454 draw_count: u32, 5455 stride: u32, 5456 ) { 5457 (self.cmd_draw_indexed_indirect)(command_buffer, buffer, offset, draw_count, stride) 5458 } 5459 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatch.html>"] cmd_dispatch( &self, command_buffer: CommandBuffer, group_count_x: u32, group_count_y: u32, group_count_z: u32, )5460 pub unsafe fn cmd_dispatch( 5461 &self, 5462 command_buffer: CommandBuffer, 5463 group_count_x: u32, 5464 group_count_y: u32, 5465 group_count_z: u32, 5466 ) { 5467 (self.cmd_dispatch)(command_buffer, group_count_x, group_count_y, group_count_z) 5468 } 5469 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchIndirect.html>"] cmd_dispatch_indirect( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, )5470 pub unsafe fn cmd_dispatch_indirect( 5471 &self, 5472 command_buffer: CommandBuffer, 5473 buffer: Buffer, 5474 offset: DeviceSize, 5475 ) { 5476 (self.cmd_dispatch_indirect)(command_buffer, buffer, offset) 5477 } 5478 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBuffer.html>"] cmd_copy_buffer( &self, command_buffer: CommandBuffer, src_buffer: Buffer, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferCopy, )5479 pub unsafe fn cmd_copy_buffer( 5480 &self, 5481 command_buffer: CommandBuffer, 5482 src_buffer: Buffer, 5483 dst_buffer: Buffer, 5484 region_count: u32, 5485 p_regions: *const BufferCopy, 5486 ) { 5487 (self.cmd_copy_buffer)( 5488 command_buffer, 5489 src_buffer, 5490 dst_buffer, 5491 region_count, 5492 p_regions, 5493 ) 5494 } 5495 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImage.html>"] cmd_copy_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageCopy, )5496 pub unsafe fn cmd_copy_image( 5497 &self, 5498 command_buffer: CommandBuffer, 5499 src_image: Image, 5500 src_image_layout: ImageLayout, 5501 dst_image: Image, 5502 dst_image_layout: ImageLayout, 5503 region_count: u32, 5504 p_regions: *const ImageCopy, 5505 ) { 5506 (self.cmd_copy_image)( 5507 command_buffer, 5508 src_image, 5509 src_image_layout, 5510 dst_image, 5511 dst_image_layout, 5512 region_count, 5513 p_regions, 5514 ) 5515 } 5516 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBlitImage.html>"] cmd_blit_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageBlit, filter: Filter, )5517 pub unsafe fn cmd_blit_image( 5518 &self, 5519 command_buffer: CommandBuffer, 5520 src_image: Image, 5521 src_image_layout: ImageLayout, 5522 dst_image: Image, 5523 dst_image_layout: ImageLayout, 5524 region_count: u32, 5525 p_regions: *const ImageBlit, 5526 filter: Filter, 5527 ) { 5528 (self.cmd_blit_image)( 5529 command_buffer, 5530 src_image, 5531 src_image_layout, 5532 dst_image, 5533 dst_image_layout, 5534 region_count, 5535 p_regions, 5536 filter, 5537 ) 5538 } 5539 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyBufferToImage.html>"] cmd_copy_buffer_to_image( &self, command_buffer: CommandBuffer, src_buffer: Buffer, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const BufferImageCopy, )5540 pub unsafe fn cmd_copy_buffer_to_image( 5541 &self, 5542 command_buffer: CommandBuffer, 5543 src_buffer: Buffer, 5544 dst_image: Image, 5545 dst_image_layout: ImageLayout, 5546 region_count: u32, 5547 p_regions: *const BufferImageCopy, 5548 ) { 5549 (self.cmd_copy_buffer_to_image)( 5550 command_buffer, 5551 src_buffer, 5552 dst_image, 5553 dst_image_layout, 5554 region_count, 5555 p_regions, 5556 ) 5557 } 5558 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyImageToBuffer.html>"] cmd_copy_image_to_buffer( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_buffer: Buffer, region_count: u32, p_regions: *const BufferImageCopy, )5559 pub unsafe fn cmd_copy_image_to_buffer( 5560 &self, 5561 command_buffer: CommandBuffer, 5562 src_image: Image, 5563 src_image_layout: ImageLayout, 5564 dst_buffer: Buffer, 5565 region_count: u32, 5566 p_regions: *const BufferImageCopy, 5567 ) { 5568 (self.cmd_copy_image_to_buffer)( 5569 command_buffer, 5570 src_image, 5571 src_image_layout, 5572 dst_buffer, 5573 region_count, 5574 p_regions, 5575 ) 5576 } 5577 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdUpdateBuffer.html>"] cmd_update_buffer( &self, command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, data_size: DeviceSize, p_data: *const c_void, )5578 pub unsafe fn cmd_update_buffer( 5579 &self, 5580 command_buffer: CommandBuffer, 5581 dst_buffer: Buffer, 5582 dst_offset: DeviceSize, 5583 data_size: DeviceSize, 5584 p_data: *const c_void, 5585 ) { 5586 (self.cmd_update_buffer)(command_buffer, dst_buffer, dst_offset, data_size, p_data) 5587 } 5588 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdFillBuffer.html>"] cmd_fill_buffer( &self, command_buffer: CommandBuffer, dst_buffer: Buffer, dst_offset: DeviceSize, size: DeviceSize, data: u32, )5589 pub unsafe fn cmd_fill_buffer( 5590 &self, 5591 command_buffer: CommandBuffer, 5592 dst_buffer: Buffer, 5593 dst_offset: DeviceSize, 5594 size: DeviceSize, 5595 data: u32, 5596 ) { 5597 (self.cmd_fill_buffer)(command_buffer, dst_buffer, dst_offset, size, data) 5598 } 5599 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearColorImage.html>"] cmd_clear_color_image( &self, command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_color: *const ClearColorValue, range_count: u32, p_ranges: *const ImageSubresourceRange, )5600 pub unsafe fn cmd_clear_color_image( 5601 &self, 5602 command_buffer: CommandBuffer, 5603 image: Image, 5604 image_layout: ImageLayout, 5605 p_color: *const ClearColorValue, 5606 range_count: u32, 5607 p_ranges: *const ImageSubresourceRange, 5608 ) { 5609 (self.cmd_clear_color_image)( 5610 command_buffer, 5611 image, 5612 image_layout, 5613 p_color, 5614 range_count, 5615 p_ranges, 5616 ) 5617 } 5618 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearDepthStencilImage.html>"] cmd_clear_depth_stencil_image( &self, command_buffer: CommandBuffer, image: Image, image_layout: ImageLayout, p_depth_stencil: *const ClearDepthStencilValue, range_count: u32, p_ranges: *const ImageSubresourceRange, )5619 pub unsafe fn cmd_clear_depth_stencil_image( 5620 &self, 5621 command_buffer: CommandBuffer, 5622 image: Image, 5623 image_layout: ImageLayout, 5624 p_depth_stencil: *const ClearDepthStencilValue, 5625 range_count: u32, 5626 p_ranges: *const ImageSubresourceRange, 5627 ) { 5628 (self.cmd_clear_depth_stencil_image)( 5629 command_buffer, 5630 image, 5631 image_layout, 5632 p_depth_stencil, 5633 range_count, 5634 p_ranges, 5635 ) 5636 } 5637 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdClearAttachments.html>"] cmd_clear_attachments( &self, command_buffer: CommandBuffer, attachment_count: u32, p_attachments: *const ClearAttachment, rect_count: u32, p_rects: *const ClearRect, )5638 pub unsafe fn cmd_clear_attachments( 5639 &self, 5640 command_buffer: CommandBuffer, 5641 attachment_count: u32, 5642 p_attachments: *const ClearAttachment, 5643 rect_count: u32, 5644 p_rects: *const ClearRect, 5645 ) { 5646 (self.cmd_clear_attachments)( 5647 command_buffer, 5648 attachment_count, 5649 p_attachments, 5650 rect_count, 5651 p_rects, 5652 ) 5653 } 5654 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResolveImage.html>"] cmd_resolve_image( &self, command_buffer: CommandBuffer, src_image: Image, src_image_layout: ImageLayout, dst_image: Image, dst_image_layout: ImageLayout, region_count: u32, p_regions: *const ImageResolve, )5655 pub unsafe fn cmd_resolve_image( 5656 &self, 5657 command_buffer: CommandBuffer, 5658 src_image: Image, 5659 src_image_layout: ImageLayout, 5660 dst_image: Image, 5661 dst_image_layout: ImageLayout, 5662 region_count: u32, 5663 p_regions: *const ImageResolve, 5664 ) { 5665 (self.cmd_resolve_image)( 5666 command_buffer, 5667 src_image, 5668 src_image_layout, 5669 dst_image, 5670 dst_image_layout, 5671 region_count, 5672 p_regions, 5673 ) 5674 } 5675 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetEvent.html>"] cmd_set_event( &self, command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, )5676 pub unsafe fn cmd_set_event( 5677 &self, 5678 command_buffer: CommandBuffer, 5679 event: Event, 5680 stage_mask: PipelineStageFlags, 5681 ) { 5682 (self.cmd_set_event)(command_buffer, event, stage_mask) 5683 } 5684 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetEvent.html>"] cmd_reset_event( &self, command_buffer: CommandBuffer, event: Event, stage_mask: PipelineStageFlags, )5685 pub unsafe fn cmd_reset_event( 5686 &self, 5687 command_buffer: CommandBuffer, 5688 event: Event, 5689 stage_mask: PipelineStageFlags, 5690 ) { 5691 (self.cmd_reset_event)(command_buffer, event, stage_mask) 5692 } 5693 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWaitEvents.html>"] cmd_wait_events( &self, command_buffer: CommandBuffer, event_count: u32, p_events: *const Event, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, )5694 pub unsafe fn cmd_wait_events( 5695 &self, 5696 command_buffer: CommandBuffer, 5697 event_count: u32, 5698 p_events: *const Event, 5699 src_stage_mask: PipelineStageFlags, 5700 dst_stage_mask: PipelineStageFlags, 5701 memory_barrier_count: u32, 5702 p_memory_barriers: *const MemoryBarrier, 5703 buffer_memory_barrier_count: u32, 5704 p_buffer_memory_barriers: *const BufferMemoryBarrier, 5705 image_memory_barrier_count: u32, 5706 p_image_memory_barriers: *const ImageMemoryBarrier, 5707 ) { 5708 (self.cmd_wait_events)( 5709 command_buffer, 5710 event_count, 5711 p_events, 5712 src_stage_mask, 5713 dst_stage_mask, 5714 memory_barrier_count, 5715 p_memory_barriers, 5716 buffer_memory_barrier_count, 5717 p_buffer_memory_barriers, 5718 image_memory_barrier_count, 5719 p_image_memory_barriers, 5720 ) 5721 } 5722 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPipelineBarrier.html>"] cmd_pipeline_barrier( &self, command_buffer: CommandBuffer, src_stage_mask: PipelineStageFlags, dst_stage_mask: PipelineStageFlags, dependency_flags: DependencyFlags, memory_barrier_count: u32, p_memory_barriers: *const MemoryBarrier, buffer_memory_barrier_count: u32, p_buffer_memory_barriers: *const BufferMemoryBarrier, image_memory_barrier_count: u32, p_image_memory_barriers: *const ImageMemoryBarrier, )5723 pub unsafe fn cmd_pipeline_barrier( 5724 &self, 5725 command_buffer: CommandBuffer, 5726 src_stage_mask: PipelineStageFlags, 5727 dst_stage_mask: PipelineStageFlags, 5728 dependency_flags: DependencyFlags, 5729 memory_barrier_count: u32, 5730 p_memory_barriers: *const MemoryBarrier, 5731 buffer_memory_barrier_count: u32, 5732 p_buffer_memory_barriers: *const BufferMemoryBarrier, 5733 image_memory_barrier_count: u32, 5734 p_image_memory_barriers: *const ImageMemoryBarrier, 5735 ) { 5736 (self.cmd_pipeline_barrier)( 5737 command_buffer, 5738 src_stage_mask, 5739 dst_stage_mask, 5740 dependency_flags, 5741 memory_barrier_count, 5742 p_memory_barriers, 5743 buffer_memory_barrier_count, 5744 p_buffer_memory_barriers, 5745 image_memory_barrier_count, 5746 p_image_memory_barriers, 5747 ) 5748 } 5749 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginQuery.html>"] cmd_begin_query( &self, command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, flags: QueryControlFlags, )5750 pub unsafe fn cmd_begin_query( 5751 &self, 5752 command_buffer: CommandBuffer, 5753 query_pool: QueryPool, 5754 query: u32, 5755 flags: QueryControlFlags, 5756 ) { 5757 (self.cmd_begin_query)(command_buffer, query_pool, query, flags) 5758 } 5759 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndQuery.html>"] cmd_end_query( &self, command_buffer: CommandBuffer, query_pool: QueryPool, query: u32, )5760 pub unsafe fn cmd_end_query( 5761 &self, 5762 command_buffer: CommandBuffer, 5763 query_pool: QueryPool, 5764 query: u32, 5765 ) { 5766 (self.cmd_end_query)(command_buffer, query_pool, query) 5767 } 5768 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdResetQueryPool.html>"] cmd_reset_query_pool( &self, command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, )5769 pub unsafe fn cmd_reset_query_pool( 5770 &self, 5771 command_buffer: CommandBuffer, 5772 query_pool: QueryPool, 5773 first_query: u32, 5774 query_count: u32, 5775 ) { 5776 (self.cmd_reset_query_pool)(command_buffer, query_pool, first_query, query_count) 5777 } 5778 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdWriteTimestamp.html>"] cmd_write_timestamp( &self, command_buffer: CommandBuffer, pipeline_stage: PipelineStageFlags, query_pool: QueryPool, query: u32, )5779 pub unsafe fn cmd_write_timestamp( 5780 &self, 5781 command_buffer: CommandBuffer, 5782 pipeline_stage: PipelineStageFlags, 5783 query_pool: QueryPool, 5784 query: u32, 5785 ) { 5786 (self.cmd_write_timestamp)(command_buffer, pipeline_stage, query_pool, query) 5787 } 5788 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdCopyQueryPoolResults.html>"] cmd_copy_query_pool_results( &self, command_buffer: CommandBuffer, query_pool: QueryPool, first_query: u32, query_count: u32, dst_buffer: Buffer, dst_offset: DeviceSize, stride: DeviceSize, flags: QueryResultFlags, )5789 pub unsafe fn cmd_copy_query_pool_results( 5790 &self, 5791 command_buffer: CommandBuffer, 5792 query_pool: QueryPool, 5793 first_query: u32, 5794 query_count: u32, 5795 dst_buffer: Buffer, 5796 dst_offset: DeviceSize, 5797 stride: DeviceSize, 5798 flags: QueryResultFlags, 5799 ) { 5800 (self.cmd_copy_query_pool_results)( 5801 command_buffer, 5802 query_pool, 5803 first_query, 5804 query_count, 5805 dst_buffer, 5806 dst_offset, 5807 stride, 5808 flags, 5809 ) 5810 } 5811 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdPushConstants.html>"] cmd_push_constants( &self, command_buffer: CommandBuffer, layout: PipelineLayout, stage_flags: ShaderStageFlags, offset: u32, size: u32, p_values: *const c_void, )5812 pub unsafe fn cmd_push_constants( 5813 &self, 5814 command_buffer: CommandBuffer, 5815 layout: PipelineLayout, 5816 stage_flags: ShaderStageFlags, 5817 offset: u32, 5818 size: u32, 5819 p_values: *const c_void, 5820 ) { 5821 (self.cmd_push_constants)(command_buffer, layout, stage_flags, offset, size, p_values) 5822 } 5823 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass.html>"] cmd_begin_render_pass( &self, command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, contents: SubpassContents, )5824 pub unsafe fn cmd_begin_render_pass( 5825 &self, 5826 command_buffer: CommandBuffer, 5827 p_render_pass_begin: *const RenderPassBeginInfo, 5828 contents: SubpassContents, 5829 ) { 5830 (self.cmd_begin_render_pass)(command_buffer, p_render_pass_begin, contents) 5831 } 5832 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass.html>"] cmd_next_subpass( &self, command_buffer: CommandBuffer, contents: SubpassContents, )5833 pub unsafe fn cmd_next_subpass( 5834 &self, 5835 command_buffer: CommandBuffer, 5836 contents: SubpassContents, 5837 ) { 5838 (self.cmd_next_subpass)(command_buffer, contents) 5839 } 5840 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass.html>"] cmd_end_render_pass(&self, command_buffer: CommandBuffer)5841 pub unsafe fn cmd_end_render_pass(&self, command_buffer: CommandBuffer) { 5842 (self.cmd_end_render_pass)(command_buffer) 5843 } 5844 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdExecuteCommands.html>"] cmd_execute_commands( &self, command_buffer: CommandBuffer, command_buffer_count: u32, p_command_buffers: *const CommandBuffer, )5845 pub unsafe fn cmd_execute_commands( 5846 &self, 5847 command_buffer: CommandBuffer, 5848 command_buffer_count: u32, 5849 p_command_buffers: *const CommandBuffer, 5850 ) { 5851 (self.cmd_execute_commands)(command_buffer, command_buffer_count, p_command_buffers) 5852 } 5853 } 5854 #[allow(non_camel_case_types)] 5855 pub type PFN_vkEnumerateInstanceVersion = extern "system" fn(p_api_version: *mut u32) -> Result; 5856 pub struct EntryFnV1_1 { 5857 pub enumerate_instance_version: extern "system" fn(p_api_version: *mut u32) -> Result, 5858 } 5859 unsafe impl Send for EntryFnV1_1 {} 5860 unsafe impl Sync for EntryFnV1_1 {} 5861 impl ::std::clone::Clone for EntryFnV1_1 { clone(&self) -> Self5862 fn clone(&self) -> Self { 5863 EntryFnV1_1 { 5864 enumerate_instance_version: self.enumerate_instance_version, 5865 } 5866 } 5867 } 5868 impl EntryFnV1_1 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,5869 pub fn load<F>(mut _f: F) -> Self 5870 where 5871 F: FnMut(&::std::ffi::CStr) -> *const c_void, 5872 { 5873 EntryFnV1_1 { 5874 enumerate_instance_version: unsafe { 5875 extern "system" fn enumerate_instance_version(_p_api_version: *mut u32) -> Result { 5876 panic!(concat!( 5877 "Unable to load ", 5878 stringify!(enumerate_instance_version) 5879 )) 5880 } 5881 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5882 b"vkEnumerateInstanceVersion\0", 5883 ); 5884 let val = _f(cname); 5885 if val.is_null() { 5886 enumerate_instance_version 5887 } else { 5888 ::std::mem::transmute(val) 5889 } 5890 }, 5891 } 5892 } 5893 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumerateInstanceVersion.html>"] enumerate_instance_version(&self, p_api_version: *mut u32) -> Result5894 pub unsafe fn enumerate_instance_version(&self, p_api_version: *mut u32) -> Result { 5895 (self.enumerate_instance_version)(p_api_version) 5896 } 5897 } 5898 pub struct InstanceFnV1_1 { 5899 pub enumerate_physical_device_groups: extern "system" fn( 5900 instance: Instance, 5901 p_physical_device_group_count: *mut u32, 5902 p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, 5903 ) -> Result, 5904 pub get_physical_device_features2: extern "system" fn( 5905 physical_device: PhysicalDevice, 5906 p_features: *mut PhysicalDeviceFeatures2, 5907 ), 5908 pub get_physical_device_properties2: extern "system" fn( 5909 physical_device: PhysicalDevice, 5910 p_properties: *mut PhysicalDeviceProperties2, 5911 ), 5912 pub get_physical_device_format_properties2: extern "system" fn( 5913 physical_device: PhysicalDevice, 5914 format: Format, 5915 p_format_properties: *mut FormatProperties2, 5916 ), 5917 pub get_physical_device_image_format_properties2: extern "system" fn( 5918 physical_device: PhysicalDevice, 5919 p_image_format_info: *const PhysicalDeviceImageFormatInfo2, 5920 p_image_format_properties: *mut ImageFormatProperties2, 5921 ) -> Result, 5922 pub get_physical_device_queue_family_properties2: extern "system" fn( 5923 physical_device: PhysicalDevice, 5924 p_queue_family_property_count: *mut u32, 5925 p_queue_family_properties: *mut QueueFamilyProperties2, 5926 ), 5927 pub get_physical_device_memory_properties2: extern "system" fn( 5928 physical_device: PhysicalDevice, 5929 p_memory_properties: *mut PhysicalDeviceMemoryProperties2, 5930 ), 5931 pub get_physical_device_sparse_image_format_properties2: extern "system" fn( 5932 physical_device: PhysicalDevice, 5933 p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, 5934 p_property_count: *mut u32, 5935 p_properties: *mut SparseImageFormatProperties2, 5936 ), 5937 pub get_physical_device_external_buffer_properties: extern "system" fn( 5938 physical_device: PhysicalDevice, 5939 p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, 5940 p_external_buffer_properties: *mut ExternalBufferProperties, 5941 ), 5942 pub get_physical_device_external_fence_properties: extern "system" fn( 5943 physical_device: PhysicalDevice, 5944 p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, 5945 p_external_fence_properties: *mut ExternalFenceProperties, 5946 ), 5947 pub get_physical_device_external_semaphore_properties: extern "system" fn( 5948 physical_device: PhysicalDevice, 5949 p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, 5950 p_external_semaphore_properties: *mut ExternalSemaphoreProperties, 5951 ), 5952 } 5953 unsafe impl Send for InstanceFnV1_1 {} 5954 unsafe impl Sync for InstanceFnV1_1 {} 5955 impl ::std::clone::Clone for InstanceFnV1_1 { clone(&self) -> Self5956 fn clone(&self) -> Self { 5957 InstanceFnV1_1 { 5958 enumerate_physical_device_groups: self.enumerate_physical_device_groups, 5959 get_physical_device_features2: self.get_physical_device_features2, 5960 get_physical_device_properties2: self.get_physical_device_properties2, 5961 get_physical_device_format_properties2: self.get_physical_device_format_properties2, 5962 get_physical_device_image_format_properties2: self 5963 .get_physical_device_image_format_properties2, 5964 get_physical_device_queue_family_properties2: self 5965 .get_physical_device_queue_family_properties2, 5966 get_physical_device_memory_properties2: self.get_physical_device_memory_properties2, 5967 get_physical_device_sparse_image_format_properties2: self 5968 .get_physical_device_sparse_image_format_properties2, 5969 get_physical_device_external_buffer_properties: self 5970 .get_physical_device_external_buffer_properties, 5971 get_physical_device_external_fence_properties: self 5972 .get_physical_device_external_fence_properties, 5973 get_physical_device_external_semaphore_properties: self 5974 .get_physical_device_external_semaphore_properties, 5975 } 5976 } 5977 } 5978 impl InstanceFnV1_1 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,5979 pub fn load<F>(mut _f: F) -> Self 5980 where 5981 F: FnMut(&::std::ffi::CStr) -> *const c_void, 5982 { 5983 InstanceFnV1_1 { 5984 enumerate_physical_device_groups: unsafe { 5985 extern "system" fn enumerate_physical_device_groups( 5986 _instance: Instance, 5987 _p_physical_device_group_count: *mut u32, 5988 _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, 5989 ) -> Result { 5990 panic!(concat!( 5991 "Unable to load ", 5992 stringify!(enumerate_physical_device_groups) 5993 )) 5994 } 5995 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 5996 b"vkEnumeratePhysicalDeviceGroups\0", 5997 ); 5998 let val = _f(cname); 5999 if val.is_null() { 6000 enumerate_physical_device_groups 6001 } else { 6002 ::std::mem::transmute(val) 6003 } 6004 }, 6005 get_physical_device_features2: unsafe { 6006 extern "system" fn get_physical_device_features2( 6007 _physical_device: PhysicalDevice, 6008 _p_features: *mut PhysicalDeviceFeatures2, 6009 ) { 6010 panic!(concat!( 6011 "Unable to load ", 6012 stringify!(get_physical_device_features2) 6013 )) 6014 } 6015 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6016 b"vkGetPhysicalDeviceFeatures2\0", 6017 ); 6018 let val = _f(cname); 6019 if val.is_null() { 6020 get_physical_device_features2 6021 } else { 6022 ::std::mem::transmute(val) 6023 } 6024 }, 6025 get_physical_device_properties2: unsafe { 6026 extern "system" fn get_physical_device_properties2( 6027 _physical_device: PhysicalDevice, 6028 _p_properties: *mut PhysicalDeviceProperties2, 6029 ) { 6030 panic!(concat!( 6031 "Unable to load ", 6032 stringify!(get_physical_device_properties2) 6033 )) 6034 } 6035 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6036 b"vkGetPhysicalDeviceProperties2\0", 6037 ); 6038 let val = _f(cname); 6039 if val.is_null() { 6040 get_physical_device_properties2 6041 } else { 6042 ::std::mem::transmute(val) 6043 } 6044 }, 6045 get_physical_device_format_properties2: unsafe { 6046 extern "system" fn get_physical_device_format_properties2( 6047 _physical_device: PhysicalDevice, 6048 _format: Format, 6049 _p_format_properties: *mut FormatProperties2, 6050 ) { 6051 panic!(concat!( 6052 "Unable to load ", 6053 stringify!(get_physical_device_format_properties2) 6054 )) 6055 } 6056 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6057 b"vkGetPhysicalDeviceFormatProperties2\0", 6058 ); 6059 let val = _f(cname); 6060 if val.is_null() { 6061 get_physical_device_format_properties2 6062 } else { 6063 ::std::mem::transmute(val) 6064 } 6065 }, 6066 get_physical_device_image_format_properties2: unsafe { 6067 extern "system" fn get_physical_device_image_format_properties2( 6068 _physical_device: PhysicalDevice, 6069 _p_image_format_info: *const PhysicalDeviceImageFormatInfo2, 6070 _p_image_format_properties: *mut ImageFormatProperties2, 6071 ) -> Result { 6072 panic!(concat!( 6073 "Unable to load ", 6074 stringify!(get_physical_device_image_format_properties2) 6075 )) 6076 } 6077 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6078 b"vkGetPhysicalDeviceImageFormatProperties2\0", 6079 ); 6080 let val = _f(cname); 6081 if val.is_null() { 6082 get_physical_device_image_format_properties2 6083 } else { 6084 ::std::mem::transmute(val) 6085 } 6086 }, 6087 get_physical_device_queue_family_properties2: unsafe { 6088 extern "system" fn get_physical_device_queue_family_properties2( 6089 _physical_device: PhysicalDevice, 6090 _p_queue_family_property_count: *mut u32, 6091 _p_queue_family_properties: *mut QueueFamilyProperties2, 6092 ) { 6093 panic!(concat!( 6094 "Unable to load ", 6095 stringify!(get_physical_device_queue_family_properties2) 6096 )) 6097 } 6098 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6099 b"vkGetPhysicalDeviceQueueFamilyProperties2\0", 6100 ); 6101 let val = _f(cname); 6102 if val.is_null() { 6103 get_physical_device_queue_family_properties2 6104 } else { 6105 ::std::mem::transmute(val) 6106 } 6107 }, 6108 get_physical_device_memory_properties2: unsafe { 6109 extern "system" fn get_physical_device_memory_properties2( 6110 _physical_device: PhysicalDevice, 6111 _p_memory_properties: *mut PhysicalDeviceMemoryProperties2, 6112 ) { 6113 panic!(concat!( 6114 "Unable to load ", 6115 stringify!(get_physical_device_memory_properties2) 6116 )) 6117 } 6118 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6119 b"vkGetPhysicalDeviceMemoryProperties2\0", 6120 ); 6121 let val = _f(cname); 6122 if val.is_null() { 6123 get_physical_device_memory_properties2 6124 } else { 6125 ::std::mem::transmute(val) 6126 } 6127 }, 6128 get_physical_device_sparse_image_format_properties2: unsafe { 6129 extern "system" fn get_physical_device_sparse_image_format_properties2( 6130 _physical_device: PhysicalDevice, 6131 _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, 6132 _p_property_count: *mut u32, 6133 _p_properties: *mut SparseImageFormatProperties2, 6134 ) { 6135 panic!(concat!( 6136 "Unable to load ", 6137 stringify!(get_physical_device_sparse_image_format_properties2) 6138 )) 6139 } 6140 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6141 b"vkGetPhysicalDeviceSparseImageFormatProperties2\0", 6142 ); 6143 let val = _f(cname); 6144 if val.is_null() { 6145 get_physical_device_sparse_image_format_properties2 6146 } else { 6147 ::std::mem::transmute(val) 6148 } 6149 }, 6150 get_physical_device_external_buffer_properties: unsafe { 6151 extern "system" fn get_physical_device_external_buffer_properties( 6152 _physical_device: PhysicalDevice, 6153 _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, 6154 _p_external_buffer_properties: *mut ExternalBufferProperties, 6155 ) { 6156 panic!(concat!( 6157 "Unable to load ", 6158 stringify!(get_physical_device_external_buffer_properties) 6159 )) 6160 } 6161 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6162 b"vkGetPhysicalDeviceExternalBufferProperties\0", 6163 ); 6164 let val = _f(cname); 6165 if val.is_null() { 6166 get_physical_device_external_buffer_properties 6167 } else { 6168 ::std::mem::transmute(val) 6169 } 6170 }, 6171 get_physical_device_external_fence_properties: unsafe { 6172 extern "system" fn get_physical_device_external_fence_properties( 6173 _physical_device: PhysicalDevice, 6174 _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, 6175 _p_external_fence_properties: *mut ExternalFenceProperties, 6176 ) { 6177 panic!(concat!( 6178 "Unable to load ", 6179 stringify!(get_physical_device_external_fence_properties) 6180 )) 6181 } 6182 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6183 b"vkGetPhysicalDeviceExternalFenceProperties\0", 6184 ); 6185 let val = _f(cname); 6186 if val.is_null() { 6187 get_physical_device_external_fence_properties 6188 } else { 6189 ::std::mem::transmute(val) 6190 } 6191 }, 6192 get_physical_device_external_semaphore_properties: unsafe { 6193 extern "system" fn get_physical_device_external_semaphore_properties( 6194 _physical_device: PhysicalDevice, 6195 _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, 6196 _p_external_semaphore_properties: *mut ExternalSemaphoreProperties, 6197 ) { 6198 panic!(concat!( 6199 "Unable to load ", 6200 stringify!(get_physical_device_external_semaphore_properties) 6201 )) 6202 } 6203 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6204 b"vkGetPhysicalDeviceExternalSemaphoreProperties\0", 6205 ); 6206 let val = _f(cname); 6207 if val.is_null() { 6208 get_physical_device_external_semaphore_properties 6209 } else { 6210 ::std::mem::transmute(val) 6211 } 6212 }, 6213 } 6214 } 6215 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkEnumeratePhysicalDeviceGroups.html>"] enumerate_physical_device_groups( &self, instance: Instance, p_physical_device_group_count: *mut u32, p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, ) -> Result6216 pub unsafe fn enumerate_physical_device_groups( 6217 &self, 6218 instance: Instance, 6219 p_physical_device_group_count: *mut u32, 6220 p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties, 6221 ) -> Result { 6222 (self.enumerate_physical_device_groups)( 6223 instance, 6224 p_physical_device_group_count, 6225 p_physical_device_group_properties, 6226 ) 6227 } 6228 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFeatures2.html>"] get_physical_device_features2( &self, physical_device: PhysicalDevice, p_features: *mut PhysicalDeviceFeatures2, )6229 pub unsafe fn get_physical_device_features2( 6230 &self, 6231 physical_device: PhysicalDevice, 6232 p_features: *mut PhysicalDeviceFeatures2, 6233 ) { 6234 (self.get_physical_device_features2)(physical_device, p_features) 6235 } 6236 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceProperties2.html>"] get_physical_device_properties2( &self, physical_device: PhysicalDevice, p_properties: *mut PhysicalDeviceProperties2, )6237 pub unsafe fn get_physical_device_properties2( 6238 &self, 6239 physical_device: PhysicalDevice, 6240 p_properties: *mut PhysicalDeviceProperties2, 6241 ) { 6242 (self.get_physical_device_properties2)(physical_device, p_properties) 6243 } 6244 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceFormatProperties2.html>"] get_physical_device_format_properties2( &self, physical_device: PhysicalDevice, format: Format, p_format_properties: *mut FormatProperties2, )6245 pub unsafe fn get_physical_device_format_properties2( 6246 &self, 6247 physical_device: PhysicalDevice, 6248 format: Format, 6249 p_format_properties: *mut FormatProperties2, 6250 ) { 6251 (self.get_physical_device_format_properties2)(physical_device, format, p_format_properties) 6252 } 6253 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceImageFormatProperties2.html>"] get_physical_device_image_format_properties2( &self, physical_device: PhysicalDevice, p_image_format_info: *const PhysicalDeviceImageFormatInfo2, p_image_format_properties: *mut ImageFormatProperties2, ) -> Result6254 pub unsafe fn get_physical_device_image_format_properties2( 6255 &self, 6256 physical_device: PhysicalDevice, 6257 p_image_format_info: *const PhysicalDeviceImageFormatInfo2, 6258 p_image_format_properties: *mut ImageFormatProperties2, 6259 ) -> Result { 6260 (self.get_physical_device_image_format_properties2)( 6261 physical_device, 6262 p_image_format_info, 6263 p_image_format_properties, 6264 ) 6265 } 6266 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceQueueFamilyProperties2.html>"] get_physical_device_queue_family_properties2( &self, physical_device: PhysicalDevice, p_queue_family_property_count: *mut u32, p_queue_family_properties: *mut QueueFamilyProperties2, )6267 pub unsafe fn get_physical_device_queue_family_properties2( 6268 &self, 6269 physical_device: PhysicalDevice, 6270 p_queue_family_property_count: *mut u32, 6271 p_queue_family_properties: *mut QueueFamilyProperties2, 6272 ) { 6273 (self.get_physical_device_queue_family_properties2)( 6274 physical_device, 6275 p_queue_family_property_count, 6276 p_queue_family_properties, 6277 ) 6278 } 6279 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceMemoryProperties2.html>"] get_physical_device_memory_properties2( &self, physical_device: PhysicalDevice, p_memory_properties: *mut PhysicalDeviceMemoryProperties2, )6280 pub unsafe fn get_physical_device_memory_properties2( 6281 &self, 6282 physical_device: PhysicalDevice, 6283 p_memory_properties: *mut PhysicalDeviceMemoryProperties2, 6284 ) { 6285 (self.get_physical_device_memory_properties2)(physical_device, p_memory_properties) 6286 } 6287 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceSparseImageFormatProperties2.html>"] get_physical_device_sparse_image_format_properties2( &self, physical_device: PhysicalDevice, p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, p_property_count: *mut u32, p_properties: *mut SparseImageFormatProperties2, )6288 pub unsafe fn get_physical_device_sparse_image_format_properties2( 6289 &self, 6290 physical_device: PhysicalDevice, 6291 p_format_info: *const PhysicalDeviceSparseImageFormatInfo2, 6292 p_property_count: *mut u32, 6293 p_properties: *mut SparseImageFormatProperties2, 6294 ) { 6295 (self.get_physical_device_sparse_image_format_properties2)( 6296 physical_device, 6297 p_format_info, 6298 p_property_count, 6299 p_properties, 6300 ) 6301 } 6302 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalBufferProperties.html>"] get_physical_device_external_buffer_properties( &self, physical_device: PhysicalDevice, p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, p_external_buffer_properties: *mut ExternalBufferProperties, )6303 pub unsafe fn get_physical_device_external_buffer_properties( 6304 &self, 6305 physical_device: PhysicalDevice, 6306 p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo, 6307 p_external_buffer_properties: *mut ExternalBufferProperties, 6308 ) { 6309 (self.get_physical_device_external_buffer_properties)( 6310 physical_device, 6311 p_external_buffer_info, 6312 p_external_buffer_properties, 6313 ) 6314 } 6315 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalFenceProperties.html>"] get_physical_device_external_fence_properties( &self, physical_device: PhysicalDevice, p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, p_external_fence_properties: *mut ExternalFenceProperties, )6316 pub unsafe fn get_physical_device_external_fence_properties( 6317 &self, 6318 physical_device: PhysicalDevice, 6319 p_external_fence_info: *const PhysicalDeviceExternalFenceInfo, 6320 p_external_fence_properties: *mut ExternalFenceProperties, 6321 ) { 6322 (self.get_physical_device_external_fence_properties)( 6323 physical_device, 6324 p_external_fence_info, 6325 p_external_fence_properties, 6326 ) 6327 } 6328 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetPhysicalDeviceExternalSemaphoreProperties.html>"] get_physical_device_external_semaphore_properties( &self, physical_device: PhysicalDevice, p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, p_external_semaphore_properties: *mut ExternalSemaphoreProperties, )6329 pub unsafe fn get_physical_device_external_semaphore_properties( 6330 &self, 6331 physical_device: PhysicalDevice, 6332 p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo, 6333 p_external_semaphore_properties: *mut ExternalSemaphoreProperties, 6334 ) { 6335 (self.get_physical_device_external_semaphore_properties)( 6336 physical_device, 6337 p_external_semaphore_info, 6338 p_external_semaphore_properties, 6339 ) 6340 } 6341 } 6342 #[allow(non_camel_case_types)] 6343 pub type PFN_vkGetDeviceQueue2 = extern "system" fn( 6344 device: Device, 6345 bind_info_count: u32, 6346 p_bind_infos: *const BindBufferMemoryInfo, 6347 ) -> Result; 6348 pub struct DeviceFnV1_1 { 6349 pub bind_buffer_memory2: extern "system" fn( 6350 device: Device, 6351 bind_info_count: u32, 6352 p_bind_infos: *const BindBufferMemoryInfo, 6353 ) -> Result, 6354 pub bind_image_memory2: extern "system" fn( 6355 device: Device, 6356 bind_info_count: u32, 6357 p_bind_infos: *const BindImageMemoryInfo, 6358 ) -> Result, 6359 pub get_device_group_peer_memory_features: extern "system" fn( 6360 device: Device, 6361 heap_index: u32, 6362 local_device_index: u32, 6363 remote_device_index: u32, 6364 p_peer_memory_features: *mut PeerMemoryFeatureFlags, 6365 ), 6366 pub cmd_set_device_mask: extern "system" fn(command_buffer: CommandBuffer, device_mask: u32), 6367 pub cmd_dispatch_base: extern "system" fn( 6368 command_buffer: CommandBuffer, 6369 base_group_x: u32, 6370 base_group_y: u32, 6371 base_group_z: u32, 6372 group_count_x: u32, 6373 group_count_y: u32, 6374 group_count_z: u32, 6375 ), 6376 pub get_image_memory_requirements2: extern "system" fn( 6377 device: Device, 6378 p_info: *const ImageMemoryRequirementsInfo2, 6379 p_memory_requirements: *mut MemoryRequirements2, 6380 ), 6381 pub get_buffer_memory_requirements2: extern "system" fn( 6382 device: Device, 6383 p_info: *const BufferMemoryRequirementsInfo2, 6384 p_memory_requirements: *mut MemoryRequirements2, 6385 ), 6386 pub get_image_sparse_memory_requirements2: extern "system" fn( 6387 device: Device, 6388 p_info: *const ImageSparseMemoryRequirementsInfo2, 6389 p_sparse_memory_requirement_count: *mut u32, 6390 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, 6391 ), 6392 pub trim_command_pool: 6393 extern "system" fn(device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags), 6394 pub get_device_queue2: extern "system" fn( 6395 device: Device, 6396 p_queue_info: *const DeviceQueueInfo2, 6397 p_queue: *mut Queue, 6398 ), 6399 pub create_sampler_ycbcr_conversion: extern "system" fn( 6400 device: Device, 6401 p_create_info: *const SamplerYcbcrConversionCreateInfo, 6402 p_allocator: *const AllocationCallbacks, 6403 p_ycbcr_conversion: *mut SamplerYcbcrConversion, 6404 ) -> Result, 6405 pub destroy_sampler_ycbcr_conversion: extern "system" fn( 6406 device: Device, 6407 ycbcr_conversion: SamplerYcbcrConversion, 6408 p_allocator: *const AllocationCallbacks, 6409 ), 6410 pub create_descriptor_update_template: extern "system" fn( 6411 device: Device, 6412 p_create_info: *const DescriptorUpdateTemplateCreateInfo, 6413 p_allocator: *const AllocationCallbacks, 6414 p_descriptor_update_template: *mut DescriptorUpdateTemplate, 6415 ) -> Result, 6416 pub destroy_descriptor_update_template: extern "system" fn( 6417 device: Device, 6418 descriptor_update_template: DescriptorUpdateTemplate, 6419 p_allocator: *const AllocationCallbacks, 6420 ), 6421 pub update_descriptor_set_with_template: extern "system" fn( 6422 device: Device, 6423 descriptor_set: DescriptorSet, 6424 descriptor_update_template: DescriptorUpdateTemplate, 6425 p_data: *const c_void, 6426 ), 6427 pub get_descriptor_set_layout_support: extern "system" fn( 6428 device: Device, 6429 p_create_info: *const DescriptorSetLayoutCreateInfo, 6430 p_support: *mut DescriptorSetLayoutSupport, 6431 ), 6432 } 6433 unsafe impl Send for DeviceFnV1_1 {} 6434 unsafe impl Sync for DeviceFnV1_1 {} 6435 impl ::std::clone::Clone for DeviceFnV1_1 { clone(&self) -> Self6436 fn clone(&self) -> Self { 6437 DeviceFnV1_1 { 6438 bind_buffer_memory2: self.bind_buffer_memory2, 6439 bind_image_memory2: self.bind_image_memory2, 6440 get_device_group_peer_memory_features: self.get_device_group_peer_memory_features, 6441 cmd_set_device_mask: self.cmd_set_device_mask, 6442 cmd_dispatch_base: self.cmd_dispatch_base, 6443 get_image_memory_requirements2: self.get_image_memory_requirements2, 6444 get_buffer_memory_requirements2: self.get_buffer_memory_requirements2, 6445 get_image_sparse_memory_requirements2: self.get_image_sparse_memory_requirements2, 6446 trim_command_pool: self.trim_command_pool, 6447 get_device_queue2: self.get_device_queue2, 6448 create_sampler_ycbcr_conversion: self.create_sampler_ycbcr_conversion, 6449 destroy_sampler_ycbcr_conversion: self.destroy_sampler_ycbcr_conversion, 6450 create_descriptor_update_template: self.create_descriptor_update_template, 6451 destroy_descriptor_update_template: self.destroy_descriptor_update_template, 6452 update_descriptor_set_with_template: self.update_descriptor_set_with_template, 6453 get_descriptor_set_layout_support: self.get_descriptor_set_layout_support, 6454 } 6455 } 6456 } 6457 impl DeviceFnV1_1 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,6458 pub fn load<F>(mut _f: F) -> Self 6459 where 6460 F: FnMut(&::std::ffi::CStr) -> *const c_void, 6461 { 6462 DeviceFnV1_1 { 6463 bind_buffer_memory2: unsafe { 6464 extern "system" fn bind_buffer_memory2( 6465 _device: Device, 6466 _bind_info_count: u32, 6467 _p_bind_infos: *const BindBufferMemoryInfo, 6468 ) -> Result { 6469 panic!(concat!("Unable to load ", stringify!(bind_buffer_memory2))) 6470 } 6471 let cname = 6472 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2\0"); 6473 let val = _f(cname); 6474 if val.is_null() { 6475 bind_buffer_memory2 6476 } else { 6477 ::std::mem::transmute(val) 6478 } 6479 }, 6480 bind_image_memory2: unsafe { 6481 extern "system" fn bind_image_memory2( 6482 _device: Device, 6483 _bind_info_count: u32, 6484 _p_bind_infos: *const BindImageMemoryInfo, 6485 ) -> Result { 6486 panic!(concat!("Unable to load ", stringify!(bind_image_memory2))) 6487 } 6488 let cname = 6489 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2\0"); 6490 let val = _f(cname); 6491 if val.is_null() { 6492 bind_image_memory2 6493 } else { 6494 ::std::mem::transmute(val) 6495 } 6496 }, 6497 get_device_group_peer_memory_features: unsafe { 6498 extern "system" fn get_device_group_peer_memory_features( 6499 _device: Device, 6500 _heap_index: u32, 6501 _local_device_index: u32, 6502 _remote_device_index: u32, 6503 _p_peer_memory_features: *mut PeerMemoryFeatureFlags, 6504 ) { 6505 panic!(concat!( 6506 "Unable to load ", 6507 stringify!(get_device_group_peer_memory_features) 6508 )) 6509 } 6510 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6511 b"vkGetDeviceGroupPeerMemoryFeatures\0", 6512 ); 6513 let val = _f(cname); 6514 if val.is_null() { 6515 get_device_group_peer_memory_features 6516 } else { 6517 ::std::mem::transmute(val) 6518 } 6519 }, 6520 cmd_set_device_mask: unsafe { 6521 extern "system" fn cmd_set_device_mask( 6522 _command_buffer: CommandBuffer, 6523 _device_mask: u32, 6524 ) { 6525 panic!(concat!("Unable to load ", stringify!(cmd_set_device_mask))) 6526 } 6527 let cname = 6528 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMask\0"); 6529 let val = _f(cname); 6530 if val.is_null() { 6531 cmd_set_device_mask 6532 } else { 6533 ::std::mem::transmute(val) 6534 } 6535 }, 6536 cmd_dispatch_base: unsafe { 6537 extern "system" fn cmd_dispatch_base( 6538 _command_buffer: CommandBuffer, 6539 _base_group_x: u32, 6540 _base_group_y: u32, 6541 _base_group_z: u32, 6542 _group_count_x: u32, 6543 _group_count_y: u32, 6544 _group_count_z: u32, 6545 ) { 6546 panic!(concat!("Unable to load ", stringify!(cmd_dispatch_base))) 6547 } 6548 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBase\0"); 6549 let val = _f(cname); 6550 if val.is_null() { 6551 cmd_dispatch_base 6552 } else { 6553 ::std::mem::transmute(val) 6554 } 6555 }, 6556 get_image_memory_requirements2: unsafe { 6557 extern "system" fn get_image_memory_requirements2( 6558 _device: Device, 6559 _p_info: *const ImageMemoryRequirementsInfo2, 6560 _p_memory_requirements: *mut MemoryRequirements2, 6561 ) { 6562 panic!(concat!( 6563 "Unable to load ", 6564 stringify!(get_image_memory_requirements2) 6565 )) 6566 } 6567 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6568 b"vkGetImageMemoryRequirements2\0", 6569 ); 6570 let val = _f(cname); 6571 if val.is_null() { 6572 get_image_memory_requirements2 6573 } else { 6574 ::std::mem::transmute(val) 6575 } 6576 }, 6577 get_buffer_memory_requirements2: unsafe { 6578 extern "system" fn get_buffer_memory_requirements2( 6579 _device: Device, 6580 _p_info: *const BufferMemoryRequirementsInfo2, 6581 _p_memory_requirements: *mut MemoryRequirements2, 6582 ) { 6583 panic!(concat!( 6584 "Unable to load ", 6585 stringify!(get_buffer_memory_requirements2) 6586 )) 6587 } 6588 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6589 b"vkGetBufferMemoryRequirements2\0", 6590 ); 6591 let val = _f(cname); 6592 if val.is_null() { 6593 get_buffer_memory_requirements2 6594 } else { 6595 ::std::mem::transmute(val) 6596 } 6597 }, 6598 get_image_sparse_memory_requirements2: unsafe { 6599 extern "system" fn get_image_sparse_memory_requirements2( 6600 _device: Device, 6601 _p_info: *const ImageSparseMemoryRequirementsInfo2, 6602 _p_sparse_memory_requirement_count: *mut u32, 6603 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, 6604 ) { 6605 panic!(concat!( 6606 "Unable to load ", 6607 stringify!(get_image_sparse_memory_requirements2) 6608 )) 6609 } 6610 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6611 b"vkGetImageSparseMemoryRequirements2\0", 6612 ); 6613 let val = _f(cname); 6614 if val.is_null() { 6615 get_image_sparse_memory_requirements2 6616 } else { 6617 ::std::mem::transmute(val) 6618 } 6619 }, 6620 trim_command_pool: unsafe { 6621 extern "system" fn trim_command_pool( 6622 _device: Device, 6623 _command_pool: CommandPool, 6624 _flags: CommandPoolTrimFlags, 6625 ) { 6626 panic!(concat!("Unable to load ", stringify!(trim_command_pool))) 6627 } 6628 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPool\0"); 6629 let val = _f(cname); 6630 if val.is_null() { 6631 trim_command_pool 6632 } else { 6633 ::std::mem::transmute(val) 6634 } 6635 }, 6636 get_device_queue2: unsafe { 6637 extern "system" fn get_device_queue2( 6638 _device: Device, 6639 _p_queue_info: *const DeviceQueueInfo2, 6640 _p_queue: *mut Queue, 6641 ) { 6642 panic!(concat!("Unable to load ", stringify!(get_device_queue2))) 6643 } 6644 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceQueue2\0"); 6645 let val = _f(cname); 6646 if val.is_null() { 6647 get_device_queue2 6648 } else { 6649 ::std::mem::transmute(val) 6650 } 6651 }, 6652 create_sampler_ycbcr_conversion: unsafe { 6653 extern "system" fn create_sampler_ycbcr_conversion( 6654 _device: Device, 6655 _p_create_info: *const SamplerYcbcrConversionCreateInfo, 6656 _p_allocator: *const AllocationCallbacks, 6657 _p_ycbcr_conversion: *mut SamplerYcbcrConversion, 6658 ) -> Result { 6659 panic!(concat!( 6660 "Unable to load ", 6661 stringify!(create_sampler_ycbcr_conversion) 6662 )) 6663 } 6664 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6665 b"vkCreateSamplerYcbcrConversion\0", 6666 ); 6667 let val = _f(cname); 6668 if val.is_null() { 6669 create_sampler_ycbcr_conversion 6670 } else { 6671 ::std::mem::transmute(val) 6672 } 6673 }, 6674 destroy_sampler_ycbcr_conversion: unsafe { 6675 extern "system" fn destroy_sampler_ycbcr_conversion( 6676 _device: Device, 6677 _ycbcr_conversion: SamplerYcbcrConversion, 6678 _p_allocator: *const AllocationCallbacks, 6679 ) { 6680 panic!(concat!( 6681 "Unable to load ", 6682 stringify!(destroy_sampler_ycbcr_conversion) 6683 )) 6684 } 6685 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6686 b"vkDestroySamplerYcbcrConversion\0", 6687 ); 6688 let val = _f(cname); 6689 if val.is_null() { 6690 destroy_sampler_ycbcr_conversion 6691 } else { 6692 ::std::mem::transmute(val) 6693 } 6694 }, 6695 create_descriptor_update_template: unsafe { 6696 extern "system" fn create_descriptor_update_template( 6697 _device: Device, 6698 _p_create_info: *const DescriptorUpdateTemplateCreateInfo, 6699 _p_allocator: *const AllocationCallbacks, 6700 _p_descriptor_update_template: *mut DescriptorUpdateTemplate, 6701 ) -> Result { 6702 panic!(concat!( 6703 "Unable to load ", 6704 stringify!(create_descriptor_update_template) 6705 )) 6706 } 6707 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6708 b"vkCreateDescriptorUpdateTemplate\0", 6709 ); 6710 let val = _f(cname); 6711 if val.is_null() { 6712 create_descriptor_update_template 6713 } else { 6714 ::std::mem::transmute(val) 6715 } 6716 }, 6717 destroy_descriptor_update_template: unsafe { 6718 extern "system" fn destroy_descriptor_update_template( 6719 _device: Device, 6720 _descriptor_update_template: DescriptorUpdateTemplate, 6721 _p_allocator: *const AllocationCallbacks, 6722 ) { 6723 panic!(concat!( 6724 "Unable to load ", 6725 stringify!(destroy_descriptor_update_template) 6726 )) 6727 } 6728 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6729 b"vkDestroyDescriptorUpdateTemplate\0", 6730 ); 6731 let val = _f(cname); 6732 if val.is_null() { 6733 destroy_descriptor_update_template 6734 } else { 6735 ::std::mem::transmute(val) 6736 } 6737 }, 6738 update_descriptor_set_with_template: unsafe { 6739 extern "system" fn update_descriptor_set_with_template( 6740 _device: Device, 6741 _descriptor_set: DescriptorSet, 6742 _descriptor_update_template: DescriptorUpdateTemplate, 6743 _p_data: *const c_void, 6744 ) { 6745 panic!(concat!( 6746 "Unable to load ", 6747 stringify!(update_descriptor_set_with_template) 6748 )) 6749 } 6750 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6751 b"vkUpdateDescriptorSetWithTemplate\0", 6752 ); 6753 let val = _f(cname); 6754 if val.is_null() { 6755 update_descriptor_set_with_template 6756 } else { 6757 ::std::mem::transmute(val) 6758 } 6759 }, 6760 get_descriptor_set_layout_support: unsafe { 6761 extern "system" fn get_descriptor_set_layout_support( 6762 _device: Device, 6763 _p_create_info: *const DescriptorSetLayoutCreateInfo, 6764 _p_support: *mut DescriptorSetLayoutSupport, 6765 ) { 6766 panic!(concat!( 6767 "Unable to load ", 6768 stringify!(get_descriptor_set_layout_support) 6769 )) 6770 } 6771 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 6772 b"vkGetDescriptorSetLayoutSupport\0", 6773 ); 6774 let val = _f(cname); 6775 if val.is_null() { 6776 get_descriptor_set_layout_support 6777 } else { 6778 ::std::mem::transmute(val) 6779 } 6780 }, 6781 } 6782 } 6783 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindBufferMemory2.html>"] bind_buffer_memory2( &self, device: Device, bind_info_count: u32, p_bind_infos: *const BindBufferMemoryInfo, ) -> Result6784 pub unsafe fn bind_buffer_memory2( 6785 &self, 6786 device: Device, 6787 bind_info_count: u32, 6788 p_bind_infos: *const BindBufferMemoryInfo, 6789 ) -> Result { 6790 (self.bind_buffer_memory2)(device, bind_info_count, p_bind_infos) 6791 } 6792 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkBindImageMemory2.html>"] bind_image_memory2( &self, device: Device, bind_info_count: u32, p_bind_infos: *const BindImageMemoryInfo, ) -> Result6793 pub unsafe fn bind_image_memory2( 6794 &self, 6795 device: Device, 6796 bind_info_count: u32, 6797 p_bind_infos: *const BindImageMemoryInfo, 6798 ) -> Result { 6799 (self.bind_image_memory2)(device, bind_info_count, p_bind_infos) 6800 } 6801 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceGroupPeerMemoryFeatures.html>"] get_device_group_peer_memory_features( &self, device: Device, heap_index: u32, local_device_index: u32, remote_device_index: u32, p_peer_memory_features: *mut PeerMemoryFeatureFlags, )6802 pub unsafe fn get_device_group_peer_memory_features( 6803 &self, 6804 device: Device, 6805 heap_index: u32, 6806 local_device_index: u32, 6807 remote_device_index: u32, 6808 p_peer_memory_features: *mut PeerMemoryFeatureFlags, 6809 ) { 6810 (self.get_device_group_peer_memory_features)( 6811 device, 6812 heap_index, 6813 local_device_index, 6814 remote_device_index, 6815 p_peer_memory_features, 6816 ) 6817 } 6818 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdSetDeviceMask.html>"] cmd_set_device_mask(&self, command_buffer: CommandBuffer, device_mask: u32)6819 pub unsafe fn cmd_set_device_mask(&self, command_buffer: CommandBuffer, device_mask: u32) { 6820 (self.cmd_set_device_mask)(command_buffer, device_mask) 6821 } 6822 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDispatchBase.html>"] cmd_dispatch_base( &self, command_buffer: CommandBuffer, base_group_x: u32, base_group_y: u32, base_group_z: u32, group_count_x: u32, group_count_y: u32, group_count_z: u32, )6823 pub unsafe fn cmd_dispatch_base( 6824 &self, 6825 command_buffer: CommandBuffer, 6826 base_group_x: u32, 6827 base_group_y: u32, 6828 base_group_z: u32, 6829 group_count_x: u32, 6830 group_count_y: u32, 6831 group_count_z: u32, 6832 ) { 6833 (self.cmd_dispatch_base)( 6834 command_buffer, 6835 base_group_x, 6836 base_group_y, 6837 base_group_z, 6838 group_count_x, 6839 group_count_y, 6840 group_count_z, 6841 ) 6842 } 6843 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageMemoryRequirements2.html>"] get_image_memory_requirements2( &self, device: Device, p_info: *const ImageMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, )6844 pub unsafe fn get_image_memory_requirements2( 6845 &self, 6846 device: Device, 6847 p_info: *const ImageMemoryRequirementsInfo2, 6848 p_memory_requirements: *mut MemoryRequirements2, 6849 ) { 6850 (self.get_image_memory_requirements2)(device, p_info, p_memory_requirements) 6851 } 6852 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferMemoryRequirements2.html>"] get_buffer_memory_requirements2( &self, device: Device, p_info: *const BufferMemoryRequirementsInfo2, p_memory_requirements: *mut MemoryRequirements2, )6853 pub unsafe fn get_buffer_memory_requirements2( 6854 &self, 6855 device: Device, 6856 p_info: *const BufferMemoryRequirementsInfo2, 6857 p_memory_requirements: *mut MemoryRequirements2, 6858 ) { 6859 (self.get_buffer_memory_requirements2)(device, p_info, p_memory_requirements) 6860 } 6861 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetImageSparseMemoryRequirements2.html>"] get_image_sparse_memory_requirements2( &self, device: Device, p_info: *const ImageSparseMemoryRequirementsInfo2, p_sparse_memory_requirement_count: *mut u32, p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, )6862 pub unsafe fn get_image_sparse_memory_requirements2( 6863 &self, 6864 device: Device, 6865 p_info: *const ImageSparseMemoryRequirementsInfo2, 6866 p_sparse_memory_requirement_count: *mut u32, 6867 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2, 6868 ) { 6869 (self.get_image_sparse_memory_requirements2)( 6870 device, 6871 p_info, 6872 p_sparse_memory_requirement_count, 6873 p_sparse_memory_requirements, 6874 ) 6875 } 6876 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkTrimCommandPool.html>"] trim_command_pool( &self, device: Device, command_pool: CommandPool, flags: CommandPoolTrimFlags, )6877 pub unsafe fn trim_command_pool( 6878 &self, 6879 device: Device, 6880 command_pool: CommandPool, 6881 flags: CommandPoolTrimFlags, 6882 ) { 6883 (self.trim_command_pool)(device, command_pool, flags) 6884 } 6885 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceQueue2.html>"] get_device_queue2( &self, device: Device, p_queue_info: *const DeviceQueueInfo2, p_queue: *mut Queue, )6886 pub unsafe fn get_device_queue2( 6887 &self, 6888 device: Device, 6889 p_queue_info: *const DeviceQueueInfo2, 6890 p_queue: *mut Queue, 6891 ) { 6892 (self.get_device_queue2)(device, p_queue_info, p_queue) 6893 } 6894 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateSamplerYcbcrConversion.html>"] create_sampler_ycbcr_conversion( &self, device: Device, p_create_info: *const SamplerYcbcrConversionCreateInfo, p_allocator: *const AllocationCallbacks, p_ycbcr_conversion: *mut SamplerYcbcrConversion, ) -> Result6895 pub unsafe fn create_sampler_ycbcr_conversion( 6896 &self, 6897 device: Device, 6898 p_create_info: *const SamplerYcbcrConversionCreateInfo, 6899 p_allocator: *const AllocationCallbacks, 6900 p_ycbcr_conversion: *mut SamplerYcbcrConversion, 6901 ) -> Result { 6902 (self.create_sampler_ycbcr_conversion)( 6903 device, 6904 p_create_info, 6905 p_allocator, 6906 p_ycbcr_conversion, 6907 ) 6908 } 6909 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroySamplerYcbcrConversion.html>"] destroy_sampler_ycbcr_conversion( &self, device: Device, ycbcr_conversion: SamplerYcbcrConversion, p_allocator: *const AllocationCallbacks, )6910 pub unsafe fn destroy_sampler_ycbcr_conversion( 6911 &self, 6912 device: Device, 6913 ycbcr_conversion: SamplerYcbcrConversion, 6914 p_allocator: *const AllocationCallbacks, 6915 ) { 6916 (self.destroy_sampler_ycbcr_conversion)(device, ycbcr_conversion, p_allocator) 6917 } 6918 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateDescriptorUpdateTemplate.html>"] create_descriptor_update_template( &self, device: Device, p_create_info: *const DescriptorUpdateTemplateCreateInfo, p_allocator: *const AllocationCallbacks, p_descriptor_update_template: *mut DescriptorUpdateTemplate, ) -> Result6919 pub unsafe fn create_descriptor_update_template( 6920 &self, 6921 device: Device, 6922 p_create_info: *const DescriptorUpdateTemplateCreateInfo, 6923 p_allocator: *const AllocationCallbacks, 6924 p_descriptor_update_template: *mut DescriptorUpdateTemplate, 6925 ) -> Result { 6926 (self.create_descriptor_update_template)( 6927 device, 6928 p_create_info, 6929 p_allocator, 6930 p_descriptor_update_template, 6931 ) 6932 } 6933 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkDestroyDescriptorUpdateTemplate.html>"] destroy_descriptor_update_template( &self, device: Device, descriptor_update_template: DescriptorUpdateTemplate, p_allocator: *const AllocationCallbacks, )6934 pub unsafe fn destroy_descriptor_update_template( 6935 &self, 6936 device: Device, 6937 descriptor_update_template: DescriptorUpdateTemplate, 6938 p_allocator: *const AllocationCallbacks, 6939 ) { 6940 (self.destroy_descriptor_update_template)(device, descriptor_update_template, p_allocator) 6941 } 6942 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkUpdateDescriptorSetWithTemplate.html>"] update_descriptor_set_with_template( &self, device: Device, descriptor_set: DescriptorSet, descriptor_update_template: DescriptorUpdateTemplate, p_data: *const c_void, )6943 pub unsafe fn update_descriptor_set_with_template( 6944 &self, 6945 device: Device, 6946 descriptor_set: DescriptorSet, 6947 descriptor_update_template: DescriptorUpdateTemplate, 6948 p_data: *const c_void, 6949 ) { 6950 (self.update_descriptor_set_with_template)( 6951 device, 6952 descriptor_set, 6953 descriptor_update_template, 6954 p_data, 6955 ) 6956 } 6957 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDescriptorSetLayoutSupport.html>"] get_descriptor_set_layout_support( &self, device: Device, p_create_info: *const DescriptorSetLayoutCreateInfo, p_support: *mut DescriptorSetLayoutSupport, )6958 pub unsafe fn get_descriptor_set_layout_support( 6959 &self, 6960 device: Device, 6961 p_create_info: *const DescriptorSetLayoutCreateInfo, 6962 p_support: *mut DescriptorSetLayoutSupport, 6963 ) { 6964 (self.get_descriptor_set_layout_support)(device, p_create_info, p_support) 6965 } 6966 } 6967 pub struct EntryFnV1_2 {} 6968 unsafe impl Send for EntryFnV1_2 {} 6969 unsafe impl Sync for EntryFnV1_2 {} 6970 impl ::std::clone::Clone for EntryFnV1_2 { clone(&self) -> Self6971 fn clone(&self) -> Self { 6972 EntryFnV1_2 {} 6973 } 6974 } 6975 impl EntryFnV1_2 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,6976 pub fn load<F>(mut _f: F) -> Self 6977 where 6978 F: FnMut(&::std::ffi::CStr) -> *const c_void, 6979 { 6980 EntryFnV1_2 {} 6981 } 6982 } 6983 pub struct InstanceFnV1_2 {} 6984 unsafe impl Send for InstanceFnV1_2 {} 6985 unsafe impl Sync for InstanceFnV1_2 {} 6986 impl ::std::clone::Clone for InstanceFnV1_2 { clone(&self) -> Self6987 fn clone(&self) -> Self { 6988 InstanceFnV1_2 {} 6989 } 6990 } 6991 impl InstanceFnV1_2 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,6992 pub fn load<F>(mut _f: F) -> Self 6993 where 6994 F: FnMut(&::std::ffi::CStr) -> *const c_void, 6995 { 6996 InstanceFnV1_2 {} 6997 } 6998 } 6999 pub struct DeviceFnV1_2 { 7000 pub cmd_draw_indirect_count: extern "system" fn( 7001 command_buffer: CommandBuffer, 7002 buffer: Buffer, 7003 offset: DeviceSize, 7004 count_buffer: Buffer, 7005 count_buffer_offset: DeviceSize, 7006 max_draw_count: u32, 7007 stride: u32, 7008 ), 7009 pub cmd_draw_indexed_indirect_count: extern "system" fn( 7010 command_buffer: CommandBuffer, 7011 buffer: Buffer, 7012 offset: DeviceSize, 7013 count_buffer: Buffer, 7014 count_buffer_offset: DeviceSize, 7015 max_draw_count: u32, 7016 stride: u32, 7017 ), 7018 pub create_render_pass2: extern "system" fn( 7019 device: Device, 7020 p_create_info: *const RenderPassCreateInfo2, 7021 p_allocator: *const AllocationCallbacks, 7022 p_render_pass: *mut RenderPass, 7023 ) -> Result, 7024 pub cmd_begin_render_pass2: extern "system" fn( 7025 command_buffer: CommandBuffer, 7026 p_render_pass_begin: *const RenderPassBeginInfo, 7027 p_subpass_begin_info: *const SubpassBeginInfo, 7028 ), 7029 pub cmd_next_subpass2: extern "system" fn( 7030 command_buffer: CommandBuffer, 7031 p_subpass_begin_info: *const SubpassBeginInfo, 7032 p_subpass_end_info: *const SubpassEndInfo, 7033 ), 7034 pub cmd_end_render_pass2: extern "system" fn( 7035 command_buffer: CommandBuffer, 7036 p_subpass_end_info: *const SubpassEndInfo, 7037 ), 7038 pub reset_query_pool: extern "system" fn( 7039 device: Device, 7040 query_pool: QueryPool, 7041 first_query: u32, 7042 query_count: u32, 7043 ), 7044 pub get_semaphore_counter_value: 7045 extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result, 7046 pub wait_semaphores: extern "system" fn( 7047 device: Device, 7048 p_wait_info: *const SemaphoreWaitInfo, 7049 timeout: u64, 7050 ) -> Result, 7051 pub signal_semaphore: 7052 extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result, 7053 pub get_buffer_device_address: 7054 extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> DeviceAddress, 7055 pub get_buffer_opaque_capture_address: 7056 extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64, 7057 pub get_device_memory_opaque_capture_address: extern "system" fn( 7058 device: Device, 7059 p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, 7060 ) -> u64, 7061 } 7062 unsafe impl Send for DeviceFnV1_2 {} 7063 unsafe impl Sync for DeviceFnV1_2 {} 7064 impl ::std::clone::Clone for DeviceFnV1_2 { clone(&self) -> Self7065 fn clone(&self) -> Self { 7066 DeviceFnV1_2 { 7067 cmd_draw_indirect_count: self.cmd_draw_indirect_count, 7068 cmd_draw_indexed_indirect_count: self.cmd_draw_indexed_indirect_count, 7069 create_render_pass2: self.create_render_pass2, 7070 cmd_begin_render_pass2: self.cmd_begin_render_pass2, 7071 cmd_next_subpass2: self.cmd_next_subpass2, 7072 cmd_end_render_pass2: self.cmd_end_render_pass2, 7073 reset_query_pool: self.reset_query_pool, 7074 get_semaphore_counter_value: self.get_semaphore_counter_value, 7075 wait_semaphores: self.wait_semaphores, 7076 signal_semaphore: self.signal_semaphore, 7077 get_buffer_device_address: self.get_buffer_device_address, 7078 get_buffer_opaque_capture_address: self.get_buffer_opaque_capture_address, 7079 get_device_memory_opaque_capture_address: self.get_device_memory_opaque_capture_address, 7080 } 7081 } 7082 } 7083 impl DeviceFnV1_2 { load<F>(mut _f: F) -> Self where F: FnMut(&::std::ffi::CStr) -> *const c_void,7084 pub fn load<F>(mut _f: F) -> Self 7085 where 7086 F: FnMut(&::std::ffi::CStr) -> *const c_void, 7087 { 7088 DeviceFnV1_2 { 7089 cmd_draw_indirect_count: unsafe { 7090 extern "system" fn cmd_draw_indirect_count( 7091 _command_buffer: CommandBuffer, 7092 _buffer: Buffer, 7093 _offset: DeviceSize, 7094 _count_buffer: Buffer, 7095 _count_buffer_offset: DeviceSize, 7096 _max_draw_count: u32, 7097 _stride: u32, 7098 ) { 7099 panic!(concat!( 7100 "Unable to load ", 7101 stringify!(cmd_draw_indirect_count) 7102 )) 7103 } 7104 let cname = 7105 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCount\0"); 7106 let val = _f(cname); 7107 if val.is_null() { 7108 cmd_draw_indirect_count 7109 } else { 7110 ::std::mem::transmute(val) 7111 } 7112 }, 7113 cmd_draw_indexed_indirect_count: unsafe { 7114 extern "system" fn cmd_draw_indexed_indirect_count( 7115 _command_buffer: CommandBuffer, 7116 _buffer: Buffer, 7117 _offset: DeviceSize, 7118 _count_buffer: Buffer, 7119 _count_buffer_offset: DeviceSize, 7120 _max_draw_count: u32, 7121 _stride: u32, 7122 ) { 7123 panic!(concat!( 7124 "Unable to load ", 7125 stringify!(cmd_draw_indexed_indirect_count) 7126 )) 7127 } 7128 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 7129 b"vkCmdDrawIndexedIndirectCount\0", 7130 ); 7131 let val = _f(cname); 7132 if val.is_null() { 7133 cmd_draw_indexed_indirect_count 7134 } else { 7135 ::std::mem::transmute(val) 7136 } 7137 }, 7138 create_render_pass2: unsafe { 7139 extern "system" fn create_render_pass2( 7140 _device: Device, 7141 _p_create_info: *const RenderPassCreateInfo2, 7142 _p_allocator: *const AllocationCallbacks, 7143 _p_render_pass: *mut RenderPass, 7144 ) -> Result { 7145 panic!(concat!("Unable to load ", stringify!(create_render_pass2))) 7146 } 7147 let cname = 7148 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2\0"); 7149 let val = _f(cname); 7150 if val.is_null() { 7151 create_render_pass2 7152 } else { 7153 ::std::mem::transmute(val) 7154 } 7155 }, 7156 cmd_begin_render_pass2: unsafe { 7157 extern "system" fn cmd_begin_render_pass2( 7158 _command_buffer: CommandBuffer, 7159 _p_render_pass_begin: *const RenderPassBeginInfo, 7160 _p_subpass_begin_info: *const SubpassBeginInfo, 7161 ) { 7162 panic!(concat!( 7163 "Unable to load ", 7164 stringify!(cmd_begin_render_pass2) 7165 )) 7166 } 7167 let cname = 7168 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2\0"); 7169 let val = _f(cname); 7170 if val.is_null() { 7171 cmd_begin_render_pass2 7172 } else { 7173 ::std::mem::transmute(val) 7174 } 7175 }, 7176 cmd_next_subpass2: unsafe { 7177 extern "system" fn cmd_next_subpass2( 7178 _command_buffer: CommandBuffer, 7179 _p_subpass_begin_info: *const SubpassBeginInfo, 7180 _p_subpass_end_info: *const SubpassEndInfo, 7181 ) { 7182 panic!(concat!("Unable to load ", stringify!(cmd_next_subpass2))) 7183 } 7184 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2\0"); 7185 let val = _f(cname); 7186 if val.is_null() { 7187 cmd_next_subpass2 7188 } else { 7189 ::std::mem::transmute(val) 7190 } 7191 }, 7192 cmd_end_render_pass2: unsafe { 7193 extern "system" fn cmd_end_render_pass2( 7194 _command_buffer: CommandBuffer, 7195 _p_subpass_end_info: *const SubpassEndInfo, 7196 ) { 7197 panic!(concat!("Unable to load ", stringify!(cmd_end_render_pass2))) 7198 } 7199 let cname = 7200 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2\0"); 7201 let val = _f(cname); 7202 if val.is_null() { 7203 cmd_end_render_pass2 7204 } else { 7205 ::std::mem::transmute(val) 7206 } 7207 }, 7208 reset_query_pool: unsafe { 7209 extern "system" fn reset_query_pool( 7210 _device: Device, 7211 _query_pool: QueryPool, 7212 _first_query: u32, 7213 _query_count: u32, 7214 ) { 7215 panic!(concat!("Unable to load ", stringify!(reset_query_pool))) 7216 } 7217 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPool\0"); 7218 let val = _f(cname); 7219 if val.is_null() { 7220 reset_query_pool 7221 } else { 7222 ::std::mem::transmute(val) 7223 } 7224 }, 7225 get_semaphore_counter_value: unsafe { 7226 extern "system" fn get_semaphore_counter_value( 7227 _device: Device, 7228 _semaphore: Semaphore, 7229 _p_value: *mut u64, 7230 ) -> Result { 7231 panic!(concat!( 7232 "Unable to load ", 7233 stringify!(get_semaphore_counter_value) 7234 )) 7235 } 7236 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 7237 b"vkGetSemaphoreCounterValue\0", 7238 ); 7239 let val = _f(cname); 7240 if val.is_null() { 7241 get_semaphore_counter_value 7242 } else { 7243 ::std::mem::transmute(val) 7244 } 7245 }, 7246 wait_semaphores: unsafe { 7247 extern "system" fn wait_semaphores( 7248 _device: Device, 7249 _p_wait_info: *const SemaphoreWaitInfo, 7250 _timeout: u64, 7251 ) -> Result { 7252 panic!(concat!("Unable to load ", stringify!(wait_semaphores))) 7253 } 7254 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphores\0"); 7255 let val = _f(cname); 7256 if val.is_null() { 7257 wait_semaphores 7258 } else { 7259 ::std::mem::transmute(val) 7260 } 7261 }, 7262 signal_semaphore: unsafe { 7263 extern "system" fn signal_semaphore( 7264 _device: Device, 7265 _p_signal_info: *const SemaphoreSignalInfo, 7266 ) -> Result { 7267 panic!(concat!("Unable to load ", stringify!(signal_semaphore))) 7268 } 7269 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphore\0"); 7270 let val = _f(cname); 7271 if val.is_null() { 7272 signal_semaphore 7273 } else { 7274 ::std::mem::transmute(val) 7275 } 7276 }, 7277 get_buffer_device_address: unsafe { 7278 extern "system" fn get_buffer_device_address( 7279 _device: Device, 7280 _p_info: *const BufferDeviceAddressInfo, 7281 ) -> DeviceAddress { 7282 panic!(concat!( 7283 "Unable to load ", 7284 stringify!(get_buffer_device_address) 7285 )) 7286 } 7287 let cname = 7288 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetBufferDeviceAddress\0"); 7289 let val = _f(cname); 7290 if val.is_null() { 7291 get_buffer_device_address 7292 } else { 7293 ::std::mem::transmute(val) 7294 } 7295 }, 7296 get_buffer_opaque_capture_address: unsafe { 7297 extern "system" fn get_buffer_opaque_capture_address( 7298 _device: Device, 7299 _p_info: *const BufferDeviceAddressInfo, 7300 ) -> u64 { 7301 panic!(concat!( 7302 "Unable to load ", 7303 stringify!(get_buffer_opaque_capture_address) 7304 )) 7305 } 7306 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 7307 b"vkGetBufferOpaqueCaptureAddress\0", 7308 ); 7309 let val = _f(cname); 7310 if val.is_null() { 7311 get_buffer_opaque_capture_address 7312 } else { 7313 ::std::mem::transmute(val) 7314 } 7315 }, 7316 get_device_memory_opaque_capture_address: unsafe { 7317 extern "system" fn get_device_memory_opaque_capture_address( 7318 _device: Device, 7319 _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, 7320 ) -> u64 { 7321 panic!(concat!( 7322 "Unable to load ", 7323 stringify!(get_device_memory_opaque_capture_address) 7324 )) 7325 } 7326 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked( 7327 b"vkGetDeviceMemoryOpaqueCaptureAddress\0", 7328 ); 7329 let val = _f(cname); 7330 if val.is_null() { 7331 get_device_memory_opaque_capture_address 7332 } else { 7333 ::std::mem::transmute(val) 7334 } 7335 }, 7336 } 7337 } 7338 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndirectCount.html>"] cmd_draw_indirect_count( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, )7339 pub unsafe fn cmd_draw_indirect_count( 7340 &self, 7341 command_buffer: CommandBuffer, 7342 buffer: Buffer, 7343 offset: DeviceSize, 7344 count_buffer: Buffer, 7345 count_buffer_offset: DeviceSize, 7346 max_draw_count: u32, 7347 stride: u32, 7348 ) { 7349 (self.cmd_draw_indirect_count)( 7350 command_buffer, 7351 buffer, 7352 offset, 7353 count_buffer, 7354 count_buffer_offset, 7355 max_draw_count, 7356 stride, 7357 ) 7358 } 7359 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdDrawIndexedIndirectCount.html>"] cmd_draw_indexed_indirect_count( &self, command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize, count_buffer: Buffer, count_buffer_offset: DeviceSize, max_draw_count: u32, stride: u32, )7360 pub unsafe fn cmd_draw_indexed_indirect_count( 7361 &self, 7362 command_buffer: CommandBuffer, 7363 buffer: Buffer, 7364 offset: DeviceSize, 7365 count_buffer: Buffer, 7366 count_buffer_offset: DeviceSize, 7367 max_draw_count: u32, 7368 stride: u32, 7369 ) { 7370 (self.cmd_draw_indexed_indirect_count)( 7371 command_buffer, 7372 buffer, 7373 offset, 7374 count_buffer, 7375 count_buffer_offset, 7376 max_draw_count, 7377 stride, 7378 ) 7379 } 7380 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCreateRenderPass2.html>"] create_render_pass2( &self, device: Device, p_create_info: *const RenderPassCreateInfo2, p_allocator: *const AllocationCallbacks, p_render_pass: *mut RenderPass, ) -> Result7381 pub unsafe fn create_render_pass2( 7382 &self, 7383 device: Device, 7384 p_create_info: *const RenderPassCreateInfo2, 7385 p_allocator: *const AllocationCallbacks, 7386 p_render_pass: *mut RenderPass, 7387 ) -> Result { 7388 (self.create_render_pass2)(device, p_create_info, p_allocator, p_render_pass) 7389 } 7390 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdBeginRenderPass2.html>"] cmd_begin_render_pass2( &self, command_buffer: CommandBuffer, p_render_pass_begin: *const RenderPassBeginInfo, p_subpass_begin_info: *const SubpassBeginInfo, )7391 pub unsafe fn cmd_begin_render_pass2( 7392 &self, 7393 command_buffer: CommandBuffer, 7394 p_render_pass_begin: *const RenderPassBeginInfo, 7395 p_subpass_begin_info: *const SubpassBeginInfo, 7396 ) { 7397 (self.cmd_begin_render_pass2)(command_buffer, p_render_pass_begin, p_subpass_begin_info) 7398 } 7399 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdNextSubpass2.html>"] cmd_next_subpass2( &self, command_buffer: CommandBuffer, p_subpass_begin_info: *const SubpassBeginInfo, p_subpass_end_info: *const SubpassEndInfo, )7400 pub unsafe fn cmd_next_subpass2( 7401 &self, 7402 command_buffer: CommandBuffer, 7403 p_subpass_begin_info: *const SubpassBeginInfo, 7404 p_subpass_end_info: *const SubpassEndInfo, 7405 ) { 7406 (self.cmd_next_subpass2)(command_buffer, p_subpass_begin_info, p_subpass_end_info) 7407 } 7408 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkCmdEndRenderPass2.html>"] cmd_end_render_pass2( &self, command_buffer: CommandBuffer, p_subpass_end_info: *const SubpassEndInfo, )7409 pub unsafe fn cmd_end_render_pass2( 7410 &self, 7411 command_buffer: CommandBuffer, 7412 p_subpass_end_info: *const SubpassEndInfo, 7413 ) { 7414 (self.cmd_end_render_pass2)(command_buffer, p_subpass_end_info) 7415 } 7416 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkResetQueryPool.html>"] reset_query_pool( &self, device: Device, query_pool: QueryPool, first_query: u32, query_count: u32, )7417 pub unsafe fn reset_query_pool( 7418 &self, 7419 device: Device, 7420 query_pool: QueryPool, 7421 first_query: u32, 7422 query_count: u32, 7423 ) { 7424 (self.reset_query_pool)(device, query_pool, first_query, query_count) 7425 } 7426 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetSemaphoreCounterValue.html>"] get_semaphore_counter_value( &self, device: Device, semaphore: Semaphore, p_value: *mut u64, ) -> Result7427 pub unsafe fn get_semaphore_counter_value( 7428 &self, 7429 device: Device, 7430 semaphore: Semaphore, 7431 p_value: *mut u64, 7432 ) -> Result { 7433 (self.get_semaphore_counter_value)(device, semaphore, p_value) 7434 } 7435 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkWaitSemaphores.html>"] wait_semaphores( &self, device: Device, p_wait_info: *const SemaphoreWaitInfo, timeout: u64, ) -> Result7436 pub unsafe fn wait_semaphores( 7437 &self, 7438 device: Device, 7439 p_wait_info: *const SemaphoreWaitInfo, 7440 timeout: u64, 7441 ) -> Result { 7442 (self.wait_semaphores)(device, p_wait_info, timeout) 7443 } 7444 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkSignalSemaphore.html>"] signal_semaphore( &self, device: Device, p_signal_info: *const SemaphoreSignalInfo, ) -> Result7445 pub unsafe fn signal_semaphore( 7446 &self, 7447 device: Device, 7448 p_signal_info: *const SemaphoreSignalInfo, 7449 ) -> Result { 7450 (self.signal_semaphore)(device, p_signal_info) 7451 } 7452 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferDeviceAddress.html>"] get_buffer_device_address( &self, device: Device, p_info: *const BufferDeviceAddressInfo, ) -> DeviceAddress7453 pub unsafe fn get_buffer_device_address( 7454 &self, 7455 device: Device, 7456 p_info: *const BufferDeviceAddressInfo, 7457 ) -> DeviceAddress { 7458 (self.get_buffer_device_address)(device, p_info) 7459 } 7460 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetBufferOpaqueCaptureAddress.html>"] get_buffer_opaque_capture_address( &self, device: Device, p_info: *const BufferDeviceAddressInfo, ) -> u647461 pub unsafe fn get_buffer_opaque_capture_address( 7462 &self, 7463 device: Device, 7464 p_info: *const BufferDeviceAddressInfo, 7465 ) -> u64 { 7466 (self.get_buffer_opaque_capture_address)(device, p_info) 7467 } 7468 #[doc = "<https://www.khronos.org/registry/vulkan/specs/1.2-extensions/man/html/vkGetDeviceMemoryOpaqueCaptureAddress.html>"] get_device_memory_opaque_capture_address( &self, device: Device, p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, ) -> u647469 pub unsafe fn get_device_memory_opaque_capture_address( 7470 &self, 7471 device: Device, 7472 p_info: *const DeviceMemoryOpaqueCaptureAddressInfo, 7473 ) -> u64 { 7474 (self.get_device_memory_opaque_capture_address)(device, p_info) 7475 } 7476 } 7477