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