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