1use crate::vk::aliases::*;
2use crate::vk::bitflags::*;
3use crate::vk::definitions::*;
4use crate::vk::enums::*;
5use crate::vk::platform_types::*;
6use std::os::raw::*;
7impl KhrSurfaceFn {
8 #[inline]
9 pub const fn name() -> &'static ::std::ffi::CStr {
10 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_surface\0") }
11 }
12 pub const SPEC_VERSION: u32 = 25u32;
13}
14#[allow(non_camel_case_types)]
15pub type PFN_vkDestroySurfaceKHR = unsafe extern "system" fn(
16 instance: Instance,
17 surface: SurfaceKHR,
18 p_allocator: *const AllocationCallbacks,
19);
20#[allow(non_camel_case_types)]
21pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn(
22 physical_device: PhysicalDevice,
23 queue_family_index: u32,
24 surface: SurfaceKHR,
25 p_supported: *mut Bool32,
26) -> Result;
27#[allow(non_camel_case_types)]
28pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn(
29 physical_device: PhysicalDevice,
30 surface: SurfaceKHR,
31 p_surface_capabilities: *mut SurfaceCapabilitiesKHR,
32) -> Result;
33#[allow(non_camel_case_types)]
34pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn(
35 physical_device: PhysicalDevice,
36 surface: SurfaceKHR,
37 p_surface_format_count: *mut u32,
38 p_surface_formats: *mut SurfaceFormatKHR,
39) -> Result;
40#[allow(non_camel_case_types)]
41pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn(
42 physical_device: PhysicalDevice,
43 surface: SurfaceKHR,
44 p_present_mode_count: *mut u32,
45 p_present_modes: *mut PresentModeKHR,
46) -> Result;
47#[derive(Clone)]
48pub struct KhrSurfaceFn {
49 pub destroy_surface_khr: PFN_vkDestroySurfaceKHR,
50 pub get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupportKHR,
51 pub get_physical_device_surface_capabilities_khr: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
52 pub get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR,
53 pub get_physical_device_surface_present_modes_khr:
54 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR,
55}
56unsafe impl Send for KhrSurfaceFn {}
57unsafe impl Sync for KhrSurfaceFn {}
58impl KhrSurfaceFn {
59 pub fn load<F>(mut _f: F) -> Self
60 where
61 F: FnMut(&::std::ffi::CStr) -> *const c_void,
62 {
63 Self {
64 destroy_surface_khr: unsafe {
65 unsafe extern "system" fn destroy_surface_khr(
66 _instance: Instance,
67 _surface: SurfaceKHR,
68 _p_allocator: *const AllocationCallbacks,
69 ) {
70 panic!(concat!("Unable to load ", stringify!(destroy_surface_khr)))
71 }
72 let cname =
73 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySurfaceKHR\0");
74 let val = _f(cname);
75 if val.is_null() {
76 destroy_surface_khr
77 } else {
78 ::std::mem::transmute(val)
79 }
80 },
81 get_physical_device_surface_support_khr: unsafe {
82 unsafe extern "system" fn get_physical_device_surface_support_khr(
83 _physical_device: PhysicalDevice,
84 _queue_family_index: u32,
85 _surface: SurfaceKHR,
86 _p_supported: *mut Bool32,
87 ) -> Result {
88 panic!(concat!(
89 "Unable to load ",
90 stringify!(get_physical_device_surface_support_khr)
91 ))
92 }
93 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
94 b"vkGetPhysicalDeviceSurfaceSupportKHR\0",
95 );
96 let val = _f(cname);
97 if val.is_null() {
98 get_physical_device_surface_support_khr
99 } else {
100 ::std::mem::transmute(val)
101 }
102 },
103 get_physical_device_surface_capabilities_khr: unsafe {
104 unsafe extern "system" fn get_physical_device_surface_capabilities_khr(
105 _physical_device: PhysicalDevice,
106 _surface: SurfaceKHR,
107 _p_surface_capabilities: *mut SurfaceCapabilitiesKHR,
108 ) -> Result {
109 panic!(concat!(
110 "Unable to load ",
111 stringify!(get_physical_device_surface_capabilities_khr)
112 ))
113 }
114 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
115 b"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\0",
116 );
117 let val = _f(cname);
118 if val.is_null() {
119 get_physical_device_surface_capabilities_khr
120 } else {
121 ::std::mem::transmute(val)
122 }
123 },
124 get_physical_device_surface_formats_khr: unsafe {
125 unsafe extern "system" fn get_physical_device_surface_formats_khr(
126 _physical_device: PhysicalDevice,
127 _surface: SurfaceKHR,
128 _p_surface_format_count: *mut u32,
129 _p_surface_formats: *mut SurfaceFormatKHR,
130 ) -> Result {
131 panic!(concat!(
132 "Unable to load ",
133 stringify!(get_physical_device_surface_formats_khr)
134 ))
135 }
136 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
137 b"vkGetPhysicalDeviceSurfaceFormatsKHR\0",
138 );
139 let val = _f(cname);
140 if val.is_null() {
141 get_physical_device_surface_formats_khr
142 } else {
143 ::std::mem::transmute(val)
144 }
145 },
146 get_physical_device_surface_present_modes_khr: unsafe {
147 unsafe extern "system" fn get_physical_device_surface_present_modes_khr(
148 _physical_device: PhysicalDevice,
149 _surface: SurfaceKHR,
150 _p_present_mode_count: *mut u32,
151 _p_present_modes: *mut PresentModeKHR,
152 ) -> Result {
153 panic!(concat!(
154 "Unable to load ",
155 stringify!(get_physical_device_surface_present_modes_khr)
156 ))
157 }
158 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
159 b"vkGetPhysicalDeviceSurfacePresentModesKHR\0",
160 );
161 let val = _f(cname);
162 if val.is_null() {
163 get_physical_device_surface_present_modes_khr
164 } else {
165 ::std::mem::transmute(val)
166 }
167 },
168 }
169 }
170}
171#[doc = "Generated from 'VK_KHR_surface'"]
172impl ObjectType {
173 pub const SURFACE_KHR: Self = Self(1_000_000_000);
174}
175#[doc = "Generated from 'VK_KHR_surface'"]
176impl Result {
177 pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1_000_000_000);
178 pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Self(-1_000_000_001);
179}
180impl KhrSwapchainFn {
181 #[inline]
182 pub const fn name() -> &'static ::std::ffi::CStr {
183 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain\0") }
184 }
185 pub const SPEC_VERSION: u32 = 70u32;
186}
187#[allow(non_camel_case_types)]
188pub type PFN_vkCreateSwapchainKHR = unsafe extern "system" fn(
189 device: Device,
190 p_create_info: *const SwapchainCreateInfoKHR,
191 p_allocator: *const AllocationCallbacks,
192 p_swapchain: *mut SwapchainKHR,
193) -> Result;
194#[allow(non_camel_case_types)]
195pub type PFN_vkDestroySwapchainKHR = unsafe extern "system" fn(
196 device: Device,
197 swapchain: SwapchainKHR,
198 p_allocator: *const AllocationCallbacks,
199);
200#[allow(non_camel_case_types)]
201pub type PFN_vkGetSwapchainImagesKHR = unsafe extern "system" fn(
202 device: Device,
203 swapchain: SwapchainKHR,
204 p_swapchain_image_count: *mut u32,
205 p_swapchain_images: *mut Image,
206) -> Result;
207#[allow(non_camel_case_types)]
208pub type PFN_vkAcquireNextImageKHR = unsafe extern "system" fn(
209 device: Device,
210 swapchain: SwapchainKHR,
211 timeout: u64,
212 semaphore: Semaphore,
213 fence: Fence,
214 p_image_index: *mut u32,
215) -> Result;
216#[allow(non_camel_case_types)]
217pub type PFN_vkQueuePresentKHR =
218 unsafe extern "system" fn(queue: Queue, p_present_info: *const PresentInfoKHR) -> Result;
219#[allow(non_camel_case_types)]
220pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn(
221 device: Device,
222 p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
223) -> Result;
224#[allow(non_camel_case_types)]
225pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn(
226 device: Device,
227 surface: SurfaceKHR,
228 p_modes: *mut DeviceGroupPresentModeFlagsKHR,
229) -> Result;
230#[allow(non_camel_case_types)]
231pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn(
232 physical_device: PhysicalDevice,
233 surface: SurfaceKHR,
234 p_rect_count: *mut u32,
235 p_rects: *mut Rect2D,
236) -> Result;
237#[allow(non_camel_case_types)]
238pub type PFN_vkAcquireNextImage2KHR = unsafe extern "system" fn(
239 device: Device,
240 p_acquire_info: *const AcquireNextImageInfoKHR,
241 p_image_index: *mut u32,
242) -> Result;
243#[derive(Clone)]
244pub struct KhrSwapchainFn {
245 pub create_swapchain_khr: PFN_vkCreateSwapchainKHR,
246 pub destroy_swapchain_khr: PFN_vkDestroySwapchainKHR,
247 pub get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR,
248 pub acquire_next_image_khr: PFN_vkAcquireNextImageKHR,
249 pub queue_present_khr: PFN_vkQueuePresentKHR,
250 pub get_device_group_present_capabilities_khr: PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
251 pub get_device_group_surface_present_modes_khr: PFN_vkGetDeviceGroupSurfacePresentModesKHR,
252 pub get_physical_device_present_rectangles_khr: PFN_vkGetPhysicalDevicePresentRectanglesKHR,
253 pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR,
254}
255unsafe impl Send for KhrSwapchainFn {}
256unsafe impl Sync for KhrSwapchainFn {}
257impl KhrSwapchainFn {
258 pub fn load<F>(mut _f: F) -> Self
259 where
260 F: FnMut(&::std::ffi::CStr) -> *const c_void,
261 {
262 Self {
263 create_swapchain_khr: unsafe {
264 unsafe extern "system" fn create_swapchain_khr(
265 _device: Device,
266 _p_create_info: *const SwapchainCreateInfoKHR,
267 _p_allocator: *const AllocationCallbacks,
268 _p_swapchain: *mut SwapchainKHR,
269 ) -> Result {
270 panic!(concat!("Unable to load ", stringify!(create_swapchain_khr)))
271 }
272 let cname =
273 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSwapchainKHR\0");
274 let val = _f(cname);
275 if val.is_null() {
276 create_swapchain_khr
277 } else {
278 ::std::mem::transmute(val)
279 }
280 },
281 destroy_swapchain_khr: unsafe {
282 unsafe extern "system" fn destroy_swapchain_khr(
283 _device: Device,
284 _swapchain: SwapchainKHR,
285 _p_allocator: *const AllocationCallbacks,
286 ) {
287 panic!(concat!(
288 "Unable to load ",
289 stringify!(destroy_swapchain_khr)
290 ))
291 }
292 let cname =
293 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySwapchainKHR\0");
294 let val = _f(cname);
295 if val.is_null() {
296 destroy_swapchain_khr
297 } else {
298 ::std::mem::transmute(val)
299 }
300 },
301 get_swapchain_images_khr: unsafe {
302 unsafe extern "system" fn get_swapchain_images_khr(
303 _device: Device,
304 _swapchain: SwapchainKHR,
305 _p_swapchain_image_count: *mut u32,
306 _p_swapchain_images: *mut Image,
307 ) -> Result {
308 panic!(concat!(
309 "Unable to load ",
310 stringify!(get_swapchain_images_khr)
311 ))
312 }
313 let cname =
314 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainImagesKHR\0");
315 let val = _f(cname);
316 if val.is_null() {
317 get_swapchain_images_khr
318 } else {
319 ::std::mem::transmute(val)
320 }
321 },
322 acquire_next_image_khr: unsafe {
323 unsafe extern "system" fn acquire_next_image_khr(
324 _device: Device,
325 _swapchain: SwapchainKHR,
326 _timeout: u64,
327 _semaphore: Semaphore,
328 _fence: Fence,
329 _p_image_index: *mut u32,
330 ) -> Result {
331 panic!(concat!(
332 "Unable to load ",
333 stringify!(acquire_next_image_khr)
334 ))
335 }
336 let cname =
337 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImageKHR\0");
338 let val = _f(cname);
339 if val.is_null() {
340 acquire_next_image_khr
341 } else {
342 ::std::mem::transmute(val)
343 }
344 },
345 queue_present_khr: unsafe {
346 unsafe extern "system" fn queue_present_khr(
347 _queue: Queue,
348 _p_present_info: *const PresentInfoKHR,
349 ) -> Result {
350 panic!(concat!("Unable to load ", stringify!(queue_present_khr)))
351 }
352 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueuePresentKHR\0");
353 let val = _f(cname);
354 if val.is_null() {
355 queue_present_khr
356 } else {
357 ::std::mem::transmute(val)
358 }
359 },
360 get_device_group_present_capabilities_khr: unsafe {
361 unsafe extern "system" fn get_device_group_present_capabilities_khr(
362 _device: Device,
363 _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
364 ) -> Result {
365 panic!(concat!(
366 "Unable to load ",
367 stringify!(get_device_group_present_capabilities_khr)
368 ))
369 }
370 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
371 b"vkGetDeviceGroupPresentCapabilitiesKHR\0",
372 );
373 let val = _f(cname);
374 if val.is_null() {
375 get_device_group_present_capabilities_khr
376 } else {
377 ::std::mem::transmute(val)
378 }
379 },
380 get_device_group_surface_present_modes_khr: unsafe {
381 unsafe extern "system" fn get_device_group_surface_present_modes_khr(
382 _device: Device,
383 _surface: SurfaceKHR,
384 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
385 ) -> Result {
386 panic!(concat!(
387 "Unable to load ",
388 stringify!(get_device_group_surface_present_modes_khr)
389 ))
390 }
391 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
392 b"vkGetDeviceGroupSurfacePresentModesKHR\0",
393 );
394 let val = _f(cname);
395 if val.is_null() {
396 get_device_group_surface_present_modes_khr
397 } else {
398 ::std::mem::transmute(val)
399 }
400 },
401 get_physical_device_present_rectangles_khr: unsafe {
402 unsafe extern "system" fn get_physical_device_present_rectangles_khr(
403 _physical_device: PhysicalDevice,
404 _surface: SurfaceKHR,
405 _p_rect_count: *mut u32,
406 _p_rects: *mut Rect2D,
407 ) -> Result {
408 panic!(concat!(
409 "Unable to load ",
410 stringify!(get_physical_device_present_rectangles_khr)
411 ))
412 }
413 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
414 b"vkGetPhysicalDevicePresentRectanglesKHR\0",
415 );
416 let val = _f(cname);
417 if val.is_null() {
418 get_physical_device_present_rectangles_khr
419 } else {
420 ::std::mem::transmute(val)
421 }
422 },
423 acquire_next_image2_khr: unsafe {
424 unsafe extern "system" fn acquire_next_image2_khr(
425 _device: Device,
426 _p_acquire_info: *const AcquireNextImageInfoKHR,
427 _p_image_index: *mut u32,
428 ) -> Result {
429 panic!(concat!(
430 "Unable to load ",
431 stringify!(acquire_next_image2_khr)
432 ))
433 }
434 let cname =
435 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0");
436 let val = _f(cname);
437 if val.is_null() {
438 acquire_next_image2_khr
439 } else {
440 ::std::mem::transmute(val)
441 }
442 },
443 }
444 }
445}
446#[doc = "Generated from 'VK_KHR_swapchain'"]
447impl ImageLayout {
448 pub const PRESENT_SRC_KHR: Self = Self(1_000_001_002);
449}
450#[doc = "Generated from 'VK_KHR_swapchain'"]
451impl ObjectType {
452 pub const SWAPCHAIN_KHR: Self = Self(1_000_001_000);
453}
454#[doc = "Generated from 'VK_KHR_swapchain'"]
455impl Result {
456 pub const SUBOPTIMAL_KHR: Self = Self(1_000_001_003);
457 pub const ERROR_OUT_OF_DATE_KHR: Self = Self(-1_000_001_004);
458}
459#[doc = "Generated from 'VK_KHR_swapchain'"]
460impl StructureType {
461 pub const SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_001_000);
462 pub const PRESENT_INFO_KHR: Self = Self(1_000_001_001);
463 pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = Self(1_000_060_007);
464 pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_008);
465 pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = Self(1_000_060_009);
466 pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = Self(1_000_060_010);
467 pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = Self(1_000_060_011);
468 pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_012);
469}
470#[doc = "Generated from 'VK_KHR_swapchain'"]
471impl SwapchainCreateFlagsKHR {
472 #[doc = "Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"]
473 pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b1);
474 #[doc = "Swapchain is protected"]
475 pub const PROTECTED: Self = Self(0b10);
476}
477impl KhrDisplayFn {
478 #[inline]
479 pub const fn name() -> &'static ::std::ffi::CStr {
480 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display\0") }
481 }
482 pub const SPEC_VERSION: u32 = 23u32;
483}
484#[allow(non_camel_case_types)]
485pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn(
486 physical_device: PhysicalDevice,
487 p_property_count: *mut u32,
488 p_properties: *mut DisplayPropertiesKHR,
489) -> Result;
490#[allow(non_camel_case_types)]
491pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn(
492 physical_device: PhysicalDevice,
493 p_property_count: *mut u32,
494 p_properties: *mut DisplayPlanePropertiesKHR,
495) -> Result;
496#[allow(non_camel_case_types)]
497pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn(
498 physical_device: PhysicalDevice,
499 plane_index: u32,
500 p_display_count: *mut u32,
501 p_displays: *mut DisplayKHR,
502) -> Result;
503#[allow(non_camel_case_types)]
504pub type PFN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn(
505 physical_device: PhysicalDevice,
506 display: DisplayKHR,
507 p_property_count: *mut u32,
508 p_properties: *mut DisplayModePropertiesKHR,
509) -> Result;
510#[allow(non_camel_case_types)]
511pub type PFN_vkCreateDisplayModeKHR = unsafe extern "system" fn(
512 physical_device: PhysicalDevice,
513 display: DisplayKHR,
514 p_create_info: *const DisplayModeCreateInfoKHR,
515 p_allocator: *const AllocationCallbacks,
516 p_mode: *mut DisplayModeKHR,
517) -> Result;
518#[allow(non_camel_case_types)]
519pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn(
520 physical_device: PhysicalDevice,
521 mode: DisplayModeKHR,
522 plane_index: u32,
523 p_capabilities: *mut DisplayPlaneCapabilitiesKHR,
524) -> Result;
525#[allow(non_camel_case_types)]
526pub type PFN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn(
527 instance: Instance,
528 p_create_info: *const DisplaySurfaceCreateInfoKHR,
529 p_allocator: *const AllocationCallbacks,
530 p_surface: *mut SurfaceKHR,
531) -> Result;
532#[derive(Clone)]
533pub struct KhrDisplayFn {
534 pub get_physical_device_display_properties_khr: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR,
535 pub get_physical_device_display_plane_properties_khr:
536 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,
537 pub get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDisplaysKHR,
538 pub get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR,
539 pub create_display_mode_khr: PFN_vkCreateDisplayModeKHR,
540 pub get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR,
541 pub create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR,
542}
543unsafe impl Send for KhrDisplayFn {}
544unsafe impl Sync for KhrDisplayFn {}
545impl KhrDisplayFn {
546 pub fn load<F>(mut _f: F) -> Self
547 where
548 F: FnMut(&::std::ffi::CStr) -> *const c_void,
549 {
550 Self {
551 get_physical_device_display_properties_khr: unsafe {
552 unsafe extern "system" fn get_physical_device_display_properties_khr(
553 _physical_device: PhysicalDevice,
554 _p_property_count: *mut u32,
555 _p_properties: *mut DisplayPropertiesKHR,
556 ) -> Result {
557 panic!(concat!(
558 "Unable to load ",
559 stringify!(get_physical_device_display_properties_khr)
560 ))
561 }
562 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
563 b"vkGetPhysicalDeviceDisplayPropertiesKHR\0",
564 );
565 let val = _f(cname);
566 if val.is_null() {
567 get_physical_device_display_properties_khr
568 } else {
569 ::std::mem::transmute(val)
570 }
571 },
572 get_physical_device_display_plane_properties_khr: unsafe {
573 unsafe extern "system" fn get_physical_device_display_plane_properties_khr(
574 _physical_device: PhysicalDevice,
575 _p_property_count: *mut u32,
576 _p_properties: *mut DisplayPlanePropertiesKHR,
577 ) -> Result {
578 panic!(concat!(
579 "Unable to load ",
580 stringify!(get_physical_device_display_plane_properties_khr)
581 ))
582 }
583 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
584 b"vkGetPhysicalDeviceDisplayPlanePropertiesKHR\0",
585 );
586 let val = _f(cname);
587 if val.is_null() {
588 get_physical_device_display_plane_properties_khr
589 } else {
590 ::std::mem::transmute(val)
591 }
592 },
593 get_display_plane_supported_displays_khr: unsafe {
594 unsafe extern "system" fn get_display_plane_supported_displays_khr(
595 _physical_device: PhysicalDevice,
596 _plane_index: u32,
597 _p_display_count: *mut u32,
598 _p_displays: *mut DisplayKHR,
599 ) -> Result {
600 panic!(concat!(
601 "Unable to load ",
602 stringify!(get_display_plane_supported_displays_khr)
603 ))
604 }
605 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
606 b"vkGetDisplayPlaneSupportedDisplaysKHR\0",
607 );
608 let val = _f(cname);
609 if val.is_null() {
610 get_display_plane_supported_displays_khr
611 } else {
612 ::std::mem::transmute(val)
613 }
614 },
615 get_display_mode_properties_khr: unsafe {
616 unsafe extern "system" fn get_display_mode_properties_khr(
617 _physical_device: PhysicalDevice,
618 _display: DisplayKHR,
619 _p_property_count: *mut u32,
620 _p_properties: *mut DisplayModePropertiesKHR,
621 ) -> Result {
622 panic!(concat!(
623 "Unable to load ",
624 stringify!(get_display_mode_properties_khr)
625 ))
626 }
627 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
628 b"vkGetDisplayModePropertiesKHR\0",
629 );
630 let val = _f(cname);
631 if val.is_null() {
632 get_display_mode_properties_khr
633 } else {
634 ::std::mem::transmute(val)
635 }
636 },
637 create_display_mode_khr: unsafe {
638 unsafe extern "system" fn create_display_mode_khr(
639 _physical_device: PhysicalDevice,
640 _display: DisplayKHR,
641 _p_create_info: *const DisplayModeCreateInfoKHR,
642 _p_allocator: *const AllocationCallbacks,
643 _p_mode: *mut DisplayModeKHR,
644 ) -> Result {
645 panic!(concat!(
646 "Unable to load ",
647 stringify!(create_display_mode_khr)
648 ))
649 }
650 let cname =
651 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDisplayModeKHR\0");
652 let val = _f(cname);
653 if val.is_null() {
654 create_display_mode_khr
655 } else {
656 ::std::mem::transmute(val)
657 }
658 },
659 get_display_plane_capabilities_khr: unsafe {
660 unsafe extern "system" fn get_display_plane_capabilities_khr(
661 _physical_device: PhysicalDevice,
662 _mode: DisplayModeKHR,
663 _plane_index: u32,
664 _p_capabilities: *mut DisplayPlaneCapabilitiesKHR,
665 ) -> Result {
666 panic!(concat!(
667 "Unable to load ",
668 stringify!(get_display_plane_capabilities_khr)
669 ))
670 }
671 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
672 b"vkGetDisplayPlaneCapabilitiesKHR\0",
673 );
674 let val = _f(cname);
675 if val.is_null() {
676 get_display_plane_capabilities_khr
677 } else {
678 ::std::mem::transmute(val)
679 }
680 },
681 create_display_plane_surface_khr: unsafe {
682 unsafe extern "system" fn create_display_plane_surface_khr(
683 _instance: Instance,
684 _p_create_info: *const DisplaySurfaceCreateInfoKHR,
685 _p_allocator: *const AllocationCallbacks,
686 _p_surface: *mut SurfaceKHR,
687 ) -> Result {
688 panic!(concat!(
689 "Unable to load ",
690 stringify!(create_display_plane_surface_khr)
691 ))
692 }
693 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
694 b"vkCreateDisplayPlaneSurfaceKHR\0",
695 );
696 let val = _f(cname);
697 if val.is_null() {
698 create_display_plane_surface_khr
699 } else {
700 ::std::mem::transmute(val)
701 }
702 },
703 }
704 }
705}
706#[doc = "Generated from 'VK_KHR_display'"]
707impl ObjectType {
708 pub const DISPLAY_KHR: Self = Self(1_000_002_000);
709 pub const DISPLAY_MODE_KHR: Self = Self(1_000_002_001);
710}
711#[doc = "Generated from 'VK_KHR_display'"]
712impl StructureType {
713 pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1_000_002_000);
714 pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_002_001);
715}
716impl KhrDisplaySwapchainFn {
717 #[inline]
718 pub const fn name() -> &'static ::std::ffi::CStr {
719 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display_swapchain\0") }
720 }
721 pub const SPEC_VERSION: u32 = 10u32;
722}
723#[allow(non_camel_case_types)]
724pub type PFN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn(
725 device: Device,
726 swapchain_count: u32,
727 p_create_infos: *const SwapchainCreateInfoKHR,
728 p_allocator: *const AllocationCallbacks,
729 p_swapchains: *mut SwapchainKHR,
730) -> Result;
731#[derive(Clone)]
732pub struct KhrDisplaySwapchainFn {
733 pub create_shared_swapchains_khr: PFN_vkCreateSharedSwapchainsKHR,
734}
735unsafe impl Send for KhrDisplaySwapchainFn {}
736unsafe impl Sync for KhrDisplaySwapchainFn {}
737impl KhrDisplaySwapchainFn {
738 pub fn load<F>(mut _f: F) -> Self
739 where
740 F: FnMut(&::std::ffi::CStr) -> *const c_void,
741 {
742 Self {
743 create_shared_swapchains_khr: unsafe {
744 unsafe extern "system" fn create_shared_swapchains_khr(
745 _device: Device,
746 _swapchain_count: u32,
747 _p_create_infos: *const SwapchainCreateInfoKHR,
748 _p_allocator: *const AllocationCallbacks,
749 _p_swapchains: *mut SwapchainKHR,
750 ) -> Result {
751 panic!(concat!(
752 "Unable to load ",
753 stringify!(create_shared_swapchains_khr)
754 ))
755 }
756 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
757 b"vkCreateSharedSwapchainsKHR\0",
758 );
759 let val = _f(cname);
760 if val.is_null() {
761 create_shared_swapchains_khr
762 } else {
763 ::std::mem::transmute(val)
764 }
765 },
766 }
767 }
768}
769#[doc = "Generated from 'VK_KHR_display_swapchain'"]
770impl Result {
771 pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Self(-1_000_003_001);
772}
773#[doc = "Generated from 'VK_KHR_display_swapchain'"]
774impl StructureType {
775 pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1_000_003_000);
776}
777impl KhrXlibSurfaceFn {
778 #[inline]
779 pub const fn name() -> &'static ::std::ffi::CStr {
780 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xlib_surface\0") }
781 }
782 pub const SPEC_VERSION: u32 = 6u32;
783}
784#[allow(non_camel_case_types)]
785pub type PFN_vkCreateXlibSurfaceKHR = unsafe extern "system" fn(
786 instance: Instance,
787 p_create_info: *const XlibSurfaceCreateInfoKHR,
788 p_allocator: *const AllocationCallbacks,
789 p_surface: *mut SurfaceKHR,
790) -> Result;
791#[allow(non_camel_case_types)]
792pub type PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = unsafe extern "system" fn(
793 physical_device: PhysicalDevice,
794 queue_family_index: u32,
795 dpy: *mut Display,
796 visual_id: VisualID,
797) -> Bool32;
798#[derive(Clone)]
799pub struct KhrXlibSurfaceFn {
800 pub create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR,
801 pub get_physical_device_xlib_presentation_support_khr:
802 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR,
803}
804unsafe impl Send for KhrXlibSurfaceFn {}
805unsafe impl Sync for KhrXlibSurfaceFn {}
806impl KhrXlibSurfaceFn {
807 pub fn load<F>(mut _f: F) -> Self
808 where
809 F: FnMut(&::std::ffi::CStr) -> *const c_void,
810 {
811 Self {
812 create_xlib_surface_khr: unsafe {
813 unsafe extern "system" fn create_xlib_surface_khr(
814 _instance: Instance,
815 _p_create_info: *const XlibSurfaceCreateInfoKHR,
816 _p_allocator: *const AllocationCallbacks,
817 _p_surface: *mut SurfaceKHR,
818 ) -> Result {
819 panic!(concat!(
820 "Unable to load ",
821 stringify!(create_xlib_surface_khr)
822 ))
823 }
824 let cname =
825 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXlibSurfaceKHR\0");
826 let val = _f(cname);
827 if val.is_null() {
828 create_xlib_surface_khr
829 } else {
830 ::std::mem::transmute(val)
831 }
832 },
833 get_physical_device_xlib_presentation_support_khr: unsafe {
834 unsafe extern "system" fn get_physical_device_xlib_presentation_support_khr(
835 _physical_device: PhysicalDevice,
836 _queue_family_index: u32,
837 _dpy: *mut Display,
838 _visual_id: VisualID,
839 ) -> Bool32 {
840 panic!(concat!(
841 "Unable to load ",
842 stringify!(get_physical_device_xlib_presentation_support_khr)
843 ))
844 }
845 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
846 b"vkGetPhysicalDeviceXlibPresentationSupportKHR\0",
847 );
848 let val = _f(cname);
849 if val.is_null() {
850 get_physical_device_xlib_presentation_support_khr
851 } else {
852 ::std::mem::transmute(val)
853 }
854 },
855 }
856 }
857}
858#[doc = "Generated from 'VK_KHR_xlib_surface'"]
859impl StructureType {
860 pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_004_000);
861}
862impl KhrXcbSurfaceFn {
863 #[inline]
864 pub const fn name() -> &'static ::std::ffi::CStr {
865 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xcb_surface\0") }
866 }
867 pub const SPEC_VERSION: u32 = 6u32;
868}
869#[allow(non_camel_case_types)]
870pub type PFN_vkCreateXcbSurfaceKHR = unsafe extern "system" fn(
871 instance: Instance,
872 p_create_info: *const XcbSurfaceCreateInfoKHR,
873 p_allocator: *const AllocationCallbacks,
874 p_surface: *mut SurfaceKHR,
875) -> Result;
876#[allow(non_camel_case_types)]
877pub type PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe extern "system" fn(
878 physical_device: PhysicalDevice,
879 queue_family_index: u32,
880 connection: *mut xcb_connection_t,
881 visual_id: xcb_visualid_t,
882) -> Bool32;
883#[derive(Clone)]
884pub struct KhrXcbSurfaceFn {
885 pub create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR,
886 pub get_physical_device_xcb_presentation_support_khr:
887 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
888}
889unsafe impl Send for KhrXcbSurfaceFn {}
890unsafe impl Sync for KhrXcbSurfaceFn {}
891impl KhrXcbSurfaceFn {
892 pub fn load<F>(mut _f: F) -> Self
893 where
894 F: FnMut(&::std::ffi::CStr) -> *const c_void,
895 {
896 Self {
897 create_xcb_surface_khr: unsafe {
898 unsafe extern "system" fn create_xcb_surface_khr(
899 _instance: Instance,
900 _p_create_info: *const XcbSurfaceCreateInfoKHR,
901 _p_allocator: *const AllocationCallbacks,
902 _p_surface: *mut SurfaceKHR,
903 ) -> Result {
904 panic!(concat!(
905 "Unable to load ",
906 stringify!(create_xcb_surface_khr)
907 ))
908 }
909 let cname =
910 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXcbSurfaceKHR\0");
911 let val = _f(cname);
912 if val.is_null() {
913 create_xcb_surface_khr
914 } else {
915 ::std::mem::transmute(val)
916 }
917 },
918 get_physical_device_xcb_presentation_support_khr: unsafe {
919 unsafe extern "system" fn get_physical_device_xcb_presentation_support_khr(
920 _physical_device: PhysicalDevice,
921 _queue_family_index: u32,
922 _connection: *mut xcb_connection_t,
923 _visual_id: xcb_visualid_t,
924 ) -> Bool32 {
925 panic!(concat!(
926 "Unable to load ",
927 stringify!(get_physical_device_xcb_presentation_support_khr)
928 ))
929 }
930 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
931 b"vkGetPhysicalDeviceXcbPresentationSupportKHR\0",
932 );
933 let val = _f(cname);
934 if val.is_null() {
935 get_physical_device_xcb_presentation_support_khr
936 } else {
937 ::std::mem::transmute(val)
938 }
939 },
940 }
941 }
942}
943#[doc = "Generated from 'VK_KHR_xcb_surface'"]
944impl StructureType {
945 pub const XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_005_000);
946}
947impl KhrWaylandSurfaceFn {
948 #[inline]
949 pub const fn name() -> &'static ::std::ffi::CStr {
950 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_wayland_surface\0") }
951 }
952 pub const SPEC_VERSION: u32 = 6u32;
953}
954#[allow(non_camel_case_types)]
955pub type PFN_vkCreateWaylandSurfaceKHR = unsafe extern "system" fn(
956 instance: Instance,
957 p_create_info: *const WaylandSurfaceCreateInfoKHR,
958 p_allocator: *const AllocationCallbacks,
959 p_surface: *mut SurfaceKHR,
960) -> Result;
961#[allow(non_camel_case_types)]
962pub type PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = unsafe extern "system" fn(
963 physical_device: PhysicalDevice,
964 queue_family_index: u32,
965 display: *mut wl_display,
966)
967 -> Bool32;
968#[derive(Clone)]
969pub struct KhrWaylandSurfaceFn {
970 pub create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR,
971 pub get_physical_device_wayland_presentation_support_khr:
972 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
973}
974unsafe impl Send for KhrWaylandSurfaceFn {}
975unsafe impl Sync for KhrWaylandSurfaceFn {}
976impl KhrWaylandSurfaceFn {
977 pub fn load<F>(mut _f: F) -> Self
978 where
979 F: FnMut(&::std::ffi::CStr) -> *const c_void,
980 {
981 Self {
982 create_wayland_surface_khr: unsafe {
983 unsafe extern "system" fn create_wayland_surface_khr(
984 _instance: Instance,
985 _p_create_info: *const WaylandSurfaceCreateInfoKHR,
986 _p_allocator: *const AllocationCallbacks,
987 _p_surface: *mut SurfaceKHR,
988 ) -> Result {
989 panic!(concat!(
990 "Unable to load ",
991 stringify!(create_wayland_surface_khr)
992 ))
993 }
994 let cname =
995 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWaylandSurfaceKHR\0");
996 let val = _f(cname);
997 if val.is_null() {
998 create_wayland_surface_khr
999 } else {
1000 ::std::mem::transmute(val)
1001 }
1002 },
1003 get_physical_device_wayland_presentation_support_khr: unsafe {
1004 unsafe extern "system" fn get_physical_device_wayland_presentation_support_khr(
1005 _physical_device: PhysicalDevice,
1006 _queue_family_index: u32,
1007 _display: *mut wl_display,
1008 ) -> Bool32 {
1009 panic!(concat!(
1010 "Unable to load ",
1011 stringify!(get_physical_device_wayland_presentation_support_khr)
1012 ))
1013 }
1014 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1015 b"vkGetPhysicalDeviceWaylandPresentationSupportKHR\0",
1016 );
1017 let val = _f(cname);
1018 if val.is_null() {
1019 get_physical_device_wayland_presentation_support_khr
1020 } else {
1021 ::std::mem::transmute(val)
1022 }
1023 },
1024 }
1025 }
1026}
1027#[doc = "Generated from 'VK_KHR_wayland_surface'"]
1028impl StructureType {
1029 pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_006_000);
1030}
1031impl KhrMirSurfaceFn {
1032 #[inline]
1033 pub const fn name() -> &'static ::std::ffi::CStr {
1034 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_mir_surface\0") }
1035 }
1036 pub const SPEC_VERSION: u32 = 4u32;
1037}
1038#[derive(Clone)]
1039pub struct KhrMirSurfaceFn {}
1040unsafe impl Send for KhrMirSurfaceFn {}
1041unsafe impl Sync for KhrMirSurfaceFn {}
1042impl KhrMirSurfaceFn {
1043 pub fn load<F>(mut _f: F) -> Self
1044 where
1045 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1046 {
1047 Self {}
1048 }
1049}
1050impl KhrAndroidSurfaceFn {
1051 #[inline]
1052 pub const fn name() -> &'static ::std::ffi::CStr {
1053 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_android_surface\0") }
1054 }
1055 pub const SPEC_VERSION: u32 = 6u32;
1056}
1057#[allow(non_camel_case_types)]
1058pub type PFN_vkCreateAndroidSurfaceKHR = unsafe extern "system" fn(
1059 instance: Instance,
1060 p_create_info: *const AndroidSurfaceCreateInfoKHR,
1061 p_allocator: *const AllocationCallbacks,
1062 p_surface: *mut SurfaceKHR,
1063) -> Result;
1064#[derive(Clone)]
1065pub struct KhrAndroidSurfaceFn {
1066 pub create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR,
1067}
1068unsafe impl Send for KhrAndroidSurfaceFn {}
1069unsafe impl Sync for KhrAndroidSurfaceFn {}
1070impl KhrAndroidSurfaceFn {
1071 pub fn load<F>(mut _f: F) -> Self
1072 where
1073 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1074 {
1075 Self {
1076 create_android_surface_khr: unsafe {
1077 unsafe extern "system" fn create_android_surface_khr(
1078 _instance: Instance,
1079 _p_create_info: *const AndroidSurfaceCreateInfoKHR,
1080 _p_allocator: *const AllocationCallbacks,
1081 _p_surface: *mut SurfaceKHR,
1082 ) -> Result {
1083 panic!(concat!(
1084 "Unable to load ",
1085 stringify!(create_android_surface_khr)
1086 ))
1087 }
1088 let cname =
1089 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateAndroidSurfaceKHR\0");
1090 let val = _f(cname);
1091 if val.is_null() {
1092 create_android_surface_khr
1093 } else {
1094 ::std::mem::transmute(val)
1095 }
1096 },
1097 }
1098 }
1099}
1100#[doc = "Generated from 'VK_KHR_android_surface'"]
1101impl StructureType {
1102 pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_008_000);
1103}
1104impl KhrWin32SurfaceFn {
1105 #[inline]
1106 pub const fn name() -> &'static ::std::ffi::CStr {
1107 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_surface\0") }
1108 }
1109 pub const SPEC_VERSION: u32 = 6u32;
1110}
1111#[allow(non_camel_case_types)]
1112pub type PFN_vkCreateWin32SurfaceKHR = unsafe extern "system" fn(
1113 instance: Instance,
1114 p_create_info: *const Win32SurfaceCreateInfoKHR,
1115 p_allocator: *const AllocationCallbacks,
1116 p_surface: *mut SurfaceKHR,
1117) -> Result;
1118#[allow(non_camel_case_types)]
1119pub type PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR =
1120 unsafe extern "system" fn(physical_device: PhysicalDevice, queue_family_index: u32) -> Bool32;
1121#[derive(Clone)]
1122pub struct KhrWin32SurfaceFn {
1123 pub create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR,
1124 pub get_physical_device_win32_presentation_support_khr:
1125 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR,
1126}
1127unsafe impl Send for KhrWin32SurfaceFn {}
1128unsafe impl Sync for KhrWin32SurfaceFn {}
1129impl KhrWin32SurfaceFn {
1130 pub fn load<F>(mut _f: F) -> Self
1131 where
1132 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1133 {
1134 Self {
1135 create_win32_surface_khr: unsafe {
1136 unsafe extern "system" fn create_win32_surface_khr(
1137 _instance: Instance,
1138 _p_create_info: *const Win32SurfaceCreateInfoKHR,
1139 _p_allocator: *const AllocationCallbacks,
1140 _p_surface: *mut SurfaceKHR,
1141 ) -> Result {
1142 panic!(concat!(
1143 "Unable to load ",
1144 stringify!(create_win32_surface_khr)
1145 ))
1146 }
1147 let cname =
1148 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWin32SurfaceKHR\0");
1149 let val = _f(cname);
1150 if val.is_null() {
1151 create_win32_surface_khr
1152 } else {
1153 ::std::mem::transmute(val)
1154 }
1155 },
1156 get_physical_device_win32_presentation_support_khr: unsafe {
1157 unsafe extern "system" fn get_physical_device_win32_presentation_support_khr(
1158 _physical_device: PhysicalDevice,
1159 _queue_family_index: u32,
1160 ) -> Bool32 {
1161 panic!(concat!(
1162 "Unable to load ",
1163 stringify!(get_physical_device_win32_presentation_support_khr)
1164 ))
1165 }
1166 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1167 b"vkGetPhysicalDeviceWin32PresentationSupportKHR\0",
1168 );
1169 let val = _f(cname);
1170 if val.is_null() {
1171 get_physical_device_win32_presentation_support_khr
1172 } else {
1173 ::std::mem::transmute(val)
1174 }
1175 },
1176 }
1177 }
1178}
1179#[doc = "Generated from 'VK_KHR_win32_surface'"]
1180impl StructureType {
1181 pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_009_000);
1182}
1183impl AndroidNativeBufferFn {
1184 #[inline]
1185 pub const fn name() -> &'static ::std::ffi::CStr {
1186 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_native_buffer\0") }
1187 }
1188 pub const SPEC_VERSION: u32 = 8u32;
1189}
1190#[allow(non_camel_case_types)]
1191pub type PFN_vkGetSwapchainGrallocUsageANDROID = unsafe extern "system" fn(
1192 device: Device,
1193 format: Format,
1194 image_usage: ImageUsageFlags,
1195 gralloc_usage: *mut c_int,
1196) -> Result;
1197#[allow(non_camel_case_types)]
1198pub type PFN_vkAcquireImageANDROID = unsafe extern "system" fn(
1199 device: Device,
1200 image: Image,
1201 native_fence_fd: c_int,
1202 semaphore: Semaphore,
1203 fence: Fence,
1204) -> Result;
1205#[allow(non_camel_case_types)]
1206pub type PFN_vkQueueSignalReleaseImageANDROID = unsafe extern "system" fn(
1207 queue: Queue,
1208 wait_semaphore_count: u32,
1209 p_wait_semaphores: *const Semaphore,
1210 image: Image,
1211 p_native_fence_fd: *mut c_int,
1212) -> Result;
1213#[allow(non_camel_case_types)]
1214pub type PFN_vkGetSwapchainGrallocUsage2ANDROID = unsafe extern "system" fn(
1215 device: Device,
1216 format: Format,
1217 image_usage: ImageUsageFlags,
1218 swapchain_image_usage: SwapchainImageUsageFlagsANDROID,
1219 gralloc_consumer_usage: *mut u64,
1220 gralloc_producer_usage: *mut u64,
1221) -> Result;
1222#[derive(Clone)]
1223pub struct AndroidNativeBufferFn {
1224 pub get_swapchain_gralloc_usage_android: PFN_vkGetSwapchainGrallocUsageANDROID,
1225 pub acquire_image_android: PFN_vkAcquireImageANDROID,
1226 pub queue_signal_release_image_android: PFN_vkQueueSignalReleaseImageANDROID,
1227 pub get_swapchain_gralloc_usage2_android: PFN_vkGetSwapchainGrallocUsage2ANDROID,
1228}
1229unsafe impl Send for AndroidNativeBufferFn {}
1230unsafe impl Sync for AndroidNativeBufferFn {}
1231impl AndroidNativeBufferFn {
1232 pub fn load<F>(mut _f: F) -> Self
1233 where
1234 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1235 {
1236 Self {
1237 get_swapchain_gralloc_usage_android: unsafe {
1238 unsafe extern "system" fn get_swapchain_gralloc_usage_android(
1239 _device: Device,
1240 _format: Format,
1241 _image_usage: ImageUsageFlags,
1242 _gralloc_usage: *mut c_int,
1243 ) -> Result {
1244 panic!(concat!(
1245 "Unable to load ",
1246 stringify!(get_swapchain_gralloc_usage_android)
1247 ))
1248 }
1249 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1250 b"vkGetSwapchainGrallocUsageANDROID\0",
1251 );
1252 let val = _f(cname);
1253 if val.is_null() {
1254 get_swapchain_gralloc_usage_android
1255 } else {
1256 ::std::mem::transmute(val)
1257 }
1258 },
1259 acquire_image_android: unsafe {
1260 unsafe extern "system" fn acquire_image_android(
1261 _device: Device,
1262 _image: Image,
1263 _native_fence_fd: c_int,
1264 _semaphore: Semaphore,
1265 _fence: Fence,
1266 ) -> Result {
1267 panic!(concat!(
1268 "Unable to load ",
1269 stringify!(acquire_image_android)
1270 ))
1271 }
1272 let cname =
1273 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireImageANDROID\0");
1274 let val = _f(cname);
1275 if val.is_null() {
1276 acquire_image_android
1277 } else {
1278 ::std::mem::transmute(val)
1279 }
1280 },
1281 queue_signal_release_image_android: unsafe {
1282 unsafe extern "system" fn queue_signal_release_image_android(
1283 _queue: Queue,
1284 _wait_semaphore_count: u32,
1285 _p_wait_semaphores: *const Semaphore,
1286 _image: Image,
1287 _p_native_fence_fd: *mut c_int,
1288 ) -> Result {
1289 panic!(concat!(
1290 "Unable to load ",
1291 stringify!(queue_signal_release_image_android)
1292 ))
1293 }
1294 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1295 b"vkQueueSignalReleaseImageANDROID\0",
1296 );
1297 let val = _f(cname);
1298 if val.is_null() {
1299 queue_signal_release_image_android
1300 } else {
1301 ::std::mem::transmute(val)
1302 }
1303 },
1304 get_swapchain_gralloc_usage2_android: unsafe {
1305 unsafe extern "system" fn get_swapchain_gralloc_usage2_android(
1306 _device: Device,
1307 _format: Format,
1308 _image_usage: ImageUsageFlags,
1309 _swapchain_image_usage: SwapchainImageUsageFlagsANDROID,
1310 _gralloc_consumer_usage: *mut u64,
1311 _gralloc_producer_usage: *mut u64,
1312 ) -> Result {
1313 panic!(concat!(
1314 "Unable to load ",
1315 stringify!(get_swapchain_gralloc_usage2_android)
1316 ))
1317 }
1318 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1319 b"vkGetSwapchainGrallocUsage2ANDROID\0",
1320 );
1321 let val = _f(cname);
1322 if val.is_null() {
1323 get_swapchain_gralloc_usage2_android
1324 } else {
1325 ::std::mem::transmute(val)
1326 }
1327 },
1328 }
1329 }
1330}
1331#[doc = "Generated from 'VK_ANDROID_native_buffer'"]
1332impl StructureType {
1333 pub const NATIVE_BUFFER_ANDROID: Self = Self(1_000_010_000);
1334 pub const SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID: Self = Self(1_000_010_001);
1335 pub const PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: Self = Self(1_000_010_002);
1336}
1337impl ExtDebugReportFn {
1338 #[inline]
1339 pub const fn name() -> &'static ::std::ffi::CStr {
1340 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_report\0") }
1341 }
1342 pub const SPEC_VERSION: u32 = 10u32;
1343}
1344#[allow(non_camel_case_types)]
1345pub type PFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn(
1346 instance: Instance,
1347 p_create_info: *const DebugReportCallbackCreateInfoEXT,
1348 p_allocator: *const AllocationCallbacks,
1349 p_callback: *mut DebugReportCallbackEXT,
1350) -> Result;
1351#[allow(non_camel_case_types)]
1352pub type PFN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn(
1353 instance: Instance,
1354 callback: DebugReportCallbackEXT,
1355 p_allocator: *const AllocationCallbacks,
1356);
1357#[allow(non_camel_case_types)]
1358pub type PFN_vkDebugReportMessageEXT = unsafe extern "system" fn(
1359 instance: Instance,
1360 flags: DebugReportFlagsEXT,
1361 object_type: DebugReportObjectTypeEXT,
1362 object: u64,
1363 location: usize,
1364 message_code: i32,
1365 p_layer_prefix: *const c_char,
1366 p_message: *const c_char,
1367);
1368#[derive(Clone)]
1369pub struct ExtDebugReportFn {
1370 pub create_debug_report_callback_ext: PFN_vkCreateDebugReportCallbackEXT,
1371 pub destroy_debug_report_callback_ext: PFN_vkDestroyDebugReportCallbackEXT,
1372 pub debug_report_message_ext: PFN_vkDebugReportMessageEXT,
1373}
1374unsafe impl Send for ExtDebugReportFn {}
1375unsafe impl Sync for ExtDebugReportFn {}
1376impl ExtDebugReportFn {
1377 pub fn load<F>(mut _f: F) -> Self
1378 where
1379 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1380 {
1381 Self {
1382 create_debug_report_callback_ext: unsafe {
1383 unsafe extern "system" fn create_debug_report_callback_ext(
1384 _instance: Instance,
1385 _p_create_info: *const DebugReportCallbackCreateInfoEXT,
1386 _p_allocator: *const AllocationCallbacks,
1387 _p_callback: *mut DebugReportCallbackEXT,
1388 ) -> Result {
1389 panic!(concat!(
1390 "Unable to load ",
1391 stringify!(create_debug_report_callback_ext)
1392 ))
1393 }
1394 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1395 b"vkCreateDebugReportCallbackEXT\0",
1396 );
1397 let val = _f(cname);
1398 if val.is_null() {
1399 create_debug_report_callback_ext
1400 } else {
1401 ::std::mem::transmute(val)
1402 }
1403 },
1404 destroy_debug_report_callback_ext: unsafe {
1405 unsafe extern "system" fn destroy_debug_report_callback_ext(
1406 _instance: Instance,
1407 _callback: DebugReportCallbackEXT,
1408 _p_allocator: *const AllocationCallbacks,
1409 ) {
1410 panic!(concat!(
1411 "Unable to load ",
1412 stringify!(destroy_debug_report_callback_ext)
1413 ))
1414 }
1415 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1416 b"vkDestroyDebugReportCallbackEXT\0",
1417 );
1418 let val = _f(cname);
1419 if val.is_null() {
1420 destroy_debug_report_callback_ext
1421 } else {
1422 ::std::mem::transmute(val)
1423 }
1424 },
1425 debug_report_message_ext: unsafe {
1426 unsafe extern "system" fn debug_report_message_ext(
1427 _instance: Instance,
1428 _flags: DebugReportFlagsEXT,
1429 _object_type: DebugReportObjectTypeEXT,
1430 _object: u64,
1431 _location: usize,
1432 _message_code: i32,
1433 _p_layer_prefix: *const c_char,
1434 _p_message: *const c_char,
1435 ) {
1436 panic!(concat!(
1437 "Unable to load ",
1438 stringify!(debug_report_message_ext)
1439 ))
1440 }
1441 let cname =
1442 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDebugReportMessageEXT\0");
1443 let val = _f(cname);
1444 if val.is_null() {
1445 debug_report_message_ext
1446 } else {
1447 ::std::mem::transmute(val)
1448 }
1449 },
1450 }
1451 }
1452}
1453#[doc = "Generated from 'VK_EXT_debug_report'"]
1454impl DebugReportObjectTypeEXT {
1455 pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000);
1456 pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000);
1457}
1458#[doc = "Generated from 'VK_EXT_debug_report'"]
1459impl ObjectType {
1460 pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(1_000_011_000);
1461}
1462#[doc = "Generated from 'VK_EXT_debug_report'"]
1463impl Result {
1464 pub const ERROR_VALIDATION_FAILED_EXT: Self = Self(-1_000_011_001);
1465}
1466#[doc = "Generated from 'VK_EXT_debug_report'"]
1467impl StructureType {
1468 pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1_000_011_000);
1469}
1470impl NvGlslShaderFn {
1471 #[inline]
1472 pub const fn name() -> &'static ::std::ffi::CStr {
1473 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_glsl_shader\0") }
1474 }
1475 pub const SPEC_VERSION: u32 = 1u32;
1476}
1477#[derive(Clone)]
1478pub struct NvGlslShaderFn {}
1479unsafe impl Send for NvGlslShaderFn {}
1480unsafe impl Sync for NvGlslShaderFn {}
1481impl NvGlslShaderFn {
1482 pub fn load<F>(mut _f: F) -> Self
1483 where
1484 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1485 {
1486 Self {}
1487 }
1488}
1489#[doc = "Generated from 'VK_NV_glsl_shader'"]
1490impl Result {
1491 pub const ERROR_INVALID_SHADER_NV: Self = Self(-1_000_012_000);
1492}
1493impl ExtDepthRangeUnrestrictedFn {
1494 #[inline]
1495 pub const fn name() -> &'static ::std::ffi::CStr {
1496 unsafe {
1497 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_range_unrestricted\0")
1498 }
1499 }
1500 pub const SPEC_VERSION: u32 = 1u32;
1501}
1502#[derive(Clone)]
1503pub struct ExtDepthRangeUnrestrictedFn {}
1504unsafe impl Send for ExtDepthRangeUnrestrictedFn {}
1505unsafe impl Sync for ExtDepthRangeUnrestrictedFn {}
1506impl ExtDepthRangeUnrestrictedFn {
1507 pub fn load<F>(mut _f: F) -> Self
1508 where
1509 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1510 {
1511 Self {}
1512 }
1513}
1514impl KhrSamplerMirrorClampToEdgeFn {
1515 #[inline]
1516 pub const fn name() -> &'static ::std::ffi::CStr {
1517 unsafe {
1518 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1519 b"VK_KHR_sampler_mirror_clamp_to_edge\0",
1520 )
1521 }
1522 }
1523 pub const SPEC_VERSION: u32 = 3u32;
1524}
1525#[derive(Clone)]
1526pub struct KhrSamplerMirrorClampToEdgeFn {}
1527unsafe impl Send for KhrSamplerMirrorClampToEdgeFn {}
1528unsafe impl Sync for KhrSamplerMirrorClampToEdgeFn {}
1529impl KhrSamplerMirrorClampToEdgeFn {
1530 pub fn load<F>(mut _f: F) -> Self
1531 where
1532 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1533 {
1534 Self {}
1535 }
1536}
1537#[doc = "Generated from 'VK_KHR_sampler_mirror_clamp_to_edge'"]
1538impl SamplerAddressMode {
1539 #[doc = "Note that this defines what was previously a core enum, and so uses the 'value' attribute rather than 'offset', and does not have a suffix. This is a special case, and should not be repeated"]
1540 pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4);
1541 #[deprecated = "Introduced for consistency with extension suffixing rules"]
1542 pub const MIRROR_CLAMP_TO_EDGE_KHR: Self = Self::MIRROR_CLAMP_TO_EDGE;
1543}
1544impl ImgFilterCubicFn {
1545 #[inline]
1546 pub const fn name() -> &'static ::std::ffi::CStr {
1547 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_filter_cubic\0") }
1548 }
1549 pub const SPEC_VERSION: u32 = 1u32;
1550}
1551#[derive(Clone)]
1552pub struct ImgFilterCubicFn {}
1553unsafe impl Send for ImgFilterCubicFn {}
1554unsafe impl Sync for ImgFilterCubicFn {}
1555impl ImgFilterCubicFn {
1556 pub fn load<F>(mut _f: F) -> Self
1557 where
1558 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1559 {
1560 Self {}
1561 }
1562}
1563#[doc = "Generated from 'VK_IMG_filter_cubic'"]
1564impl Filter {
1565 pub const CUBIC_IMG: Self = Self::CUBIC_EXT;
1566}
1567#[doc = "Generated from 'VK_IMG_filter_cubic'"]
1568impl FormatFeatureFlags {
1569 #[doc = "Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled"]
1570 pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC_EXT;
1571}
1572impl AmdExtension17Fn {
1573 #[inline]
1574 pub const fn name() -> &'static ::std::ffi::CStr {
1575 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_17\0") }
1576 }
1577 pub const SPEC_VERSION: u32 = 0u32;
1578}
1579#[derive(Clone)]
1580pub struct AmdExtension17Fn {}
1581unsafe impl Send for AmdExtension17Fn {}
1582unsafe impl Sync for AmdExtension17Fn {}
1583impl AmdExtension17Fn {
1584 pub fn load<F>(mut _f: F) -> Self
1585 where
1586 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1587 {
1588 Self {}
1589 }
1590}
1591impl AmdExtension18Fn {
1592 #[inline]
1593 pub const fn name() -> &'static ::std::ffi::CStr {
1594 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_18\0") }
1595 }
1596 pub const SPEC_VERSION: u32 = 0u32;
1597}
1598#[derive(Clone)]
1599pub struct AmdExtension18Fn {}
1600unsafe impl Send for AmdExtension18Fn {}
1601unsafe impl Sync for AmdExtension18Fn {}
1602impl AmdExtension18Fn {
1603 pub fn load<F>(mut _f: F) -> Self
1604 where
1605 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1606 {
1607 Self {}
1608 }
1609}
1610impl AmdRasterizationOrderFn {
1611 #[inline]
1612 pub const fn name() -> &'static ::std::ffi::CStr {
1613 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_rasterization_order\0") }
1614 }
1615 pub const SPEC_VERSION: u32 = 1u32;
1616}
1617#[derive(Clone)]
1618pub struct AmdRasterizationOrderFn {}
1619unsafe impl Send for AmdRasterizationOrderFn {}
1620unsafe impl Sync for AmdRasterizationOrderFn {}
1621impl AmdRasterizationOrderFn {
1622 pub fn load<F>(mut _f: F) -> Self
1623 where
1624 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1625 {
1626 Self {}
1627 }
1628}
1629#[doc = "Generated from 'VK_AMD_rasterization_order'"]
1630impl StructureType {
1631 pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = Self(1_000_018_000);
1632}
1633impl AmdExtension20Fn {
1634 #[inline]
1635 pub const fn name() -> &'static ::std::ffi::CStr {
1636 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_20\0") }
1637 }
1638 pub const SPEC_VERSION: u32 = 0u32;
1639}
1640#[derive(Clone)]
1641pub struct AmdExtension20Fn {}
1642unsafe impl Send for AmdExtension20Fn {}
1643unsafe impl Sync for AmdExtension20Fn {}
1644impl AmdExtension20Fn {
1645 pub fn load<F>(mut _f: F) -> Self
1646 where
1647 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1648 {
1649 Self {}
1650 }
1651}
1652impl AmdShaderTrinaryMinmaxFn {
1653 #[inline]
1654 pub const fn name() -> &'static ::std::ffi::CStr {
1655 unsafe {
1656 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_trinary_minmax\0")
1657 }
1658 }
1659 pub const SPEC_VERSION: u32 = 1u32;
1660}
1661#[derive(Clone)]
1662pub struct AmdShaderTrinaryMinmaxFn {}
1663unsafe impl Send for AmdShaderTrinaryMinmaxFn {}
1664unsafe impl Sync for AmdShaderTrinaryMinmaxFn {}
1665impl AmdShaderTrinaryMinmaxFn {
1666 pub fn load<F>(mut _f: F) -> Self
1667 where
1668 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1669 {
1670 Self {}
1671 }
1672}
1673impl AmdShaderExplicitVertexParameterFn {
1674 #[inline]
1675 pub const fn name() -> &'static ::std::ffi::CStr {
1676 unsafe {
1677 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1678 b"VK_AMD_shader_explicit_vertex_parameter\0",
1679 )
1680 }
1681 }
1682 pub const SPEC_VERSION: u32 = 1u32;
1683}
1684#[derive(Clone)]
1685pub struct AmdShaderExplicitVertexParameterFn {}
1686unsafe impl Send for AmdShaderExplicitVertexParameterFn {}
1687unsafe impl Sync for AmdShaderExplicitVertexParameterFn {}
1688impl AmdShaderExplicitVertexParameterFn {
1689 pub fn load<F>(mut _f: F) -> Self
1690 where
1691 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1692 {
1693 Self {}
1694 }
1695}
1696impl ExtDebugMarkerFn {
1697 #[inline]
1698 pub const fn name() -> &'static ::std::ffi::CStr {
1699 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_marker\0") }
1700 }
1701 pub const SPEC_VERSION: u32 = 4u32;
1702}
1703#[allow(non_camel_case_types)]
1704pub type PFN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn(
1705 device: Device,
1706 p_tag_info: *const DebugMarkerObjectTagInfoEXT,
1707) -> Result;
1708#[allow(non_camel_case_types)]
1709pub type PFN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn(
1710 device: Device,
1711 p_name_info: *const DebugMarkerObjectNameInfoEXT,
1712) -> Result;
1713#[allow(non_camel_case_types)]
1714pub type PFN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn(
1715 command_buffer: CommandBuffer,
1716 p_marker_info: *const DebugMarkerMarkerInfoEXT,
1717);
1718#[allow(non_camel_case_types)]
1719pub type PFN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(command_buffer: CommandBuffer);
1720#[allow(non_camel_case_types)]
1721pub type PFN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn(
1722 command_buffer: CommandBuffer,
1723 p_marker_info: *const DebugMarkerMarkerInfoEXT,
1724);
1725#[derive(Clone)]
1726pub struct ExtDebugMarkerFn {
1727 pub debug_marker_set_object_tag_ext: PFN_vkDebugMarkerSetObjectTagEXT,
1728 pub debug_marker_set_object_name_ext: PFN_vkDebugMarkerSetObjectNameEXT,
1729 pub cmd_debug_marker_begin_ext: PFN_vkCmdDebugMarkerBeginEXT,
1730 pub cmd_debug_marker_end_ext: PFN_vkCmdDebugMarkerEndEXT,
1731 pub cmd_debug_marker_insert_ext: PFN_vkCmdDebugMarkerInsertEXT,
1732}
1733unsafe impl Send for ExtDebugMarkerFn {}
1734unsafe impl Sync for ExtDebugMarkerFn {}
1735impl ExtDebugMarkerFn {
1736 pub fn load<F>(mut _f: F) -> Self
1737 where
1738 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1739 {
1740 Self {
1741 debug_marker_set_object_tag_ext: unsafe {
1742 unsafe extern "system" fn debug_marker_set_object_tag_ext(
1743 _device: Device,
1744 _p_tag_info: *const DebugMarkerObjectTagInfoEXT,
1745 ) -> Result {
1746 panic!(concat!(
1747 "Unable to load ",
1748 stringify!(debug_marker_set_object_tag_ext)
1749 ))
1750 }
1751 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1752 b"vkDebugMarkerSetObjectTagEXT\0",
1753 );
1754 let val = _f(cname);
1755 if val.is_null() {
1756 debug_marker_set_object_tag_ext
1757 } else {
1758 ::std::mem::transmute(val)
1759 }
1760 },
1761 debug_marker_set_object_name_ext: unsafe {
1762 unsafe extern "system" fn debug_marker_set_object_name_ext(
1763 _device: Device,
1764 _p_name_info: *const DebugMarkerObjectNameInfoEXT,
1765 ) -> Result {
1766 panic!(concat!(
1767 "Unable to load ",
1768 stringify!(debug_marker_set_object_name_ext)
1769 ))
1770 }
1771 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1772 b"vkDebugMarkerSetObjectNameEXT\0",
1773 );
1774 let val = _f(cname);
1775 if val.is_null() {
1776 debug_marker_set_object_name_ext
1777 } else {
1778 ::std::mem::transmute(val)
1779 }
1780 },
1781 cmd_debug_marker_begin_ext: unsafe {
1782 unsafe extern "system" fn cmd_debug_marker_begin_ext(
1783 _command_buffer: CommandBuffer,
1784 _p_marker_info: *const DebugMarkerMarkerInfoEXT,
1785 ) {
1786 panic!(concat!(
1787 "Unable to load ",
1788 stringify!(cmd_debug_marker_begin_ext)
1789 ))
1790 }
1791 let cname =
1792 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerBeginEXT\0");
1793 let val = _f(cname);
1794 if val.is_null() {
1795 cmd_debug_marker_begin_ext
1796 } else {
1797 ::std::mem::transmute(val)
1798 }
1799 },
1800 cmd_debug_marker_end_ext: unsafe {
1801 unsafe extern "system" fn cmd_debug_marker_end_ext(_command_buffer: CommandBuffer) {
1802 panic!(concat!(
1803 "Unable to load ",
1804 stringify!(cmd_debug_marker_end_ext)
1805 ))
1806 }
1807 let cname =
1808 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerEndEXT\0");
1809 let val = _f(cname);
1810 if val.is_null() {
1811 cmd_debug_marker_end_ext
1812 } else {
1813 ::std::mem::transmute(val)
1814 }
1815 },
1816 cmd_debug_marker_insert_ext: unsafe {
1817 unsafe extern "system" fn cmd_debug_marker_insert_ext(
1818 _command_buffer: CommandBuffer,
1819 _p_marker_info: *const DebugMarkerMarkerInfoEXT,
1820 ) {
1821 panic!(concat!(
1822 "Unable to load ",
1823 stringify!(cmd_debug_marker_insert_ext)
1824 ))
1825 }
1826 let cname =
1827 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerInsertEXT\0");
1828 let val = _f(cname);
1829 if val.is_null() {
1830 cmd_debug_marker_insert_ext
1831 } else {
1832 ::std::mem::transmute(val)
1833 }
1834 },
1835 }
1836 }
1837}
1838#[doc = "Generated from 'VK_EXT_debug_marker'"]
1839impl StructureType {
1840 pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = Self(1_000_022_000);
1841 pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = Self(1_000_022_001);
1842 pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = Self(1_000_022_002);
1843}
1844impl KhrVideoQueueFn {
1845 #[inline]
1846 pub const fn name() -> &'static ::std::ffi::CStr {
1847 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") }
1848 }
1849 pub const SPEC_VERSION: u32 = 8u32;
1850}
1851#[allow(non_camel_case_types)]
1852pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(
1853 physical_device: PhysicalDevice,
1854 p_video_profile: *const VideoProfileInfoKHR,
1855 p_capabilities: *mut VideoCapabilitiesKHR,
1856) -> Result;
1857#[allow(non_camel_case_types)]
1858pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn(
1859 physical_device: PhysicalDevice,
1860 p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR,
1861 p_video_format_property_count: *mut u32,
1862 p_video_format_properties: *mut VideoFormatPropertiesKHR,
1863) -> Result;
1864#[allow(non_camel_case_types)]
1865pub type PFN_vkCreateVideoSessionKHR = unsafe extern "system" fn(
1866 device: Device,
1867 p_create_info: *const VideoSessionCreateInfoKHR,
1868 p_allocator: *const AllocationCallbacks,
1869 p_video_session: *mut VideoSessionKHR,
1870) -> Result;
1871#[allow(non_camel_case_types)]
1872pub type PFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(
1873 device: Device,
1874 video_session: VideoSessionKHR,
1875 p_allocator: *const AllocationCallbacks,
1876);
1877#[allow(non_camel_case_types)]
1878pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(
1879 device: Device,
1880 video_session: VideoSessionKHR,
1881 p_memory_requirements_count: *mut u32,
1882 p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR,
1883) -> Result;
1884#[allow(non_camel_case_types)]
1885pub type PFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(
1886 device: Device,
1887 video_session: VideoSessionKHR,
1888 bind_session_memory_info_count: u32,
1889 p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR,
1890) -> Result;
1891#[allow(non_camel_case_types)]
1892pub type PFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(
1893 device: Device,
1894 p_create_info: *const VideoSessionParametersCreateInfoKHR,
1895 p_allocator: *const AllocationCallbacks,
1896 p_video_session_parameters: *mut VideoSessionParametersKHR,
1897) -> Result;
1898#[allow(non_camel_case_types)]
1899pub type PFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn(
1900 device: Device,
1901 video_session_parameters: VideoSessionParametersKHR,
1902 p_update_info: *const VideoSessionParametersUpdateInfoKHR,
1903) -> Result;
1904#[allow(non_camel_case_types)]
1905pub type PFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn(
1906 device: Device,
1907 video_session_parameters: VideoSessionParametersKHR,
1908 p_allocator: *const AllocationCallbacks,
1909);
1910#[allow(non_camel_case_types)]
1911pub type PFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn(
1912 command_buffer: CommandBuffer,
1913 p_begin_info: *const VideoBeginCodingInfoKHR,
1914);
1915#[allow(non_camel_case_types)]
1916pub type PFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn(
1917 command_buffer: CommandBuffer,
1918 p_end_coding_info: *const VideoEndCodingInfoKHR,
1919);
1920#[allow(non_camel_case_types)]
1921pub type PFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn(
1922 command_buffer: CommandBuffer,
1923 p_coding_control_info: *const VideoCodingControlInfoKHR,
1924);
1925#[derive(Clone)]
1926pub struct KhrVideoQueueFn {
1927 pub get_physical_device_video_capabilities_khr: PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR,
1928 pub get_physical_device_video_format_properties_khr:
1929 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR,
1930 pub create_video_session_khr: PFN_vkCreateVideoSessionKHR,
1931 pub destroy_video_session_khr: PFN_vkDestroyVideoSessionKHR,
1932 pub get_video_session_memory_requirements_khr: PFN_vkGetVideoSessionMemoryRequirementsKHR,
1933 pub bind_video_session_memory_khr: PFN_vkBindVideoSessionMemoryKHR,
1934 pub create_video_session_parameters_khr: PFN_vkCreateVideoSessionParametersKHR,
1935 pub update_video_session_parameters_khr: PFN_vkUpdateVideoSessionParametersKHR,
1936 pub destroy_video_session_parameters_khr: PFN_vkDestroyVideoSessionParametersKHR,
1937 pub cmd_begin_video_coding_khr: PFN_vkCmdBeginVideoCodingKHR,
1938 pub cmd_end_video_coding_khr: PFN_vkCmdEndVideoCodingKHR,
1939 pub cmd_control_video_coding_khr: PFN_vkCmdControlVideoCodingKHR,
1940}
1941unsafe impl Send for KhrVideoQueueFn {}
1942unsafe impl Sync for KhrVideoQueueFn {}
1943impl KhrVideoQueueFn {
1944 pub fn load<F>(mut _f: F) -> Self
1945 where
1946 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1947 {
1948 Self {
1949 get_physical_device_video_capabilities_khr: unsafe {
1950 unsafe extern "system" fn get_physical_device_video_capabilities_khr(
1951 _physical_device: PhysicalDevice,
1952 _p_video_profile: *const VideoProfileInfoKHR,
1953 _p_capabilities: *mut VideoCapabilitiesKHR,
1954 ) -> Result {
1955 panic!(concat!(
1956 "Unable to load ",
1957 stringify!(get_physical_device_video_capabilities_khr)
1958 ))
1959 }
1960 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1961 b"vkGetPhysicalDeviceVideoCapabilitiesKHR\0",
1962 );
1963 let val = _f(cname);
1964 if val.is_null() {
1965 get_physical_device_video_capabilities_khr
1966 } else {
1967 ::std::mem::transmute(val)
1968 }
1969 },
1970 get_physical_device_video_format_properties_khr: unsafe {
1971 unsafe extern "system" fn get_physical_device_video_format_properties_khr(
1972 _physical_device: PhysicalDevice,
1973 _p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR,
1974 _p_video_format_property_count: *mut u32,
1975 _p_video_format_properties: *mut VideoFormatPropertiesKHR,
1976 ) -> Result {
1977 panic!(concat!(
1978 "Unable to load ",
1979 stringify!(get_physical_device_video_format_properties_khr)
1980 ))
1981 }
1982 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1983 b"vkGetPhysicalDeviceVideoFormatPropertiesKHR\0",
1984 );
1985 let val = _f(cname);
1986 if val.is_null() {
1987 get_physical_device_video_format_properties_khr
1988 } else {
1989 ::std::mem::transmute(val)
1990 }
1991 },
1992 create_video_session_khr: unsafe {
1993 unsafe extern "system" fn create_video_session_khr(
1994 _device: Device,
1995 _p_create_info: *const VideoSessionCreateInfoKHR,
1996 _p_allocator: *const AllocationCallbacks,
1997 _p_video_session: *mut VideoSessionKHR,
1998 ) -> Result {
1999 panic!(concat!(
2000 "Unable to load ",
2001 stringify!(create_video_session_khr)
2002 ))
2003 }
2004 let cname =
2005 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateVideoSessionKHR\0");
2006 let val = _f(cname);
2007 if val.is_null() {
2008 create_video_session_khr
2009 } else {
2010 ::std::mem::transmute(val)
2011 }
2012 },
2013 destroy_video_session_khr: unsafe {
2014 unsafe extern "system" fn destroy_video_session_khr(
2015 _device: Device,
2016 _video_session: VideoSessionKHR,
2017 _p_allocator: *const AllocationCallbacks,
2018 ) {
2019 panic!(concat!(
2020 "Unable to load ",
2021 stringify!(destroy_video_session_khr)
2022 ))
2023 }
2024 let cname =
2025 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyVideoSessionKHR\0");
2026 let val = _f(cname);
2027 if val.is_null() {
2028 destroy_video_session_khr
2029 } else {
2030 ::std::mem::transmute(val)
2031 }
2032 },
2033 get_video_session_memory_requirements_khr: unsafe {
2034 unsafe extern "system" fn get_video_session_memory_requirements_khr(
2035 _device: Device,
2036 _video_session: VideoSessionKHR,
2037 _p_memory_requirements_count: *mut u32,
2038 _p_memory_requirements: *mut VideoSessionMemoryRequirementsKHR,
2039 ) -> Result {
2040 panic!(concat!(
2041 "Unable to load ",
2042 stringify!(get_video_session_memory_requirements_khr)
2043 ))
2044 }
2045 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2046 b"vkGetVideoSessionMemoryRequirementsKHR\0",
2047 );
2048 let val = _f(cname);
2049 if val.is_null() {
2050 get_video_session_memory_requirements_khr
2051 } else {
2052 ::std::mem::transmute(val)
2053 }
2054 },
2055 bind_video_session_memory_khr: unsafe {
2056 unsafe extern "system" fn bind_video_session_memory_khr(
2057 _device: Device,
2058 _video_session: VideoSessionKHR,
2059 _bind_session_memory_info_count: u32,
2060 _p_bind_session_memory_infos: *const BindVideoSessionMemoryInfoKHR,
2061 ) -> Result {
2062 panic!(concat!(
2063 "Unable to load ",
2064 stringify!(bind_video_session_memory_khr)
2065 ))
2066 }
2067 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2068 b"vkBindVideoSessionMemoryKHR\0",
2069 );
2070 let val = _f(cname);
2071 if val.is_null() {
2072 bind_video_session_memory_khr
2073 } else {
2074 ::std::mem::transmute(val)
2075 }
2076 },
2077 create_video_session_parameters_khr: unsafe {
2078 unsafe extern "system" fn create_video_session_parameters_khr(
2079 _device: Device,
2080 _p_create_info: *const VideoSessionParametersCreateInfoKHR,
2081 _p_allocator: *const AllocationCallbacks,
2082 _p_video_session_parameters: *mut VideoSessionParametersKHR,
2083 ) -> Result {
2084 panic!(concat!(
2085 "Unable to load ",
2086 stringify!(create_video_session_parameters_khr)
2087 ))
2088 }
2089 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2090 b"vkCreateVideoSessionParametersKHR\0",
2091 );
2092 let val = _f(cname);
2093 if val.is_null() {
2094 create_video_session_parameters_khr
2095 } else {
2096 ::std::mem::transmute(val)
2097 }
2098 },
2099 update_video_session_parameters_khr: unsafe {
2100 unsafe extern "system" fn update_video_session_parameters_khr(
2101 _device: Device,
2102 _video_session_parameters: VideoSessionParametersKHR,
2103 _p_update_info: *const VideoSessionParametersUpdateInfoKHR,
2104 ) -> Result {
2105 panic!(concat!(
2106 "Unable to load ",
2107 stringify!(update_video_session_parameters_khr)
2108 ))
2109 }
2110 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2111 b"vkUpdateVideoSessionParametersKHR\0",
2112 );
2113 let val = _f(cname);
2114 if val.is_null() {
2115 update_video_session_parameters_khr
2116 } else {
2117 ::std::mem::transmute(val)
2118 }
2119 },
2120 destroy_video_session_parameters_khr: unsafe {
2121 unsafe extern "system" fn destroy_video_session_parameters_khr(
2122 _device: Device,
2123 _video_session_parameters: VideoSessionParametersKHR,
2124 _p_allocator: *const AllocationCallbacks,
2125 ) {
2126 panic!(concat!(
2127 "Unable to load ",
2128 stringify!(destroy_video_session_parameters_khr)
2129 ))
2130 }
2131 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2132 b"vkDestroyVideoSessionParametersKHR\0",
2133 );
2134 let val = _f(cname);
2135 if val.is_null() {
2136 destroy_video_session_parameters_khr
2137 } else {
2138 ::std::mem::transmute(val)
2139 }
2140 },
2141 cmd_begin_video_coding_khr: unsafe {
2142 unsafe extern "system" fn cmd_begin_video_coding_khr(
2143 _command_buffer: CommandBuffer,
2144 _p_begin_info: *const VideoBeginCodingInfoKHR,
2145 ) {
2146 panic!(concat!(
2147 "Unable to load ",
2148 stringify!(cmd_begin_video_coding_khr)
2149 ))
2150 }
2151 let cname =
2152 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginVideoCodingKHR\0");
2153 let val = _f(cname);
2154 if val.is_null() {
2155 cmd_begin_video_coding_khr
2156 } else {
2157 ::std::mem::transmute(val)
2158 }
2159 },
2160 cmd_end_video_coding_khr: unsafe {
2161 unsafe extern "system" fn cmd_end_video_coding_khr(
2162 _command_buffer: CommandBuffer,
2163 _p_end_coding_info: *const VideoEndCodingInfoKHR,
2164 ) {
2165 panic!(concat!(
2166 "Unable to load ",
2167 stringify!(cmd_end_video_coding_khr)
2168 ))
2169 }
2170 let cname =
2171 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndVideoCodingKHR\0");
2172 let val = _f(cname);
2173 if val.is_null() {
2174 cmd_end_video_coding_khr
2175 } else {
2176 ::std::mem::transmute(val)
2177 }
2178 },
2179 cmd_control_video_coding_khr: unsafe {
2180 unsafe extern "system" fn cmd_control_video_coding_khr(
2181 _command_buffer: CommandBuffer,
2182 _p_coding_control_info: *const VideoCodingControlInfoKHR,
2183 ) {
2184 panic!(concat!(
2185 "Unable to load ",
2186 stringify!(cmd_control_video_coding_khr)
2187 ))
2188 }
2189 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2190 b"vkCmdControlVideoCodingKHR\0",
2191 );
2192 let val = _f(cname);
2193 if val.is_null() {
2194 cmd_control_video_coding_khr
2195 } else {
2196 ::std::mem::transmute(val)
2197 }
2198 },
2199 }
2200 }
2201}
2202#[doc = "Generated from 'VK_KHR_video_queue'"]
2203impl ObjectType {
2204 #[doc = "VkVideoSessionKHR"]
2205 pub const VIDEO_SESSION_KHR: Self = Self(1_000_023_000);
2206 #[doc = "VkVideoSessionParametersKHR"]
2207 pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1_000_023_001);
2208}
2209#[doc = "Generated from 'VK_KHR_video_queue'"]
2210impl QueryResultFlags {
2211 pub const WITH_STATUS_KHR: Self = Self(0b1_0000);
2212}
2213#[doc = "Generated from 'VK_KHR_video_queue'"]
2214impl QueryType {
2215 pub const RESULT_STATUS_ONLY_KHR: Self = Self(1_000_023_000);
2216}
2217#[doc = "Generated from 'VK_KHR_video_queue'"]
2218impl Result {
2219 pub const ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_000);
2220 pub const ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_001);
2221 pub const ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_002);
2222 pub const ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_003);
2223 pub const ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_004);
2224 pub const ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: Self = Self(-1_000_023_005);
2225}
2226#[doc = "Generated from 'VK_KHR_video_queue'"]
2227impl StructureType {
2228 pub const VIDEO_PROFILE_INFO_KHR: Self = Self(1_000_023_000);
2229 pub const VIDEO_CAPABILITIES_KHR: Self = Self(1_000_023_001);
2230 pub const VIDEO_PICTURE_RESOURCE_INFO_KHR: Self = Self(1_000_023_002);
2231 pub const VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: Self = Self(1_000_023_003);
2232 pub const BIND_VIDEO_SESSION_MEMORY_INFO_KHR: Self = Self(1_000_023_004);
2233 pub const VIDEO_SESSION_CREATE_INFO_KHR: Self = Self(1_000_023_005);
2234 pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_023_006);
2235 pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: Self = Self(1_000_023_007);
2236 pub const VIDEO_BEGIN_CODING_INFO_KHR: Self = Self(1_000_023_008);
2237 pub const VIDEO_END_CODING_INFO_KHR: Self = Self(1_000_023_009);
2238 pub const VIDEO_CODING_CONTROL_INFO_KHR: Self = Self(1_000_023_010);
2239 pub const VIDEO_REFERENCE_SLOT_INFO_KHR: Self = Self(1_000_023_011);
2240 pub const QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: Self = Self(1_000_023_012);
2241 pub const VIDEO_PROFILE_LIST_INFO_KHR: Self = Self(1_000_023_013);
2242 pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1_000_023_014);
2243 pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1_000_023_015);
2244 pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: Self = Self(1_000_023_016);
2245}
2246impl KhrVideoDecodeQueueFn {
2247 #[inline]
2248 pub const fn name() -> &'static ::std::ffi::CStr {
2249 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_queue\0") }
2250 }
2251 pub const SPEC_VERSION: u32 = 7u32;
2252}
2253#[allow(non_camel_case_types)]
2254pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn(
2255 command_buffer: CommandBuffer,
2256 p_decode_info: *const VideoDecodeInfoKHR,
2257);
2258#[derive(Clone)]
2259pub struct KhrVideoDecodeQueueFn {
2260 pub cmd_decode_video_khr: PFN_vkCmdDecodeVideoKHR,
2261}
2262unsafe impl Send for KhrVideoDecodeQueueFn {}
2263unsafe impl Sync for KhrVideoDecodeQueueFn {}
2264impl KhrVideoDecodeQueueFn {
2265 pub fn load<F>(mut _f: F) -> Self
2266 where
2267 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2268 {
2269 Self {
2270 cmd_decode_video_khr: unsafe {
2271 unsafe extern "system" fn cmd_decode_video_khr(
2272 _command_buffer: CommandBuffer,
2273 _p_decode_info: *const VideoDecodeInfoKHR,
2274 ) {
2275 panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr)))
2276 }
2277 let cname =
2278 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecodeVideoKHR\0");
2279 let val = _f(cname);
2280 if val.is_null() {
2281 cmd_decode_video_khr
2282 } else {
2283 ::std::mem::transmute(val)
2284 }
2285 },
2286 }
2287 }
2288}
2289#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2290impl AccessFlags2 {
2291 pub const VIDEO_DECODE_READ_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
2292 pub const VIDEO_DECODE_WRITE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
2293}
2294#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2295impl BufferUsageFlags {
2296 pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b10_0000_0000_0000);
2297 pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000_0000);
2298}
2299#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2300impl FormatFeatureFlags {
2301 pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
2302 pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2303}
2304#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2305impl FormatFeatureFlags2 {
2306 pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
2307 pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2308}
2309#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2310impl ImageLayout {
2311 pub const VIDEO_DECODE_DST_KHR: Self = Self(1_000_024_000);
2312 pub const VIDEO_DECODE_SRC_KHR: Self = Self(1_000_024_001);
2313 pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002);
2314}
2315#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2316impl ImageUsageFlags {
2317 pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000);
2318 pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b1000_0000_0000);
2319 pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b1_0000_0000_0000);
2320}
2321#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2322impl PipelineStageFlags2 {
2323 pub const VIDEO_DECODE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2324}
2325#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2326impl QueueFlags {
2327 pub const VIDEO_DECODE_KHR: Self = Self(0b10_0000);
2328}
2329#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2330impl StructureType {
2331 pub const VIDEO_DECODE_INFO_KHR: Self = Self(1_000_024_000);
2332 pub const VIDEO_DECODE_CAPABILITIES_KHR: Self = Self(1_000_024_001);
2333 pub const VIDEO_DECODE_USAGE_INFO_KHR: Self = Self(1_000_024_002);
2334}
2335impl AmdGcnShaderFn {
2336 #[inline]
2337 pub const fn name() -> &'static ::std::ffi::CStr {
2338 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gcn_shader\0") }
2339 }
2340 pub const SPEC_VERSION: u32 = 1u32;
2341}
2342#[derive(Clone)]
2343pub struct AmdGcnShaderFn {}
2344unsafe impl Send for AmdGcnShaderFn {}
2345unsafe impl Sync for AmdGcnShaderFn {}
2346impl AmdGcnShaderFn {
2347 pub fn load<F>(mut _f: F) -> Self
2348 where
2349 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2350 {
2351 Self {}
2352 }
2353}
2354impl NvDedicatedAllocationFn {
2355 #[inline]
2356 pub const fn name() -> &'static ::std::ffi::CStr {
2357 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_dedicated_allocation\0") }
2358 }
2359 pub const SPEC_VERSION: u32 = 1u32;
2360}
2361#[derive(Clone)]
2362pub struct NvDedicatedAllocationFn {}
2363unsafe impl Send for NvDedicatedAllocationFn {}
2364unsafe impl Sync for NvDedicatedAllocationFn {}
2365impl NvDedicatedAllocationFn {
2366 pub fn load<F>(mut _f: F) -> Self
2367 where
2368 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2369 {
2370 Self {}
2371 }
2372}
2373#[doc = "Generated from 'VK_NV_dedicated_allocation'"]
2374impl StructureType {
2375 pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = Self(1_000_026_000);
2376 pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = Self(1_000_026_001);
2377 pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_026_002);
2378}
2379impl ExtExtension28Fn {
2380 #[inline]
2381 pub const fn name() -> &'static ::std::ffi::CStr {
2382 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_28\0") }
2383 }
2384 pub const SPEC_VERSION: u32 = 0u32;
2385}
2386#[derive(Clone)]
2387pub struct ExtExtension28Fn {}
2388unsafe impl Send for ExtExtension28Fn {}
2389unsafe impl Sync for ExtExtension28Fn {}
2390impl ExtExtension28Fn {
2391 pub fn load<F>(mut _f: F) -> Self
2392 where
2393 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2394 {
2395 Self {}
2396 }
2397}
2398impl ExtTransformFeedbackFn {
2399 #[inline]
2400 pub const fn name() -> &'static ::std::ffi::CStr {
2401 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_transform_feedback\0") }
2402 }
2403 pub const SPEC_VERSION: u32 = 1u32;
2404}
2405#[allow(non_camel_case_types)]
2406pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn(
2407 command_buffer: CommandBuffer,
2408 first_binding: u32,
2409 binding_count: u32,
2410 p_buffers: *const Buffer,
2411 p_offsets: *const DeviceSize,
2412 p_sizes: *const DeviceSize,
2413);
2414#[allow(non_camel_case_types)]
2415pub type PFN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn(
2416 command_buffer: CommandBuffer,
2417 first_counter_buffer: u32,
2418 counter_buffer_count: u32,
2419 p_counter_buffers: *const Buffer,
2420 p_counter_buffer_offsets: *const DeviceSize,
2421);
2422#[allow(non_camel_case_types)]
2423pub type PFN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn(
2424 command_buffer: CommandBuffer,
2425 first_counter_buffer: u32,
2426 counter_buffer_count: u32,
2427 p_counter_buffers: *const Buffer,
2428 p_counter_buffer_offsets: *const DeviceSize,
2429);
2430#[allow(non_camel_case_types)]
2431pub type PFN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn(
2432 command_buffer: CommandBuffer,
2433 query_pool: QueryPool,
2434 query: u32,
2435 flags: QueryControlFlags,
2436 index: u32,
2437);
2438#[allow(non_camel_case_types)]
2439pub type PFN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn(
2440 command_buffer: CommandBuffer,
2441 query_pool: QueryPool,
2442 query: u32,
2443 index: u32,
2444);
2445#[allow(non_camel_case_types)]
2446pub type PFN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn(
2447 command_buffer: CommandBuffer,
2448 instance_count: u32,
2449 first_instance: u32,
2450 counter_buffer: Buffer,
2451 counter_buffer_offset: DeviceSize,
2452 counter_offset: u32,
2453 vertex_stride: u32,
2454);
2455#[derive(Clone)]
2456pub struct ExtTransformFeedbackFn {
2457 pub cmd_bind_transform_feedback_buffers_ext: PFN_vkCmdBindTransformFeedbackBuffersEXT,
2458 pub cmd_begin_transform_feedback_ext: PFN_vkCmdBeginTransformFeedbackEXT,
2459 pub cmd_end_transform_feedback_ext: PFN_vkCmdEndTransformFeedbackEXT,
2460 pub cmd_begin_query_indexed_ext: PFN_vkCmdBeginQueryIndexedEXT,
2461 pub cmd_end_query_indexed_ext: PFN_vkCmdEndQueryIndexedEXT,
2462 pub cmd_draw_indirect_byte_count_ext: PFN_vkCmdDrawIndirectByteCountEXT,
2463}
2464unsafe impl Send for ExtTransformFeedbackFn {}
2465unsafe impl Sync for ExtTransformFeedbackFn {}
2466impl ExtTransformFeedbackFn {
2467 pub fn load<F>(mut _f: F) -> Self
2468 where
2469 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2470 {
2471 Self {
2472 cmd_bind_transform_feedback_buffers_ext: unsafe {
2473 unsafe extern "system" fn cmd_bind_transform_feedback_buffers_ext(
2474 _command_buffer: CommandBuffer,
2475 _first_binding: u32,
2476 _binding_count: u32,
2477 _p_buffers: *const Buffer,
2478 _p_offsets: *const DeviceSize,
2479 _p_sizes: *const DeviceSize,
2480 ) {
2481 panic!(concat!(
2482 "Unable to load ",
2483 stringify!(cmd_bind_transform_feedback_buffers_ext)
2484 ))
2485 }
2486 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2487 b"vkCmdBindTransformFeedbackBuffersEXT\0",
2488 );
2489 let val = _f(cname);
2490 if val.is_null() {
2491 cmd_bind_transform_feedback_buffers_ext
2492 } else {
2493 ::std::mem::transmute(val)
2494 }
2495 },
2496 cmd_begin_transform_feedback_ext: unsafe {
2497 unsafe extern "system" fn cmd_begin_transform_feedback_ext(
2498 _command_buffer: CommandBuffer,
2499 _first_counter_buffer: u32,
2500 _counter_buffer_count: u32,
2501 _p_counter_buffers: *const Buffer,
2502 _p_counter_buffer_offsets: *const DeviceSize,
2503 ) {
2504 panic!(concat!(
2505 "Unable to load ",
2506 stringify!(cmd_begin_transform_feedback_ext)
2507 ))
2508 }
2509 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2510 b"vkCmdBeginTransformFeedbackEXT\0",
2511 );
2512 let val = _f(cname);
2513 if val.is_null() {
2514 cmd_begin_transform_feedback_ext
2515 } else {
2516 ::std::mem::transmute(val)
2517 }
2518 },
2519 cmd_end_transform_feedback_ext: unsafe {
2520 unsafe extern "system" fn cmd_end_transform_feedback_ext(
2521 _command_buffer: CommandBuffer,
2522 _first_counter_buffer: u32,
2523 _counter_buffer_count: u32,
2524 _p_counter_buffers: *const Buffer,
2525 _p_counter_buffer_offsets: *const DeviceSize,
2526 ) {
2527 panic!(concat!(
2528 "Unable to load ",
2529 stringify!(cmd_end_transform_feedback_ext)
2530 ))
2531 }
2532 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2533 b"vkCmdEndTransformFeedbackEXT\0",
2534 );
2535 let val = _f(cname);
2536 if val.is_null() {
2537 cmd_end_transform_feedback_ext
2538 } else {
2539 ::std::mem::transmute(val)
2540 }
2541 },
2542 cmd_begin_query_indexed_ext: unsafe {
2543 unsafe extern "system" fn cmd_begin_query_indexed_ext(
2544 _command_buffer: CommandBuffer,
2545 _query_pool: QueryPool,
2546 _query: u32,
2547 _flags: QueryControlFlags,
2548 _index: u32,
2549 ) {
2550 panic!(concat!(
2551 "Unable to load ",
2552 stringify!(cmd_begin_query_indexed_ext)
2553 ))
2554 }
2555 let cname =
2556 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQueryIndexedEXT\0");
2557 let val = _f(cname);
2558 if val.is_null() {
2559 cmd_begin_query_indexed_ext
2560 } else {
2561 ::std::mem::transmute(val)
2562 }
2563 },
2564 cmd_end_query_indexed_ext: unsafe {
2565 unsafe extern "system" fn cmd_end_query_indexed_ext(
2566 _command_buffer: CommandBuffer,
2567 _query_pool: QueryPool,
2568 _query: u32,
2569 _index: u32,
2570 ) {
2571 panic!(concat!(
2572 "Unable to load ",
2573 stringify!(cmd_end_query_indexed_ext)
2574 ))
2575 }
2576 let cname =
2577 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQueryIndexedEXT\0");
2578 let val = _f(cname);
2579 if val.is_null() {
2580 cmd_end_query_indexed_ext
2581 } else {
2582 ::std::mem::transmute(val)
2583 }
2584 },
2585 cmd_draw_indirect_byte_count_ext: unsafe {
2586 unsafe extern "system" fn cmd_draw_indirect_byte_count_ext(
2587 _command_buffer: CommandBuffer,
2588 _instance_count: u32,
2589 _first_instance: u32,
2590 _counter_buffer: Buffer,
2591 _counter_buffer_offset: DeviceSize,
2592 _counter_offset: u32,
2593 _vertex_stride: u32,
2594 ) {
2595 panic!(concat!(
2596 "Unable to load ",
2597 stringify!(cmd_draw_indirect_byte_count_ext)
2598 ))
2599 }
2600 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2601 b"vkCmdDrawIndirectByteCountEXT\0",
2602 );
2603 let val = _f(cname);
2604 if val.is_null() {
2605 cmd_draw_indirect_byte_count_ext
2606 } else {
2607 ::std::mem::transmute(val)
2608 }
2609 },
2610 }
2611 }
2612}
2613#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2614impl AccessFlags {
2615 pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
2616 pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2617 pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self =
2618 Self(0b1000_0000_0000_0000_0000_0000_0000);
2619}
2620#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2621impl BufferUsageFlags {
2622 pub const TRANSFORM_FEEDBACK_BUFFER_EXT: Self = Self(0b1000_0000_0000);
2623 pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT: Self = Self(0b1_0000_0000_0000);
2624}
2625#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2626impl PipelineStageFlags {
2627 pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
2628}
2629#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2630impl QueryType {
2631 pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1_000_028_004);
2632}
2633#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2634impl StructureType {
2635 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: Self = Self(1_000_028_000);
2636 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: Self = Self(1_000_028_001);
2637 pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: Self = Self(1_000_028_002);
2638}
2639impl NvxBinaryImportFn {
2640 #[inline]
2641 pub const fn name() -> &'static ::std::ffi::CStr {
2642 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_binary_import\0") }
2643 }
2644 pub const SPEC_VERSION: u32 = 1u32;
2645}
2646#[allow(non_camel_case_types)]
2647pub type PFN_vkCreateCuModuleNVX = unsafe extern "system" fn(
2648 device: Device,
2649 p_create_info: *const CuModuleCreateInfoNVX,
2650 p_allocator: *const AllocationCallbacks,
2651 p_module: *mut CuModuleNVX,
2652) -> Result;
2653#[allow(non_camel_case_types)]
2654pub type PFN_vkCreateCuFunctionNVX = unsafe extern "system" fn(
2655 device: Device,
2656 p_create_info: *const CuFunctionCreateInfoNVX,
2657 p_allocator: *const AllocationCallbacks,
2658 p_function: *mut CuFunctionNVX,
2659) -> Result;
2660#[allow(non_camel_case_types)]
2661pub type PFN_vkDestroyCuModuleNVX = unsafe extern "system" fn(
2662 device: Device,
2663 module: CuModuleNVX,
2664 p_allocator: *const AllocationCallbacks,
2665);
2666#[allow(non_camel_case_types)]
2667pub type PFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn(
2668 device: Device,
2669 function: CuFunctionNVX,
2670 p_allocator: *const AllocationCallbacks,
2671);
2672#[allow(non_camel_case_types)]
2673pub type PFN_vkCmdCuLaunchKernelNVX =
2674 unsafe extern "system" fn(command_buffer: CommandBuffer, p_launch_info: *const CuLaunchInfoNVX);
2675#[derive(Clone)]
2676pub struct NvxBinaryImportFn {
2677 pub create_cu_module_nvx: PFN_vkCreateCuModuleNVX,
2678 pub create_cu_function_nvx: PFN_vkCreateCuFunctionNVX,
2679 pub destroy_cu_module_nvx: PFN_vkDestroyCuModuleNVX,
2680 pub destroy_cu_function_nvx: PFN_vkDestroyCuFunctionNVX,
2681 pub cmd_cu_launch_kernel_nvx: PFN_vkCmdCuLaunchKernelNVX,
2682}
2683unsafe impl Send for NvxBinaryImportFn {}
2684unsafe impl Sync for NvxBinaryImportFn {}
2685impl NvxBinaryImportFn {
2686 pub fn load<F>(mut _f: F) -> Self
2687 where
2688 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2689 {
2690 Self {
2691 create_cu_module_nvx: unsafe {
2692 unsafe extern "system" fn create_cu_module_nvx(
2693 _device: Device,
2694 _p_create_info: *const CuModuleCreateInfoNVX,
2695 _p_allocator: *const AllocationCallbacks,
2696 _p_module: *mut CuModuleNVX,
2697 ) -> Result {
2698 panic!(concat!("Unable to load ", stringify!(create_cu_module_nvx)))
2699 }
2700 let cname =
2701 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuModuleNVX\0");
2702 let val = _f(cname);
2703 if val.is_null() {
2704 create_cu_module_nvx
2705 } else {
2706 ::std::mem::transmute(val)
2707 }
2708 },
2709 create_cu_function_nvx: unsafe {
2710 unsafe extern "system" fn create_cu_function_nvx(
2711 _device: Device,
2712 _p_create_info: *const CuFunctionCreateInfoNVX,
2713 _p_allocator: *const AllocationCallbacks,
2714 _p_function: *mut CuFunctionNVX,
2715 ) -> Result {
2716 panic!(concat!(
2717 "Unable to load ",
2718 stringify!(create_cu_function_nvx)
2719 ))
2720 }
2721 let cname =
2722 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuFunctionNVX\0");
2723 let val = _f(cname);
2724 if val.is_null() {
2725 create_cu_function_nvx
2726 } else {
2727 ::std::mem::transmute(val)
2728 }
2729 },
2730 destroy_cu_module_nvx: unsafe {
2731 unsafe extern "system" fn destroy_cu_module_nvx(
2732 _device: Device,
2733 _module: CuModuleNVX,
2734 _p_allocator: *const AllocationCallbacks,
2735 ) {
2736 panic!(concat!(
2737 "Unable to load ",
2738 stringify!(destroy_cu_module_nvx)
2739 ))
2740 }
2741 let cname =
2742 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuModuleNVX\0");
2743 let val = _f(cname);
2744 if val.is_null() {
2745 destroy_cu_module_nvx
2746 } else {
2747 ::std::mem::transmute(val)
2748 }
2749 },
2750 destroy_cu_function_nvx: unsafe {
2751 unsafe extern "system" fn destroy_cu_function_nvx(
2752 _device: Device,
2753 _function: CuFunctionNVX,
2754 _p_allocator: *const AllocationCallbacks,
2755 ) {
2756 panic!(concat!(
2757 "Unable to load ",
2758 stringify!(destroy_cu_function_nvx)
2759 ))
2760 }
2761 let cname =
2762 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuFunctionNVX\0");
2763 let val = _f(cname);
2764 if val.is_null() {
2765 destroy_cu_function_nvx
2766 } else {
2767 ::std::mem::transmute(val)
2768 }
2769 },
2770 cmd_cu_launch_kernel_nvx: unsafe {
2771 unsafe extern "system" fn cmd_cu_launch_kernel_nvx(
2772 _command_buffer: CommandBuffer,
2773 _p_launch_info: *const CuLaunchInfoNVX,
2774 ) {
2775 panic!(concat!(
2776 "Unable to load ",
2777 stringify!(cmd_cu_launch_kernel_nvx)
2778 ))
2779 }
2780 let cname =
2781 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCuLaunchKernelNVX\0");
2782 let val = _f(cname);
2783 if val.is_null() {
2784 cmd_cu_launch_kernel_nvx
2785 } else {
2786 ::std::mem::transmute(val)
2787 }
2788 },
2789 }
2790 }
2791}
2792#[doc = "Generated from 'VK_NVX_binary_import'"]
2793impl DebugReportObjectTypeEXT {
2794 pub const CU_MODULE_NVX: Self = Self(1_000_029_000);
2795 pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001);
2796}
2797#[doc = "Generated from 'VK_NVX_binary_import'"]
2798impl ObjectType {
2799 pub const CU_MODULE_NVX: Self = Self(1_000_029_000);
2800 pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001);
2801}
2802#[doc = "Generated from 'VK_NVX_binary_import'"]
2803impl StructureType {
2804 pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1_000_029_000);
2805 pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1_000_029_001);
2806 pub const CU_LAUNCH_INFO_NVX: Self = Self(1_000_029_002);
2807}
2808impl NvxImageViewHandleFn {
2809 #[inline]
2810 pub const fn name() -> &'static ::std::ffi::CStr {
2811 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_image_view_handle\0") }
2812 }
2813 pub const SPEC_VERSION: u32 = 2u32;
2814}
2815#[allow(non_camel_case_types)]
2816pub type PFN_vkGetImageViewHandleNVX =
2817 unsafe extern "system" fn(device: Device, p_info: *const ImageViewHandleInfoNVX) -> u32;
2818#[allow(non_camel_case_types)]
2819pub type PFN_vkGetImageViewAddressNVX = unsafe extern "system" fn(
2820 device: Device,
2821 image_view: ImageView,
2822 p_properties: *mut ImageViewAddressPropertiesNVX,
2823) -> Result;
2824#[derive(Clone)]
2825pub struct NvxImageViewHandleFn {
2826 pub get_image_view_handle_nvx: PFN_vkGetImageViewHandleNVX,
2827 pub get_image_view_address_nvx: PFN_vkGetImageViewAddressNVX,
2828}
2829unsafe impl Send for NvxImageViewHandleFn {}
2830unsafe impl Sync for NvxImageViewHandleFn {}
2831impl NvxImageViewHandleFn {
2832 pub fn load<F>(mut _f: F) -> Self
2833 where
2834 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2835 {
2836 Self {
2837 get_image_view_handle_nvx: unsafe {
2838 unsafe extern "system" fn get_image_view_handle_nvx(
2839 _device: Device,
2840 _p_info: *const ImageViewHandleInfoNVX,
2841 ) -> u32 {
2842 panic!(concat!(
2843 "Unable to load ",
2844 stringify!(get_image_view_handle_nvx)
2845 ))
2846 }
2847 let cname =
2848 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewHandleNVX\0");
2849 let val = _f(cname);
2850 if val.is_null() {
2851 get_image_view_handle_nvx
2852 } else {
2853 ::std::mem::transmute(val)
2854 }
2855 },
2856 get_image_view_address_nvx: unsafe {
2857 unsafe extern "system" fn get_image_view_address_nvx(
2858 _device: Device,
2859 _image_view: ImageView,
2860 _p_properties: *mut ImageViewAddressPropertiesNVX,
2861 ) -> Result {
2862 panic!(concat!(
2863 "Unable to load ",
2864 stringify!(get_image_view_address_nvx)
2865 ))
2866 }
2867 let cname =
2868 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewAddressNVX\0");
2869 let val = _f(cname);
2870 if val.is_null() {
2871 get_image_view_address_nvx
2872 } else {
2873 ::std::mem::transmute(val)
2874 }
2875 },
2876 }
2877 }
2878}
2879#[doc = "Generated from 'VK_NVX_image_view_handle'"]
2880impl StructureType {
2881 pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1_000_030_000);
2882 pub const IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: Self = Self(1_000_030_001);
2883}
2884impl AmdExtension32Fn {
2885 #[inline]
2886 pub const fn name() -> &'static ::std::ffi::CStr {
2887 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_32\0") }
2888 }
2889 pub const SPEC_VERSION: u32 = 0u32;
2890}
2891#[derive(Clone)]
2892pub struct AmdExtension32Fn {}
2893unsafe impl Send for AmdExtension32Fn {}
2894unsafe impl Sync for AmdExtension32Fn {}
2895impl AmdExtension32Fn {
2896 pub fn load<F>(mut _f: F) -> Self
2897 where
2898 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2899 {
2900 Self {}
2901 }
2902}
2903impl AmdExtension33Fn {
2904 #[inline]
2905 pub const fn name() -> &'static ::std::ffi::CStr {
2906 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_33\0") }
2907 }
2908 pub const SPEC_VERSION: u32 = 0u32;
2909}
2910#[derive(Clone)]
2911pub struct AmdExtension33Fn {}
2912unsafe impl Send for AmdExtension33Fn {}
2913unsafe impl Sync for AmdExtension33Fn {}
2914impl AmdExtension33Fn {
2915 pub fn load<F>(mut _f: F) -> Self
2916 where
2917 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2918 {
2919 Self {}
2920 }
2921}
2922impl AmdDrawIndirectCountFn {
2923 #[inline]
2924 pub const fn name() -> &'static ::std::ffi::CStr {
2925 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_draw_indirect_count\0") }
2926 }
2927 pub const SPEC_VERSION: u32 = 2u32;
2928}
2929#[allow(non_camel_case_types)]
2930pub type PFN_vkCmdDrawIndirectCount = unsafe extern "system" fn(
2931 command_buffer: CommandBuffer,
2932 buffer: Buffer,
2933 offset: DeviceSize,
2934 count_buffer: Buffer,
2935 count_buffer_offset: DeviceSize,
2936 max_draw_count: u32,
2937 stride: u32,
2938);
2939#[allow(non_camel_case_types)]
2940pub type PFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn(
2941 command_buffer: CommandBuffer,
2942 buffer: Buffer,
2943 offset: DeviceSize,
2944 count_buffer: Buffer,
2945 count_buffer_offset: DeviceSize,
2946 max_draw_count: u32,
2947 stride: u32,
2948);
2949#[derive(Clone)]
2950pub struct AmdDrawIndirectCountFn {
2951 pub cmd_draw_indirect_count_amd: PFN_vkCmdDrawIndirectCount,
2952 pub cmd_draw_indexed_indirect_count_amd: PFN_vkCmdDrawIndexedIndirectCount,
2953}
2954unsafe impl Send for AmdDrawIndirectCountFn {}
2955unsafe impl Sync for AmdDrawIndirectCountFn {}
2956impl AmdDrawIndirectCountFn {
2957 pub fn load<F>(mut _f: F) -> Self
2958 where
2959 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2960 {
2961 Self {
2962 cmd_draw_indirect_count_amd: unsafe {
2963 unsafe extern "system" fn cmd_draw_indirect_count_amd(
2964 _command_buffer: CommandBuffer,
2965 _buffer: Buffer,
2966 _offset: DeviceSize,
2967 _count_buffer: Buffer,
2968 _count_buffer_offset: DeviceSize,
2969 _max_draw_count: u32,
2970 _stride: u32,
2971 ) {
2972 panic!(concat!(
2973 "Unable to load ",
2974 stringify!(cmd_draw_indirect_count_amd)
2975 ))
2976 }
2977 let cname =
2978 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountAMD\0");
2979 let val = _f(cname);
2980 if val.is_null() {
2981 cmd_draw_indirect_count_amd
2982 } else {
2983 ::std::mem::transmute(val)
2984 }
2985 },
2986 cmd_draw_indexed_indirect_count_amd: unsafe {
2987 unsafe extern "system" fn cmd_draw_indexed_indirect_count_amd(
2988 _command_buffer: CommandBuffer,
2989 _buffer: Buffer,
2990 _offset: DeviceSize,
2991 _count_buffer: Buffer,
2992 _count_buffer_offset: DeviceSize,
2993 _max_draw_count: u32,
2994 _stride: u32,
2995 ) {
2996 panic!(concat!(
2997 "Unable to load ",
2998 stringify!(cmd_draw_indexed_indirect_count_amd)
2999 ))
3000 }
3001 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3002 b"vkCmdDrawIndexedIndirectCountAMD\0",
3003 );
3004 let val = _f(cname);
3005 if val.is_null() {
3006 cmd_draw_indexed_indirect_count_amd
3007 } else {
3008 ::std::mem::transmute(val)
3009 }
3010 },
3011 }
3012 }
3013}
3014impl AmdExtension35Fn {
3015 #[inline]
3016 pub const fn name() -> &'static ::std::ffi::CStr {
3017 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_35\0") }
3018 }
3019 pub const SPEC_VERSION: u32 = 0u32;
3020}
3021#[derive(Clone)]
3022pub struct AmdExtension35Fn {}
3023unsafe impl Send for AmdExtension35Fn {}
3024unsafe impl Sync for AmdExtension35Fn {}
3025impl AmdExtension35Fn {
3026 pub fn load<F>(mut _f: F) -> Self
3027 where
3028 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3029 {
3030 Self {}
3031 }
3032}
3033impl AmdNegativeViewportHeightFn {
3034 #[inline]
3035 pub const fn name() -> &'static ::std::ffi::CStr {
3036 unsafe {
3037 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_negative_viewport_height\0")
3038 }
3039 }
3040 pub const SPEC_VERSION: u32 = 1u32;
3041}
3042#[derive(Clone)]
3043pub struct AmdNegativeViewportHeightFn {}
3044unsafe impl Send for AmdNegativeViewportHeightFn {}
3045unsafe impl Sync for AmdNegativeViewportHeightFn {}
3046impl AmdNegativeViewportHeightFn {
3047 pub fn load<F>(mut _f: F) -> Self
3048 where
3049 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3050 {
3051 Self {}
3052 }
3053}
3054impl AmdGpuShaderHalfFloatFn {
3055 #[inline]
3056 pub const fn name() -> &'static ::std::ffi::CStr {
3057 unsafe {
3058 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_half_float\0")
3059 }
3060 }
3061 pub const SPEC_VERSION: u32 = 2u32;
3062}
3063#[derive(Clone)]
3064pub struct AmdGpuShaderHalfFloatFn {}
3065unsafe impl Send for AmdGpuShaderHalfFloatFn {}
3066unsafe impl Sync for AmdGpuShaderHalfFloatFn {}
3067impl AmdGpuShaderHalfFloatFn {
3068 pub fn load<F>(mut _f: F) -> Self
3069 where
3070 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3071 {
3072 Self {}
3073 }
3074}
3075impl AmdShaderBallotFn {
3076 #[inline]
3077 pub const fn name() -> &'static ::std::ffi::CStr {
3078 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_ballot\0") }
3079 }
3080 pub const SPEC_VERSION: u32 = 1u32;
3081}
3082#[derive(Clone)]
3083pub struct AmdShaderBallotFn {}
3084unsafe impl Send for AmdShaderBallotFn {}
3085unsafe impl Sync for AmdShaderBallotFn {}
3086impl AmdShaderBallotFn {
3087 pub fn load<F>(mut _f: F) -> Self
3088 where
3089 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3090 {
3091 Self {}
3092 }
3093}
3094impl ExtVideoEncodeH264Fn {
3095 #[inline]
3096 pub const fn name() -> &'static ::std::ffi::CStr {
3097 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") }
3098 }
3099 pub const SPEC_VERSION: u32 = 10u32;
3100}
3101#[derive(Clone)]
3102pub struct ExtVideoEncodeH264Fn {}
3103unsafe impl Send for ExtVideoEncodeH264Fn {}
3104unsafe impl Sync for ExtVideoEncodeH264Fn {}
3105impl ExtVideoEncodeH264Fn {
3106 pub fn load<F>(mut _f: F) -> Self
3107 where
3108 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3109 {
3110 Self {}
3111 }
3112}
3113#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
3114impl StructureType {
3115 pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000);
3116 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001);
3117 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002);
3118 pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003);
3119 pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004);
3120 pub const VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: Self = Self(1_000_038_005);
3121 pub const VIDEO_ENCODE_H264_PROFILE_INFO_EXT: Self = Self(1_000_038_007);
3122 pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008);
3123 pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009);
3124}
3125#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
3126impl VideoCodecOperationFlagsKHR {
3127 pub const ENCODE_H264_EXT: Self = Self(0b1_0000_0000_0000_0000);
3128}
3129impl ExtVideoEncodeH265Fn {
3130 #[inline]
3131 pub const fn name() -> &'static ::std::ffi::CStr {
3132 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") }
3133 }
3134 pub const SPEC_VERSION: u32 = 10u32;
3135}
3136#[derive(Clone)]
3137pub struct ExtVideoEncodeH265Fn {}
3138unsafe impl Send for ExtVideoEncodeH265Fn {}
3139unsafe impl Sync for ExtVideoEncodeH265Fn {}
3140impl ExtVideoEncodeH265Fn {
3141 pub fn load<F>(mut _f: F) -> Self
3142 where
3143 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3144 {
3145 Self {}
3146 }
3147}
3148#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
3149impl StructureType {
3150 pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000);
3151 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001);
3152 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002);
3153 pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003);
3154 pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004);
3155 pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: Self = Self(1_000_039_005);
3156 pub const VIDEO_ENCODE_H265_PROFILE_INFO_EXT: Self = Self(1_000_039_007);
3157 pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009);
3158 pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010);
3159}
3160#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
3161impl VideoCodecOperationFlagsKHR {
3162 pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000);
3163}
3164impl KhrVideoDecodeH264Fn {
3165 #[inline]
3166 pub const fn name() -> &'static ::std::ffi::CStr {
3167 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h264\0") }
3168 }
3169 pub const SPEC_VERSION: u32 = 8u32;
3170}
3171#[derive(Clone)]
3172pub struct KhrVideoDecodeH264Fn {}
3173unsafe impl Send for KhrVideoDecodeH264Fn {}
3174unsafe impl Sync for KhrVideoDecodeH264Fn {}
3175impl KhrVideoDecodeH264Fn {
3176 pub fn load<F>(mut _f: F) -> Self
3177 where
3178 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3179 {
3180 Self {}
3181 }
3182}
3183#[doc = "Generated from 'VK_KHR_video_decode_h264'"]
3184impl StructureType {
3185 pub const VIDEO_DECODE_H264_CAPABILITIES_KHR: Self = Self(1_000_040_000);
3186 pub const VIDEO_DECODE_H264_PICTURE_INFO_KHR: Self = Self(1_000_040_001);
3187 pub const VIDEO_DECODE_H264_PROFILE_INFO_KHR: Self = Self(1_000_040_003);
3188 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_040_004);
3189 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_040_005);
3190 pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: Self = Self(1_000_040_006);
3191}
3192#[doc = "Generated from 'VK_KHR_video_decode_h264'"]
3193impl VideoCodecOperationFlagsKHR {
3194 pub const DECODE_H264: Self = Self(0b1);
3195}
3196impl AmdTextureGatherBiasLodFn {
3197 #[inline]
3198 pub const fn name() -> &'static ::std::ffi::CStr {
3199 unsafe {
3200 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_texture_gather_bias_lod\0")
3201 }
3202 }
3203 pub const SPEC_VERSION: u32 = 1u32;
3204}
3205#[derive(Clone)]
3206pub struct AmdTextureGatherBiasLodFn {}
3207unsafe impl Send for AmdTextureGatherBiasLodFn {}
3208unsafe impl Sync for AmdTextureGatherBiasLodFn {}
3209impl AmdTextureGatherBiasLodFn {
3210 pub fn load<F>(mut _f: F) -> Self
3211 where
3212 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3213 {
3214 Self {}
3215 }
3216}
3217#[doc = "Generated from 'VK_AMD_texture_gather_bias_lod'"]
3218impl StructureType {
3219 pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = Self(1_000_041_000);
3220}
3221impl AmdShaderInfoFn {
3222 #[inline]
3223 pub const fn name() -> &'static ::std::ffi::CStr {
3224 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_info\0") }
3225 }
3226 pub const SPEC_VERSION: u32 = 1u32;
3227}
3228#[allow(non_camel_case_types)]
3229pub type PFN_vkGetShaderInfoAMD = unsafe extern "system" fn(
3230 device: Device,
3231 pipeline: Pipeline,
3232 shader_stage: ShaderStageFlags,
3233 info_type: ShaderInfoTypeAMD,
3234 p_info_size: *mut usize,
3235 p_info: *mut c_void,
3236) -> Result;
3237#[derive(Clone)]
3238pub struct AmdShaderInfoFn {
3239 pub get_shader_info_amd: PFN_vkGetShaderInfoAMD,
3240}
3241unsafe impl Send for AmdShaderInfoFn {}
3242unsafe impl Sync for AmdShaderInfoFn {}
3243impl AmdShaderInfoFn {
3244 pub fn load<F>(mut _f: F) -> Self
3245 where
3246 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3247 {
3248 Self {
3249 get_shader_info_amd: unsafe {
3250 unsafe extern "system" fn get_shader_info_amd(
3251 _device: Device,
3252 _pipeline: Pipeline,
3253 _shader_stage: ShaderStageFlags,
3254 _info_type: ShaderInfoTypeAMD,
3255 _p_info_size: *mut usize,
3256 _p_info: *mut c_void,
3257 ) -> Result {
3258 panic!(concat!("Unable to load ", stringify!(get_shader_info_amd)))
3259 }
3260 let cname =
3261 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetShaderInfoAMD\0");
3262 let val = _f(cname);
3263 if val.is_null() {
3264 get_shader_info_amd
3265 } else {
3266 ::std::mem::transmute(val)
3267 }
3268 },
3269 }
3270 }
3271}
3272impl AmdExtension44Fn {
3273 #[inline]
3274 pub const fn name() -> &'static ::std::ffi::CStr {
3275 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_44\0") }
3276 }
3277 pub const SPEC_VERSION: u32 = 0u32;
3278}
3279#[derive(Clone)]
3280pub struct AmdExtension44Fn {}
3281unsafe impl Send for AmdExtension44Fn {}
3282unsafe impl Sync for AmdExtension44Fn {}
3283impl AmdExtension44Fn {
3284 pub fn load<F>(mut _f: F) -> Self
3285 where
3286 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3287 {
3288 Self {}
3289 }
3290}
3291impl KhrDynamicRenderingFn {
3292 #[inline]
3293 pub const fn name() -> &'static ::std::ffi::CStr {
3294 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dynamic_rendering\0") }
3295 }
3296 pub const SPEC_VERSION: u32 = 1u32;
3297}
3298#[allow(non_camel_case_types)]
3299pub type PFN_vkCmdBeginRendering = unsafe extern "system" fn(
3300 command_buffer: CommandBuffer,
3301 p_rendering_info: *const RenderingInfo,
3302);
3303#[allow(non_camel_case_types)]
3304pub type PFN_vkCmdEndRendering = unsafe extern "system" fn(command_buffer: CommandBuffer);
3305#[derive(Clone)]
3306pub struct KhrDynamicRenderingFn {
3307 pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering,
3308 pub cmd_end_rendering_khr: PFN_vkCmdEndRendering,
3309}
3310unsafe impl Send for KhrDynamicRenderingFn {}
3311unsafe impl Sync for KhrDynamicRenderingFn {}
3312impl KhrDynamicRenderingFn {
3313 pub fn load<F>(mut _f: F) -> Self
3314 where
3315 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3316 {
3317 Self {
3318 cmd_begin_rendering_khr: unsafe {
3319 unsafe extern "system" fn cmd_begin_rendering_khr(
3320 _command_buffer: CommandBuffer,
3321 _p_rendering_info: *const RenderingInfo,
3322 ) {
3323 panic!(concat!(
3324 "Unable to load ",
3325 stringify!(cmd_begin_rendering_khr)
3326 ))
3327 }
3328 let cname =
3329 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0");
3330 let val = _f(cname);
3331 if val.is_null() {
3332 cmd_begin_rendering_khr
3333 } else {
3334 ::std::mem::transmute(val)
3335 }
3336 },
3337 cmd_end_rendering_khr: unsafe {
3338 unsafe extern "system" fn cmd_end_rendering_khr(_command_buffer: CommandBuffer) {
3339 panic!(concat!(
3340 "Unable to load ",
3341 stringify!(cmd_end_rendering_khr)
3342 ))
3343 }
3344 let cname =
3345 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0");
3346 let val = _f(cname);
3347 if val.is_null() {
3348 cmd_end_rendering_khr
3349 } else {
3350 ::std::mem::transmute(val)
3351 }
3352 },
3353 }
3354 }
3355}
3356#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
3357impl AttachmentStoreOp {
3358 pub const NONE_KHR: Self = Self::NONE;
3359}
3360#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
3361impl PipelineCreateFlags {
3362 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
3363 Self(0b10_0000_0000_0000_0000_0000);
3364 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self =
3365 Self(0b100_0000_0000_0000_0000_0000);
3366}
3367#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
3368impl StructureType {
3369 pub const RENDERING_INFO_KHR: Self = Self::RENDERING_INFO;
3370 pub const RENDERING_ATTACHMENT_INFO_KHR: Self = Self::RENDERING_ATTACHMENT_INFO;
3371 pub const PIPELINE_RENDERING_CREATE_INFO_KHR: Self = Self::PIPELINE_RENDERING_CREATE_INFO;
3372 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: Self =
3373 Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
3374 pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: Self =
3375 Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
3376 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_006);
3377 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1_000_044_007);
3378 pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1_000_044_008);
3379 pub const ATTACHMENT_SAMPLE_COUNT_INFO_NV: Self = Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
3380 pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: Self = Self(1_000_044_009);
3381}
3382impl AmdExtension46Fn {
3383 #[inline]
3384 pub const fn name() -> &'static ::std::ffi::CStr {
3385 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_46\0") }
3386 }
3387 pub const SPEC_VERSION: u32 = 0u32;
3388}
3389#[derive(Clone)]
3390pub struct AmdExtension46Fn {}
3391unsafe impl Send for AmdExtension46Fn {}
3392unsafe impl Sync for AmdExtension46Fn {}
3393impl AmdExtension46Fn {
3394 pub fn load<F>(mut _f: F) -> Self
3395 where
3396 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3397 {
3398 Self {}
3399 }
3400}
3401impl AmdShaderImageLoadStoreLodFn {
3402 #[inline]
3403 pub const fn name() -> &'static ::std::ffi::CStr {
3404 unsafe {
3405 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_image_load_store_lod\0")
3406 }
3407 }
3408 pub const SPEC_VERSION: u32 = 1u32;
3409}
3410#[derive(Clone)]
3411pub struct AmdShaderImageLoadStoreLodFn {}
3412unsafe impl Send for AmdShaderImageLoadStoreLodFn {}
3413unsafe impl Sync for AmdShaderImageLoadStoreLodFn {}
3414impl AmdShaderImageLoadStoreLodFn {
3415 pub fn load<F>(mut _f: F) -> Self
3416 where
3417 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3418 {
3419 Self {}
3420 }
3421}
3422impl NvxExtension48Fn {
3423 #[inline]
3424 pub const fn name() -> &'static ::std::ffi::CStr {
3425 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_extension_48\0") }
3426 }
3427 pub const SPEC_VERSION: u32 = 0u32;
3428}
3429#[derive(Clone)]
3430pub struct NvxExtension48Fn {}
3431unsafe impl Send for NvxExtension48Fn {}
3432unsafe impl Sync for NvxExtension48Fn {}
3433impl NvxExtension48Fn {
3434 pub fn load<F>(mut _f: F) -> Self
3435 where
3436 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3437 {
3438 Self {}
3439 }
3440}
3441impl GoogleExtension49Fn {
3442 #[inline]
3443 pub const fn name() -> &'static ::std::ffi::CStr {
3444 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_49\0") }
3445 }
3446 pub const SPEC_VERSION: u32 = 0u32;
3447}
3448#[derive(Clone)]
3449pub struct GoogleExtension49Fn {}
3450unsafe impl Send for GoogleExtension49Fn {}
3451unsafe impl Sync for GoogleExtension49Fn {}
3452impl GoogleExtension49Fn {
3453 pub fn load<F>(mut _f: F) -> Self
3454 where
3455 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3456 {
3457 Self {}
3458 }
3459}
3460impl GgpStreamDescriptorSurfaceFn {
3461 #[inline]
3462 pub const fn name() -> &'static ::std::ffi::CStr {
3463 unsafe {
3464 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_stream_descriptor_surface\0")
3465 }
3466 }
3467 pub const SPEC_VERSION: u32 = 1u32;
3468}
3469#[allow(non_camel_case_types)]
3470pub type PFN_vkCreateStreamDescriptorSurfaceGGP = unsafe extern "system" fn(
3471 instance: Instance,
3472 p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP,
3473 p_allocator: *const AllocationCallbacks,
3474 p_surface: *mut SurfaceKHR,
3475) -> Result;
3476#[derive(Clone)]
3477pub struct GgpStreamDescriptorSurfaceFn {
3478 pub create_stream_descriptor_surface_ggp: PFN_vkCreateStreamDescriptorSurfaceGGP,
3479}
3480unsafe impl Send for GgpStreamDescriptorSurfaceFn {}
3481unsafe impl Sync for GgpStreamDescriptorSurfaceFn {}
3482impl GgpStreamDescriptorSurfaceFn {
3483 pub fn load<F>(mut _f: F) -> Self
3484 where
3485 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3486 {
3487 Self {
3488 create_stream_descriptor_surface_ggp: unsafe {
3489 unsafe extern "system" fn create_stream_descriptor_surface_ggp(
3490 _instance: Instance,
3491 _p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP,
3492 _p_allocator: *const AllocationCallbacks,
3493 _p_surface: *mut SurfaceKHR,
3494 ) -> Result {
3495 panic!(concat!(
3496 "Unable to load ",
3497 stringify!(create_stream_descriptor_surface_ggp)
3498 ))
3499 }
3500 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3501 b"vkCreateStreamDescriptorSurfaceGGP\0",
3502 );
3503 let val = _f(cname);
3504 if val.is_null() {
3505 create_stream_descriptor_surface_ggp
3506 } else {
3507 ::std::mem::transmute(val)
3508 }
3509 },
3510 }
3511 }
3512}
3513#[doc = "Generated from 'VK_GGP_stream_descriptor_surface'"]
3514impl StructureType {
3515 pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: Self = Self(1_000_049_000);
3516}
3517impl NvCornerSampledImageFn {
3518 #[inline]
3519 pub const fn name() -> &'static ::std::ffi::CStr {
3520 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_corner_sampled_image\0") }
3521 }
3522 pub const SPEC_VERSION: u32 = 2u32;
3523}
3524#[derive(Clone)]
3525pub struct NvCornerSampledImageFn {}
3526unsafe impl Send for NvCornerSampledImageFn {}
3527unsafe impl Sync for NvCornerSampledImageFn {}
3528impl NvCornerSampledImageFn {
3529 pub fn load<F>(mut _f: F) -> Self
3530 where
3531 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3532 {
3533 Self {}
3534 }
3535}
3536#[doc = "Generated from 'VK_NV_corner_sampled_image'"]
3537impl ImageCreateFlags {
3538 pub const CORNER_SAMPLED_NV: Self = Self(0b10_0000_0000_0000);
3539}
3540#[doc = "Generated from 'VK_NV_corner_sampled_image'"]
3541impl StructureType {
3542 pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: Self = Self(1_000_050_000);
3543}
3544impl NvExtension53Fn {
3545 #[inline]
3546 pub const fn name() -> &'static ::std::ffi::CStr {
3547 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_53\0") }
3548 }
3549 pub const SPEC_VERSION: u32 = 0u32;
3550}
3551#[derive(Clone)]
3552pub struct NvExtension53Fn {}
3553unsafe impl Send for NvExtension53Fn {}
3554unsafe impl Sync for NvExtension53Fn {}
3555impl NvExtension53Fn {
3556 pub fn load<F>(mut _f: F) -> Self
3557 where
3558 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3559 {
3560 Self {}
3561 }
3562}
3563impl KhrMultiviewFn {
3564 #[inline]
3565 pub const fn name() -> &'static ::std::ffi::CStr {
3566 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_multiview\0") }
3567 }
3568 pub const SPEC_VERSION: u32 = 1u32;
3569}
3570#[derive(Clone)]
3571pub struct KhrMultiviewFn {}
3572unsafe impl Send for KhrMultiviewFn {}
3573unsafe impl Sync for KhrMultiviewFn {}
3574impl KhrMultiviewFn {
3575 pub fn load<F>(mut _f: F) -> Self
3576 where
3577 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3578 {
3579 Self {}
3580 }
3581}
3582#[doc = "Generated from 'VK_KHR_multiview'"]
3583impl DependencyFlags {
3584 pub const VIEW_LOCAL_KHR: Self = Self::VIEW_LOCAL;
3585}
3586#[doc = "Generated from 'VK_KHR_multiview'"]
3587impl StructureType {
3588 pub const RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: Self = Self::RENDER_PASS_MULTIVIEW_CREATE_INFO;
3589 pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: Self =
3590 Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
3591 pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: Self =
3592 Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
3593}
3594impl ImgFormatPvrtcFn {
3595 #[inline]
3596 pub const fn name() -> &'static ::std::ffi::CStr {
3597 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_format_pvrtc\0") }
3598 }
3599 pub const SPEC_VERSION: u32 = 1u32;
3600}
3601#[derive(Clone)]
3602pub struct ImgFormatPvrtcFn {}
3603unsafe impl Send for ImgFormatPvrtcFn {}
3604unsafe impl Sync for ImgFormatPvrtcFn {}
3605impl ImgFormatPvrtcFn {
3606 pub fn load<F>(mut _f: F) -> Self
3607 where
3608 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3609 {
3610 Self {}
3611 }
3612}
3613#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
3614impl Format {
3615 pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_000);
3616 pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_001);
3617 pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_002);
3618 pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_003);
3619 pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_004);
3620 pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_005);
3621 pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_006);
3622 pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_007);
3623}
3624impl NvExternalMemoryCapabilitiesFn {
3625 #[inline]
3626 pub const fn name() -> &'static ::std::ffi::CStr {
3627 unsafe {
3628 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_capabilities\0")
3629 }
3630 }
3631 pub const SPEC_VERSION: u32 = 1u32;
3632}
3633#[allow(non_camel_case_types)]
3634pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV =
3635 unsafe extern "system" fn(
3636 physical_device: PhysicalDevice,
3637 format: Format,
3638 ty: ImageType,
3639 tiling: ImageTiling,
3640 usage: ImageUsageFlags,
3641 flags: ImageCreateFlags,
3642 external_handle_type: ExternalMemoryHandleTypeFlagsNV,
3643 p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV,
3644 ) -> Result;
3645#[derive(Clone)]
3646pub struct NvExternalMemoryCapabilitiesFn {
3647 pub get_physical_device_external_image_format_properties_nv:
3648 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,
3649}
3650unsafe impl Send for NvExternalMemoryCapabilitiesFn {}
3651unsafe impl Sync for NvExternalMemoryCapabilitiesFn {}
3652impl NvExternalMemoryCapabilitiesFn {
3653 pub fn load<F>(mut _f: F) -> Self
3654 where
3655 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3656 {
3657 Self {
3658 get_physical_device_external_image_format_properties_nv: unsafe {
3659 unsafe extern "system" fn get_physical_device_external_image_format_properties_nv(
3660 _physical_device: PhysicalDevice,
3661 _format: Format,
3662 _ty: ImageType,
3663 _tiling: ImageTiling,
3664 _usage: ImageUsageFlags,
3665 _flags: ImageCreateFlags,
3666 _external_handle_type: ExternalMemoryHandleTypeFlagsNV,
3667 _p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV,
3668 ) -> Result {
3669 panic!(concat!(
3670 "Unable to load ",
3671 stringify!(get_physical_device_external_image_format_properties_nv)
3672 ))
3673 }
3674 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3675 b"vkGetPhysicalDeviceExternalImageFormatPropertiesNV\0",
3676 );
3677 let val = _f(cname);
3678 if val.is_null() {
3679 get_physical_device_external_image_format_properties_nv
3680 } else {
3681 ::std::mem::transmute(val)
3682 }
3683 },
3684 }
3685 }
3686}
3687impl NvExternalMemoryFn {
3688 #[inline]
3689 pub const fn name() -> &'static ::std::ffi::CStr {
3690 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory\0") }
3691 }
3692 pub const SPEC_VERSION: u32 = 1u32;
3693}
3694#[derive(Clone)]
3695pub struct NvExternalMemoryFn {}
3696unsafe impl Send for NvExternalMemoryFn {}
3697unsafe impl Sync for NvExternalMemoryFn {}
3698impl NvExternalMemoryFn {
3699 pub fn load<F>(mut _f: F) -> Self
3700 where
3701 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3702 {
3703 Self {}
3704 }
3705}
3706#[doc = "Generated from 'VK_NV_external_memory'"]
3707impl StructureType {
3708 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = Self(1_000_056_000);
3709 pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_056_001);
3710}
3711impl NvExternalMemoryWin32Fn {
3712 #[inline]
3713 pub const fn name() -> &'static ::std::ffi::CStr {
3714 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_win32\0") }
3715 }
3716 pub const SPEC_VERSION: u32 = 1u32;
3717}
3718#[allow(non_camel_case_types)]
3719pub type PFN_vkGetMemoryWin32HandleNV = unsafe extern "system" fn(
3720 device: Device,
3721 memory: DeviceMemory,
3722 handle_type: ExternalMemoryHandleTypeFlagsNV,
3723 p_handle: *mut HANDLE,
3724) -> Result;
3725#[derive(Clone)]
3726pub struct NvExternalMemoryWin32Fn {
3727 pub get_memory_win32_handle_nv: PFN_vkGetMemoryWin32HandleNV,
3728}
3729unsafe impl Send for NvExternalMemoryWin32Fn {}
3730unsafe impl Sync for NvExternalMemoryWin32Fn {}
3731impl NvExternalMemoryWin32Fn {
3732 pub fn load<F>(mut _f: F) -> Self
3733 where
3734 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3735 {
3736 Self {
3737 get_memory_win32_handle_nv: unsafe {
3738 unsafe extern "system" fn get_memory_win32_handle_nv(
3739 _device: Device,
3740 _memory: DeviceMemory,
3741 _handle_type: ExternalMemoryHandleTypeFlagsNV,
3742 _p_handle: *mut HANDLE,
3743 ) -> Result {
3744 panic!(concat!(
3745 "Unable to load ",
3746 stringify!(get_memory_win32_handle_nv)
3747 ))
3748 }
3749 let cname =
3750 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleNV\0");
3751 let val = _f(cname);
3752 if val.is_null() {
3753 get_memory_win32_handle_nv
3754 } else {
3755 ::std::mem::transmute(val)
3756 }
3757 },
3758 }
3759 }
3760}
3761#[doc = "Generated from 'VK_NV_external_memory_win32'"]
3762impl StructureType {
3763 pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_000);
3764 pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_001);
3765}
3766impl NvWin32KeyedMutexFn {
3767 #[inline]
3768 pub const fn name() -> &'static ::std::ffi::CStr {
3769 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_win32_keyed_mutex\0") }
3770 }
3771 pub const SPEC_VERSION: u32 = 2u32;
3772}
3773#[derive(Clone)]
3774pub struct NvWin32KeyedMutexFn {}
3775unsafe impl Send for NvWin32KeyedMutexFn {}
3776unsafe impl Sync for NvWin32KeyedMutexFn {}
3777impl NvWin32KeyedMutexFn {
3778 pub fn load<F>(mut _f: F) -> Self
3779 where
3780 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3781 {
3782 Self {}
3783 }
3784}
3785#[doc = "Generated from 'VK_NV_win32_keyed_mutex'"]
3786impl StructureType {
3787 pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = Self(1_000_058_000);
3788}
3789impl KhrGetPhysicalDeviceProperties2Fn {
3790 #[inline]
3791 pub const fn name() -> &'static ::std::ffi::CStr {
3792 unsafe {
3793 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3794 b"VK_KHR_get_physical_device_properties2\0",
3795 )
3796 }
3797 }
3798 pub const SPEC_VERSION: u32 = 2u32;
3799}
3800#[allow(non_camel_case_types)]
3801pub type PFN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn(
3802 physical_device: PhysicalDevice,
3803 p_features: *mut PhysicalDeviceFeatures2,
3804);
3805#[allow(non_camel_case_types)]
3806pub type PFN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn(
3807 physical_device: PhysicalDevice,
3808 p_properties: *mut PhysicalDeviceProperties2,
3809);
3810#[allow(non_camel_case_types)]
3811pub type PFN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn(
3812 physical_device: PhysicalDevice,
3813 format: Format,
3814 p_format_properties: *mut FormatProperties2,
3815);
3816#[allow(non_camel_case_types)]
3817pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn(
3818 physical_device: PhysicalDevice,
3819 p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
3820 p_image_format_properties: *mut ImageFormatProperties2,
3821) -> Result;
3822#[allow(non_camel_case_types)]
3823pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn(
3824 physical_device: PhysicalDevice,
3825 p_queue_family_property_count: *mut u32,
3826 p_queue_family_properties: *mut QueueFamilyProperties2,
3827);
3828#[allow(non_camel_case_types)]
3829pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn(
3830 physical_device: PhysicalDevice,
3831 p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
3832);
3833#[allow(non_camel_case_types)]
3834pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn(
3835 physical_device: PhysicalDevice,
3836 p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
3837 p_property_count: *mut u32,
3838 p_properties: *mut SparseImageFormatProperties2,
3839);
3840#[derive(Clone)]
3841pub struct KhrGetPhysicalDeviceProperties2Fn {
3842 pub get_physical_device_features2_khr: PFN_vkGetPhysicalDeviceFeatures2,
3843 pub get_physical_device_properties2_khr: PFN_vkGetPhysicalDeviceProperties2,
3844 pub get_physical_device_format_properties2_khr: PFN_vkGetPhysicalDeviceFormatProperties2,
3845 pub get_physical_device_image_format_properties2_khr:
3846 PFN_vkGetPhysicalDeviceImageFormatProperties2,
3847 pub get_physical_device_queue_family_properties2_khr:
3848 PFN_vkGetPhysicalDeviceQueueFamilyProperties2,
3849 pub get_physical_device_memory_properties2_khr: PFN_vkGetPhysicalDeviceMemoryProperties2,
3850 pub get_physical_device_sparse_image_format_properties2_khr:
3851 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2,
3852}
3853unsafe impl Send for KhrGetPhysicalDeviceProperties2Fn {}
3854unsafe impl Sync for KhrGetPhysicalDeviceProperties2Fn {}
3855impl KhrGetPhysicalDeviceProperties2Fn {
3856 pub fn load<F>(mut _f: F) -> Self
3857 where
3858 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3859 {
3860 Self {
3861 get_physical_device_features2_khr: unsafe {
3862 unsafe extern "system" fn get_physical_device_features2_khr(
3863 _physical_device: PhysicalDevice,
3864 _p_features: *mut PhysicalDeviceFeatures2,
3865 ) {
3866 panic!(concat!(
3867 "Unable to load ",
3868 stringify!(get_physical_device_features2_khr)
3869 ))
3870 }
3871 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3872 b"vkGetPhysicalDeviceFeatures2KHR\0",
3873 );
3874 let val = _f(cname);
3875 if val.is_null() {
3876 get_physical_device_features2_khr
3877 } else {
3878 ::std::mem::transmute(val)
3879 }
3880 },
3881 get_physical_device_properties2_khr: unsafe {
3882 unsafe extern "system" fn get_physical_device_properties2_khr(
3883 _physical_device: PhysicalDevice,
3884 _p_properties: *mut PhysicalDeviceProperties2,
3885 ) {
3886 panic!(concat!(
3887 "Unable to load ",
3888 stringify!(get_physical_device_properties2_khr)
3889 ))
3890 }
3891 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3892 b"vkGetPhysicalDeviceProperties2KHR\0",
3893 );
3894 let val = _f(cname);
3895 if val.is_null() {
3896 get_physical_device_properties2_khr
3897 } else {
3898 ::std::mem::transmute(val)
3899 }
3900 },
3901 get_physical_device_format_properties2_khr: unsafe {
3902 unsafe extern "system" fn get_physical_device_format_properties2_khr(
3903 _physical_device: PhysicalDevice,
3904 _format: Format,
3905 _p_format_properties: *mut FormatProperties2,
3906 ) {
3907 panic!(concat!(
3908 "Unable to load ",
3909 stringify!(get_physical_device_format_properties2_khr)
3910 ))
3911 }
3912 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3913 b"vkGetPhysicalDeviceFormatProperties2KHR\0",
3914 );
3915 let val = _f(cname);
3916 if val.is_null() {
3917 get_physical_device_format_properties2_khr
3918 } else {
3919 ::std::mem::transmute(val)
3920 }
3921 },
3922 get_physical_device_image_format_properties2_khr: unsafe {
3923 unsafe extern "system" fn get_physical_device_image_format_properties2_khr(
3924 _physical_device: PhysicalDevice,
3925 _p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
3926 _p_image_format_properties: *mut ImageFormatProperties2,
3927 ) -> Result {
3928 panic!(concat!(
3929 "Unable to load ",
3930 stringify!(get_physical_device_image_format_properties2_khr)
3931 ))
3932 }
3933 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3934 b"vkGetPhysicalDeviceImageFormatProperties2KHR\0",
3935 );
3936 let val = _f(cname);
3937 if val.is_null() {
3938 get_physical_device_image_format_properties2_khr
3939 } else {
3940 ::std::mem::transmute(val)
3941 }
3942 },
3943 get_physical_device_queue_family_properties2_khr: unsafe {
3944 unsafe extern "system" fn get_physical_device_queue_family_properties2_khr(
3945 _physical_device: PhysicalDevice,
3946 _p_queue_family_property_count: *mut u32,
3947 _p_queue_family_properties: *mut QueueFamilyProperties2,
3948 ) {
3949 panic!(concat!(
3950 "Unable to load ",
3951 stringify!(get_physical_device_queue_family_properties2_khr)
3952 ))
3953 }
3954 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3955 b"vkGetPhysicalDeviceQueueFamilyProperties2KHR\0",
3956 );
3957 let val = _f(cname);
3958 if val.is_null() {
3959 get_physical_device_queue_family_properties2_khr
3960 } else {
3961 ::std::mem::transmute(val)
3962 }
3963 },
3964 get_physical_device_memory_properties2_khr: unsafe {
3965 unsafe extern "system" fn get_physical_device_memory_properties2_khr(
3966 _physical_device: PhysicalDevice,
3967 _p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
3968 ) {
3969 panic!(concat!(
3970 "Unable to load ",
3971 stringify!(get_physical_device_memory_properties2_khr)
3972 ))
3973 }
3974 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3975 b"vkGetPhysicalDeviceMemoryProperties2KHR\0",
3976 );
3977 let val = _f(cname);
3978 if val.is_null() {
3979 get_physical_device_memory_properties2_khr
3980 } else {
3981 ::std::mem::transmute(val)
3982 }
3983 },
3984 get_physical_device_sparse_image_format_properties2_khr: unsafe {
3985 unsafe extern "system" fn get_physical_device_sparse_image_format_properties2_khr(
3986 _physical_device: PhysicalDevice,
3987 _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
3988 _p_property_count: *mut u32,
3989 _p_properties: *mut SparseImageFormatProperties2,
3990 ) {
3991 panic!(concat!(
3992 "Unable to load ",
3993 stringify!(get_physical_device_sparse_image_format_properties2_khr)
3994 ))
3995 }
3996 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3997 b"vkGetPhysicalDeviceSparseImageFormatProperties2KHR\0",
3998 );
3999 let val = _f(cname);
4000 if val.is_null() {
4001 get_physical_device_sparse_image_format_properties2_khr
4002 } else {
4003 ::std::mem::transmute(val)
4004 }
4005 },
4006 }
4007 }
4008}
4009#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
4010impl StructureType {
4011 pub const PHYSICAL_DEVICE_FEATURES_2_KHR: Self = Self::PHYSICAL_DEVICE_FEATURES_2;
4012 pub const PHYSICAL_DEVICE_PROPERTIES_2_KHR: Self = Self::PHYSICAL_DEVICE_PROPERTIES_2;
4013 pub const FORMAT_PROPERTIES_2_KHR: Self = Self::FORMAT_PROPERTIES_2;
4014 pub const IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::IMAGE_FORMAT_PROPERTIES_2;
4015 pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: Self =
4016 Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
4017 pub const QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self::QUEUE_FAMILY_PROPERTIES_2;
4018 pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: Self =
4019 Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
4020 pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2;
4021 pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: Self =
4022 Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
4023}
4024impl KhrDeviceGroupFn {
4025 #[inline]
4026 pub const fn name() -> &'static ::std::ffi::CStr {
4027 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group\0") }
4028 }
4029 pub const SPEC_VERSION: u32 = 4u32;
4030}
4031#[allow(non_camel_case_types)]
4032pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn(
4033 device: Device,
4034 heap_index: u32,
4035 local_device_index: u32,
4036 remote_device_index: u32,
4037 p_peer_memory_features: *mut PeerMemoryFeatureFlags,
4038);
4039#[allow(non_camel_case_types)]
4040pub type PFN_vkCmdSetDeviceMask =
4041 unsafe extern "system" fn(command_buffer: CommandBuffer, device_mask: u32);
4042#[allow(non_camel_case_types)]
4043pub type PFN_vkCmdDispatchBase = unsafe extern "system" fn(
4044 command_buffer: CommandBuffer,
4045 base_group_x: u32,
4046 base_group_y: u32,
4047 base_group_z: u32,
4048 group_count_x: u32,
4049 group_count_y: u32,
4050 group_count_z: u32,
4051);
4052#[derive(Clone)]
4053pub struct KhrDeviceGroupFn {
4054 pub get_device_group_peer_memory_features_khr: PFN_vkGetDeviceGroupPeerMemoryFeatures,
4055 pub cmd_set_device_mask_khr: PFN_vkCmdSetDeviceMask,
4056 pub cmd_dispatch_base_khr: PFN_vkCmdDispatchBase,
4057 pub get_device_group_present_capabilities_khr:
4058 crate::vk::PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
4059 pub get_device_group_surface_present_modes_khr:
4060 crate::vk::PFN_vkGetDeviceGroupSurfacePresentModesKHR,
4061 pub get_physical_device_present_rectangles_khr:
4062 crate::vk::PFN_vkGetPhysicalDevicePresentRectanglesKHR,
4063 pub acquire_next_image2_khr: crate::vk::PFN_vkAcquireNextImage2KHR,
4064}
4065unsafe impl Send for KhrDeviceGroupFn {}
4066unsafe impl Sync for KhrDeviceGroupFn {}
4067impl KhrDeviceGroupFn {
4068 pub fn load<F>(mut _f: F) -> Self
4069 where
4070 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4071 {
4072 Self {
4073 get_device_group_peer_memory_features_khr: unsafe {
4074 unsafe extern "system" fn get_device_group_peer_memory_features_khr(
4075 _device: Device,
4076 _heap_index: u32,
4077 _local_device_index: u32,
4078 _remote_device_index: u32,
4079 _p_peer_memory_features: *mut PeerMemoryFeatureFlags,
4080 ) {
4081 panic!(concat!(
4082 "Unable to load ",
4083 stringify!(get_device_group_peer_memory_features_khr)
4084 ))
4085 }
4086 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4087 b"vkGetDeviceGroupPeerMemoryFeaturesKHR\0",
4088 );
4089 let val = _f(cname);
4090 if val.is_null() {
4091 get_device_group_peer_memory_features_khr
4092 } else {
4093 ::std::mem::transmute(val)
4094 }
4095 },
4096 cmd_set_device_mask_khr: unsafe {
4097 unsafe extern "system" fn cmd_set_device_mask_khr(
4098 _command_buffer: CommandBuffer,
4099 _device_mask: u32,
4100 ) {
4101 panic!(concat!(
4102 "Unable to load ",
4103 stringify!(cmd_set_device_mask_khr)
4104 ))
4105 }
4106 let cname =
4107 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMaskKHR\0");
4108 let val = _f(cname);
4109 if val.is_null() {
4110 cmd_set_device_mask_khr
4111 } else {
4112 ::std::mem::transmute(val)
4113 }
4114 },
4115 cmd_dispatch_base_khr: unsafe {
4116 unsafe extern "system" fn cmd_dispatch_base_khr(
4117 _command_buffer: CommandBuffer,
4118 _base_group_x: u32,
4119 _base_group_y: u32,
4120 _base_group_z: u32,
4121 _group_count_x: u32,
4122 _group_count_y: u32,
4123 _group_count_z: u32,
4124 ) {
4125 panic!(concat!(
4126 "Unable to load ",
4127 stringify!(cmd_dispatch_base_khr)
4128 ))
4129 }
4130 let cname =
4131 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBaseKHR\0");
4132 let val = _f(cname);
4133 if val.is_null() {
4134 cmd_dispatch_base_khr
4135 } else {
4136 ::std::mem::transmute(val)
4137 }
4138 },
4139 get_device_group_present_capabilities_khr: unsafe {
4140 unsafe extern "system" fn get_device_group_present_capabilities_khr(
4141 _device: Device,
4142 _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
4143 ) -> Result {
4144 panic!(concat!(
4145 "Unable to load ",
4146 stringify!(get_device_group_present_capabilities_khr)
4147 ))
4148 }
4149 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4150 b"vkGetDeviceGroupPresentCapabilitiesKHR\0",
4151 );
4152 let val = _f(cname);
4153 if val.is_null() {
4154 get_device_group_present_capabilities_khr
4155 } else {
4156 ::std::mem::transmute(val)
4157 }
4158 },
4159 get_device_group_surface_present_modes_khr: unsafe {
4160 unsafe extern "system" fn get_device_group_surface_present_modes_khr(
4161 _device: Device,
4162 _surface: SurfaceKHR,
4163 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
4164 ) -> Result {
4165 panic!(concat!(
4166 "Unable to load ",
4167 stringify!(get_device_group_surface_present_modes_khr)
4168 ))
4169 }
4170 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4171 b"vkGetDeviceGroupSurfacePresentModesKHR\0",
4172 );
4173 let val = _f(cname);
4174 if val.is_null() {
4175 get_device_group_surface_present_modes_khr
4176 } else {
4177 ::std::mem::transmute(val)
4178 }
4179 },
4180 get_physical_device_present_rectangles_khr: unsafe {
4181 unsafe extern "system" fn get_physical_device_present_rectangles_khr(
4182 _physical_device: PhysicalDevice,
4183 _surface: SurfaceKHR,
4184 _p_rect_count: *mut u32,
4185 _p_rects: *mut Rect2D,
4186 ) -> Result {
4187 panic!(concat!(
4188 "Unable to load ",
4189 stringify!(get_physical_device_present_rectangles_khr)
4190 ))
4191 }
4192 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4193 b"vkGetPhysicalDevicePresentRectanglesKHR\0",
4194 );
4195 let val = _f(cname);
4196 if val.is_null() {
4197 get_physical_device_present_rectangles_khr
4198 } else {
4199 ::std::mem::transmute(val)
4200 }
4201 },
4202 acquire_next_image2_khr: unsafe {
4203 unsafe extern "system" fn acquire_next_image2_khr(
4204 _device: Device,
4205 _p_acquire_info: *const AcquireNextImageInfoKHR,
4206 _p_image_index: *mut u32,
4207 ) -> Result {
4208 panic!(concat!(
4209 "Unable to load ",
4210 stringify!(acquire_next_image2_khr)
4211 ))
4212 }
4213 let cname =
4214 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0");
4215 let val = _f(cname);
4216 if val.is_null() {
4217 acquire_next_image2_khr
4218 } else {
4219 ::std::mem::transmute(val)
4220 }
4221 },
4222 }
4223 }
4224}
4225#[doc = "Generated from 'VK_KHR_device_group'"]
4226impl DependencyFlags {
4227 pub const DEVICE_GROUP_KHR: Self = Self::DEVICE_GROUP;
4228}
4229#[doc = "Generated from 'VK_KHR_device_group'"]
4230impl ImageCreateFlags {
4231 pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = Self::SPLIT_INSTANCE_BIND_REGIONS;
4232}
4233#[doc = "Generated from 'VK_KHR_device_group'"]
4234impl MemoryAllocateFlags {
4235 pub const DEVICE_MASK_KHR: Self = Self::DEVICE_MASK;
4236}
4237#[doc = "Generated from 'VK_KHR_device_group'"]
4238impl PeerMemoryFeatureFlags {
4239 pub const COPY_SRC_KHR: Self = Self::COPY_SRC;
4240 pub const COPY_DST_KHR: Self = Self::COPY_DST;
4241 pub const GENERIC_SRC_KHR: Self = Self::GENERIC_SRC;
4242 pub const GENERIC_DST_KHR: Self = Self::GENERIC_DST;
4243}
4244#[doc = "Generated from 'VK_KHR_device_group'"]
4245impl PipelineCreateFlags {
4246 pub const VIEW_INDEX_FROM_DEVICE_INDEX_KHR: Self = Self::VIEW_INDEX_FROM_DEVICE_INDEX;
4247}
4248#[doc = "Generated from 'VK_KHR_device_group'"]
4249impl StructureType {
4250 pub const MEMORY_ALLOCATE_FLAGS_INFO_KHR: Self = Self::MEMORY_ALLOCATE_FLAGS_INFO;
4251 pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: Self =
4252 Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
4253 pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: Self =
4254 Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
4255 pub const DEVICE_GROUP_SUBMIT_INFO_KHR: Self = Self::DEVICE_GROUP_SUBMIT_INFO;
4256 pub const DEVICE_GROUP_BIND_SPARSE_INFO_KHR: Self = Self::DEVICE_GROUP_BIND_SPARSE_INFO;
4257 pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: Self =
4258 Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
4259 pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: Self =
4260 Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
4261}
4262impl ExtValidationFlagsFn {
4263 #[inline]
4264 pub const fn name() -> &'static ::std::ffi::CStr {
4265 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_flags\0") }
4266 }
4267 pub const SPEC_VERSION: u32 = 2u32;
4268}
4269#[derive(Clone)]
4270pub struct ExtValidationFlagsFn {}
4271unsafe impl Send for ExtValidationFlagsFn {}
4272unsafe impl Sync for ExtValidationFlagsFn {}
4273impl ExtValidationFlagsFn {
4274 pub fn load<F>(mut _f: F) -> Self
4275 where
4276 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4277 {
4278 Self {}
4279 }
4280}
4281#[doc = "Generated from 'VK_EXT_validation_flags'"]
4282impl StructureType {
4283 pub const VALIDATION_FLAGS_EXT: Self = Self(1_000_061_000);
4284}
4285impl NnViSurfaceFn {
4286 #[inline]
4287 pub const fn name() -> &'static ::std::ffi::CStr {
4288 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NN_vi_surface\0") }
4289 }
4290 pub const SPEC_VERSION: u32 = 1u32;
4291}
4292#[allow(non_camel_case_types)]
4293pub type PFN_vkCreateViSurfaceNN = unsafe extern "system" fn(
4294 instance: Instance,
4295 p_create_info: *const ViSurfaceCreateInfoNN,
4296 p_allocator: *const AllocationCallbacks,
4297 p_surface: *mut SurfaceKHR,
4298) -> Result;
4299#[derive(Clone)]
4300pub struct NnViSurfaceFn {
4301 pub create_vi_surface_nn: PFN_vkCreateViSurfaceNN,
4302}
4303unsafe impl Send for NnViSurfaceFn {}
4304unsafe impl Sync for NnViSurfaceFn {}
4305impl NnViSurfaceFn {
4306 pub fn load<F>(mut _f: F) -> Self
4307 where
4308 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4309 {
4310 Self {
4311 create_vi_surface_nn: unsafe {
4312 unsafe extern "system" fn create_vi_surface_nn(
4313 _instance: Instance,
4314 _p_create_info: *const ViSurfaceCreateInfoNN,
4315 _p_allocator: *const AllocationCallbacks,
4316 _p_surface: *mut SurfaceKHR,
4317 ) -> Result {
4318 panic!(concat!("Unable to load ", stringify!(create_vi_surface_nn)))
4319 }
4320 let cname =
4321 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateViSurfaceNN\0");
4322 let val = _f(cname);
4323 if val.is_null() {
4324 create_vi_surface_nn
4325 } else {
4326 ::std::mem::transmute(val)
4327 }
4328 },
4329 }
4330 }
4331}
4332#[doc = "Generated from 'VK_NN_vi_surface'"]
4333impl StructureType {
4334 pub const VI_SURFACE_CREATE_INFO_NN: Self = Self(1_000_062_000);
4335}
4336impl KhrShaderDrawParametersFn {
4337 #[inline]
4338 pub const fn name() -> &'static ::std::ffi::CStr {
4339 unsafe {
4340 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_draw_parameters\0")
4341 }
4342 }
4343 pub const SPEC_VERSION: u32 = 1u32;
4344}
4345#[derive(Clone)]
4346pub struct KhrShaderDrawParametersFn {}
4347unsafe impl Send for KhrShaderDrawParametersFn {}
4348unsafe impl Sync for KhrShaderDrawParametersFn {}
4349impl KhrShaderDrawParametersFn {
4350 pub fn load<F>(mut _f: F) -> Self
4351 where
4352 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4353 {
4354 Self {}
4355 }
4356}
4357impl ExtShaderSubgroupBallotFn {
4358 #[inline]
4359 pub const fn name() -> &'static ::std::ffi::CStr {
4360 unsafe {
4361 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_ballot\0")
4362 }
4363 }
4364 pub const SPEC_VERSION: u32 = 1u32;
4365}
4366#[derive(Clone)]
4367pub struct ExtShaderSubgroupBallotFn {}
4368unsafe impl Send for ExtShaderSubgroupBallotFn {}
4369unsafe impl Sync for ExtShaderSubgroupBallotFn {}
4370impl ExtShaderSubgroupBallotFn {
4371 pub fn load<F>(mut _f: F) -> Self
4372 where
4373 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4374 {
4375 Self {}
4376 }
4377}
4378impl ExtShaderSubgroupVoteFn {
4379 #[inline]
4380 pub const fn name() -> &'static ::std::ffi::CStr {
4381 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_vote\0") }
4382 }
4383 pub const SPEC_VERSION: u32 = 1u32;
4384}
4385#[derive(Clone)]
4386pub struct ExtShaderSubgroupVoteFn {}
4387unsafe impl Send for ExtShaderSubgroupVoteFn {}
4388unsafe impl Sync for ExtShaderSubgroupVoteFn {}
4389impl ExtShaderSubgroupVoteFn {
4390 pub fn load<F>(mut _f: F) -> Self
4391 where
4392 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4393 {
4394 Self {}
4395 }
4396}
4397impl ExtTextureCompressionAstcHdrFn {
4398 #[inline]
4399 pub const fn name() -> &'static ::std::ffi::CStr {
4400 unsafe {
4401 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4402 b"VK_EXT_texture_compression_astc_hdr\0",
4403 )
4404 }
4405 }
4406 pub const SPEC_VERSION: u32 = 1u32;
4407}
4408#[derive(Clone)]
4409pub struct ExtTextureCompressionAstcHdrFn {}
4410unsafe impl Send for ExtTextureCompressionAstcHdrFn {}
4411unsafe impl Sync for ExtTextureCompressionAstcHdrFn {}
4412impl ExtTextureCompressionAstcHdrFn {
4413 pub fn load<F>(mut _f: F) -> Self
4414 where
4415 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4416 {
4417 Self {}
4418 }
4419}
4420#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
4421impl Format {
4422 pub const ASTC_4X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_4X4_SFLOAT_BLOCK;
4423 pub const ASTC_5X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X4_SFLOAT_BLOCK;
4424 pub const ASTC_5X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X5_SFLOAT_BLOCK;
4425 pub const ASTC_6X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X5_SFLOAT_BLOCK;
4426 pub const ASTC_6X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X6_SFLOAT_BLOCK;
4427 pub const ASTC_8X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X5_SFLOAT_BLOCK;
4428 pub const ASTC_8X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X6_SFLOAT_BLOCK;
4429 pub const ASTC_8X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X8_SFLOAT_BLOCK;
4430 pub const ASTC_10X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X5_SFLOAT_BLOCK;
4431 pub const ASTC_10X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X6_SFLOAT_BLOCK;
4432 pub const ASTC_10X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X8_SFLOAT_BLOCK;
4433 pub const ASTC_10X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X10_SFLOAT_BLOCK;
4434 pub const ASTC_12X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X10_SFLOAT_BLOCK;
4435 pub const ASTC_12X12_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X12_SFLOAT_BLOCK;
4436}
4437#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
4438impl StructureType {
4439 pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: Self =
4440 Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
4441}
4442impl ExtAstcDecodeModeFn {
4443 #[inline]
4444 pub const fn name() -> &'static ::std::ffi::CStr {
4445 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_astc_decode_mode\0") }
4446 }
4447 pub const SPEC_VERSION: u32 = 1u32;
4448}
4449#[derive(Clone)]
4450pub struct ExtAstcDecodeModeFn {}
4451unsafe impl Send for ExtAstcDecodeModeFn {}
4452unsafe impl Sync for ExtAstcDecodeModeFn {}
4453impl ExtAstcDecodeModeFn {
4454 pub fn load<F>(mut _f: F) -> Self
4455 where
4456 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4457 {
4458 Self {}
4459 }
4460}
4461#[doc = "Generated from 'VK_EXT_astc_decode_mode'"]
4462impl StructureType {
4463 pub const IMAGE_VIEW_ASTC_DECODE_MODE_EXT: Self = Self(1_000_067_000);
4464 pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: Self = Self(1_000_067_001);
4465}
4466impl ExtPipelineRobustnessFn {
4467 #[inline]
4468 pub const fn name() -> &'static ::std::ffi::CStr {
4469 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_robustness\0") }
4470 }
4471 pub const SPEC_VERSION: u32 = 1u32;
4472}
4473#[derive(Clone)]
4474pub struct ExtPipelineRobustnessFn {}
4475unsafe impl Send for ExtPipelineRobustnessFn {}
4476unsafe impl Sync for ExtPipelineRobustnessFn {}
4477impl ExtPipelineRobustnessFn {
4478 pub fn load<F>(mut _f: F) -> Self
4479 where
4480 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4481 {
4482 Self {}
4483 }
4484}
4485#[doc = "Generated from 'VK_EXT_pipeline_robustness'"]
4486impl StructureType {
4487 pub const PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: Self = Self(1_000_068_000);
4488 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: Self = Self(1_000_068_001);
4489 pub const PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: Self = Self(1_000_068_002);
4490}
4491impl KhrMaintenance1Fn {
4492 #[inline]
4493 pub const fn name() -> &'static ::std::ffi::CStr {
4494 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance1\0") }
4495 }
4496 pub const SPEC_VERSION: u32 = 2u32;
4497}
4498#[allow(non_camel_case_types)]
4499pub type PFN_vkTrimCommandPool = unsafe extern "system" fn(
4500 device: Device,
4501 command_pool: CommandPool,
4502 flags: CommandPoolTrimFlags,
4503);
4504#[derive(Clone)]
4505pub struct KhrMaintenance1Fn {
4506 pub trim_command_pool_khr: PFN_vkTrimCommandPool,
4507}
4508unsafe impl Send for KhrMaintenance1Fn {}
4509unsafe impl Sync for KhrMaintenance1Fn {}
4510impl KhrMaintenance1Fn {
4511 pub fn load<F>(mut _f: F) -> Self
4512 where
4513 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4514 {
4515 Self {
4516 trim_command_pool_khr: unsafe {
4517 unsafe extern "system" fn trim_command_pool_khr(
4518 _device: Device,
4519 _command_pool: CommandPool,
4520 _flags: CommandPoolTrimFlags,
4521 ) {
4522 panic!(concat!(
4523 "Unable to load ",
4524 stringify!(trim_command_pool_khr)
4525 ))
4526 }
4527 let cname =
4528 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPoolKHR\0");
4529 let val = _f(cname);
4530 if val.is_null() {
4531 trim_command_pool_khr
4532 } else {
4533 ::std::mem::transmute(val)
4534 }
4535 },
4536 }
4537 }
4538}
4539#[doc = "Generated from 'VK_KHR_maintenance1'"]
4540impl FormatFeatureFlags {
4541 pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC;
4542 pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST;
4543}
4544#[doc = "Generated from 'VK_KHR_maintenance1'"]
4545impl ImageCreateFlags {
4546 pub const TYPE_2D_ARRAY_COMPATIBLE_KHR: Self = Self::TYPE_2D_ARRAY_COMPATIBLE;
4547}
4548#[doc = "Generated from 'VK_KHR_maintenance1'"]
4549impl Result {
4550 pub const ERROR_OUT_OF_POOL_MEMORY_KHR: Self = Self::ERROR_OUT_OF_POOL_MEMORY;
4551}
4552impl KhrDeviceGroupCreationFn {
4553 #[inline]
4554 pub const fn name() -> &'static ::std::ffi::CStr {
4555 unsafe {
4556 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group_creation\0")
4557 }
4558 }
4559 pub const SPEC_VERSION: u32 = 1u32;
4560}
4561#[allow(non_camel_case_types)]
4562pub type PFN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn(
4563 instance: Instance,
4564 p_physical_device_group_count: *mut u32,
4565 p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
4566) -> Result;
4567#[derive(Clone)]
4568pub struct KhrDeviceGroupCreationFn {
4569 pub enumerate_physical_device_groups_khr: PFN_vkEnumeratePhysicalDeviceGroups,
4570}
4571unsafe impl Send for KhrDeviceGroupCreationFn {}
4572unsafe impl Sync for KhrDeviceGroupCreationFn {}
4573impl KhrDeviceGroupCreationFn {
4574 pub fn load<F>(mut _f: F) -> Self
4575 where
4576 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4577 {
4578 Self {
4579 enumerate_physical_device_groups_khr: unsafe {
4580 unsafe extern "system" fn enumerate_physical_device_groups_khr(
4581 _instance: Instance,
4582 _p_physical_device_group_count: *mut u32,
4583 _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
4584 ) -> Result {
4585 panic!(concat!(
4586 "Unable to load ",
4587 stringify!(enumerate_physical_device_groups_khr)
4588 ))
4589 }
4590 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4591 b"vkEnumeratePhysicalDeviceGroupsKHR\0",
4592 );
4593 let val = _f(cname);
4594 if val.is_null() {
4595 enumerate_physical_device_groups_khr
4596 } else {
4597 ::std::mem::transmute(val)
4598 }
4599 },
4600 }
4601 }
4602}
4603#[doc = "Generated from 'VK_KHR_device_group_creation'"]
4604impl MemoryHeapFlags {
4605 pub const MULTI_INSTANCE_KHR: Self = Self::MULTI_INSTANCE;
4606}
4607#[doc = "Generated from 'VK_KHR_device_group_creation'"]
4608impl StructureType {
4609 pub const PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_GROUP_PROPERTIES;
4610 pub const DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: Self = Self::DEVICE_GROUP_DEVICE_CREATE_INFO;
4611}
4612impl KhrExternalMemoryCapabilitiesFn {
4613 #[inline]
4614 pub const fn name() -> &'static ::std::ffi::CStr {
4615 unsafe {
4616 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4617 b"VK_KHR_external_memory_capabilities\0",
4618 )
4619 }
4620 }
4621 pub const SPEC_VERSION: u32 = 1u32;
4622}
4623#[allow(non_camel_case_types)]
4624pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn(
4625 physical_device: PhysicalDevice,
4626 p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
4627 p_external_buffer_properties: *mut ExternalBufferProperties,
4628);
4629#[derive(Clone)]
4630pub struct KhrExternalMemoryCapabilitiesFn {
4631 pub get_physical_device_external_buffer_properties_khr:
4632 PFN_vkGetPhysicalDeviceExternalBufferProperties,
4633}
4634unsafe impl Send for KhrExternalMemoryCapabilitiesFn {}
4635unsafe impl Sync for KhrExternalMemoryCapabilitiesFn {}
4636impl KhrExternalMemoryCapabilitiesFn {
4637 pub fn load<F>(mut _f: F) -> Self
4638 where
4639 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4640 {
4641 Self {
4642 get_physical_device_external_buffer_properties_khr: unsafe {
4643 unsafe extern "system" fn get_physical_device_external_buffer_properties_khr(
4644 _physical_device: PhysicalDevice,
4645 _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
4646 _p_external_buffer_properties: *mut ExternalBufferProperties,
4647 ) {
4648 panic!(concat!(
4649 "Unable to load ",
4650 stringify!(get_physical_device_external_buffer_properties_khr)
4651 ))
4652 }
4653 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4654 b"vkGetPhysicalDeviceExternalBufferPropertiesKHR\0",
4655 );
4656 let val = _f(cname);
4657 if val.is_null() {
4658 get_physical_device_external_buffer_properties_khr
4659 } else {
4660 ::std::mem::transmute(val)
4661 }
4662 },
4663 }
4664 }
4665}
4666#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
4667impl ExternalMemoryFeatureFlags {
4668 pub const DEDICATED_ONLY_KHR: Self = Self::DEDICATED_ONLY;
4669 pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
4670 pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
4671}
4672#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
4673impl ExternalMemoryHandleTypeFlags {
4674 pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
4675 pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
4676 pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
4677 pub const D3D11_TEXTURE_KHR: Self = Self::D3D11_TEXTURE;
4678 pub const D3D11_TEXTURE_KMT_KHR: Self = Self::D3D11_TEXTURE_KMT;
4679 pub const D3D12_HEAP_KHR: Self = Self::D3D12_HEAP;
4680 pub const D3D12_RESOURCE_KHR: Self = Self::D3D12_RESOURCE;
4681}
4682#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
4683impl StructureType {
4684 pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: Self =
4685 Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
4686 pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES;
4687 pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: Self =
4688 Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
4689 pub const EXTERNAL_BUFFER_PROPERTIES_KHR: Self = Self::EXTERNAL_BUFFER_PROPERTIES;
4690 pub const PHYSICAL_DEVICE_ID_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_ID_PROPERTIES;
4691}
4692impl KhrExternalMemoryFn {
4693 #[inline]
4694 pub const fn name() -> &'static ::std::ffi::CStr {
4695 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory\0") }
4696 }
4697 pub const SPEC_VERSION: u32 = 1u32;
4698}
4699#[derive(Clone)]
4700pub struct KhrExternalMemoryFn {}
4701unsafe impl Send for KhrExternalMemoryFn {}
4702unsafe impl Sync for KhrExternalMemoryFn {}
4703impl KhrExternalMemoryFn {
4704 pub fn load<F>(mut _f: F) -> Self
4705 where
4706 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4707 {
4708 Self {}
4709 }
4710}
4711#[doc = "Generated from 'VK_KHR_external_memory'"]
4712impl Result {
4713 pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR: Self = Self::ERROR_INVALID_EXTERNAL_HANDLE;
4714}
4715#[doc = "Generated from 'VK_KHR_external_memory'"]
4716impl StructureType {
4717 pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: Self =
4718 Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
4719 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: Self = Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
4720 pub const EXPORT_MEMORY_ALLOCATE_INFO_KHR: Self = Self::EXPORT_MEMORY_ALLOCATE_INFO;
4721}
4722impl KhrExternalMemoryWin32Fn {
4723 #[inline]
4724 pub const fn name() -> &'static ::std::ffi::CStr {
4725 unsafe {
4726 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_win32\0")
4727 }
4728 }
4729 pub const SPEC_VERSION: u32 = 1u32;
4730}
4731#[allow(non_camel_case_types)]
4732pub type PFN_vkGetMemoryWin32HandleKHR = unsafe extern "system" fn(
4733 device: Device,
4734 p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR,
4735 p_handle: *mut HANDLE,
4736) -> Result;
4737#[allow(non_camel_case_types)]
4738pub type PFN_vkGetMemoryWin32HandlePropertiesKHR = unsafe extern "system" fn(
4739 device: Device,
4740 handle_type: ExternalMemoryHandleTypeFlags,
4741 handle: HANDLE,
4742 p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR,
4743) -> Result;
4744#[derive(Clone)]
4745pub struct KhrExternalMemoryWin32Fn {
4746 pub get_memory_win32_handle_khr: PFN_vkGetMemoryWin32HandleKHR,
4747 pub get_memory_win32_handle_properties_khr: PFN_vkGetMemoryWin32HandlePropertiesKHR,
4748}
4749unsafe impl Send for KhrExternalMemoryWin32Fn {}
4750unsafe impl Sync for KhrExternalMemoryWin32Fn {}
4751impl KhrExternalMemoryWin32Fn {
4752 pub fn load<F>(mut _f: F) -> Self
4753 where
4754 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4755 {
4756 Self {
4757 get_memory_win32_handle_khr: unsafe {
4758 unsafe extern "system" fn get_memory_win32_handle_khr(
4759 _device: Device,
4760 _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR,
4761 _p_handle: *mut HANDLE,
4762 ) -> Result {
4763 panic!(concat!(
4764 "Unable to load ",
4765 stringify!(get_memory_win32_handle_khr)
4766 ))
4767 }
4768 let cname =
4769 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleKHR\0");
4770 let val = _f(cname);
4771 if val.is_null() {
4772 get_memory_win32_handle_khr
4773 } else {
4774 ::std::mem::transmute(val)
4775 }
4776 },
4777 get_memory_win32_handle_properties_khr: unsafe {
4778 unsafe extern "system" fn get_memory_win32_handle_properties_khr(
4779 _device: Device,
4780 _handle_type: ExternalMemoryHandleTypeFlags,
4781 _handle: HANDLE,
4782 _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR,
4783 ) -> Result {
4784 panic!(concat!(
4785 "Unable to load ",
4786 stringify!(get_memory_win32_handle_properties_khr)
4787 ))
4788 }
4789 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4790 b"vkGetMemoryWin32HandlePropertiesKHR\0",
4791 );
4792 let val = _f(cname);
4793 if val.is_null() {
4794 get_memory_win32_handle_properties_khr
4795 } else {
4796 ::std::mem::transmute(val)
4797 }
4798 },
4799 }
4800 }
4801}
4802#[doc = "Generated from 'VK_KHR_external_memory_win32'"]
4803impl StructureType {
4804 pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_000);
4805 pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_001);
4806 pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = Self(1_000_073_002);
4807 pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_003);
4808}
4809impl KhrExternalMemoryFdFn {
4810 #[inline]
4811 pub const fn name() -> &'static ::std::ffi::CStr {
4812 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_fd\0") }
4813 }
4814 pub const SPEC_VERSION: u32 = 1u32;
4815}
4816#[allow(non_camel_case_types)]
4817pub type PFN_vkGetMemoryFdKHR = unsafe extern "system" fn(
4818 device: Device,
4819 p_get_fd_info: *const MemoryGetFdInfoKHR,
4820 p_fd: *mut c_int,
4821) -> Result;
4822#[allow(non_camel_case_types)]
4823pub type PFN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn(
4824 device: Device,
4825 handle_type: ExternalMemoryHandleTypeFlags,
4826 fd: c_int,
4827 p_memory_fd_properties: *mut MemoryFdPropertiesKHR,
4828) -> Result;
4829#[derive(Clone)]
4830pub struct KhrExternalMemoryFdFn {
4831 pub get_memory_fd_khr: PFN_vkGetMemoryFdKHR,
4832 pub get_memory_fd_properties_khr: PFN_vkGetMemoryFdPropertiesKHR,
4833}
4834unsafe impl Send for KhrExternalMemoryFdFn {}
4835unsafe impl Sync for KhrExternalMemoryFdFn {}
4836impl KhrExternalMemoryFdFn {
4837 pub fn load<F>(mut _f: F) -> Self
4838 where
4839 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4840 {
4841 Self {
4842 get_memory_fd_khr: unsafe {
4843 unsafe extern "system" fn get_memory_fd_khr(
4844 _device: Device,
4845 _p_get_fd_info: *const MemoryGetFdInfoKHR,
4846 _p_fd: *mut c_int,
4847 ) -> Result {
4848 panic!(concat!("Unable to load ", stringify!(get_memory_fd_khr)))
4849 }
4850 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryFdKHR\0");
4851 let val = _f(cname);
4852 if val.is_null() {
4853 get_memory_fd_khr
4854 } else {
4855 ::std::mem::transmute(val)
4856 }
4857 },
4858 get_memory_fd_properties_khr: unsafe {
4859 unsafe extern "system" fn get_memory_fd_properties_khr(
4860 _device: Device,
4861 _handle_type: ExternalMemoryHandleTypeFlags,
4862 _fd: c_int,
4863 _p_memory_fd_properties: *mut MemoryFdPropertiesKHR,
4864 ) -> Result {
4865 panic!(concat!(
4866 "Unable to load ",
4867 stringify!(get_memory_fd_properties_khr)
4868 ))
4869 }
4870 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4871 b"vkGetMemoryFdPropertiesKHR\0",
4872 );
4873 let val = _f(cname);
4874 if val.is_null() {
4875 get_memory_fd_properties_khr
4876 } else {
4877 ::std::mem::transmute(val)
4878 }
4879 },
4880 }
4881 }
4882}
4883#[doc = "Generated from 'VK_KHR_external_memory_fd'"]
4884impl StructureType {
4885 pub const IMPORT_MEMORY_FD_INFO_KHR: Self = Self(1_000_074_000);
4886 pub const MEMORY_FD_PROPERTIES_KHR: Self = Self(1_000_074_001);
4887 pub const MEMORY_GET_FD_INFO_KHR: Self = Self(1_000_074_002);
4888}
4889impl KhrWin32KeyedMutexFn {
4890 #[inline]
4891 pub const fn name() -> &'static ::std::ffi::CStr {
4892 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_keyed_mutex\0") }
4893 }
4894 pub const SPEC_VERSION: u32 = 1u32;
4895}
4896#[derive(Clone)]
4897pub struct KhrWin32KeyedMutexFn {}
4898unsafe impl Send for KhrWin32KeyedMutexFn {}
4899unsafe impl Sync for KhrWin32KeyedMutexFn {}
4900impl KhrWin32KeyedMutexFn {
4901 pub fn load<F>(mut _f: F) -> Self
4902 where
4903 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4904 {
4905 Self {}
4906 }
4907}
4908#[doc = "Generated from 'VK_KHR_win32_keyed_mutex'"]
4909impl StructureType {
4910 pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1_000_075_000);
4911}
4912impl KhrExternalSemaphoreCapabilitiesFn {
4913 #[inline]
4914 pub const fn name() -> &'static ::std::ffi::CStr {
4915 unsafe {
4916 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4917 b"VK_KHR_external_semaphore_capabilities\0",
4918 )
4919 }
4920 }
4921 pub const SPEC_VERSION: u32 = 1u32;
4922}
4923#[allow(non_camel_case_types)]
4924pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn(
4925 physical_device: PhysicalDevice,
4926 p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
4927 p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
4928);
4929#[derive(Clone)]
4930pub struct KhrExternalSemaphoreCapabilitiesFn {
4931 pub get_physical_device_external_semaphore_properties_khr:
4932 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties,
4933}
4934unsafe impl Send for KhrExternalSemaphoreCapabilitiesFn {}
4935unsafe impl Sync for KhrExternalSemaphoreCapabilitiesFn {}
4936impl KhrExternalSemaphoreCapabilitiesFn {
4937 pub fn load<F>(mut _f: F) -> Self
4938 where
4939 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4940 {
4941 Self {
4942 get_physical_device_external_semaphore_properties_khr: unsafe {
4943 unsafe extern "system" fn get_physical_device_external_semaphore_properties_khr(
4944 _physical_device: PhysicalDevice,
4945 _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
4946 _p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
4947 ) {
4948 panic!(concat!(
4949 "Unable to load ",
4950 stringify!(get_physical_device_external_semaphore_properties_khr)
4951 ))
4952 }
4953 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4954 b"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR\0",
4955 );
4956 let val = _f(cname);
4957 if val.is_null() {
4958 get_physical_device_external_semaphore_properties_khr
4959 } else {
4960 ::std::mem::transmute(val)
4961 }
4962 },
4963 }
4964 }
4965}
4966#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
4967impl ExternalSemaphoreFeatureFlags {
4968 pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
4969 pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
4970}
4971#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
4972impl ExternalSemaphoreHandleTypeFlags {
4973 pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
4974 pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
4975 pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
4976 pub const D3D12_FENCE_KHR: Self = Self::D3D12_FENCE;
4977 pub const SYNC_FD_KHR: Self = Self::SYNC_FD;
4978}
4979#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
4980impl StructureType {
4981 pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: Self =
4982 Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
4983 pub const EXTERNAL_SEMAPHORE_PROPERTIES_KHR: Self = Self::EXTERNAL_SEMAPHORE_PROPERTIES;
4984}
4985impl KhrExternalSemaphoreFn {
4986 #[inline]
4987 pub const fn name() -> &'static ::std::ffi::CStr {
4988 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore\0") }
4989 }
4990 pub const SPEC_VERSION: u32 = 1u32;
4991}
4992#[derive(Clone)]
4993pub struct KhrExternalSemaphoreFn {}
4994unsafe impl Send for KhrExternalSemaphoreFn {}
4995unsafe impl Sync for KhrExternalSemaphoreFn {}
4996impl KhrExternalSemaphoreFn {
4997 pub fn load<F>(mut _f: F) -> Self
4998 where
4999 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5000 {
5001 Self {}
5002 }
5003}
5004#[doc = "Generated from 'VK_KHR_external_semaphore'"]
5005impl SemaphoreImportFlags {
5006 pub const TEMPORARY_KHR: Self = Self::TEMPORARY;
5007}
5008#[doc = "Generated from 'VK_KHR_external_semaphore'"]
5009impl StructureType {
5010 pub const EXPORT_SEMAPHORE_CREATE_INFO_KHR: Self = Self::EXPORT_SEMAPHORE_CREATE_INFO;
5011}
5012impl KhrExternalSemaphoreWin32Fn {
5013 #[inline]
5014 pub const fn name() -> &'static ::std::ffi::CStr {
5015 unsafe {
5016 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_win32\0")
5017 }
5018 }
5019 pub const SPEC_VERSION: u32 = 1u32;
5020}
5021#[allow(non_camel_case_types)]
5022pub type PFN_vkImportSemaphoreWin32HandleKHR = unsafe extern "system" fn(
5023 device: Device,
5024 p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR,
5025) -> Result;
5026#[allow(non_camel_case_types)]
5027pub type PFN_vkGetSemaphoreWin32HandleKHR = unsafe extern "system" fn(
5028 device: Device,
5029 p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR,
5030 p_handle: *mut HANDLE,
5031) -> Result;
5032#[derive(Clone)]
5033pub struct KhrExternalSemaphoreWin32Fn {
5034 pub import_semaphore_win32_handle_khr: PFN_vkImportSemaphoreWin32HandleKHR,
5035 pub get_semaphore_win32_handle_khr: PFN_vkGetSemaphoreWin32HandleKHR,
5036}
5037unsafe impl Send for KhrExternalSemaphoreWin32Fn {}
5038unsafe impl Sync for KhrExternalSemaphoreWin32Fn {}
5039impl KhrExternalSemaphoreWin32Fn {
5040 pub fn load<F>(mut _f: F) -> Self
5041 where
5042 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5043 {
5044 Self {
5045 import_semaphore_win32_handle_khr: unsafe {
5046 unsafe extern "system" fn import_semaphore_win32_handle_khr(
5047 _device: Device,
5048 _p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR,
5049 ) -> Result {
5050 panic!(concat!(
5051 "Unable to load ",
5052 stringify!(import_semaphore_win32_handle_khr)
5053 ))
5054 }
5055 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5056 b"vkImportSemaphoreWin32HandleKHR\0",
5057 );
5058 let val = _f(cname);
5059 if val.is_null() {
5060 import_semaphore_win32_handle_khr
5061 } else {
5062 ::std::mem::transmute(val)
5063 }
5064 },
5065 get_semaphore_win32_handle_khr: unsafe {
5066 unsafe extern "system" fn get_semaphore_win32_handle_khr(
5067 _device: Device,
5068 _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR,
5069 _p_handle: *mut HANDLE,
5070 ) -> Result {
5071 panic!(concat!(
5072 "Unable to load ",
5073 stringify!(get_semaphore_win32_handle_khr)
5074 ))
5075 }
5076 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5077 b"vkGetSemaphoreWin32HandleKHR\0",
5078 );
5079 let val = _f(cname);
5080 if val.is_null() {
5081 get_semaphore_win32_handle_khr
5082 } else {
5083 ::std::mem::transmute(val)
5084 }
5085 },
5086 }
5087 }
5088}
5089#[doc = "Generated from 'VK_KHR_external_semaphore_win32'"]
5090impl StructureType {
5091 pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_000);
5092 pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_001);
5093 pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = Self(1_000_078_002);
5094 pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_003);
5095}
5096impl KhrExternalSemaphoreFdFn {
5097 #[inline]
5098 pub const fn name() -> &'static ::std::ffi::CStr {
5099 unsafe {
5100 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_fd\0")
5101 }
5102 }
5103 pub const SPEC_VERSION: u32 = 1u32;
5104}
5105#[allow(non_camel_case_types)]
5106pub type PFN_vkImportSemaphoreFdKHR = unsafe extern "system" fn(
5107 device: Device,
5108 p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR,
5109) -> Result;
5110#[allow(non_camel_case_types)]
5111pub type PFN_vkGetSemaphoreFdKHR = unsafe extern "system" fn(
5112 device: Device,
5113 p_get_fd_info: *const SemaphoreGetFdInfoKHR,
5114 p_fd: *mut c_int,
5115) -> Result;
5116#[derive(Clone)]
5117pub struct KhrExternalSemaphoreFdFn {
5118 pub import_semaphore_fd_khr: PFN_vkImportSemaphoreFdKHR,
5119 pub get_semaphore_fd_khr: PFN_vkGetSemaphoreFdKHR,
5120}
5121unsafe impl Send for KhrExternalSemaphoreFdFn {}
5122unsafe impl Sync for KhrExternalSemaphoreFdFn {}
5123impl KhrExternalSemaphoreFdFn {
5124 pub fn load<F>(mut _f: F) -> Self
5125 where
5126 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5127 {
5128 Self {
5129 import_semaphore_fd_khr: unsafe {
5130 unsafe extern "system" fn import_semaphore_fd_khr(
5131 _device: Device,
5132 _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR,
5133 ) -> Result {
5134 panic!(concat!(
5135 "Unable to load ",
5136 stringify!(import_semaphore_fd_khr)
5137 ))
5138 }
5139 let cname =
5140 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportSemaphoreFdKHR\0");
5141 let val = _f(cname);
5142 if val.is_null() {
5143 import_semaphore_fd_khr
5144 } else {
5145 ::std::mem::transmute(val)
5146 }
5147 },
5148 get_semaphore_fd_khr: unsafe {
5149 unsafe extern "system" fn get_semaphore_fd_khr(
5150 _device: Device,
5151 _p_get_fd_info: *const SemaphoreGetFdInfoKHR,
5152 _p_fd: *mut c_int,
5153 ) -> Result {
5154 panic!(concat!("Unable to load ", stringify!(get_semaphore_fd_khr)))
5155 }
5156 let cname =
5157 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSemaphoreFdKHR\0");
5158 let val = _f(cname);
5159 if val.is_null() {
5160 get_semaphore_fd_khr
5161 } else {
5162 ::std::mem::transmute(val)
5163 }
5164 },
5165 }
5166 }
5167}
5168#[doc = "Generated from 'VK_KHR_external_semaphore_fd'"]
5169impl StructureType {
5170 pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = Self(1_000_079_000);
5171 pub const SEMAPHORE_GET_FD_INFO_KHR: Self = Self(1_000_079_001);
5172}
5173impl KhrPushDescriptorFn {
5174 #[inline]
5175 pub const fn name() -> &'static ::std::ffi::CStr {
5176 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_push_descriptor\0") }
5177 }
5178 pub const SPEC_VERSION: u32 = 2u32;
5179}
5180#[allow(non_camel_case_types)]
5181pub type PFN_vkCmdPushDescriptorSetKHR = unsafe extern "system" fn(
5182 command_buffer: CommandBuffer,
5183 pipeline_bind_point: PipelineBindPoint,
5184 layout: PipelineLayout,
5185 set: u32,
5186 descriptor_write_count: u32,
5187 p_descriptor_writes: *const WriteDescriptorSet,
5188);
5189#[allow(non_camel_case_types)]
5190pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = unsafe extern "system" fn(
5191 command_buffer: CommandBuffer,
5192 descriptor_update_template: DescriptorUpdateTemplate,
5193 layout: PipelineLayout,
5194 set: u32,
5195 p_data: *const c_void,
5196);
5197#[derive(Clone)]
5198pub struct KhrPushDescriptorFn {
5199 pub cmd_push_descriptor_set_khr: PFN_vkCmdPushDescriptorSetKHR,
5200 pub cmd_push_descriptor_set_with_template_khr: PFN_vkCmdPushDescriptorSetWithTemplateKHR,
5201}
5202unsafe impl Send for KhrPushDescriptorFn {}
5203unsafe impl Sync for KhrPushDescriptorFn {}
5204impl KhrPushDescriptorFn {
5205 pub fn load<F>(mut _f: F) -> Self
5206 where
5207 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5208 {
5209 Self {
5210 cmd_push_descriptor_set_khr: unsafe {
5211 unsafe extern "system" fn cmd_push_descriptor_set_khr(
5212 _command_buffer: CommandBuffer,
5213 _pipeline_bind_point: PipelineBindPoint,
5214 _layout: PipelineLayout,
5215 _set: u32,
5216 _descriptor_write_count: u32,
5217 _p_descriptor_writes: *const WriteDescriptorSet,
5218 ) {
5219 panic!(concat!(
5220 "Unable to load ",
5221 stringify!(cmd_push_descriptor_set_khr)
5222 ))
5223 }
5224 let cname =
5225 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushDescriptorSetKHR\0");
5226 let val = _f(cname);
5227 if val.is_null() {
5228 cmd_push_descriptor_set_khr
5229 } else {
5230 ::std::mem::transmute(val)
5231 }
5232 },
5233 cmd_push_descriptor_set_with_template_khr: unsafe {
5234 unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr(
5235 _command_buffer: CommandBuffer,
5236 _descriptor_update_template: DescriptorUpdateTemplate,
5237 _layout: PipelineLayout,
5238 _set: u32,
5239 _p_data: *const c_void,
5240 ) {
5241 panic!(concat!(
5242 "Unable to load ",
5243 stringify!(cmd_push_descriptor_set_with_template_khr)
5244 ))
5245 }
5246 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5247 b"vkCmdPushDescriptorSetWithTemplateKHR\0",
5248 );
5249 let val = _f(cname);
5250 if val.is_null() {
5251 cmd_push_descriptor_set_with_template_khr
5252 } else {
5253 ::std::mem::transmute(val)
5254 }
5255 },
5256 }
5257 }
5258}
5259#[doc = "Generated from 'VK_KHR_push_descriptor'"]
5260impl DescriptorSetLayoutCreateFlags {
5261 #[doc = "Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"]
5262 pub const PUSH_DESCRIPTOR_KHR: Self = Self(0b1);
5263}
5264#[doc = "Generated from 'VK_KHR_push_descriptor'"]
5265impl DescriptorUpdateTemplateType {
5266 #[doc = "Create descriptor update template for pushed descriptor updates"]
5267 pub const PUSH_DESCRIPTORS_KHR: Self = Self(1);
5268}
5269#[doc = "Generated from 'VK_KHR_push_descriptor'"]
5270impl StructureType {
5271 pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = Self(1_000_080_000);
5272}
5273impl ExtConditionalRenderingFn {
5274 #[inline]
5275 pub const fn name() -> &'static ::std::ffi::CStr {
5276 unsafe {
5277 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conditional_rendering\0")
5278 }
5279 }
5280 pub const SPEC_VERSION: u32 = 2u32;
5281}
5282#[allow(non_camel_case_types)]
5283pub type PFN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn(
5284 command_buffer: CommandBuffer,
5285 p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT,
5286);
5287#[allow(non_camel_case_types)]
5288pub type PFN_vkCmdEndConditionalRenderingEXT =
5289 unsafe extern "system" fn(command_buffer: CommandBuffer);
5290#[derive(Clone)]
5291pub struct ExtConditionalRenderingFn {
5292 pub cmd_begin_conditional_rendering_ext: PFN_vkCmdBeginConditionalRenderingEXT,
5293 pub cmd_end_conditional_rendering_ext: PFN_vkCmdEndConditionalRenderingEXT,
5294}
5295unsafe impl Send for ExtConditionalRenderingFn {}
5296unsafe impl Sync for ExtConditionalRenderingFn {}
5297impl ExtConditionalRenderingFn {
5298 pub fn load<F>(mut _f: F) -> Self
5299 where
5300 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5301 {
5302 Self {
5303 cmd_begin_conditional_rendering_ext: unsafe {
5304 unsafe extern "system" fn cmd_begin_conditional_rendering_ext(
5305 _command_buffer: CommandBuffer,
5306 _p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT,
5307 ) {
5308 panic!(concat!(
5309 "Unable to load ",
5310 stringify!(cmd_begin_conditional_rendering_ext)
5311 ))
5312 }
5313 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5314 b"vkCmdBeginConditionalRenderingEXT\0",
5315 );
5316 let val = _f(cname);
5317 if val.is_null() {
5318 cmd_begin_conditional_rendering_ext
5319 } else {
5320 ::std::mem::transmute(val)
5321 }
5322 },
5323 cmd_end_conditional_rendering_ext: unsafe {
5324 unsafe extern "system" fn cmd_end_conditional_rendering_ext(
5325 _command_buffer: CommandBuffer,
5326 ) {
5327 panic!(concat!(
5328 "Unable to load ",
5329 stringify!(cmd_end_conditional_rendering_ext)
5330 ))
5331 }
5332 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5333 b"vkCmdEndConditionalRenderingEXT\0",
5334 );
5335 let val = _f(cname);
5336 if val.is_null() {
5337 cmd_end_conditional_rendering_ext
5338 } else {
5339 ::std::mem::transmute(val)
5340 }
5341 },
5342 }
5343 }
5344}
5345#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5346impl AccessFlags {
5347 #[doc = "read access flag for reading conditional rendering predicate"]
5348 pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
5349}
5350#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5351impl BufferUsageFlags {
5352 #[doc = "Specifies the buffer can be used as predicate in conditional rendering"]
5353 pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b10_0000_0000);
5354}
5355#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5356impl PipelineStageFlags {
5357 #[doc = "A pipeline stage for conditional rendering predicate fetch"]
5358 pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000);
5359}
5360#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5361impl StructureType {
5362 pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self(1_000_081_000);
5363 pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: Self = Self(1_000_081_001);
5364 pub const CONDITIONAL_RENDERING_BEGIN_INFO_EXT: Self = Self(1_000_081_002);
5365}
5366impl KhrShaderFloat16Int8Fn {
5367 #[inline]
5368 pub const fn name() -> &'static ::std::ffi::CStr {
5369 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float16_int8\0") }
5370 }
5371 pub const SPEC_VERSION: u32 = 1u32;
5372}
5373#[derive(Clone)]
5374pub struct KhrShaderFloat16Int8Fn {}
5375unsafe impl Send for KhrShaderFloat16Int8Fn {}
5376unsafe impl Sync for KhrShaderFloat16Int8Fn {}
5377impl KhrShaderFloat16Int8Fn {
5378 pub fn load<F>(mut _f: F) -> Self
5379 where
5380 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5381 {
5382 Self {}
5383 }
5384}
5385#[doc = "Generated from 'VK_KHR_shader_float16_int8'"]
5386impl StructureType {
5387 pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: Self =
5388 Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
5389 pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: Self =
5390 Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
5391}
5392impl Khr16bitStorageFn {
5393 #[inline]
5394 pub const fn name() -> &'static ::std::ffi::CStr {
5395 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_16bit_storage\0") }
5396 }
5397 pub const SPEC_VERSION: u32 = 1u32;
5398}
5399#[derive(Clone)]
5400pub struct Khr16bitStorageFn {}
5401unsafe impl Send for Khr16bitStorageFn {}
5402unsafe impl Sync for Khr16bitStorageFn {}
5403impl Khr16bitStorageFn {
5404 pub fn load<F>(mut _f: F) -> Self
5405 where
5406 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5407 {
5408 Self {}
5409 }
5410}
5411#[doc = "Generated from 'VK_KHR_16bit_storage'"]
5412impl StructureType {
5413 pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: Self =
5414 Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
5415}
5416impl KhrIncrementalPresentFn {
5417 #[inline]
5418 pub const fn name() -> &'static ::std::ffi::CStr {
5419 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_incremental_present\0") }
5420 }
5421 pub const SPEC_VERSION: u32 = 2u32;
5422}
5423#[derive(Clone)]
5424pub struct KhrIncrementalPresentFn {}
5425unsafe impl Send for KhrIncrementalPresentFn {}
5426unsafe impl Sync for KhrIncrementalPresentFn {}
5427impl KhrIncrementalPresentFn {
5428 pub fn load<F>(mut _f: F) -> Self
5429 where
5430 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5431 {
5432 Self {}
5433 }
5434}
5435#[doc = "Generated from 'VK_KHR_incremental_present'"]
5436impl StructureType {
5437 pub const PRESENT_REGIONS_KHR: Self = Self(1_000_084_000);
5438}
5439impl KhrDescriptorUpdateTemplateFn {
5440 #[inline]
5441 pub const fn name() -> &'static ::std::ffi::CStr {
5442 unsafe {
5443 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_descriptor_update_template\0")
5444 }
5445 }
5446 pub const SPEC_VERSION: u32 = 1u32;
5447}
5448#[allow(non_camel_case_types)]
5449pub type PFN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn(
5450 device: Device,
5451 p_create_info: *const DescriptorUpdateTemplateCreateInfo,
5452 p_allocator: *const AllocationCallbacks,
5453 p_descriptor_update_template: *mut DescriptorUpdateTemplate,
5454) -> Result;
5455#[allow(non_camel_case_types)]
5456pub type PFN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn(
5457 device: Device,
5458 descriptor_update_template: DescriptorUpdateTemplate,
5459 p_allocator: *const AllocationCallbacks,
5460);
5461#[allow(non_camel_case_types)]
5462pub type PFN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn(
5463 device: Device,
5464 descriptor_set: DescriptorSet,
5465 descriptor_update_template: DescriptorUpdateTemplate,
5466 p_data: *const c_void,
5467);
5468#[derive(Clone)]
5469pub struct KhrDescriptorUpdateTemplateFn {
5470 pub create_descriptor_update_template_khr: PFN_vkCreateDescriptorUpdateTemplate,
5471 pub destroy_descriptor_update_template_khr: PFN_vkDestroyDescriptorUpdateTemplate,
5472 pub update_descriptor_set_with_template_khr: PFN_vkUpdateDescriptorSetWithTemplate,
5473 pub cmd_push_descriptor_set_with_template_khr:
5474 crate::vk::PFN_vkCmdPushDescriptorSetWithTemplateKHR,
5475}
5476unsafe impl Send for KhrDescriptorUpdateTemplateFn {}
5477unsafe impl Sync for KhrDescriptorUpdateTemplateFn {}
5478impl KhrDescriptorUpdateTemplateFn {
5479 pub fn load<F>(mut _f: F) -> Self
5480 where
5481 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5482 {
5483 Self {
5484 create_descriptor_update_template_khr: unsafe {
5485 unsafe extern "system" fn create_descriptor_update_template_khr(
5486 _device: Device,
5487 _p_create_info: *const DescriptorUpdateTemplateCreateInfo,
5488 _p_allocator: *const AllocationCallbacks,
5489 _p_descriptor_update_template: *mut DescriptorUpdateTemplate,
5490 ) -> Result {
5491 panic!(concat!(
5492 "Unable to load ",
5493 stringify!(create_descriptor_update_template_khr)
5494 ))
5495 }
5496 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5497 b"vkCreateDescriptorUpdateTemplateKHR\0",
5498 );
5499 let val = _f(cname);
5500 if val.is_null() {
5501 create_descriptor_update_template_khr
5502 } else {
5503 ::std::mem::transmute(val)
5504 }
5505 },
5506 destroy_descriptor_update_template_khr: unsafe {
5507 unsafe extern "system" fn destroy_descriptor_update_template_khr(
5508 _device: Device,
5509 _descriptor_update_template: DescriptorUpdateTemplate,
5510 _p_allocator: *const AllocationCallbacks,
5511 ) {
5512 panic!(concat!(
5513 "Unable to load ",
5514 stringify!(destroy_descriptor_update_template_khr)
5515 ))
5516 }
5517 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5518 b"vkDestroyDescriptorUpdateTemplateKHR\0",
5519 );
5520 let val = _f(cname);
5521 if val.is_null() {
5522 destroy_descriptor_update_template_khr
5523 } else {
5524 ::std::mem::transmute(val)
5525 }
5526 },
5527 update_descriptor_set_with_template_khr: unsafe {
5528 unsafe extern "system" fn update_descriptor_set_with_template_khr(
5529 _device: Device,
5530 _descriptor_set: DescriptorSet,
5531 _descriptor_update_template: DescriptorUpdateTemplate,
5532 _p_data: *const c_void,
5533 ) {
5534 panic!(concat!(
5535 "Unable to load ",
5536 stringify!(update_descriptor_set_with_template_khr)
5537 ))
5538 }
5539 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5540 b"vkUpdateDescriptorSetWithTemplateKHR\0",
5541 );
5542 let val = _f(cname);
5543 if val.is_null() {
5544 update_descriptor_set_with_template_khr
5545 } else {
5546 ::std::mem::transmute(val)
5547 }
5548 },
5549 cmd_push_descriptor_set_with_template_khr: unsafe {
5550 unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr(
5551 _command_buffer: CommandBuffer,
5552 _descriptor_update_template: DescriptorUpdateTemplate,
5553 _layout: PipelineLayout,
5554 _set: u32,
5555 _p_data: *const c_void,
5556 ) {
5557 panic!(concat!(
5558 "Unable to load ",
5559 stringify!(cmd_push_descriptor_set_with_template_khr)
5560 ))
5561 }
5562 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5563 b"vkCmdPushDescriptorSetWithTemplateKHR\0",
5564 );
5565 let val = _f(cname);
5566 if val.is_null() {
5567 cmd_push_descriptor_set_with_template_khr
5568 } else {
5569 ::std::mem::transmute(val)
5570 }
5571 },
5572 }
5573 }
5574}
5575#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5576impl DebugReportObjectTypeEXT {
5577 pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
5578}
5579#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5580impl DescriptorUpdateTemplateType {
5581 pub const DESCRIPTOR_SET_KHR: Self = Self::DESCRIPTOR_SET;
5582}
5583#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5584impl ObjectType {
5585 pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
5586}
5587#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5588impl StructureType {
5589 pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: Self =
5590 Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
5591}
5592impl NvxDeviceGeneratedCommandsFn {
5593 #[inline]
5594 pub const fn name() -> &'static ::std::ffi::CStr {
5595 unsafe {
5596 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_device_generated_commands\0")
5597 }
5598 }
5599 pub const SPEC_VERSION: u32 = 3u32;
5600}
5601#[derive(Clone)]
5602pub struct NvxDeviceGeneratedCommandsFn {}
5603unsafe impl Send for NvxDeviceGeneratedCommandsFn {}
5604unsafe impl Sync for NvxDeviceGeneratedCommandsFn {}
5605impl NvxDeviceGeneratedCommandsFn {
5606 pub fn load<F>(mut _f: F) -> Self
5607 where
5608 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5609 {
5610 Self {}
5611 }
5612}
5613impl NvClipSpaceWScalingFn {
5614 #[inline]
5615 pub const fn name() -> &'static ::std::ffi::CStr {
5616 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_clip_space_w_scaling\0") }
5617 }
5618 pub const SPEC_VERSION: u32 = 1u32;
5619}
5620#[allow(non_camel_case_types)]
5621pub type PFN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn(
5622 command_buffer: CommandBuffer,
5623 first_viewport: u32,
5624 viewport_count: u32,
5625 p_viewport_w_scalings: *const ViewportWScalingNV,
5626);
5627#[derive(Clone)]
5628pub struct NvClipSpaceWScalingFn {
5629 pub cmd_set_viewport_w_scaling_nv: PFN_vkCmdSetViewportWScalingNV,
5630}
5631unsafe impl Send for NvClipSpaceWScalingFn {}
5632unsafe impl Sync for NvClipSpaceWScalingFn {}
5633impl NvClipSpaceWScalingFn {
5634 pub fn load<F>(mut _f: F) -> Self
5635 where
5636 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5637 {
5638 Self {
5639 cmd_set_viewport_w_scaling_nv: unsafe {
5640 unsafe extern "system" fn cmd_set_viewport_w_scaling_nv(
5641 _command_buffer: CommandBuffer,
5642 _first_viewport: u32,
5643 _viewport_count: u32,
5644 _p_viewport_w_scalings: *const ViewportWScalingNV,
5645 ) {
5646 panic!(concat!(
5647 "Unable to load ",
5648 stringify!(cmd_set_viewport_w_scaling_nv)
5649 ))
5650 }
5651 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5652 b"vkCmdSetViewportWScalingNV\0",
5653 );
5654 let val = _f(cname);
5655 if val.is_null() {
5656 cmd_set_viewport_w_scaling_nv
5657 } else {
5658 ::std::mem::transmute(val)
5659 }
5660 },
5661 }
5662 }
5663}
5664#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"]
5665impl DynamicState {
5666 pub const VIEWPORT_W_SCALING_NV: Self = Self(1_000_087_000);
5667}
5668#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"]
5669impl StructureType {
5670 pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self(1_000_087_000);
5671}
5672impl ExtDirectModeDisplayFn {
5673 #[inline]
5674 pub const fn name() -> &'static ::std::ffi::CStr {
5675 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_direct_mode_display\0") }
5676 }
5677 pub const SPEC_VERSION: u32 = 1u32;
5678}
5679#[allow(non_camel_case_types)]
5680pub type PFN_vkReleaseDisplayEXT =
5681 unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result;
5682#[derive(Clone)]
5683pub struct ExtDirectModeDisplayFn {
5684 pub release_display_ext: PFN_vkReleaseDisplayEXT,
5685}
5686unsafe impl Send for ExtDirectModeDisplayFn {}
5687unsafe impl Sync for ExtDirectModeDisplayFn {}
5688impl ExtDirectModeDisplayFn {
5689 pub fn load<F>(mut _f: F) -> Self
5690 where
5691 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5692 {
5693 Self {
5694 release_display_ext: unsafe {
5695 unsafe extern "system" fn release_display_ext(
5696 _physical_device: PhysicalDevice,
5697 _display: DisplayKHR,
5698 ) -> Result {
5699 panic!(concat!("Unable to load ", stringify!(release_display_ext)))
5700 }
5701 let cname =
5702 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseDisplayEXT\0");
5703 let val = _f(cname);
5704 if val.is_null() {
5705 release_display_ext
5706 } else {
5707 ::std::mem::transmute(val)
5708 }
5709 },
5710 }
5711 }
5712}
5713impl ExtAcquireXlibDisplayFn {
5714 #[inline]
5715 pub const fn name() -> &'static ::std::ffi::CStr {
5716 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_xlib_display\0") }
5717 }
5718 pub const SPEC_VERSION: u32 = 1u32;
5719}
5720#[allow(non_camel_case_types)]
5721pub type PFN_vkAcquireXlibDisplayEXT = unsafe extern "system" fn(
5722 physical_device: PhysicalDevice,
5723 dpy: *mut Display,
5724 display: DisplayKHR,
5725) -> Result;
5726#[allow(non_camel_case_types)]
5727pub type PFN_vkGetRandROutputDisplayEXT = unsafe extern "system" fn(
5728 physical_device: PhysicalDevice,
5729 dpy: *mut Display,
5730 rr_output: RROutput,
5731 p_display: *mut DisplayKHR,
5732) -> Result;
5733#[derive(Clone)]
5734pub struct ExtAcquireXlibDisplayFn {
5735 pub acquire_xlib_display_ext: PFN_vkAcquireXlibDisplayEXT,
5736 pub get_rand_r_output_display_ext: PFN_vkGetRandROutputDisplayEXT,
5737}
5738unsafe impl Send for ExtAcquireXlibDisplayFn {}
5739unsafe impl Sync for ExtAcquireXlibDisplayFn {}
5740impl ExtAcquireXlibDisplayFn {
5741 pub fn load<F>(mut _f: F) -> Self
5742 where
5743 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5744 {
5745 Self {
5746 acquire_xlib_display_ext: unsafe {
5747 unsafe extern "system" fn acquire_xlib_display_ext(
5748 _physical_device: PhysicalDevice,
5749 _dpy: *mut Display,
5750 _display: DisplayKHR,
5751 ) -> Result {
5752 panic!(concat!(
5753 "Unable to load ",
5754 stringify!(acquire_xlib_display_ext)
5755 ))
5756 }
5757 let cname =
5758 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireXlibDisplayEXT\0");
5759 let val = _f(cname);
5760 if val.is_null() {
5761 acquire_xlib_display_ext
5762 } else {
5763 ::std::mem::transmute(val)
5764 }
5765 },
5766 get_rand_r_output_display_ext: unsafe {
5767 unsafe extern "system" fn get_rand_r_output_display_ext(
5768 _physical_device: PhysicalDevice,
5769 _dpy: *mut Display,
5770 _rr_output: RROutput,
5771 _p_display: *mut DisplayKHR,
5772 ) -> Result {
5773 panic!(concat!(
5774 "Unable to load ",
5775 stringify!(get_rand_r_output_display_ext)
5776 ))
5777 }
5778 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5779 b"vkGetRandROutputDisplayEXT\0",
5780 );
5781 let val = _f(cname);
5782 if val.is_null() {
5783 get_rand_r_output_display_ext
5784 } else {
5785 ::std::mem::transmute(val)
5786 }
5787 },
5788 }
5789 }
5790}
5791impl ExtDisplaySurfaceCounterFn {
5792 #[inline]
5793 pub const fn name() -> &'static ::std::ffi::CStr {
5794 unsafe {
5795 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_surface_counter\0")
5796 }
5797 }
5798 pub const SPEC_VERSION: u32 = 1u32;
5799}
5800#[allow(non_camel_case_types)]
5801pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn(
5802 physical_device: PhysicalDevice,
5803 surface: SurfaceKHR,
5804 p_surface_capabilities: *mut SurfaceCapabilities2EXT,
5805) -> Result;
5806#[derive(Clone)]
5807pub struct ExtDisplaySurfaceCounterFn {
5808 pub get_physical_device_surface_capabilities2_ext:
5809 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT,
5810}
5811unsafe impl Send for ExtDisplaySurfaceCounterFn {}
5812unsafe impl Sync for ExtDisplaySurfaceCounterFn {}
5813impl ExtDisplaySurfaceCounterFn {
5814 pub fn load<F>(mut _f: F) -> Self
5815 where
5816 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5817 {
5818 Self {
5819 get_physical_device_surface_capabilities2_ext: unsafe {
5820 unsafe extern "system" fn get_physical_device_surface_capabilities2_ext(
5821 _physical_device: PhysicalDevice,
5822 _surface: SurfaceKHR,
5823 _p_surface_capabilities: *mut SurfaceCapabilities2EXT,
5824 ) -> Result {
5825 panic!(concat!(
5826 "Unable to load ",
5827 stringify!(get_physical_device_surface_capabilities2_ext)
5828 ))
5829 }
5830 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5831 b"vkGetPhysicalDeviceSurfaceCapabilities2EXT\0",
5832 );
5833 let val = _f(cname);
5834 if val.is_null() {
5835 get_physical_device_surface_capabilities2_ext
5836 } else {
5837 ::std::mem::transmute(val)
5838 }
5839 },
5840 }
5841 }
5842}
5843#[doc = "Generated from 'VK_EXT_display_surface_counter'"]
5844impl StructureType {
5845 pub const SURFACE_CAPABILITIES_2_EXT: Self = Self(1_000_090_000);
5846}
5847impl ExtDisplayControlFn {
5848 #[inline]
5849 pub const fn name() -> &'static ::std::ffi::CStr {
5850 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_control\0") }
5851 }
5852 pub const SPEC_VERSION: u32 = 1u32;
5853}
5854#[allow(non_camel_case_types)]
5855pub type PFN_vkDisplayPowerControlEXT = unsafe extern "system" fn(
5856 device: Device,
5857 display: DisplayKHR,
5858 p_display_power_info: *const DisplayPowerInfoEXT,
5859) -> Result;
5860#[allow(non_camel_case_types)]
5861pub type PFN_vkRegisterDeviceEventEXT = unsafe extern "system" fn(
5862 device: Device,
5863 p_device_event_info: *const DeviceEventInfoEXT,
5864 p_allocator: *const AllocationCallbacks,
5865 p_fence: *mut Fence,
5866) -> Result;
5867#[allow(non_camel_case_types)]
5868pub type PFN_vkRegisterDisplayEventEXT = unsafe extern "system" fn(
5869 device: Device,
5870 display: DisplayKHR,
5871 p_display_event_info: *const DisplayEventInfoEXT,
5872 p_allocator: *const AllocationCallbacks,
5873 p_fence: *mut Fence,
5874) -> Result;
5875#[allow(non_camel_case_types)]
5876pub type PFN_vkGetSwapchainCounterEXT = unsafe extern "system" fn(
5877 device: Device,
5878 swapchain: SwapchainKHR,
5879 counter: SurfaceCounterFlagsEXT,
5880 p_counter_value: *mut u64,
5881) -> Result;
5882#[derive(Clone)]
5883pub struct ExtDisplayControlFn {
5884 pub display_power_control_ext: PFN_vkDisplayPowerControlEXT,
5885 pub register_device_event_ext: PFN_vkRegisterDeviceEventEXT,
5886 pub register_display_event_ext: PFN_vkRegisterDisplayEventEXT,
5887 pub get_swapchain_counter_ext: PFN_vkGetSwapchainCounterEXT,
5888}
5889unsafe impl Send for ExtDisplayControlFn {}
5890unsafe impl Sync for ExtDisplayControlFn {}
5891impl ExtDisplayControlFn {
5892 pub fn load<F>(mut _f: F) -> Self
5893 where
5894 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5895 {
5896 Self {
5897 display_power_control_ext: unsafe {
5898 unsafe extern "system" fn display_power_control_ext(
5899 _device: Device,
5900 _display: DisplayKHR,
5901 _p_display_power_info: *const DisplayPowerInfoEXT,
5902 ) -> Result {
5903 panic!(concat!(
5904 "Unable to load ",
5905 stringify!(display_power_control_ext)
5906 ))
5907 }
5908 let cname =
5909 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDisplayPowerControlEXT\0");
5910 let val = _f(cname);
5911 if val.is_null() {
5912 display_power_control_ext
5913 } else {
5914 ::std::mem::transmute(val)
5915 }
5916 },
5917 register_device_event_ext: unsafe {
5918 unsafe extern "system" fn register_device_event_ext(
5919 _device: Device,
5920 _p_device_event_info: *const DeviceEventInfoEXT,
5921 _p_allocator: *const AllocationCallbacks,
5922 _p_fence: *mut Fence,
5923 ) -> Result {
5924 panic!(concat!(
5925 "Unable to load ",
5926 stringify!(register_device_event_ext)
5927 ))
5928 }
5929 let cname =
5930 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDeviceEventEXT\0");
5931 let val = _f(cname);
5932 if val.is_null() {
5933 register_device_event_ext
5934 } else {
5935 ::std::mem::transmute(val)
5936 }
5937 },
5938 register_display_event_ext: unsafe {
5939 unsafe extern "system" fn register_display_event_ext(
5940 _device: Device,
5941 _display: DisplayKHR,
5942 _p_display_event_info: *const DisplayEventInfoEXT,
5943 _p_allocator: *const AllocationCallbacks,
5944 _p_fence: *mut Fence,
5945 ) -> Result {
5946 panic!(concat!(
5947 "Unable to load ",
5948 stringify!(register_display_event_ext)
5949 ))
5950 }
5951 let cname =
5952 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDisplayEventEXT\0");
5953 let val = _f(cname);
5954 if val.is_null() {
5955 register_display_event_ext
5956 } else {
5957 ::std::mem::transmute(val)
5958 }
5959 },
5960 get_swapchain_counter_ext: unsafe {
5961 unsafe extern "system" fn get_swapchain_counter_ext(
5962 _device: Device,
5963 _swapchain: SwapchainKHR,
5964 _counter: SurfaceCounterFlagsEXT,
5965 _p_counter_value: *mut u64,
5966 ) -> Result {
5967 panic!(concat!(
5968 "Unable to load ",
5969 stringify!(get_swapchain_counter_ext)
5970 ))
5971 }
5972 let cname =
5973 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainCounterEXT\0");
5974 let val = _f(cname);
5975 if val.is_null() {
5976 get_swapchain_counter_ext
5977 } else {
5978 ::std::mem::transmute(val)
5979 }
5980 },
5981 }
5982 }
5983}
5984#[doc = "Generated from 'VK_EXT_display_control'"]
5985impl StructureType {
5986 pub const DISPLAY_POWER_INFO_EXT: Self = Self(1_000_091_000);
5987 pub const DEVICE_EVENT_INFO_EXT: Self = Self(1_000_091_001);
5988 pub const DISPLAY_EVENT_INFO_EXT: Self = Self(1_000_091_002);
5989 pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = Self(1_000_091_003);
5990}
5991impl GoogleDisplayTimingFn {
5992 #[inline]
5993 pub const fn name() -> &'static ::std::ffi::CStr {
5994 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_display_timing\0") }
5995 }
5996 pub const SPEC_VERSION: u32 = 1u32;
5997}
5998#[allow(non_camel_case_types)]
5999pub type PFN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn(
6000 device: Device,
6001 swapchain: SwapchainKHR,
6002 p_display_timing_properties: *mut RefreshCycleDurationGOOGLE,
6003) -> Result;
6004#[allow(non_camel_case_types)]
6005pub type PFN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn(
6006 device: Device,
6007 swapchain: SwapchainKHR,
6008 p_presentation_timing_count: *mut u32,
6009 p_presentation_timings: *mut PastPresentationTimingGOOGLE,
6010) -> Result;
6011#[derive(Clone)]
6012pub struct GoogleDisplayTimingFn {
6013 pub get_refresh_cycle_duration_google: PFN_vkGetRefreshCycleDurationGOOGLE,
6014 pub get_past_presentation_timing_google: PFN_vkGetPastPresentationTimingGOOGLE,
6015}
6016unsafe impl Send for GoogleDisplayTimingFn {}
6017unsafe impl Sync for GoogleDisplayTimingFn {}
6018impl GoogleDisplayTimingFn {
6019 pub fn load<F>(mut _f: F) -> Self
6020 where
6021 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6022 {
6023 Self {
6024 get_refresh_cycle_duration_google: unsafe {
6025 unsafe extern "system" fn get_refresh_cycle_duration_google(
6026 _device: Device,
6027 _swapchain: SwapchainKHR,
6028 _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE,
6029 ) -> Result {
6030 panic!(concat!(
6031 "Unable to load ",
6032 stringify!(get_refresh_cycle_duration_google)
6033 ))
6034 }
6035 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6036 b"vkGetRefreshCycleDurationGOOGLE\0",
6037 );
6038 let val = _f(cname);
6039 if val.is_null() {
6040 get_refresh_cycle_duration_google
6041 } else {
6042 ::std::mem::transmute(val)
6043 }
6044 },
6045 get_past_presentation_timing_google: unsafe {
6046 unsafe extern "system" fn get_past_presentation_timing_google(
6047 _device: Device,
6048 _swapchain: SwapchainKHR,
6049 _p_presentation_timing_count: *mut u32,
6050 _p_presentation_timings: *mut PastPresentationTimingGOOGLE,
6051 ) -> Result {
6052 panic!(concat!(
6053 "Unable to load ",
6054 stringify!(get_past_presentation_timing_google)
6055 ))
6056 }
6057 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6058 b"vkGetPastPresentationTimingGOOGLE\0",
6059 );
6060 let val = _f(cname);
6061 if val.is_null() {
6062 get_past_presentation_timing_google
6063 } else {
6064 ::std::mem::transmute(val)
6065 }
6066 },
6067 }
6068 }
6069}
6070#[doc = "Generated from 'VK_GOOGLE_display_timing'"]
6071impl StructureType {
6072 pub const PRESENT_TIMES_INFO_GOOGLE: Self = Self(1_000_092_000);
6073}
6074impl ReservedDoNotUse94Fn {
6075 #[inline]
6076 pub const fn name() -> &'static ::std::ffi::CStr {
6077 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_RESERVED_do_not_use_94\0") }
6078 }
6079 pub const SPEC_VERSION: u32 = 1u32;
6080}
6081#[derive(Clone)]
6082pub struct ReservedDoNotUse94Fn {}
6083unsafe impl Send for ReservedDoNotUse94Fn {}
6084unsafe impl Sync for ReservedDoNotUse94Fn {}
6085impl ReservedDoNotUse94Fn {
6086 pub fn load<F>(mut _f: F) -> Self
6087 where
6088 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6089 {
6090 Self {}
6091 }
6092}
6093impl NvSampleMaskOverrideCoverageFn {
6094 #[inline]
6095 pub const fn name() -> &'static ::std::ffi::CStr {
6096 unsafe {
6097 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6098 b"VK_NV_sample_mask_override_coverage\0",
6099 )
6100 }
6101 }
6102 pub const SPEC_VERSION: u32 = 1u32;
6103}
6104#[derive(Clone)]
6105pub struct NvSampleMaskOverrideCoverageFn {}
6106unsafe impl Send for NvSampleMaskOverrideCoverageFn {}
6107unsafe impl Sync for NvSampleMaskOverrideCoverageFn {}
6108impl NvSampleMaskOverrideCoverageFn {
6109 pub fn load<F>(mut _f: F) -> Self
6110 where
6111 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6112 {
6113 Self {}
6114 }
6115}
6116impl NvGeometryShaderPassthroughFn {
6117 #[inline]
6118 pub const fn name() -> &'static ::std::ffi::CStr {
6119 unsafe {
6120 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_geometry_shader_passthrough\0")
6121 }
6122 }
6123 pub const SPEC_VERSION: u32 = 1u32;
6124}
6125#[derive(Clone)]
6126pub struct NvGeometryShaderPassthroughFn {}
6127unsafe impl Send for NvGeometryShaderPassthroughFn {}
6128unsafe impl Sync for NvGeometryShaderPassthroughFn {}
6129impl NvGeometryShaderPassthroughFn {
6130 pub fn load<F>(mut _f: F) -> Self
6131 where
6132 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6133 {
6134 Self {}
6135 }
6136}
6137impl NvViewportArray2Fn {
6138 #[inline]
6139 pub const fn name() -> &'static ::std::ffi::CStr {
6140 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_array2\0") }
6141 }
6142 pub const SPEC_VERSION: u32 = 1u32;
6143}
6144#[derive(Clone)]
6145pub struct NvViewportArray2Fn {}
6146unsafe impl Send for NvViewportArray2Fn {}
6147unsafe impl Sync for NvViewportArray2Fn {}
6148impl NvViewportArray2Fn {
6149 pub fn load<F>(mut _f: F) -> Self
6150 where
6151 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6152 {
6153 Self {}
6154 }
6155}
6156impl NvxMultiviewPerViewAttributesFn {
6157 #[inline]
6158 pub const fn name() -> &'static ::std::ffi::CStr {
6159 unsafe {
6160 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6161 b"VK_NVX_multiview_per_view_attributes\0",
6162 )
6163 }
6164 }
6165 pub const SPEC_VERSION: u32 = 1u32;
6166}
6167#[derive(Clone)]
6168pub struct NvxMultiviewPerViewAttributesFn {}
6169unsafe impl Send for NvxMultiviewPerViewAttributesFn {}
6170unsafe impl Sync for NvxMultiviewPerViewAttributesFn {}
6171impl NvxMultiviewPerViewAttributesFn {
6172 pub fn load<F>(mut _f: F) -> Self
6173 where
6174 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6175 {
6176 Self {}
6177 }
6178}
6179#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"]
6180impl StructureType {
6181 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self =
6182 Self(1_000_097_000);
6183}
6184#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"]
6185impl SubpassDescriptionFlags {
6186 pub const PER_VIEW_ATTRIBUTES_NVX: Self = Self(0b1);
6187 pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = Self(0b10);
6188}
6189impl NvViewportSwizzleFn {
6190 #[inline]
6191 pub const fn name() -> &'static ::std::ffi::CStr {
6192 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_swizzle\0") }
6193 }
6194 pub const SPEC_VERSION: u32 = 1u32;
6195}
6196#[derive(Clone)]
6197pub struct NvViewportSwizzleFn {}
6198unsafe impl Send for NvViewportSwizzleFn {}
6199unsafe impl Sync for NvViewportSwizzleFn {}
6200impl NvViewportSwizzleFn {
6201 pub fn load<F>(mut _f: F) -> Self
6202 where
6203 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6204 {
6205 Self {}
6206 }
6207}
6208#[doc = "Generated from 'VK_NV_viewport_swizzle'"]
6209impl StructureType {
6210 pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = Self(1_000_098_000);
6211}
6212impl ExtDiscardRectanglesFn {
6213 #[inline]
6214 pub const fn name() -> &'static ::std::ffi::CStr {
6215 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_discard_rectangles\0") }
6216 }
6217 pub const SPEC_VERSION: u32 = 2u32;
6218}
6219#[allow(non_camel_case_types)]
6220pub type PFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(
6221 command_buffer: CommandBuffer,
6222 first_discard_rectangle: u32,
6223 discard_rectangle_count: u32,
6224 p_discard_rectangles: *const Rect2D,
6225);
6226#[allow(non_camel_case_types)]
6227pub type PFN_vkCmdSetDiscardRectangleEnableEXT =
6228 unsafe extern "system" fn(command_buffer: CommandBuffer, discard_rectangle_enable: Bool32);
6229#[allow(non_camel_case_types)]
6230pub type PFN_vkCmdSetDiscardRectangleModeEXT = unsafe extern "system" fn(
6231 command_buffer: CommandBuffer,
6232 discard_rectangle_mode: DiscardRectangleModeEXT,
6233);
6234#[derive(Clone)]
6235pub struct ExtDiscardRectanglesFn {
6236 pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT,
6237 pub cmd_set_discard_rectangle_enable_ext: PFN_vkCmdSetDiscardRectangleEnableEXT,
6238 pub cmd_set_discard_rectangle_mode_ext: PFN_vkCmdSetDiscardRectangleModeEXT,
6239}
6240unsafe impl Send for ExtDiscardRectanglesFn {}
6241unsafe impl Sync for ExtDiscardRectanglesFn {}
6242impl ExtDiscardRectanglesFn {
6243 pub fn load<F>(mut _f: F) -> Self
6244 where
6245 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6246 {
6247 Self {
6248 cmd_set_discard_rectangle_ext: unsafe {
6249 unsafe extern "system" fn cmd_set_discard_rectangle_ext(
6250 _command_buffer: CommandBuffer,
6251 _first_discard_rectangle: u32,
6252 _discard_rectangle_count: u32,
6253 _p_discard_rectangles: *const Rect2D,
6254 ) {
6255 panic!(concat!(
6256 "Unable to load ",
6257 stringify!(cmd_set_discard_rectangle_ext)
6258 ))
6259 }
6260 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6261 b"vkCmdSetDiscardRectangleEXT\0",
6262 );
6263 let val = _f(cname);
6264 if val.is_null() {
6265 cmd_set_discard_rectangle_ext
6266 } else {
6267 ::std::mem::transmute(val)
6268 }
6269 },
6270 cmd_set_discard_rectangle_enable_ext: unsafe {
6271 unsafe extern "system" fn cmd_set_discard_rectangle_enable_ext(
6272 _command_buffer: CommandBuffer,
6273 _discard_rectangle_enable: Bool32,
6274 ) {
6275 panic!(concat!(
6276 "Unable to load ",
6277 stringify!(cmd_set_discard_rectangle_enable_ext)
6278 ))
6279 }
6280 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6281 b"vkCmdSetDiscardRectangleEnableEXT\0",
6282 );
6283 let val = _f(cname);
6284 if val.is_null() {
6285 cmd_set_discard_rectangle_enable_ext
6286 } else {
6287 ::std::mem::transmute(val)
6288 }
6289 },
6290 cmd_set_discard_rectangle_mode_ext: unsafe {
6291 unsafe extern "system" fn cmd_set_discard_rectangle_mode_ext(
6292 _command_buffer: CommandBuffer,
6293 _discard_rectangle_mode: DiscardRectangleModeEXT,
6294 ) {
6295 panic!(concat!(
6296 "Unable to load ",
6297 stringify!(cmd_set_discard_rectangle_mode_ext)
6298 ))
6299 }
6300 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6301 b"vkCmdSetDiscardRectangleModeEXT\0",
6302 );
6303 let val = _f(cname);
6304 if val.is_null() {
6305 cmd_set_discard_rectangle_mode_ext
6306 } else {
6307 ::std::mem::transmute(val)
6308 }
6309 },
6310 }
6311 }
6312}
6313#[doc = "Generated from 'VK_EXT_discard_rectangles'"]
6314impl DynamicState {
6315 pub const DISCARD_RECTANGLE_EXT: Self = Self(1_000_099_000);
6316 pub const DISCARD_RECTANGLE_ENABLE_EXT: Self = Self(1_000_099_001);
6317 pub const DISCARD_RECTANGLE_MODE_EXT: Self = Self(1_000_099_002);
6318}
6319#[doc = "Generated from 'VK_EXT_discard_rectangles'"]
6320impl StructureType {
6321 pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self(1_000_099_000);
6322 pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = Self(1_000_099_001);
6323}
6324impl NvExtension101Fn {
6325 #[inline]
6326 pub const fn name() -> &'static ::std::ffi::CStr {
6327 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_101\0") }
6328 }
6329 pub const SPEC_VERSION: u32 = 0u32;
6330}
6331#[derive(Clone)]
6332pub struct NvExtension101Fn {}
6333unsafe impl Send for NvExtension101Fn {}
6334unsafe impl Sync for NvExtension101Fn {}
6335impl NvExtension101Fn {
6336 pub fn load<F>(mut _f: F) -> Self
6337 where
6338 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6339 {
6340 Self {}
6341 }
6342}
6343impl ExtConservativeRasterizationFn {
6344 #[inline]
6345 pub const fn name() -> &'static ::std::ffi::CStr {
6346 unsafe {
6347 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conservative_rasterization\0")
6348 }
6349 }
6350 pub const SPEC_VERSION: u32 = 1u32;
6351}
6352#[derive(Clone)]
6353pub struct ExtConservativeRasterizationFn {}
6354unsafe impl Send for ExtConservativeRasterizationFn {}
6355unsafe impl Sync for ExtConservativeRasterizationFn {}
6356impl ExtConservativeRasterizationFn {
6357 pub fn load<F>(mut _f: F) -> Self
6358 where
6359 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6360 {
6361 Self {}
6362 }
6363}
6364#[doc = "Generated from 'VK_EXT_conservative_rasterization'"]
6365impl StructureType {
6366 pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_101_000);
6367 pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = Self(1_000_101_001);
6368}
6369impl ExtDepthClipEnableFn {
6370 #[inline]
6371 pub const fn name() -> &'static ::std::ffi::CStr {
6372 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_enable\0") }
6373 }
6374 pub const SPEC_VERSION: u32 = 1u32;
6375}
6376#[derive(Clone)]
6377pub struct ExtDepthClipEnableFn {}
6378unsafe impl Send for ExtDepthClipEnableFn {}
6379unsafe impl Sync for ExtDepthClipEnableFn {}
6380impl ExtDepthClipEnableFn {
6381 pub fn load<F>(mut _f: F) -> Self
6382 where
6383 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6384 {
6385 Self {}
6386 }
6387}
6388#[doc = "Generated from 'VK_EXT_depth_clip_enable'"]
6389impl StructureType {
6390 pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: Self = Self(1_000_102_000);
6391 pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: Self = Self(1_000_102_001);
6392}
6393impl NvExtension104Fn {
6394 #[inline]
6395 pub const fn name() -> &'static ::std::ffi::CStr {
6396 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_104\0") }
6397 }
6398 pub const SPEC_VERSION: u32 = 0u32;
6399}
6400#[derive(Clone)]
6401pub struct NvExtension104Fn {}
6402unsafe impl Send for NvExtension104Fn {}
6403unsafe impl Sync for NvExtension104Fn {}
6404impl NvExtension104Fn {
6405 pub fn load<F>(mut _f: F) -> Self
6406 where
6407 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6408 {
6409 Self {}
6410 }
6411}
6412#[doc = "Generated from 'VK_NV_extension_104'"]
6413impl PrivateDataSlotCreateFlags {
6414 pub const RESERVED_0_NV: Self = Self(0b1);
6415}
6416impl ExtSwapchainColorspaceFn {
6417 #[inline]
6418 pub const fn name() -> &'static ::std::ffi::CStr {
6419 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_colorspace\0") }
6420 }
6421 pub const SPEC_VERSION: u32 = 4u32;
6422}
6423#[derive(Clone)]
6424pub struct ExtSwapchainColorspaceFn {}
6425unsafe impl Send for ExtSwapchainColorspaceFn {}
6426unsafe impl Sync for ExtSwapchainColorspaceFn {}
6427impl ExtSwapchainColorspaceFn {
6428 pub fn load<F>(mut _f: F) -> Self
6429 where
6430 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6431 {
6432 Self {}
6433 }
6434}
6435#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
6436impl ColorSpaceKHR {
6437 pub const DISPLAY_P3_NONLINEAR_EXT: Self = Self(1_000_104_001);
6438 pub const EXTENDED_SRGB_LINEAR_EXT: Self = Self(1_000_104_002);
6439 pub const DISPLAY_P3_LINEAR_EXT: Self = Self(1_000_104_003);
6440 pub const DCI_P3_NONLINEAR_EXT: Self = Self(1_000_104_004);
6441 pub const BT709_LINEAR_EXT: Self = Self(1_000_104_005);
6442 pub const BT709_NONLINEAR_EXT: Self = Self(1_000_104_006);
6443 pub const BT2020_LINEAR_EXT: Self = Self(1_000_104_007);
6444 pub const HDR10_ST2084_EXT: Self = Self(1_000_104_008);
6445 pub const DOLBYVISION_EXT: Self = Self(1_000_104_009);
6446 pub const HDR10_HLG_EXT: Self = Self(1_000_104_010);
6447 pub const ADOBERGB_LINEAR_EXT: Self = Self(1_000_104_011);
6448 pub const ADOBERGB_NONLINEAR_EXT: Self = Self(1_000_104_012);
6449 pub const PASS_THROUGH_EXT: Self = Self(1_000_104_013);
6450 pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = Self(1_000_104_014);
6451}
6452impl ExtHdrMetadataFn {
6453 #[inline]
6454 pub const fn name() -> &'static ::std::ffi::CStr {
6455 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_hdr_metadata\0") }
6456 }
6457 pub const SPEC_VERSION: u32 = 2u32;
6458}
6459#[allow(non_camel_case_types)]
6460pub type PFN_vkSetHdrMetadataEXT = unsafe extern "system" fn(
6461 device: Device,
6462 swapchain_count: u32,
6463 p_swapchains: *const SwapchainKHR,
6464 p_metadata: *const HdrMetadataEXT,
6465);
6466#[derive(Clone)]
6467pub struct ExtHdrMetadataFn {
6468 pub set_hdr_metadata_ext: PFN_vkSetHdrMetadataEXT,
6469}
6470unsafe impl Send for ExtHdrMetadataFn {}
6471unsafe impl Sync for ExtHdrMetadataFn {}
6472impl ExtHdrMetadataFn {
6473 pub fn load<F>(mut _f: F) -> Self
6474 where
6475 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6476 {
6477 Self {
6478 set_hdr_metadata_ext: unsafe {
6479 unsafe extern "system" fn set_hdr_metadata_ext(
6480 _device: Device,
6481 _swapchain_count: u32,
6482 _p_swapchains: *const SwapchainKHR,
6483 _p_metadata: *const HdrMetadataEXT,
6484 ) {
6485 panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext)))
6486 }
6487 let cname =
6488 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetHdrMetadataEXT\0");
6489 let val = _f(cname);
6490 if val.is_null() {
6491 set_hdr_metadata_ext
6492 } else {
6493 ::std::mem::transmute(val)
6494 }
6495 },
6496 }
6497 }
6498}
6499#[doc = "Generated from 'VK_EXT_hdr_metadata'"]
6500impl StructureType {
6501 pub const HDR_METADATA_EXT: Self = Self(1_000_105_000);
6502}
6503impl ImgExtension107Fn {
6504 #[inline]
6505 pub const fn name() -> &'static ::std::ffi::CStr {
6506 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_107\0") }
6507 }
6508 pub const SPEC_VERSION: u32 = 0u32;
6509}
6510#[derive(Clone)]
6511pub struct ImgExtension107Fn {}
6512unsafe impl Send for ImgExtension107Fn {}
6513unsafe impl Sync for ImgExtension107Fn {}
6514impl ImgExtension107Fn {
6515 pub fn load<F>(mut _f: F) -> Self
6516 where
6517 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6518 {
6519 Self {}
6520 }
6521}
6522impl ImgExtension108Fn {
6523 #[inline]
6524 pub const fn name() -> &'static ::std::ffi::CStr {
6525 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_108\0") }
6526 }
6527 pub const SPEC_VERSION: u32 = 0u32;
6528}
6529#[derive(Clone)]
6530pub struct ImgExtension108Fn {}
6531unsafe impl Send for ImgExtension108Fn {}
6532unsafe impl Sync for ImgExtension108Fn {}
6533impl ImgExtension108Fn {
6534 pub fn load<F>(mut _f: F) -> Self
6535 where
6536 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6537 {
6538 Self {}
6539 }
6540}
6541impl KhrImagelessFramebufferFn {
6542 #[inline]
6543 pub const fn name() -> &'static ::std::ffi::CStr {
6544 unsafe {
6545 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_imageless_framebuffer\0")
6546 }
6547 }
6548 pub const SPEC_VERSION: u32 = 1u32;
6549}
6550#[derive(Clone)]
6551pub struct KhrImagelessFramebufferFn {}
6552unsafe impl Send for KhrImagelessFramebufferFn {}
6553unsafe impl Sync for KhrImagelessFramebufferFn {}
6554impl KhrImagelessFramebufferFn {
6555 pub fn load<F>(mut _f: F) -> Self
6556 where
6557 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6558 {
6559 Self {}
6560 }
6561}
6562#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
6563impl FramebufferCreateFlags {
6564 pub const IMAGELESS_KHR: Self = Self::IMAGELESS;
6565}
6566#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
6567impl StructureType {
6568 pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: Self =
6569 Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
6570 pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: Self =
6571 Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
6572 pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: Self = Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
6573 pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: Self = Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO;
6574}
6575impl KhrCreateRenderpass2Fn {
6576 #[inline]
6577 pub const fn name() -> &'static ::std::ffi::CStr {
6578 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_create_renderpass2\0") }
6579 }
6580 pub const SPEC_VERSION: u32 = 1u32;
6581}
6582#[allow(non_camel_case_types)]
6583pub type PFN_vkCreateRenderPass2 = unsafe extern "system" fn(
6584 device: Device,
6585 p_create_info: *const RenderPassCreateInfo2,
6586 p_allocator: *const AllocationCallbacks,
6587 p_render_pass: *mut RenderPass,
6588) -> Result;
6589#[allow(non_camel_case_types)]
6590pub type PFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn(
6591 command_buffer: CommandBuffer,
6592 p_render_pass_begin: *const RenderPassBeginInfo,
6593 p_subpass_begin_info: *const SubpassBeginInfo,
6594);
6595#[allow(non_camel_case_types)]
6596pub type PFN_vkCmdNextSubpass2 = unsafe extern "system" fn(
6597 command_buffer: CommandBuffer,
6598 p_subpass_begin_info: *const SubpassBeginInfo,
6599 p_subpass_end_info: *const SubpassEndInfo,
6600);
6601#[allow(non_camel_case_types)]
6602pub type PFN_vkCmdEndRenderPass2 = unsafe extern "system" fn(
6603 command_buffer: CommandBuffer,
6604 p_subpass_end_info: *const SubpassEndInfo,
6605);
6606#[derive(Clone)]
6607pub struct KhrCreateRenderpass2Fn {
6608 pub create_render_pass2_khr: PFN_vkCreateRenderPass2,
6609 pub cmd_begin_render_pass2_khr: PFN_vkCmdBeginRenderPass2,
6610 pub cmd_next_subpass2_khr: PFN_vkCmdNextSubpass2,
6611 pub cmd_end_render_pass2_khr: PFN_vkCmdEndRenderPass2,
6612}
6613unsafe impl Send for KhrCreateRenderpass2Fn {}
6614unsafe impl Sync for KhrCreateRenderpass2Fn {}
6615impl KhrCreateRenderpass2Fn {
6616 pub fn load<F>(mut _f: F) -> Self
6617 where
6618 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6619 {
6620 Self {
6621 create_render_pass2_khr: unsafe {
6622 unsafe extern "system" fn create_render_pass2_khr(
6623 _device: Device,
6624 _p_create_info: *const RenderPassCreateInfo2,
6625 _p_allocator: *const AllocationCallbacks,
6626 _p_render_pass: *mut RenderPass,
6627 ) -> Result {
6628 panic!(concat!(
6629 "Unable to load ",
6630 stringify!(create_render_pass2_khr)
6631 ))
6632 }
6633 let cname =
6634 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2KHR\0");
6635 let val = _f(cname);
6636 if val.is_null() {
6637 create_render_pass2_khr
6638 } else {
6639 ::std::mem::transmute(val)
6640 }
6641 },
6642 cmd_begin_render_pass2_khr: unsafe {
6643 unsafe extern "system" fn cmd_begin_render_pass2_khr(
6644 _command_buffer: CommandBuffer,
6645 _p_render_pass_begin: *const RenderPassBeginInfo,
6646 _p_subpass_begin_info: *const SubpassBeginInfo,
6647 ) {
6648 panic!(concat!(
6649 "Unable to load ",
6650 stringify!(cmd_begin_render_pass2_khr)
6651 ))
6652 }
6653 let cname =
6654 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2KHR\0");
6655 let val = _f(cname);
6656 if val.is_null() {
6657 cmd_begin_render_pass2_khr
6658 } else {
6659 ::std::mem::transmute(val)
6660 }
6661 },
6662 cmd_next_subpass2_khr: unsafe {
6663 unsafe extern "system" fn cmd_next_subpass2_khr(
6664 _command_buffer: CommandBuffer,
6665 _p_subpass_begin_info: *const SubpassBeginInfo,
6666 _p_subpass_end_info: *const SubpassEndInfo,
6667 ) {
6668 panic!(concat!(
6669 "Unable to load ",
6670 stringify!(cmd_next_subpass2_khr)
6671 ))
6672 }
6673 let cname =
6674 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2KHR\0");
6675 let val = _f(cname);
6676 if val.is_null() {
6677 cmd_next_subpass2_khr
6678 } else {
6679 ::std::mem::transmute(val)
6680 }
6681 },
6682 cmd_end_render_pass2_khr: unsafe {
6683 unsafe extern "system" fn cmd_end_render_pass2_khr(
6684 _command_buffer: CommandBuffer,
6685 _p_subpass_end_info: *const SubpassEndInfo,
6686 ) {
6687 panic!(concat!(
6688 "Unable to load ",
6689 stringify!(cmd_end_render_pass2_khr)
6690 ))
6691 }
6692 let cname =
6693 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2KHR\0");
6694 let val = _f(cname);
6695 if val.is_null() {
6696 cmd_end_render_pass2_khr
6697 } else {
6698 ::std::mem::transmute(val)
6699 }
6700 },
6701 }
6702 }
6703}
6704#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
6705impl StructureType {
6706 pub const ATTACHMENT_DESCRIPTION_2_KHR: Self = Self::ATTACHMENT_DESCRIPTION_2;
6707 pub const ATTACHMENT_REFERENCE_2_KHR: Self = Self::ATTACHMENT_REFERENCE_2;
6708 pub const SUBPASS_DESCRIPTION_2_KHR: Self = Self::SUBPASS_DESCRIPTION_2;
6709 pub const SUBPASS_DEPENDENCY_2_KHR: Self = Self::SUBPASS_DEPENDENCY_2;
6710 pub const RENDER_PASS_CREATE_INFO_2_KHR: Self = Self::RENDER_PASS_CREATE_INFO_2;
6711 pub const SUBPASS_BEGIN_INFO_KHR: Self = Self::SUBPASS_BEGIN_INFO;
6712 pub const SUBPASS_END_INFO_KHR: Self = Self::SUBPASS_END_INFO;
6713}
6714impl ImgExtension111Fn {
6715 #[inline]
6716 pub const fn name() -> &'static ::std::ffi::CStr {
6717 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_111\0") }
6718 }
6719 pub const SPEC_VERSION: u32 = 0u32;
6720}
6721#[derive(Clone)]
6722pub struct ImgExtension111Fn {}
6723unsafe impl Send for ImgExtension111Fn {}
6724unsafe impl Sync for ImgExtension111Fn {}
6725impl ImgExtension111Fn {
6726 pub fn load<F>(mut _f: F) -> Self
6727 where
6728 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6729 {
6730 Self {}
6731 }
6732}
6733impl KhrSharedPresentableImageFn {
6734 #[inline]
6735 pub const fn name() -> &'static ::std::ffi::CStr {
6736 unsafe {
6737 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shared_presentable_image\0")
6738 }
6739 }
6740 pub const SPEC_VERSION: u32 = 1u32;
6741}
6742#[allow(non_camel_case_types)]
6743pub type PFN_vkGetSwapchainStatusKHR =
6744 unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result;
6745#[derive(Clone)]
6746pub struct KhrSharedPresentableImageFn {
6747 pub get_swapchain_status_khr: PFN_vkGetSwapchainStatusKHR,
6748}
6749unsafe impl Send for KhrSharedPresentableImageFn {}
6750unsafe impl Sync for KhrSharedPresentableImageFn {}
6751impl KhrSharedPresentableImageFn {
6752 pub fn load<F>(mut _f: F) -> Self
6753 where
6754 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6755 {
6756 Self {
6757 get_swapchain_status_khr: unsafe {
6758 unsafe extern "system" fn get_swapchain_status_khr(
6759 _device: Device,
6760 _swapchain: SwapchainKHR,
6761 ) -> Result {
6762 panic!(concat!(
6763 "Unable to load ",
6764 stringify!(get_swapchain_status_khr)
6765 ))
6766 }
6767 let cname =
6768 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainStatusKHR\0");
6769 let val = _f(cname);
6770 if val.is_null() {
6771 get_swapchain_status_khr
6772 } else {
6773 ::std::mem::transmute(val)
6774 }
6775 },
6776 }
6777 }
6778}
6779#[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
6780impl ImageLayout {
6781 pub const SHARED_PRESENT_KHR: Self = Self(1_000_111_000);
6782}
6783#[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
6784impl PresentModeKHR {
6785 pub const SHARED_DEMAND_REFRESH: Self = Self(1_000_111_000);
6786 pub const SHARED_CONTINUOUS_REFRESH: Self = Self(1_000_111_001);
6787}
6788#[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
6789impl StructureType {
6790 pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = Self(1_000_111_000);
6791}
6792impl KhrExternalFenceCapabilitiesFn {
6793 #[inline]
6794 pub const fn name() -> &'static ::std::ffi::CStr {
6795 unsafe {
6796 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_capabilities\0")
6797 }
6798 }
6799 pub const SPEC_VERSION: u32 = 1u32;
6800}
6801#[allow(non_camel_case_types)]
6802pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn(
6803 physical_device: PhysicalDevice,
6804 p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
6805 p_external_fence_properties: *mut ExternalFenceProperties,
6806);
6807#[derive(Clone)]
6808pub struct KhrExternalFenceCapabilitiesFn {
6809 pub get_physical_device_external_fence_properties_khr:
6810 PFN_vkGetPhysicalDeviceExternalFenceProperties,
6811}
6812unsafe impl Send for KhrExternalFenceCapabilitiesFn {}
6813unsafe impl Sync for KhrExternalFenceCapabilitiesFn {}
6814impl KhrExternalFenceCapabilitiesFn {
6815 pub fn load<F>(mut _f: F) -> Self
6816 where
6817 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6818 {
6819 Self {
6820 get_physical_device_external_fence_properties_khr: unsafe {
6821 unsafe extern "system" fn get_physical_device_external_fence_properties_khr(
6822 _physical_device: PhysicalDevice,
6823 _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
6824 _p_external_fence_properties: *mut ExternalFenceProperties,
6825 ) {
6826 panic!(concat!(
6827 "Unable to load ",
6828 stringify!(get_physical_device_external_fence_properties_khr)
6829 ))
6830 }
6831 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6832 b"vkGetPhysicalDeviceExternalFencePropertiesKHR\0",
6833 );
6834 let val = _f(cname);
6835 if val.is_null() {
6836 get_physical_device_external_fence_properties_khr
6837 } else {
6838 ::std::mem::transmute(val)
6839 }
6840 },
6841 }
6842 }
6843}
6844#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
6845impl ExternalFenceFeatureFlags {
6846 pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
6847 pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
6848}
6849#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
6850impl ExternalFenceHandleTypeFlags {
6851 pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
6852 pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
6853 pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
6854 pub const SYNC_FD_KHR: Self = Self::SYNC_FD;
6855}
6856#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
6857impl StructureType {
6858 pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: Self =
6859 Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
6860 pub const EXTERNAL_FENCE_PROPERTIES_KHR: Self = Self::EXTERNAL_FENCE_PROPERTIES;
6861}
6862impl KhrExternalFenceFn {
6863 #[inline]
6864 pub const fn name() -> &'static ::std::ffi::CStr {
6865 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence\0") }
6866 }
6867 pub const SPEC_VERSION: u32 = 1u32;
6868}
6869#[derive(Clone)]
6870pub struct KhrExternalFenceFn {}
6871unsafe impl Send for KhrExternalFenceFn {}
6872unsafe impl Sync for KhrExternalFenceFn {}
6873impl KhrExternalFenceFn {
6874 pub fn load<F>(mut _f: F) -> Self
6875 where
6876 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6877 {
6878 Self {}
6879 }
6880}
6881#[doc = "Generated from 'VK_KHR_external_fence'"]
6882impl FenceImportFlags {
6883 pub const TEMPORARY_KHR: Self = Self::TEMPORARY;
6884}
6885#[doc = "Generated from 'VK_KHR_external_fence'"]
6886impl StructureType {
6887 pub const EXPORT_FENCE_CREATE_INFO_KHR: Self = Self::EXPORT_FENCE_CREATE_INFO;
6888}
6889impl KhrExternalFenceWin32Fn {
6890 #[inline]
6891 pub const fn name() -> &'static ::std::ffi::CStr {
6892 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_win32\0") }
6893 }
6894 pub const SPEC_VERSION: u32 = 1u32;
6895}
6896#[allow(non_camel_case_types)]
6897pub type PFN_vkImportFenceWin32HandleKHR = unsafe extern "system" fn(
6898 device: Device,
6899 p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR,
6900) -> Result;
6901#[allow(non_camel_case_types)]
6902pub type PFN_vkGetFenceWin32HandleKHR = unsafe extern "system" fn(
6903 device: Device,
6904 p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR,
6905 p_handle: *mut HANDLE,
6906) -> Result;
6907#[derive(Clone)]
6908pub struct KhrExternalFenceWin32Fn {
6909 pub import_fence_win32_handle_khr: PFN_vkImportFenceWin32HandleKHR,
6910 pub get_fence_win32_handle_khr: PFN_vkGetFenceWin32HandleKHR,
6911}
6912unsafe impl Send for KhrExternalFenceWin32Fn {}
6913unsafe impl Sync for KhrExternalFenceWin32Fn {}
6914impl KhrExternalFenceWin32Fn {
6915 pub fn load<F>(mut _f: F) -> Self
6916 where
6917 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6918 {
6919 Self {
6920 import_fence_win32_handle_khr: unsafe {
6921 unsafe extern "system" fn import_fence_win32_handle_khr(
6922 _device: Device,
6923 _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR,
6924 ) -> Result {
6925 panic!(concat!(
6926 "Unable to load ",
6927 stringify!(import_fence_win32_handle_khr)
6928 ))
6929 }
6930 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6931 b"vkImportFenceWin32HandleKHR\0",
6932 );
6933 let val = _f(cname);
6934 if val.is_null() {
6935 import_fence_win32_handle_khr
6936 } else {
6937 ::std::mem::transmute(val)
6938 }
6939 },
6940 get_fence_win32_handle_khr: unsafe {
6941 unsafe extern "system" fn get_fence_win32_handle_khr(
6942 _device: Device,
6943 _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR,
6944 _p_handle: *mut HANDLE,
6945 ) -> Result {
6946 panic!(concat!(
6947 "Unable to load ",
6948 stringify!(get_fence_win32_handle_khr)
6949 ))
6950 }
6951 let cname =
6952 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceWin32HandleKHR\0");
6953 let val = _f(cname);
6954 if val.is_null() {
6955 get_fence_win32_handle_khr
6956 } else {
6957 ::std::mem::transmute(val)
6958 }
6959 },
6960 }
6961 }
6962}
6963#[doc = "Generated from 'VK_KHR_external_fence_win32'"]
6964impl StructureType {
6965 pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_000);
6966 pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_001);
6967 pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_002);
6968}
6969impl KhrExternalFenceFdFn {
6970 #[inline]
6971 pub const fn name() -> &'static ::std::ffi::CStr {
6972 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_fd\0") }
6973 }
6974 pub const SPEC_VERSION: u32 = 1u32;
6975}
6976#[allow(non_camel_case_types)]
6977pub type PFN_vkImportFenceFdKHR = unsafe extern "system" fn(
6978 device: Device,
6979 p_import_fence_fd_info: *const ImportFenceFdInfoKHR,
6980) -> Result;
6981#[allow(non_camel_case_types)]
6982pub type PFN_vkGetFenceFdKHR = unsafe extern "system" fn(
6983 device: Device,
6984 p_get_fd_info: *const FenceGetFdInfoKHR,
6985 p_fd: *mut c_int,
6986) -> Result;
6987#[derive(Clone)]
6988pub struct KhrExternalFenceFdFn {
6989 pub import_fence_fd_khr: PFN_vkImportFenceFdKHR,
6990 pub get_fence_fd_khr: PFN_vkGetFenceFdKHR,
6991}
6992unsafe impl Send for KhrExternalFenceFdFn {}
6993unsafe impl Sync for KhrExternalFenceFdFn {}
6994impl KhrExternalFenceFdFn {
6995 pub fn load<F>(mut _f: F) -> Self
6996 where
6997 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6998 {
6999 Self {
7000 import_fence_fd_khr: unsafe {
7001 unsafe extern "system" fn import_fence_fd_khr(
7002 _device: Device,
7003 _p_import_fence_fd_info: *const ImportFenceFdInfoKHR,
7004 ) -> Result {
7005 panic!(concat!("Unable to load ", stringify!(import_fence_fd_khr)))
7006 }
7007 let cname =
7008 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportFenceFdKHR\0");
7009 let val = _f(cname);
7010 if val.is_null() {
7011 import_fence_fd_khr
7012 } else {
7013 ::std::mem::transmute(val)
7014 }
7015 },
7016 get_fence_fd_khr: unsafe {
7017 unsafe extern "system" fn get_fence_fd_khr(
7018 _device: Device,
7019 _p_get_fd_info: *const FenceGetFdInfoKHR,
7020 _p_fd: *mut c_int,
7021 ) -> Result {
7022 panic!(concat!("Unable to load ", stringify!(get_fence_fd_khr)))
7023 }
7024 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceFdKHR\0");
7025 let val = _f(cname);
7026 if val.is_null() {
7027 get_fence_fd_khr
7028 } else {
7029 ::std::mem::transmute(val)
7030 }
7031 },
7032 }
7033 }
7034}
7035#[doc = "Generated from 'VK_KHR_external_fence_fd'"]
7036impl StructureType {
7037 pub const IMPORT_FENCE_FD_INFO_KHR: Self = Self(1_000_115_000);
7038 pub const FENCE_GET_FD_INFO_KHR: Self = Self(1_000_115_001);
7039}
7040impl KhrPerformanceQueryFn {
7041 #[inline]
7042 pub const fn name() -> &'static ::std::ffi::CStr {
7043 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_performance_query\0") }
7044 }
7045 pub const SPEC_VERSION: u32 = 1u32;
7046}
7047#[allow(non_camel_case_types)]
7048pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR =
7049 unsafe extern "system" fn(
7050 physical_device: PhysicalDevice,
7051 queue_family_index: u32,
7052 p_counter_count: *mut u32,
7053 p_counters: *mut PerformanceCounterKHR,
7054 p_counter_descriptions: *mut PerformanceCounterDescriptionKHR,
7055 ) -> Result;
7056#[allow(non_camel_case_types)]
7057pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR =
7058 unsafe extern "system" fn(
7059 physical_device: PhysicalDevice,
7060 p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR,
7061 p_num_passes: *mut u32,
7062 );
7063#[allow(non_camel_case_types)]
7064pub type PFN_vkAcquireProfilingLockKHR =
7065 unsafe extern "system" fn(device: Device, p_info: *const AcquireProfilingLockInfoKHR) -> Result;
7066#[allow(non_camel_case_types)]
7067pub type PFN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: Device);
7068#[derive(Clone)]
7069pub struct KhrPerformanceQueryFn {
7070 pub enumerate_physical_device_queue_family_performance_query_counters_khr:
7071 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
7072 pub get_physical_device_queue_family_performance_query_passes_khr:
7073 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
7074 pub acquire_profiling_lock_khr: PFN_vkAcquireProfilingLockKHR,
7075 pub release_profiling_lock_khr: PFN_vkReleaseProfilingLockKHR,
7076}
7077unsafe impl Send for KhrPerformanceQueryFn {}
7078unsafe impl Sync for KhrPerformanceQueryFn {}
7079impl KhrPerformanceQueryFn {
7080 pub fn load<F>(mut _f: F) -> Self
7081 where
7082 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7083 {
7084 Self {
7085 enumerate_physical_device_queue_family_performance_query_counters_khr: unsafe {
7086 unsafe extern "system" fn enumerate_physical_device_queue_family_performance_query_counters_khr(
7087 _physical_device: PhysicalDevice,
7088 _queue_family_index: u32,
7089 _p_counter_count: *mut u32,
7090 _p_counters: *mut PerformanceCounterKHR,
7091 _p_counter_descriptions: *mut PerformanceCounterDescriptionKHR,
7092 ) -> Result {
7093 panic!(concat!(
7094 "Unable to load ",
7095 stringify!(
7096 enumerate_physical_device_queue_family_performance_query_counters_khr
7097 )
7098 ))
7099 }
7100 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7101 b"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR\0",
7102 );
7103 let val = _f(cname);
7104 if val.is_null() {
7105 enumerate_physical_device_queue_family_performance_query_counters_khr
7106 } else {
7107 ::std::mem::transmute(val)
7108 }
7109 },
7110 get_physical_device_queue_family_performance_query_passes_khr: unsafe {
7111 unsafe extern "system" fn get_physical_device_queue_family_performance_query_passes_khr(
7112 _physical_device: PhysicalDevice,
7113 _p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR,
7114 _p_num_passes: *mut u32,
7115 ) {
7116 panic!(concat!(
7117 "Unable to load ",
7118 stringify!(get_physical_device_queue_family_performance_query_passes_khr)
7119 ))
7120 }
7121 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7122 b"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\0",
7123 );
7124 let val = _f(cname);
7125 if val.is_null() {
7126 get_physical_device_queue_family_performance_query_passes_khr
7127 } else {
7128 ::std::mem::transmute(val)
7129 }
7130 },
7131 acquire_profiling_lock_khr: unsafe {
7132 unsafe extern "system" fn acquire_profiling_lock_khr(
7133 _device: Device,
7134 _p_info: *const AcquireProfilingLockInfoKHR,
7135 ) -> Result {
7136 panic!(concat!(
7137 "Unable to load ",
7138 stringify!(acquire_profiling_lock_khr)
7139 ))
7140 }
7141 let cname =
7142 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireProfilingLockKHR\0");
7143 let val = _f(cname);
7144 if val.is_null() {
7145 acquire_profiling_lock_khr
7146 } else {
7147 ::std::mem::transmute(val)
7148 }
7149 },
7150 release_profiling_lock_khr: unsafe {
7151 unsafe extern "system" fn release_profiling_lock_khr(_device: Device) {
7152 panic!(concat!(
7153 "Unable to load ",
7154 stringify!(release_profiling_lock_khr)
7155 ))
7156 }
7157 let cname =
7158 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseProfilingLockKHR\0");
7159 let val = _f(cname);
7160 if val.is_null() {
7161 release_profiling_lock_khr
7162 } else {
7163 ::std::mem::transmute(val)
7164 }
7165 },
7166 }
7167 }
7168}
7169#[doc = "Generated from 'VK_KHR_performance_query'"]
7170impl QueryType {
7171 pub const PERFORMANCE_QUERY_KHR: Self = Self(1_000_116_000);
7172}
7173#[doc = "Generated from 'VK_KHR_performance_query'"]
7174impl StructureType {
7175 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: Self = Self(1_000_116_000);
7176 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: Self = Self(1_000_116_001);
7177 pub const QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: Self = Self(1_000_116_002);
7178 pub const PERFORMANCE_QUERY_SUBMIT_INFO_KHR: Self = Self(1_000_116_003);
7179 pub const ACQUIRE_PROFILING_LOCK_INFO_KHR: Self = Self(1_000_116_004);
7180 pub const PERFORMANCE_COUNTER_KHR: Self = Self(1_000_116_005);
7181 pub const PERFORMANCE_COUNTER_DESCRIPTION_KHR: Self = Self(1_000_116_006);
7182}
7183impl KhrMaintenance2Fn {
7184 #[inline]
7185 pub const fn name() -> &'static ::std::ffi::CStr {
7186 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance2\0") }
7187 }
7188 pub const SPEC_VERSION: u32 = 1u32;
7189}
7190#[derive(Clone)]
7191pub struct KhrMaintenance2Fn {}
7192unsafe impl Send for KhrMaintenance2Fn {}
7193unsafe impl Sync for KhrMaintenance2Fn {}
7194impl KhrMaintenance2Fn {
7195 pub fn load<F>(mut _f: F) -> Self
7196 where
7197 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7198 {
7199 Self {}
7200 }
7201}
7202#[doc = "Generated from 'VK_KHR_maintenance2'"]
7203impl ImageCreateFlags {
7204 pub const BLOCK_TEXEL_VIEW_COMPATIBLE_KHR: Self = Self::BLOCK_TEXEL_VIEW_COMPATIBLE;
7205 pub const EXTENDED_USAGE_KHR: Self = Self::EXTENDED_USAGE;
7206}
7207#[doc = "Generated from 'VK_KHR_maintenance2'"]
7208impl ImageLayout {
7209 pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: Self =
7210 Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
7211 pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: Self =
7212 Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
7213}
7214#[doc = "Generated from 'VK_KHR_maintenance2'"]
7215impl PointClippingBehavior {
7216 pub const ALL_CLIP_PLANES_KHR: Self = Self::ALL_CLIP_PLANES;
7217 pub const USER_CLIP_PLANES_ONLY_KHR: Self = Self::USER_CLIP_PLANES_ONLY;
7218}
7219#[doc = "Generated from 'VK_KHR_maintenance2'"]
7220impl StructureType {
7221 pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: Self =
7222 Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
7223 pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: Self =
7224 Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
7225 pub const IMAGE_VIEW_USAGE_CREATE_INFO_KHR: Self = Self::IMAGE_VIEW_USAGE_CREATE_INFO;
7226 pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: Self =
7227 Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
7228}
7229#[doc = "Generated from 'VK_KHR_maintenance2'"]
7230impl TessellationDomainOrigin {
7231 pub const UPPER_LEFT_KHR: Self = Self::UPPER_LEFT;
7232 pub const LOWER_LEFT_KHR: Self = Self::LOWER_LEFT;
7233}
7234impl KhrExtension119Fn {
7235 #[inline]
7236 pub const fn name() -> &'static ::std::ffi::CStr {
7237 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_119\0") }
7238 }
7239 pub const SPEC_VERSION: u32 = 0u32;
7240}
7241#[derive(Clone)]
7242pub struct KhrExtension119Fn {}
7243unsafe impl Send for KhrExtension119Fn {}
7244unsafe impl Sync for KhrExtension119Fn {}
7245impl KhrExtension119Fn {
7246 pub fn load<F>(mut _f: F) -> Self
7247 where
7248 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7249 {
7250 Self {}
7251 }
7252}
7253impl KhrGetSurfaceCapabilities2Fn {
7254 #[inline]
7255 pub const fn name() -> &'static ::std::ffi::CStr {
7256 unsafe {
7257 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_surface_capabilities2\0")
7258 }
7259 }
7260 pub const SPEC_VERSION: u32 = 1u32;
7261}
7262#[allow(non_camel_case_types)]
7263pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn(
7264 physical_device: PhysicalDevice,
7265 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7266 p_surface_capabilities: *mut SurfaceCapabilities2KHR,
7267) -> Result;
7268#[allow(non_camel_case_types)]
7269pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn(
7270 physical_device: PhysicalDevice,
7271 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7272 p_surface_format_count: *mut u32,
7273 p_surface_formats: *mut SurfaceFormat2KHR,
7274) -> Result;
7275#[derive(Clone)]
7276pub struct KhrGetSurfaceCapabilities2Fn {
7277 pub get_physical_device_surface_capabilities2_khr:
7278 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
7279 pub get_physical_device_surface_formats2_khr: PFN_vkGetPhysicalDeviceSurfaceFormats2KHR,
7280}
7281unsafe impl Send for KhrGetSurfaceCapabilities2Fn {}
7282unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {}
7283impl KhrGetSurfaceCapabilities2Fn {
7284 pub fn load<F>(mut _f: F) -> Self
7285 where
7286 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7287 {
7288 Self {
7289 get_physical_device_surface_capabilities2_khr: unsafe {
7290 unsafe extern "system" fn get_physical_device_surface_capabilities2_khr(
7291 _physical_device: PhysicalDevice,
7292 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7293 _p_surface_capabilities: *mut SurfaceCapabilities2KHR,
7294 ) -> Result {
7295 panic!(concat!(
7296 "Unable to load ",
7297 stringify!(get_physical_device_surface_capabilities2_khr)
7298 ))
7299 }
7300 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7301 b"vkGetPhysicalDeviceSurfaceCapabilities2KHR\0",
7302 );
7303 let val = _f(cname);
7304 if val.is_null() {
7305 get_physical_device_surface_capabilities2_khr
7306 } else {
7307 ::std::mem::transmute(val)
7308 }
7309 },
7310 get_physical_device_surface_formats2_khr: unsafe {
7311 unsafe extern "system" fn get_physical_device_surface_formats2_khr(
7312 _physical_device: PhysicalDevice,
7313 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7314 _p_surface_format_count: *mut u32,
7315 _p_surface_formats: *mut SurfaceFormat2KHR,
7316 ) -> Result {
7317 panic!(concat!(
7318 "Unable to load ",
7319 stringify!(get_physical_device_surface_formats2_khr)
7320 ))
7321 }
7322 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7323 b"vkGetPhysicalDeviceSurfaceFormats2KHR\0",
7324 );
7325 let val = _f(cname);
7326 if val.is_null() {
7327 get_physical_device_surface_formats2_khr
7328 } else {
7329 ::std::mem::transmute(val)
7330 }
7331 },
7332 }
7333 }
7334}
7335#[doc = "Generated from 'VK_KHR_get_surface_capabilities2'"]
7336impl StructureType {
7337 pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = Self(1_000_119_000);
7338 pub const SURFACE_CAPABILITIES_2_KHR: Self = Self(1_000_119_001);
7339 pub const SURFACE_FORMAT_2_KHR: Self = Self(1_000_119_002);
7340}
7341impl KhrVariablePointersFn {
7342 #[inline]
7343 pub const fn name() -> &'static ::std::ffi::CStr {
7344 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_variable_pointers\0") }
7345 }
7346 pub const SPEC_VERSION: u32 = 1u32;
7347}
7348#[derive(Clone)]
7349pub struct KhrVariablePointersFn {}
7350unsafe impl Send for KhrVariablePointersFn {}
7351unsafe impl Sync for KhrVariablePointersFn {}
7352impl KhrVariablePointersFn {
7353 pub fn load<F>(mut _f: F) -> Self
7354 where
7355 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7356 {
7357 Self {}
7358 }
7359}
7360#[doc = "Generated from 'VK_KHR_variable_pointers'"]
7361impl StructureType {
7362 pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self =
7363 Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
7364 pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self =
7365 Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
7366}
7367impl KhrGetDisplayProperties2Fn {
7368 #[inline]
7369 pub const fn name() -> &'static ::std::ffi::CStr {
7370 unsafe {
7371 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_display_properties2\0")
7372 }
7373 }
7374 pub const SPEC_VERSION: u32 = 1u32;
7375}
7376#[allow(non_camel_case_types)]
7377pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn(
7378 physical_device: PhysicalDevice,
7379 p_property_count: *mut u32,
7380 p_properties: *mut DisplayProperties2KHR,
7381) -> Result;
7382#[allow(non_camel_case_types)]
7383pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn(
7384 physical_device: PhysicalDevice,
7385 p_property_count: *mut u32,
7386 p_properties: *mut DisplayPlaneProperties2KHR,
7387) -> Result;
7388#[allow(non_camel_case_types)]
7389pub type PFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn(
7390 physical_device: PhysicalDevice,
7391 display: DisplayKHR,
7392 p_property_count: *mut u32,
7393 p_properties: *mut DisplayModeProperties2KHR,
7394) -> Result;
7395#[allow(non_camel_case_types)]
7396pub type PFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn(
7397 physical_device: PhysicalDevice,
7398 p_display_plane_info: *const DisplayPlaneInfo2KHR,
7399 p_capabilities: *mut DisplayPlaneCapabilities2KHR,
7400) -> Result;
7401#[derive(Clone)]
7402pub struct KhrGetDisplayProperties2Fn {
7403 pub get_physical_device_display_properties2_khr: PFN_vkGetPhysicalDeviceDisplayProperties2KHR,
7404 pub get_physical_device_display_plane_properties2_khr:
7405 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,
7406 pub get_display_mode_properties2_khr: PFN_vkGetDisplayModeProperties2KHR,
7407 pub get_display_plane_capabilities2_khr: PFN_vkGetDisplayPlaneCapabilities2KHR,
7408}
7409unsafe impl Send for KhrGetDisplayProperties2Fn {}
7410unsafe impl Sync for KhrGetDisplayProperties2Fn {}
7411impl KhrGetDisplayProperties2Fn {
7412 pub fn load<F>(mut _f: F) -> Self
7413 where
7414 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7415 {
7416 Self {
7417 get_physical_device_display_properties2_khr: unsafe {
7418 unsafe extern "system" fn get_physical_device_display_properties2_khr(
7419 _physical_device: PhysicalDevice,
7420 _p_property_count: *mut u32,
7421 _p_properties: *mut DisplayProperties2KHR,
7422 ) -> Result {
7423 panic!(concat!(
7424 "Unable to load ",
7425 stringify!(get_physical_device_display_properties2_khr)
7426 ))
7427 }
7428 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7429 b"vkGetPhysicalDeviceDisplayProperties2KHR\0",
7430 );
7431 let val = _f(cname);
7432 if val.is_null() {
7433 get_physical_device_display_properties2_khr
7434 } else {
7435 ::std::mem::transmute(val)
7436 }
7437 },
7438 get_physical_device_display_plane_properties2_khr: unsafe {
7439 unsafe extern "system" fn get_physical_device_display_plane_properties2_khr(
7440 _physical_device: PhysicalDevice,
7441 _p_property_count: *mut u32,
7442 _p_properties: *mut DisplayPlaneProperties2KHR,
7443 ) -> Result {
7444 panic!(concat!(
7445 "Unable to load ",
7446 stringify!(get_physical_device_display_plane_properties2_khr)
7447 ))
7448 }
7449 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7450 b"vkGetPhysicalDeviceDisplayPlaneProperties2KHR\0",
7451 );
7452 let val = _f(cname);
7453 if val.is_null() {
7454 get_physical_device_display_plane_properties2_khr
7455 } else {
7456 ::std::mem::transmute(val)
7457 }
7458 },
7459 get_display_mode_properties2_khr: unsafe {
7460 unsafe extern "system" fn get_display_mode_properties2_khr(
7461 _physical_device: PhysicalDevice,
7462 _display: DisplayKHR,
7463 _p_property_count: *mut u32,
7464 _p_properties: *mut DisplayModeProperties2KHR,
7465 ) -> Result {
7466 panic!(concat!(
7467 "Unable to load ",
7468 stringify!(get_display_mode_properties2_khr)
7469 ))
7470 }
7471 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7472 b"vkGetDisplayModeProperties2KHR\0",
7473 );
7474 let val = _f(cname);
7475 if val.is_null() {
7476 get_display_mode_properties2_khr
7477 } else {
7478 ::std::mem::transmute(val)
7479 }
7480 },
7481 get_display_plane_capabilities2_khr: unsafe {
7482 unsafe extern "system" fn get_display_plane_capabilities2_khr(
7483 _physical_device: PhysicalDevice,
7484 _p_display_plane_info: *const DisplayPlaneInfo2KHR,
7485 _p_capabilities: *mut DisplayPlaneCapabilities2KHR,
7486 ) -> Result {
7487 panic!(concat!(
7488 "Unable to load ",
7489 stringify!(get_display_plane_capabilities2_khr)
7490 ))
7491 }
7492 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7493 b"vkGetDisplayPlaneCapabilities2KHR\0",
7494 );
7495 let val = _f(cname);
7496 if val.is_null() {
7497 get_display_plane_capabilities2_khr
7498 } else {
7499 ::std::mem::transmute(val)
7500 }
7501 },
7502 }
7503 }
7504}
7505#[doc = "Generated from 'VK_KHR_get_display_properties2'"]
7506impl StructureType {
7507 pub const DISPLAY_PROPERTIES_2_KHR: Self = Self(1_000_121_000);
7508 pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = Self(1_000_121_001);
7509 pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = Self(1_000_121_002);
7510 pub const DISPLAY_PLANE_INFO_2_KHR: Self = Self(1_000_121_003);
7511 pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = Self(1_000_121_004);
7512}
7513impl MvkIosSurfaceFn {
7514 #[inline]
7515 pub const fn name() -> &'static ::std::ffi::CStr {
7516 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_ios_surface\0") }
7517 }
7518 pub const SPEC_VERSION: u32 = 3u32;
7519}
7520#[allow(non_camel_case_types)]
7521pub type PFN_vkCreateIOSSurfaceMVK = unsafe extern "system" fn(
7522 instance: Instance,
7523 p_create_info: *const IOSSurfaceCreateInfoMVK,
7524 p_allocator: *const AllocationCallbacks,
7525 p_surface: *mut SurfaceKHR,
7526) -> Result;
7527#[derive(Clone)]
7528pub struct MvkIosSurfaceFn {
7529 pub create_ios_surface_mvk: PFN_vkCreateIOSSurfaceMVK,
7530}
7531unsafe impl Send for MvkIosSurfaceFn {}
7532unsafe impl Sync for MvkIosSurfaceFn {}
7533impl MvkIosSurfaceFn {
7534 pub fn load<F>(mut _f: F) -> Self
7535 where
7536 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7537 {
7538 Self {
7539 create_ios_surface_mvk: unsafe {
7540 unsafe extern "system" fn create_ios_surface_mvk(
7541 _instance: Instance,
7542 _p_create_info: *const IOSSurfaceCreateInfoMVK,
7543 _p_allocator: *const AllocationCallbacks,
7544 _p_surface: *mut SurfaceKHR,
7545 ) -> Result {
7546 panic!(concat!(
7547 "Unable to load ",
7548 stringify!(create_ios_surface_mvk)
7549 ))
7550 }
7551 let cname =
7552 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateIOSSurfaceMVK\0");
7553 let val = _f(cname);
7554 if val.is_null() {
7555 create_ios_surface_mvk
7556 } else {
7557 ::std::mem::transmute(val)
7558 }
7559 },
7560 }
7561 }
7562}
7563#[doc = "Generated from 'VK_MVK_ios_surface'"]
7564impl StructureType {
7565 pub const IOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_122_000);
7566}
7567impl MvkMacosSurfaceFn {
7568 #[inline]
7569 pub const fn name() -> &'static ::std::ffi::CStr {
7570 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_macos_surface\0") }
7571 }
7572 pub const SPEC_VERSION: u32 = 3u32;
7573}
7574#[allow(non_camel_case_types)]
7575pub type PFN_vkCreateMacOSSurfaceMVK = unsafe extern "system" fn(
7576 instance: Instance,
7577 p_create_info: *const MacOSSurfaceCreateInfoMVK,
7578 p_allocator: *const AllocationCallbacks,
7579 p_surface: *mut SurfaceKHR,
7580) -> Result;
7581#[derive(Clone)]
7582pub struct MvkMacosSurfaceFn {
7583 pub create_mac_os_surface_mvk: PFN_vkCreateMacOSSurfaceMVK,
7584}
7585unsafe impl Send for MvkMacosSurfaceFn {}
7586unsafe impl Sync for MvkMacosSurfaceFn {}
7587impl MvkMacosSurfaceFn {
7588 pub fn load<F>(mut _f: F) -> Self
7589 where
7590 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7591 {
7592 Self {
7593 create_mac_os_surface_mvk: unsafe {
7594 unsafe extern "system" fn create_mac_os_surface_mvk(
7595 _instance: Instance,
7596 _p_create_info: *const MacOSSurfaceCreateInfoMVK,
7597 _p_allocator: *const AllocationCallbacks,
7598 _p_surface: *mut SurfaceKHR,
7599 ) -> Result {
7600 panic!(concat!(
7601 "Unable to load ",
7602 stringify!(create_mac_os_surface_mvk)
7603 ))
7604 }
7605 let cname =
7606 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMacOSSurfaceMVK\0");
7607 let val = _f(cname);
7608 if val.is_null() {
7609 create_mac_os_surface_mvk
7610 } else {
7611 ::std::mem::transmute(val)
7612 }
7613 },
7614 }
7615 }
7616}
7617#[doc = "Generated from 'VK_MVK_macos_surface'"]
7618impl StructureType {
7619 pub const MACOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_123_000);
7620}
7621impl MvkMoltenvkFn {
7622 #[inline]
7623 pub const fn name() -> &'static ::std::ffi::CStr {
7624 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_moltenvk\0") }
7625 }
7626 pub const SPEC_VERSION: u32 = 0u32;
7627}
7628#[derive(Clone)]
7629pub struct MvkMoltenvkFn {}
7630unsafe impl Send for MvkMoltenvkFn {}
7631unsafe impl Sync for MvkMoltenvkFn {}
7632impl MvkMoltenvkFn {
7633 pub fn load<F>(mut _f: F) -> Self
7634 where
7635 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7636 {
7637 Self {}
7638 }
7639}
7640impl ExtExternalMemoryDmaBufFn {
7641 #[inline]
7642 pub const fn name() -> &'static ::std::ffi::CStr {
7643 unsafe {
7644 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_dma_buf\0")
7645 }
7646 }
7647 pub const SPEC_VERSION: u32 = 1u32;
7648}
7649#[derive(Clone)]
7650pub struct ExtExternalMemoryDmaBufFn {}
7651unsafe impl Send for ExtExternalMemoryDmaBufFn {}
7652unsafe impl Sync for ExtExternalMemoryDmaBufFn {}
7653impl ExtExternalMemoryDmaBufFn {
7654 pub fn load<F>(mut _f: F) -> Self
7655 where
7656 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7657 {
7658 Self {}
7659 }
7660}
7661#[doc = "Generated from 'VK_EXT_external_memory_dma_buf'"]
7662impl ExternalMemoryHandleTypeFlags {
7663 pub const DMA_BUF_EXT: Self = Self(0b10_0000_0000);
7664}
7665impl ExtQueueFamilyForeignFn {
7666 #[inline]
7667 pub const fn name() -> &'static ::std::ffi::CStr {
7668 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_queue_family_foreign\0") }
7669 }
7670 pub const SPEC_VERSION: u32 = 1u32;
7671}
7672#[derive(Clone)]
7673pub struct ExtQueueFamilyForeignFn {}
7674unsafe impl Send for ExtQueueFamilyForeignFn {}
7675unsafe impl Sync for ExtQueueFamilyForeignFn {}
7676impl ExtQueueFamilyForeignFn {
7677 pub fn load<F>(mut _f: F) -> Self
7678 where
7679 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7680 {
7681 Self {}
7682 }
7683}
7684impl KhrDedicatedAllocationFn {
7685 #[inline]
7686 pub const fn name() -> &'static ::std::ffi::CStr {
7687 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dedicated_allocation\0") }
7688 }
7689 pub const SPEC_VERSION: u32 = 3u32;
7690}
7691#[derive(Clone)]
7692pub struct KhrDedicatedAllocationFn {}
7693unsafe impl Send for KhrDedicatedAllocationFn {}
7694unsafe impl Sync for KhrDedicatedAllocationFn {}
7695impl KhrDedicatedAllocationFn {
7696 pub fn load<F>(mut _f: F) -> Self
7697 where
7698 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7699 {
7700 Self {}
7701 }
7702}
7703#[doc = "Generated from 'VK_KHR_dedicated_allocation'"]
7704impl StructureType {
7705 pub const MEMORY_DEDICATED_REQUIREMENTS_KHR: Self = Self::MEMORY_DEDICATED_REQUIREMENTS;
7706 pub const MEMORY_DEDICATED_ALLOCATE_INFO_KHR: Self = Self::MEMORY_DEDICATED_ALLOCATE_INFO;
7707}
7708impl ExtDebugUtilsFn {
7709 #[inline]
7710 pub const fn name() -> &'static ::std::ffi::CStr {
7711 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_utils\0") }
7712 }
7713 pub const SPEC_VERSION: u32 = 2u32;
7714}
7715#[allow(non_camel_case_types)]
7716pub type PFN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn(
7717 device: Device,
7718 p_name_info: *const DebugUtilsObjectNameInfoEXT,
7719) -> Result;
7720#[allow(non_camel_case_types)]
7721pub type PFN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn(
7722 device: Device,
7723 p_tag_info: *const DebugUtilsObjectTagInfoEXT,
7724) -> Result;
7725#[allow(non_camel_case_types)]
7726pub type PFN_vkQueueBeginDebugUtilsLabelEXT =
7727 unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT);
7728#[allow(non_camel_case_types)]
7729pub type PFN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: Queue);
7730#[allow(non_camel_case_types)]
7731pub type PFN_vkQueueInsertDebugUtilsLabelEXT =
7732 unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT);
7733#[allow(non_camel_case_types)]
7734pub type PFN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn(
7735 command_buffer: CommandBuffer,
7736 p_label_info: *const DebugUtilsLabelEXT,
7737);
7738#[allow(non_camel_case_types)]
7739pub type PFN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(command_buffer: CommandBuffer);
7740#[allow(non_camel_case_types)]
7741pub type PFN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn(
7742 command_buffer: CommandBuffer,
7743 p_label_info: *const DebugUtilsLabelEXT,
7744);
7745#[allow(non_camel_case_types)]
7746pub type PFN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn(
7747 instance: Instance,
7748 p_create_info: *const DebugUtilsMessengerCreateInfoEXT,
7749 p_allocator: *const AllocationCallbacks,
7750 p_messenger: *mut DebugUtilsMessengerEXT,
7751) -> Result;
7752#[allow(non_camel_case_types)]
7753pub type PFN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn(
7754 instance: Instance,
7755 messenger: DebugUtilsMessengerEXT,
7756 p_allocator: *const AllocationCallbacks,
7757);
7758#[allow(non_camel_case_types)]
7759pub type PFN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn(
7760 instance: Instance,
7761 message_severity: DebugUtilsMessageSeverityFlagsEXT,
7762 message_types: DebugUtilsMessageTypeFlagsEXT,
7763 p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
7764);
7765#[derive(Clone)]
7766pub struct ExtDebugUtilsFn {
7767 pub set_debug_utils_object_name_ext: PFN_vkSetDebugUtilsObjectNameEXT,
7768 pub set_debug_utils_object_tag_ext: PFN_vkSetDebugUtilsObjectTagEXT,
7769 pub queue_begin_debug_utils_label_ext: PFN_vkQueueBeginDebugUtilsLabelEXT,
7770 pub queue_end_debug_utils_label_ext: PFN_vkQueueEndDebugUtilsLabelEXT,
7771 pub queue_insert_debug_utils_label_ext: PFN_vkQueueInsertDebugUtilsLabelEXT,
7772 pub cmd_begin_debug_utils_label_ext: PFN_vkCmdBeginDebugUtilsLabelEXT,
7773 pub cmd_end_debug_utils_label_ext: PFN_vkCmdEndDebugUtilsLabelEXT,
7774 pub cmd_insert_debug_utils_label_ext: PFN_vkCmdInsertDebugUtilsLabelEXT,
7775 pub create_debug_utils_messenger_ext: PFN_vkCreateDebugUtilsMessengerEXT,
7776 pub destroy_debug_utils_messenger_ext: PFN_vkDestroyDebugUtilsMessengerEXT,
7777 pub submit_debug_utils_message_ext: PFN_vkSubmitDebugUtilsMessageEXT,
7778}
7779unsafe impl Send for ExtDebugUtilsFn {}
7780unsafe impl Sync for ExtDebugUtilsFn {}
7781impl ExtDebugUtilsFn {
7782 pub fn load<F>(mut _f: F) -> Self
7783 where
7784 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7785 {
7786 Self {
7787 set_debug_utils_object_name_ext: unsafe {
7788 unsafe extern "system" fn set_debug_utils_object_name_ext(
7789 _device: Device,
7790 _p_name_info: *const DebugUtilsObjectNameInfoEXT,
7791 ) -> Result {
7792 panic!(concat!(
7793 "Unable to load ",
7794 stringify!(set_debug_utils_object_name_ext)
7795 ))
7796 }
7797 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7798 b"vkSetDebugUtilsObjectNameEXT\0",
7799 );
7800 let val = _f(cname);
7801 if val.is_null() {
7802 set_debug_utils_object_name_ext
7803 } else {
7804 ::std::mem::transmute(val)
7805 }
7806 },
7807 set_debug_utils_object_tag_ext: unsafe {
7808 unsafe extern "system" fn set_debug_utils_object_tag_ext(
7809 _device: Device,
7810 _p_tag_info: *const DebugUtilsObjectTagInfoEXT,
7811 ) -> Result {
7812 panic!(concat!(
7813 "Unable to load ",
7814 stringify!(set_debug_utils_object_tag_ext)
7815 ))
7816 }
7817 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7818 b"vkSetDebugUtilsObjectTagEXT\0",
7819 );
7820 let val = _f(cname);
7821 if val.is_null() {
7822 set_debug_utils_object_tag_ext
7823 } else {
7824 ::std::mem::transmute(val)
7825 }
7826 },
7827 queue_begin_debug_utils_label_ext: unsafe {
7828 unsafe extern "system" fn queue_begin_debug_utils_label_ext(
7829 _queue: Queue,
7830 _p_label_info: *const DebugUtilsLabelEXT,
7831 ) {
7832 panic!(concat!(
7833 "Unable to load ",
7834 stringify!(queue_begin_debug_utils_label_ext)
7835 ))
7836 }
7837 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7838 b"vkQueueBeginDebugUtilsLabelEXT\0",
7839 );
7840 let val = _f(cname);
7841 if val.is_null() {
7842 queue_begin_debug_utils_label_ext
7843 } else {
7844 ::std::mem::transmute(val)
7845 }
7846 },
7847 queue_end_debug_utils_label_ext: unsafe {
7848 unsafe extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) {
7849 panic!(concat!(
7850 "Unable to load ",
7851 stringify!(queue_end_debug_utils_label_ext)
7852 ))
7853 }
7854 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7855 b"vkQueueEndDebugUtilsLabelEXT\0",
7856 );
7857 let val = _f(cname);
7858 if val.is_null() {
7859 queue_end_debug_utils_label_ext
7860 } else {
7861 ::std::mem::transmute(val)
7862 }
7863 },
7864 queue_insert_debug_utils_label_ext: unsafe {
7865 unsafe extern "system" fn queue_insert_debug_utils_label_ext(
7866 _queue: Queue,
7867 _p_label_info: *const DebugUtilsLabelEXT,
7868 ) {
7869 panic!(concat!(
7870 "Unable to load ",
7871 stringify!(queue_insert_debug_utils_label_ext)
7872 ))
7873 }
7874 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7875 b"vkQueueInsertDebugUtilsLabelEXT\0",
7876 );
7877 let val = _f(cname);
7878 if val.is_null() {
7879 queue_insert_debug_utils_label_ext
7880 } else {
7881 ::std::mem::transmute(val)
7882 }
7883 },
7884 cmd_begin_debug_utils_label_ext: unsafe {
7885 unsafe extern "system" fn cmd_begin_debug_utils_label_ext(
7886 _command_buffer: CommandBuffer,
7887 _p_label_info: *const DebugUtilsLabelEXT,
7888 ) {
7889 panic!(concat!(
7890 "Unable to load ",
7891 stringify!(cmd_begin_debug_utils_label_ext)
7892 ))
7893 }
7894 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7895 b"vkCmdBeginDebugUtilsLabelEXT\0",
7896 );
7897 let val = _f(cname);
7898 if val.is_null() {
7899 cmd_begin_debug_utils_label_ext
7900 } else {
7901 ::std::mem::transmute(val)
7902 }
7903 },
7904 cmd_end_debug_utils_label_ext: unsafe {
7905 unsafe extern "system" fn cmd_end_debug_utils_label_ext(
7906 _command_buffer: CommandBuffer,
7907 ) {
7908 panic!(concat!(
7909 "Unable to load ",
7910 stringify!(cmd_end_debug_utils_label_ext)
7911 ))
7912 }
7913 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7914 b"vkCmdEndDebugUtilsLabelEXT\0",
7915 );
7916 let val = _f(cname);
7917 if val.is_null() {
7918 cmd_end_debug_utils_label_ext
7919 } else {
7920 ::std::mem::transmute(val)
7921 }
7922 },
7923 cmd_insert_debug_utils_label_ext: unsafe {
7924 unsafe extern "system" fn cmd_insert_debug_utils_label_ext(
7925 _command_buffer: CommandBuffer,
7926 _p_label_info: *const DebugUtilsLabelEXT,
7927 ) {
7928 panic!(concat!(
7929 "Unable to load ",
7930 stringify!(cmd_insert_debug_utils_label_ext)
7931 ))
7932 }
7933 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7934 b"vkCmdInsertDebugUtilsLabelEXT\0",
7935 );
7936 let val = _f(cname);
7937 if val.is_null() {
7938 cmd_insert_debug_utils_label_ext
7939 } else {
7940 ::std::mem::transmute(val)
7941 }
7942 },
7943 create_debug_utils_messenger_ext: unsafe {
7944 unsafe extern "system" fn create_debug_utils_messenger_ext(
7945 _instance: Instance,
7946 _p_create_info: *const DebugUtilsMessengerCreateInfoEXT,
7947 _p_allocator: *const AllocationCallbacks,
7948 _p_messenger: *mut DebugUtilsMessengerEXT,
7949 ) -> Result {
7950 panic!(concat!(
7951 "Unable to load ",
7952 stringify!(create_debug_utils_messenger_ext)
7953 ))
7954 }
7955 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7956 b"vkCreateDebugUtilsMessengerEXT\0",
7957 );
7958 let val = _f(cname);
7959 if val.is_null() {
7960 create_debug_utils_messenger_ext
7961 } else {
7962 ::std::mem::transmute(val)
7963 }
7964 },
7965 destroy_debug_utils_messenger_ext: unsafe {
7966 unsafe extern "system" fn destroy_debug_utils_messenger_ext(
7967 _instance: Instance,
7968 _messenger: DebugUtilsMessengerEXT,
7969 _p_allocator: *const AllocationCallbacks,
7970 ) {
7971 panic!(concat!(
7972 "Unable to load ",
7973 stringify!(destroy_debug_utils_messenger_ext)
7974 ))
7975 }
7976 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7977 b"vkDestroyDebugUtilsMessengerEXT\0",
7978 );
7979 let val = _f(cname);
7980 if val.is_null() {
7981 destroy_debug_utils_messenger_ext
7982 } else {
7983 ::std::mem::transmute(val)
7984 }
7985 },
7986 submit_debug_utils_message_ext: unsafe {
7987 unsafe extern "system" fn submit_debug_utils_message_ext(
7988 _instance: Instance,
7989 _message_severity: DebugUtilsMessageSeverityFlagsEXT,
7990 _message_types: DebugUtilsMessageTypeFlagsEXT,
7991 _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
7992 ) {
7993 panic!(concat!(
7994 "Unable to load ",
7995 stringify!(submit_debug_utils_message_ext)
7996 ))
7997 }
7998 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7999 b"vkSubmitDebugUtilsMessageEXT\0",
8000 );
8001 let val = _f(cname);
8002 if val.is_null() {
8003 submit_debug_utils_message_ext
8004 } else {
8005 ::std::mem::transmute(val)
8006 }
8007 },
8008 }
8009 }
8010}
8011#[doc = "Generated from 'VK_EXT_debug_utils'"]
8012impl ObjectType {
8013 pub const DEBUG_UTILS_MESSENGER_EXT: Self = Self(1_000_128_000);
8014}
8015#[doc = "Generated from 'VK_EXT_debug_utils'"]
8016impl StructureType {
8017 pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1_000_128_000);
8018 pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = Self(1_000_128_001);
8019 pub const DEBUG_UTILS_LABEL_EXT: Self = Self(1_000_128_002);
8020 pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = Self(1_000_128_003);
8021 pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = Self(1_000_128_004);
8022}
8023impl AndroidExternalMemoryAndroidHardwareBufferFn {
8024 #[inline]
8025 pub const fn name() -> &'static ::std::ffi::CStr {
8026 unsafe {
8027 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8028 b"VK_ANDROID_external_memory_android_hardware_buffer\0",
8029 )
8030 }
8031 }
8032 pub const SPEC_VERSION: u32 = 5u32;
8033}
8034#[allow(non_camel_case_types)]
8035pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn(
8036 device: Device,
8037 buffer: *const AHardwareBuffer,
8038 p_properties: *mut AndroidHardwareBufferPropertiesANDROID,
8039) -> Result;
8040#[allow(non_camel_case_types)]
8041pub type PFN_vkGetMemoryAndroidHardwareBufferANDROID = unsafe extern "system" fn(
8042 device: Device,
8043 p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID,
8044 p_buffer: *mut *mut AHardwareBuffer,
8045) -> Result;
8046#[derive(Clone)]
8047pub struct AndroidExternalMemoryAndroidHardwareBufferFn {
8048 pub get_android_hardware_buffer_properties_android:
8049 PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
8050 pub get_memory_android_hardware_buffer_android: PFN_vkGetMemoryAndroidHardwareBufferANDROID,
8051}
8052unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {}
8053unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {}
8054impl AndroidExternalMemoryAndroidHardwareBufferFn {
8055 pub fn load<F>(mut _f: F) -> Self
8056 where
8057 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8058 {
8059 Self {
8060 get_android_hardware_buffer_properties_android: unsafe {
8061 unsafe extern "system" fn get_android_hardware_buffer_properties_android(
8062 _device: Device,
8063 _buffer: *const AHardwareBuffer,
8064 _p_properties: *mut AndroidHardwareBufferPropertiesANDROID,
8065 ) -> Result {
8066 panic!(concat!(
8067 "Unable to load ",
8068 stringify!(get_android_hardware_buffer_properties_android)
8069 ))
8070 }
8071 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8072 b"vkGetAndroidHardwareBufferPropertiesANDROID\0",
8073 );
8074 let val = _f(cname);
8075 if val.is_null() {
8076 get_android_hardware_buffer_properties_android
8077 } else {
8078 ::std::mem::transmute(val)
8079 }
8080 },
8081 get_memory_android_hardware_buffer_android: unsafe {
8082 unsafe extern "system" fn get_memory_android_hardware_buffer_android(
8083 _device: Device,
8084 _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID,
8085 _p_buffer: *mut *mut AHardwareBuffer,
8086 ) -> Result {
8087 panic!(concat!(
8088 "Unable to load ",
8089 stringify!(get_memory_android_hardware_buffer_android)
8090 ))
8091 }
8092 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8093 b"vkGetMemoryAndroidHardwareBufferANDROID\0",
8094 );
8095 let val = _f(cname);
8096 if val.is_null() {
8097 get_memory_android_hardware_buffer_android
8098 } else {
8099 ::std::mem::transmute(val)
8100 }
8101 },
8102 }
8103 }
8104}
8105#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
8106impl ExternalMemoryHandleTypeFlags {
8107 pub const ANDROID_HARDWARE_BUFFER_ANDROID: Self = Self(0b100_0000_0000);
8108}
8109#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
8110impl StructureType {
8111 pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = Self(1_000_129_000);
8112 pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = Self(1_000_129_001);
8113 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = Self(1_000_129_002);
8114 pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_003);
8115 pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_004);
8116 pub const EXTERNAL_FORMAT_ANDROID: Self = Self(1_000_129_005);
8117 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: Self = Self(1_000_129_006);
8118}
8119impl ExtSamplerFilterMinmaxFn {
8120 #[inline]
8121 pub const fn name() -> &'static ::std::ffi::CStr {
8122 unsafe {
8123 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sampler_filter_minmax\0")
8124 }
8125 }
8126 pub const SPEC_VERSION: u32 = 2u32;
8127}
8128#[derive(Clone)]
8129pub struct ExtSamplerFilterMinmaxFn {}
8130unsafe impl Send for ExtSamplerFilterMinmaxFn {}
8131unsafe impl Sync for ExtSamplerFilterMinmaxFn {}
8132impl ExtSamplerFilterMinmaxFn {
8133 pub fn load<F>(mut _f: F) -> Self
8134 where
8135 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8136 {
8137 Self {}
8138 }
8139}
8140#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
8141impl FormatFeatureFlags {
8142 pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX;
8143}
8144#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
8145impl SamplerReductionMode {
8146 pub const WEIGHTED_AVERAGE_EXT: Self = Self::WEIGHTED_AVERAGE;
8147 pub const MIN_EXT: Self = Self::MIN;
8148 pub const MAX_EXT: Self = Self::MAX;
8149}
8150#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
8151impl StructureType {
8152 pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self =
8153 Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
8154 pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self =
8155 Self::SAMPLER_REDUCTION_MODE_CREATE_INFO;
8156}
8157impl KhrStorageBufferStorageClassFn {
8158 #[inline]
8159 pub const fn name() -> &'static ::std::ffi::CStr {
8160 unsafe {
8161 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8162 b"VK_KHR_storage_buffer_storage_class\0",
8163 )
8164 }
8165 }
8166 pub const SPEC_VERSION: u32 = 1u32;
8167}
8168#[derive(Clone)]
8169pub struct KhrStorageBufferStorageClassFn {}
8170unsafe impl Send for KhrStorageBufferStorageClassFn {}
8171unsafe impl Sync for KhrStorageBufferStorageClassFn {}
8172impl KhrStorageBufferStorageClassFn {
8173 pub fn load<F>(mut _f: F) -> Self
8174 where
8175 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8176 {
8177 Self {}
8178 }
8179}
8180impl AmdGpuShaderInt16Fn {
8181 #[inline]
8182 pub const fn name() -> &'static ::std::ffi::CStr {
8183 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_int16\0") }
8184 }
8185 pub const SPEC_VERSION: u32 = 2u32;
8186}
8187#[derive(Clone)]
8188pub struct AmdGpuShaderInt16Fn {}
8189unsafe impl Send for AmdGpuShaderInt16Fn {}
8190unsafe impl Sync for AmdGpuShaderInt16Fn {}
8191impl AmdGpuShaderInt16Fn {
8192 pub fn load<F>(mut _f: F) -> Self
8193 where
8194 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8195 {
8196 Self {}
8197 }
8198}
8199impl AmdExtension134Fn {
8200 #[inline]
8201 pub const fn name() -> &'static ::std::ffi::CStr {
8202 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_134\0") }
8203 }
8204 pub const SPEC_VERSION: u32 = 0u32;
8205}
8206#[derive(Clone)]
8207pub struct AmdExtension134Fn {}
8208unsafe impl Send for AmdExtension134Fn {}
8209unsafe impl Sync for AmdExtension134Fn {}
8210impl AmdExtension134Fn {
8211 pub fn load<F>(mut _f: F) -> Self
8212 where
8213 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8214 {
8215 Self {}
8216 }
8217}
8218impl AmdExtension135Fn {
8219 #[inline]
8220 pub const fn name() -> &'static ::std::ffi::CStr {
8221 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_135\0") }
8222 }
8223 pub const SPEC_VERSION: u32 = 0u32;
8224}
8225#[derive(Clone)]
8226pub struct AmdExtension135Fn {}
8227unsafe impl Send for AmdExtension135Fn {}
8228unsafe impl Sync for AmdExtension135Fn {}
8229impl AmdExtension135Fn {
8230 pub fn load<F>(mut _f: F) -> Self
8231 where
8232 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8233 {
8234 Self {}
8235 }
8236}
8237#[doc = "Generated from 'VK_AMD_extension_135'"]
8238impl BufferUsageFlags {
8239 pub const RESERVED_25_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
8240}
8241impl AmdExtension136Fn {
8242 #[inline]
8243 pub const fn name() -> &'static ::std::ffi::CStr {
8244 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_136\0") }
8245 }
8246 pub const SPEC_VERSION: u32 = 0u32;
8247}
8248#[derive(Clone)]
8249pub struct AmdExtension136Fn {}
8250unsafe impl Send for AmdExtension136Fn {}
8251unsafe impl Sync for AmdExtension136Fn {}
8252impl AmdExtension136Fn {
8253 pub fn load<F>(mut _f: F) -> Self
8254 where
8255 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8256 {
8257 Self {}
8258 }
8259}
8260impl AmdMixedAttachmentSamplesFn {
8261 #[inline]
8262 pub const fn name() -> &'static ::std::ffi::CStr {
8263 unsafe {
8264 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_mixed_attachment_samples\0")
8265 }
8266 }
8267 pub const SPEC_VERSION: u32 = 1u32;
8268}
8269#[derive(Clone)]
8270pub struct AmdMixedAttachmentSamplesFn {}
8271unsafe impl Send for AmdMixedAttachmentSamplesFn {}
8272unsafe impl Sync for AmdMixedAttachmentSamplesFn {}
8273impl AmdMixedAttachmentSamplesFn {
8274 pub fn load<F>(mut _f: F) -> Self
8275 where
8276 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8277 {
8278 Self {}
8279 }
8280}
8281impl AmdShaderFragmentMaskFn {
8282 #[inline]
8283 pub const fn name() -> &'static ::std::ffi::CStr {
8284 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_fragment_mask\0") }
8285 }
8286 pub const SPEC_VERSION: u32 = 1u32;
8287}
8288#[derive(Clone)]
8289pub struct AmdShaderFragmentMaskFn {}
8290unsafe impl Send for AmdShaderFragmentMaskFn {}
8291unsafe impl Sync for AmdShaderFragmentMaskFn {}
8292impl AmdShaderFragmentMaskFn {
8293 pub fn load<F>(mut _f: F) -> Self
8294 where
8295 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8296 {
8297 Self {}
8298 }
8299}
8300impl ExtInlineUniformBlockFn {
8301 #[inline]
8302 pub const fn name() -> &'static ::std::ffi::CStr {
8303 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_inline_uniform_block\0") }
8304 }
8305 pub const SPEC_VERSION: u32 = 1u32;
8306}
8307#[derive(Clone)]
8308pub struct ExtInlineUniformBlockFn {}
8309unsafe impl Send for ExtInlineUniformBlockFn {}
8310unsafe impl Sync for ExtInlineUniformBlockFn {}
8311impl ExtInlineUniformBlockFn {
8312 pub fn load<F>(mut _f: F) -> Self
8313 where
8314 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8315 {
8316 Self {}
8317 }
8318}
8319#[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
8320impl DescriptorType {
8321 pub const INLINE_UNIFORM_BLOCK_EXT: Self = Self::INLINE_UNIFORM_BLOCK;
8322}
8323#[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
8324impl StructureType {
8325 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: Self =
8326 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
8327 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: Self =
8328 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
8329 pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: Self =
8330 Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
8331 pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: Self =
8332 Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
8333}
8334impl AmdExtension140Fn {
8335 #[inline]
8336 pub const fn name() -> &'static ::std::ffi::CStr {
8337 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_140\0") }
8338 }
8339 pub const SPEC_VERSION: u32 = 0u32;
8340}
8341#[derive(Clone)]
8342pub struct AmdExtension140Fn {}
8343unsafe impl Send for AmdExtension140Fn {}
8344unsafe impl Sync for AmdExtension140Fn {}
8345impl AmdExtension140Fn {
8346 pub fn load<F>(mut _f: F) -> Self
8347 where
8348 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8349 {
8350 Self {}
8351 }
8352}
8353impl ExtShaderStencilExportFn {
8354 #[inline]
8355 pub const fn name() -> &'static ::std::ffi::CStr {
8356 unsafe {
8357 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_stencil_export\0")
8358 }
8359 }
8360 pub const SPEC_VERSION: u32 = 1u32;
8361}
8362#[derive(Clone)]
8363pub struct ExtShaderStencilExportFn {}
8364unsafe impl Send for ExtShaderStencilExportFn {}
8365unsafe impl Sync for ExtShaderStencilExportFn {}
8366impl ExtShaderStencilExportFn {
8367 pub fn load<F>(mut _f: F) -> Self
8368 where
8369 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8370 {
8371 Self {}
8372 }
8373}
8374impl AmdExtension142Fn {
8375 #[inline]
8376 pub const fn name() -> &'static ::std::ffi::CStr {
8377 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_142\0") }
8378 }
8379 pub const SPEC_VERSION: u32 = 0u32;
8380}
8381#[derive(Clone)]
8382pub struct AmdExtension142Fn {}
8383unsafe impl Send for AmdExtension142Fn {}
8384unsafe impl Sync for AmdExtension142Fn {}
8385impl AmdExtension142Fn {
8386 pub fn load<F>(mut _f: F) -> Self
8387 where
8388 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8389 {
8390 Self {}
8391 }
8392}
8393impl AmdExtension143Fn {
8394 #[inline]
8395 pub const fn name() -> &'static ::std::ffi::CStr {
8396 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_143\0") }
8397 }
8398 pub const SPEC_VERSION: u32 = 0u32;
8399}
8400#[derive(Clone)]
8401pub struct AmdExtension143Fn {}
8402unsafe impl Send for AmdExtension143Fn {}
8403unsafe impl Sync for AmdExtension143Fn {}
8404impl AmdExtension143Fn {
8405 pub fn load<F>(mut _f: F) -> Self
8406 where
8407 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8408 {
8409 Self {}
8410 }
8411}
8412impl ExtSampleLocationsFn {
8413 #[inline]
8414 pub const fn name() -> &'static ::std::ffi::CStr {
8415 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sample_locations\0") }
8416 }
8417 pub const SPEC_VERSION: u32 = 1u32;
8418}
8419#[allow(non_camel_case_types)]
8420pub type PFN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn(
8421 command_buffer: CommandBuffer,
8422 p_sample_locations_info: *const SampleLocationsInfoEXT,
8423);
8424#[allow(non_camel_case_types)]
8425pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn(
8426 physical_device: PhysicalDevice,
8427 samples: SampleCountFlags,
8428 p_multisample_properties: *mut MultisamplePropertiesEXT,
8429);
8430#[derive(Clone)]
8431pub struct ExtSampleLocationsFn {
8432 pub cmd_set_sample_locations_ext: PFN_vkCmdSetSampleLocationsEXT,
8433 pub get_physical_device_multisample_properties_ext:
8434 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT,
8435}
8436unsafe impl Send for ExtSampleLocationsFn {}
8437unsafe impl Sync for ExtSampleLocationsFn {}
8438impl ExtSampleLocationsFn {
8439 pub fn load<F>(mut _f: F) -> Self
8440 where
8441 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8442 {
8443 Self {
8444 cmd_set_sample_locations_ext: unsafe {
8445 unsafe extern "system" fn cmd_set_sample_locations_ext(
8446 _command_buffer: CommandBuffer,
8447 _p_sample_locations_info: *const SampleLocationsInfoEXT,
8448 ) {
8449 panic!(concat!(
8450 "Unable to load ",
8451 stringify!(cmd_set_sample_locations_ext)
8452 ))
8453 }
8454 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8455 b"vkCmdSetSampleLocationsEXT\0",
8456 );
8457 let val = _f(cname);
8458 if val.is_null() {
8459 cmd_set_sample_locations_ext
8460 } else {
8461 ::std::mem::transmute(val)
8462 }
8463 },
8464 get_physical_device_multisample_properties_ext: unsafe {
8465 unsafe extern "system" fn get_physical_device_multisample_properties_ext(
8466 _physical_device: PhysicalDevice,
8467 _samples: SampleCountFlags,
8468 _p_multisample_properties: *mut MultisamplePropertiesEXT,
8469 ) {
8470 panic!(concat!(
8471 "Unable to load ",
8472 stringify!(get_physical_device_multisample_properties_ext)
8473 ))
8474 }
8475 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8476 b"vkGetPhysicalDeviceMultisamplePropertiesEXT\0",
8477 );
8478 let val = _f(cname);
8479 if val.is_null() {
8480 get_physical_device_multisample_properties_ext
8481 } else {
8482 ::std::mem::transmute(val)
8483 }
8484 },
8485 }
8486 }
8487}
8488#[doc = "Generated from 'VK_EXT_sample_locations'"]
8489impl DynamicState {
8490 pub const SAMPLE_LOCATIONS_EXT: Self = Self(1_000_143_000);
8491}
8492#[doc = "Generated from 'VK_EXT_sample_locations'"]
8493impl ImageCreateFlags {
8494 pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT: Self = Self(0b1_0000_0000_0000);
8495}
8496#[doc = "Generated from 'VK_EXT_sample_locations'"]
8497impl StructureType {
8498 pub const SAMPLE_LOCATIONS_INFO_EXT: Self = Self(1_000_143_000);
8499 pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = Self(1_000_143_001);
8500 pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = Self(1_000_143_002);
8501 pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = Self(1_000_143_003);
8502 pub const MULTISAMPLE_PROPERTIES_EXT: Self = Self(1_000_143_004);
8503}
8504impl KhrRelaxedBlockLayoutFn {
8505 #[inline]
8506 pub const fn name() -> &'static ::std::ffi::CStr {
8507 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_relaxed_block_layout\0") }
8508 }
8509 pub const SPEC_VERSION: u32 = 1u32;
8510}
8511#[derive(Clone)]
8512pub struct KhrRelaxedBlockLayoutFn {}
8513unsafe impl Send for KhrRelaxedBlockLayoutFn {}
8514unsafe impl Sync for KhrRelaxedBlockLayoutFn {}
8515impl KhrRelaxedBlockLayoutFn {
8516 pub fn load<F>(mut _f: F) -> Self
8517 where
8518 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8519 {
8520 Self {}
8521 }
8522}
8523impl ReservedDoNotUse146Fn {
8524 #[inline]
8525 pub const fn name() -> &'static ::std::ffi::CStr {
8526 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_RESERVED_do_not_use_146\0") }
8527 }
8528 pub const SPEC_VERSION: u32 = 1u32;
8529}
8530#[derive(Clone)]
8531pub struct ReservedDoNotUse146Fn {}
8532unsafe impl Send for ReservedDoNotUse146Fn {}
8533unsafe impl Sync for ReservedDoNotUse146Fn {}
8534impl ReservedDoNotUse146Fn {
8535 pub fn load<F>(mut _f: F) -> Self
8536 where
8537 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8538 {
8539 Self {}
8540 }
8541}
8542impl KhrGetMemoryRequirements2Fn {
8543 #[inline]
8544 pub const fn name() -> &'static ::std::ffi::CStr {
8545 unsafe {
8546 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_memory_requirements2\0")
8547 }
8548 }
8549 pub const SPEC_VERSION: u32 = 1u32;
8550}
8551#[allow(non_camel_case_types)]
8552pub type PFN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn(
8553 device: Device,
8554 p_info: *const ImageMemoryRequirementsInfo2,
8555 p_memory_requirements: *mut MemoryRequirements2,
8556);
8557#[allow(non_camel_case_types)]
8558pub type PFN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn(
8559 device: Device,
8560 p_info: *const BufferMemoryRequirementsInfo2,
8561 p_memory_requirements: *mut MemoryRequirements2,
8562);
8563#[allow(non_camel_case_types)]
8564pub type PFN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn(
8565 device: Device,
8566 p_info: *const ImageSparseMemoryRequirementsInfo2,
8567 p_sparse_memory_requirement_count: *mut u32,
8568 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
8569);
8570#[derive(Clone)]
8571pub struct KhrGetMemoryRequirements2Fn {
8572 pub get_image_memory_requirements2_khr: PFN_vkGetImageMemoryRequirements2,
8573 pub get_buffer_memory_requirements2_khr: PFN_vkGetBufferMemoryRequirements2,
8574 pub get_image_sparse_memory_requirements2_khr: PFN_vkGetImageSparseMemoryRequirements2,
8575}
8576unsafe impl Send for KhrGetMemoryRequirements2Fn {}
8577unsafe impl Sync for KhrGetMemoryRequirements2Fn {}
8578impl KhrGetMemoryRequirements2Fn {
8579 pub fn load<F>(mut _f: F) -> Self
8580 where
8581 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8582 {
8583 Self {
8584 get_image_memory_requirements2_khr: unsafe {
8585 unsafe extern "system" fn get_image_memory_requirements2_khr(
8586 _device: Device,
8587 _p_info: *const ImageMemoryRequirementsInfo2,
8588 _p_memory_requirements: *mut MemoryRequirements2,
8589 ) {
8590 panic!(concat!(
8591 "Unable to load ",
8592 stringify!(get_image_memory_requirements2_khr)
8593 ))
8594 }
8595 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8596 b"vkGetImageMemoryRequirements2KHR\0",
8597 );
8598 let val = _f(cname);
8599 if val.is_null() {
8600 get_image_memory_requirements2_khr
8601 } else {
8602 ::std::mem::transmute(val)
8603 }
8604 },
8605 get_buffer_memory_requirements2_khr: unsafe {
8606 unsafe extern "system" fn get_buffer_memory_requirements2_khr(
8607 _device: Device,
8608 _p_info: *const BufferMemoryRequirementsInfo2,
8609 _p_memory_requirements: *mut MemoryRequirements2,
8610 ) {
8611 panic!(concat!(
8612 "Unable to load ",
8613 stringify!(get_buffer_memory_requirements2_khr)
8614 ))
8615 }
8616 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8617 b"vkGetBufferMemoryRequirements2KHR\0",
8618 );
8619 let val = _f(cname);
8620 if val.is_null() {
8621 get_buffer_memory_requirements2_khr
8622 } else {
8623 ::std::mem::transmute(val)
8624 }
8625 },
8626 get_image_sparse_memory_requirements2_khr: unsafe {
8627 unsafe extern "system" fn get_image_sparse_memory_requirements2_khr(
8628 _device: Device,
8629 _p_info: *const ImageSparseMemoryRequirementsInfo2,
8630 _p_sparse_memory_requirement_count: *mut u32,
8631 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
8632 ) {
8633 panic!(concat!(
8634 "Unable to load ",
8635 stringify!(get_image_sparse_memory_requirements2_khr)
8636 ))
8637 }
8638 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8639 b"vkGetImageSparseMemoryRequirements2KHR\0",
8640 );
8641 let val = _f(cname);
8642 if val.is_null() {
8643 get_image_sparse_memory_requirements2_khr
8644 } else {
8645 ::std::mem::transmute(val)
8646 }
8647 },
8648 }
8649 }
8650}
8651#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"]
8652impl StructureType {
8653 pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2;
8654 pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2;
8655 pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self =
8656 Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
8657 pub const MEMORY_REQUIREMENTS_2_KHR: Self = Self::MEMORY_REQUIREMENTS_2;
8658 pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: Self =
8659 Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
8660}
8661impl KhrImageFormatListFn {
8662 #[inline]
8663 pub const fn name() -> &'static ::std::ffi::CStr {
8664 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_image_format_list\0") }
8665 }
8666 pub const SPEC_VERSION: u32 = 1u32;
8667}
8668#[derive(Clone)]
8669pub struct KhrImageFormatListFn {}
8670unsafe impl Send for KhrImageFormatListFn {}
8671unsafe impl Sync for KhrImageFormatListFn {}
8672impl KhrImageFormatListFn {
8673 pub fn load<F>(mut _f: F) -> Self
8674 where
8675 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8676 {
8677 Self {}
8678 }
8679}
8680#[doc = "Generated from 'VK_KHR_image_format_list'"]
8681impl StructureType {
8682 pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = Self::IMAGE_FORMAT_LIST_CREATE_INFO;
8683}
8684impl ExtBlendOperationAdvancedFn {
8685 #[inline]
8686 pub const fn name() -> &'static ::std::ffi::CStr {
8687 unsafe {
8688 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_blend_operation_advanced\0")
8689 }
8690 }
8691 pub const SPEC_VERSION: u32 = 2u32;
8692}
8693#[derive(Clone)]
8694pub struct ExtBlendOperationAdvancedFn {}
8695unsafe impl Send for ExtBlendOperationAdvancedFn {}
8696unsafe impl Sync for ExtBlendOperationAdvancedFn {}
8697impl ExtBlendOperationAdvancedFn {
8698 pub fn load<F>(mut _f: F) -> Self
8699 where
8700 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8701 {
8702 Self {}
8703 }
8704}
8705#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
8706impl AccessFlags {
8707 pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
8708}
8709#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
8710impl BlendOp {
8711 pub const ZERO_EXT: Self = Self(1_000_148_000);
8712 pub const SRC_EXT: Self = Self(1_000_148_001);
8713 pub const DST_EXT: Self = Self(1_000_148_002);
8714 pub const SRC_OVER_EXT: Self = Self(1_000_148_003);
8715 pub const DST_OVER_EXT: Self = Self(1_000_148_004);
8716 pub const SRC_IN_EXT: Self = Self(1_000_148_005);
8717 pub const DST_IN_EXT: Self = Self(1_000_148_006);
8718 pub const SRC_OUT_EXT: Self = Self(1_000_148_007);
8719 pub const DST_OUT_EXT: Self = Self(1_000_148_008);
8720 pub const SRC_ATOP_EXT: Self = Self(1_000_148_009);
8721 pub const DST_ATOP_EXT: Self = Self(1_000_148_010);
8722 pub const XOR_EXT: Self = Self(1_000_148_011);
8723 pub const MULTIPLY_EXT: Self = Self(1_000_148_012);
8724 pub const SCREEN_EXT: Self = Self(1_000_148_013);
8725 pub const OVERLAY_EXT: Self = Self(1_000_148_014);
8726 pub const DARKEN_EXT: Self = Self(1_000_148_015);
8727 pub const LIGHTEN_EXT: Self = Self(1_000_148_016);
8728 pub const COLORDODGE_EXT: Self = Self(1_000_148_017);
8729 pub const COLORBURN_EXT: Self = Self(1_000_148_018);
8730 pub const HARDLIGHT_EXT: Self = Self(1_000_148_019);
8731 pub const SOFTLIGHT_EXT: Self = Self(1_000_148_020);
8732 pub const DIFFERENCE_EXT: Self = Self(1_000_148_021);
8733 pub const EXCLUSION_EXT: Self = Self(1_000_148_022);
8734 pub const INVERT_EXT: Self = Self(1_000_148_023);
8735 pub const INVERT_RGB_EXT: Self = Self(1_000_148_024);
8736 pub const LINEARDODGE_EXT: Self = Self(1_000_148_025);
8737 pub const LINEARBURN_EXT: Self = Self(1_000_148_026);
8738 pub const VIVIDLIGHT_EXT: Self = Self(1_000_148_027);
8739 pub const LINEARLIGHT_EXT: Self = Self(1_000_148_028);
8740 pub const PINLIGHT_EXT: Self = Self(1_000_148_029);
8741 pub const HARDMIX_EXT: Self = Self(1_000_148_030);
8742 pub const HSL_HUE_EXT: Self = Self(1_000_148_031);
8743 pub const HSL_SATURATION_EXT: Self = Self(1_000_148_032);
8744 pub const HSL_COLOR_EXT: Self = Self(1_000_148_033);
8745 pub const HSL_LUMINOSITY_EXT: Self = Self(1_000_148_034);
8746 pub const PLUS_EXT: Self = Self(1_000_148_035);
8747 pub const PLUS_CLAMPED_EXT: Self = Self(1_000_148_036);
8748 pub const PLUS_CLAMPED_ALPHA_EXT: Self = Self(1_000_148_037);
8749 pub const PLUS_DARKER_EXT: Self = Self(1_000_148_038);
8750 pub const MINUS_EXT: Self = Self(1_000_148_039);
8751 pub const MINUS_CLAMPED_EXT: Self = Self(1_000_148_040);
8752 pub const CONTRAST_EXT: Self = Self(1_000_148_041);
8753 pub const INVERT_OVG_EXT: Self = Self(1_000_148_042);
8754 pub const RED_EXT: Self = Self(1_000_148_043);
8755 pub const GREEN_EXT: Self = Self(1_000_148_044);
8756 pub const BLUE_EXT: Self = Self(1_000_148_045);
8757}
8758#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
8759impl StructureType {
8760 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = Self(1_000_148_000);
8761 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = Self(1_000_148_001);
8762 pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = Self(1_000_148_002);
8763}
8764impl NvFragmentCoverageToColorFn {
8765 #[inline]
8766 pub const fn name() -> &'static ::std::ffi::CStr {
8767 unsafe {
8768 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_coverage_to_color\0")
8769 }
8770 }
8771 pub const SPEC_VERSION: u32 = 1u32;
8772}
8773#[derive(Clone)]
8774pub struct NvFragmentCoverageToColorFn {}
8775unsafe impl Send for NvFragmentCoverageToColorFn {}
8776unsafe impl Sync for NvFragmentCoverageToColorFn {}
8777impl NvFragmentCoverageToColorFn {
8778 pub fn load<F>(mut _f: F) -> Self
8779 where
8780 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8781 {
8782 Self {}
8783 }
8784}
8785#[doc = "Generated from 'VK_NV_fragment_coverage_to_color'"]
8786impl StructureType {
8787 pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1_000_149_000);
8788}
8789impl KhrAccelerationStructureFn {
8790 #[inline]
8791 pub const fn name() -> &'static ::std::ffi::CStr {
8792 unsafe {
8793 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_acceleration_structure\0")
8794 }
8795 }
8796 pub const SPEC_VERSION: u32 = 13u32;
8797}
8798#[allow(non_camel_case_types)]
8799pub type PFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn(
8800 device: Device,
8801 p_create_info: *const AccelerationStructureCreateInfoKHR,
8802 p_allocator: *const AllocationCallbacks,
8803 p_acceleration_structure: *mut AccelerationStructureKHR,
8804) -> Result;
8805#[allow(non_camel_case_types)]
8806pub type PFN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn(
8807 device: Device,
8808 acceleration_structure: AccelerationStructureKHR,
8809 p_allocator: *const AllocationCallbacks,
8810);
8811#[allow(non_camel_case_types)]
8812pub type PFN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn(
8813 command_buffer: CommandBuffer,
8814 info_count: u32,
8815 p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8816 pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
8817);
8818#[allow(non_camel_case_types)]
8819pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn(
8820 command_buffer: CommandBuffer,
8821 info_count: u32,
8822 p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8823 p_indirect_device_addresses: *const DeviceAddress,
8824 p_indirect_strides: *const u32,
8825 pp_max_primitive_counts: *const *const u32,
8826);
8827#[allow(non_camel_case_types)]
8828pub type PFN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn(
8829 device: Device,
8830 deferred_operation: DeferredOperationKHR,
8831 info_count: u32,
8832 p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8833 pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
8834) -> Result;
8835#[allow(non_camel_case_types)]
8836pub type PFN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn(
8837 device: Device,
8838 deferred_operation: DeferredOperationKHR,
8839 p_info: *const CopyAccelerationStructureInfoKHR,
8840) -> Result;
8841#[allow(non_camel_case_types)]
8842pub type PFN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(
8843 device: Device,
8844 deferred_operation: DeferredOperationKHR,
8845 p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
8846) -> Result;
8847#[allow(non_camel_case_types)]
8848pub type PFN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(
8849 device: Device,
8850 deferred_operation: DeferredOperationKHR,
8851 p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
8852) -> Result;
8853#[allow(non_camel_case_types)]
8854pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(
8855 device: Device,
8856 acceleration_structure_count: u32,
8857 p_acceleration_structures: *const AccelerationStructureKHR,
8858 query_type: QueryType,
8859 data_size: usize,
8860 p_data: *mut c_void,
8861 stride: usize,
8862) -> Result;
8863#[allow(non_camel_case_types)]
8864pub type PFN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn(
8865 command_buffer: CommandBuffer,
8866 p_info: *const CopyAccelerationStructureInfoKHR,
8867);
8868#[allow(non_camel_case_types)]
8869pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(
8870 command_buffer: CommandBuffer,
8871 p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
8872);
8873#[allow(non_camel_case_types)]
8874pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(
8875 command_buffer: CommandBuffer,
8876 p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
8877);
8878#[allow(non_camel_case_types)]
8879pub type PFN_vkGetAccelerationStructureDeviceAddressKHR =
8880 unsafe extern "system" fn(
8881 device: Device,
8882 p_info: *const AccelerationStructureDeviceAddressInfoKHR,
8883 ) -> DeviceAddress;
8884#[allow(non_camel_case_types)]
8885pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(
8886 command_buffer: CommandBuffer,
8887 acceleration_structure_count: u32,
8888 p_acceleration_structures: *const AccelerationStructureKHR,
8889 query_type: QueryType,
8890 query_pool: QueryPool,
8891 first_query: u32,
8892);
8893#[allow(non_camel_case_types)]
8894pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn(
8895 device: Device,
8896 p_version_info: *const AccelerationStructureVersionInfoKHR,
8897 p_compatibility: *mut AccelerationStructureCompatibilityKHR,
8898);
8899#[allow(non_camel_case_types)]
8900pub type PFN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn(
8901 device: Device,
8902 build_type: AccelerationStructureBuildTypeKHR,
8903 p_build_info: *const AccelerationStructureBuildGeometryInfoKHR,
8904 p_max_primitive_counts: *const u32,
8905 p_size_info: *mut AccelerationStructureBuildSizesInfoKHR,
8906);
8907#[derive(Clone)]
8908pub struct KhrAccelerationStructureFn {
8909 pub create_acceleration_structure_khr: PFN_vkCreateAccelerationStructureKHR,
8910 pub destroy_acceleration_structure_khr: PFN_vkDestroyAccelerationStructureKHR,
8911 pub cmd_build_acceleration_structures_khr: PFN_vkCmdBuildAccelerationStructuresKHR,
8912 pub cmd_build_acceleration_structures_indirect_khr:
8913 PFN_vkCmdBuildAccelerationStructuresIndirectKHR,
8914 pub build_acceleration_structures_khr: PFN_vkBuildAccelerationStructuresKHR,
8915 pub copy_acceleration_structure_khr: PFN_vkCopyAccelerationStructureKHR,
8916 pub copy_acceleration_structure_to_memory_khr: PFN_vkCopyAccelerationStructureToMemoryKHR,
8917 pub copy_memory_to_acceleration_structure_khr: PFN_vkCopyMemoryToAccelerationStructureKHR,
8918 pub write_acceleration_structures_properties_khr:
8919 PFN_vkWriteAccelerationStructuresPropertiesKHR,
8920 pub cmd_copy_acceleration_structure_khr: PFN_vkCmdCopyAccelerationStructureKHR,
8921 pub cmd_copy_acceleration_structure_to_memory_khr:
8922 PFN_vkCmdCopyAccelerationStructureToMemoryKHR,
8923 pub cmd_copy_memory_to_acceleration_structure_khr:
8924 PFN_vkCmdCopyMemoryToAccelerationStructureKHR,
8925 pub get_acceleration_structure_device_address_khr:
8926 PFN_vkGetAccelerationStructureDeviceAddressKHR,
8927 pub cmd_write_acceleration_structures_properties_khr:
8928 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR,
8929 pub get_device_acceleration_structure_compatibility_khr:
8930 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR,
8931 pub get_acceleration_structure_build_sizes_khr: PFN_vkGetAccelerationStructureBuildSizesKHR,
8932}
8933unsafe impl Send for KhrAccelerationStructureFn {}
8934unsafe impl Sync for KhrAccelerationStructureFn {}
8935impl KhrAccelerationStructureFn {
8936 pub fn load<F>(mut _f: F) -> Self
8937 where
8938 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8939 {
8940 Self {
8941 create_acceleration_structure_khr: unsafe {
8942 unsafe extern "system" fn create_acceleration_structure_khr(
8943 _device: Device,
8944 _p_create_info: *const AccelerationStructureCreateInfoKHR,
8945 _p_allocator: *const AllocationCallbacks,
8946 _p_acceleration_structure: *mut AccelerationStructureKHR,
8947 ) -> Result {
8948 panic!(concat!(
8949 "Unable to load ",
8950 stringify!(create_acceleration_structure_khr)
8951 ))
8952 }
8953 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8954 b"vkCreateAccelerationStructureKHR\0",
8955 );
8956 let val = _f(cname);
8957 if val.is_null() {
8958 create_acceleration_structure_khr
8959 } else {
8960 ::std::mem::transmute(val)
8961 }
8962 },
8963 destroy_acceleration_structure_khr: unsafe {
8964 unsafe extern "system" fn destroy_acceleration_structure_khr(
8965 _device: Device,
8966 _acceleration_structure: AccelerationStructureKHR,
8967 _p_allocator: *const AllocationCallbacks,
8968 ) {
8969 panic!(concat!(
8970 "Unable to load ",
8971 stringify!(destroy_acceleration_structure_khr)
8972 ))
8973 }
8974 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8975 b"vkDestroyAccelerationStructureKHR\0",
8976 );
8977 let val = _f(cname);
8978 if val.is_null() {
8979 destroy_acceleration_structure_khr
8980 } else {
8981 ::std::mem::transmute(val)
8982 }
8983 },
8984 cmd_build_acceleration_structures_khr: unsafe {
8985 unsafe extern "system" fn cmd_build_acceleration_structures_khr(
8986 _command_buffer: CommandBuffer,
8987 _info_count: u32,
8988 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8989 _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
8990 ) {
8991 panic!(concat!(
8992 "Unable to load ",
8993 stringify!(cmd_build_acceleration_structures_khr)
8994 ))
8995 }
8996 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8997 b"vkCmdBuildAccelerationStructuresKHR\0",
8998 );
8999 let val = _f(cname);
9000 if val.is_null() {
9001 cmd_build_acceleration_structures_khr
9002 } else {
9003 ::std::mem::transmute(val)
9004 }
9005 },
9006 cmd_build_acceleration_structures_indirect_khr: unsafe {
9007 unsafe extern "system" fn cmd_build_acceleration_structures_indirect_khr(
9008 _command_buffer: CommandBuffer,
9009 _info_count: u32,
9010 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
9011 _p_indirect_device_addresses: *const DeviceAddress,
9012 _p_indirect_strides: *const u32,
9013 _pp_max_primitive_counts: *const *const u32,
9014 ) {
9015 panic!(concat!(
9016 "Unable to load ",
9017 stringify!(cmd_build_acceleration_structures_indirect_khr)
9018 ))
9019 }
9020 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9021 b"vkCmdBuildAccelerationStructuresIndirectKHR\0",
9022 );
9023 let val = _f(cname);
9024 if val.is_null() {
9025 cmd_build_acceleration_structures_indirect_khr
9026 } else {
9027 ::std::mem::transmute(val)
9028 }
9029 },
9030 build_acceleration_structures_khr: unsafe {
9031 unsafe extern "system" fn build_acceleration_structures_khr(
9032 _device: Device,
9033 _deferred_operation: DeferredOperationKHR,
9034 _info_count: u32,
9035 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
9036 _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
9037 ) -> Result {
9038 panic!(concat!(
9039 "Unable to load ",
9040 stringify!(build_acceleration_structures_khr)
9041 ))
9042 }
9043 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9044 b"vkBuildAccelerationStructuresKHR\0",
9045 );
9046 let val = _f(cname);
9047 if val.is_null() {
9048 build_acceleration_structures_khr
9049 } else {
9050 ::std::mem::transmute(val)
9051 }
9052 },
9053 copy_acceleration_structure_khr: unsafe {
9054 unsafe extern "system" fn copy_acceleration_structure_khr(
9055 _device: Device,
9056 _deferred_operation: DeferredOperationKHR,
9057 _p_info: *const CopyAccelerationStructureInfoKHR,
9058 ) -> Result {
9059 panic!(concat!(
9060 "Unable to load ",
9061 stringify!(copy_acceleration_structure_khr)
9062 ))
9063 }
9064 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9065 b"vkCopyAccelerationStructureKHR\0",
9066 );
9067 let val = _f(cname);
9068 if val.is_null() {
9069 copy_acceleration_structure_khr
9070 } else {
9071 ::std::mem::transmute(val)
9072 }
9073 },
9074 copy_acceleration_structure_to_memory_khr: unsafe {
9075 unsafe extern "system" fn copy_acceleration_structure_to_memory_khr(
9076 _device: Device,
9077 _deferred_operation: DeferredOperationKHR,
9078 _p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
9079 ) -> Result {
9080 panic!(concat!(
9081 "Unable to load ",
9082 stringify!(copy_acceleration_structure_to_memory_khr)
9083 ))
9084 }
9085 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9086 b"vkCopyAccelerationStructureToMemoryKHR\0",
9087 );
9088 let val = _f(cname);
9089 if val.is_null() {
9090 copy_acceleration_structure_to_memory_khr
9091 } else {
9092 ::std::mem::transmute(val)
9093 }
9094 },
9095 copy_memory_to_acceleration_structure_khr: unsafe {
9096 unsafe extern "system" fn copy_memory_to_acceleration_structure_khr(
9097 _device: Device,
9098 _deferred_operation: DeferredOperationKHR,
9099 _p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
9100 ) -> Result {
9101 panic!(concat!(
9102 "Unable to load ",
9103 stringify!(copy_memory_to_acceleration_structure_khr)
9104 ))
9105 }
9106 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9107 b"vkCopyMemoryToAccelerationStructureKHR\0",
9108 );
9109 let val = _f(cname);
9110 if val.is_null() {
9111 copy_memory_to_acceleration_structure_khr
9112 } else {
9113 ::std::mem::transmute(val)
9114 }
9115 },
9116 write_acceleration_structures_properties_khr: unsafe {
9117 unsafe extern "system" fn write_acceleration_structures_properties_khr(
9118 _device: Device,
9119 _acceleration_structure_count: u32,
9120 _p_acceleration_structures: *const AccelerationStructureKHR,
9121 _query_type: QueryType,
9122 _data_size: usize,
9123 _p_data: *mut c_void,
9124 _stride: usize,
9125 ) -> Result {
9126 panic!(concat!(
9127 "Unable to load ",
9128 stringify!(write_acceleration_structures_properties_khr)
9129 ))
9130 }
9131 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9132 b"vkWriteAccelerationStructuresPropertiesKHR\0",
9133 );
9134 let val = _f(cname);
9135 if val.is_null() {
9136 write_acceleration_structures_properties_khr
9137 } else {
9138 ::std::mem::transmute(val)
9139 }
9140 },
9141 cmd_copy_acceleration_structure_khr: unsafe {
9142 unsafe extern "system" fn cmd_copy_acceleration_structure_khr(
9143 _command_buffer: CommandBuffer,
9144 _p_info: *const CopyAccelerationStructureInfoKHR,
9145 ) {
9146 panic!(concat!(
9147 "Unable to load ",
9148 stringify!(cmd_copy_acceleration_structure_khr)
9149 ))
9150 }
9151 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9152 b"vkCmdCopyAccelerationStructureKHR\0",
9153 );
9154 let val = _f(cname);
9155 if val.is_null() {
9156 cmd_copy_acceleration_structure_khr
9157 } else {
9158 ::std::mem::transmute(val)
9159 }
9160 },
9161 cmd_copy_acceleration_structure_to_memory_khr: unsafe {
9162 unsafe extern "system" fn cmd_copy_acceleration_structure_to_memory_khr(
9163 _command_buffer: CommandBuffer,
9164 _p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
9165 ) {
9166 panic!(concat!(
9167 "Unable to load ",
9168 stringify!(cmd_copy_acceleration_structure_to_memory_khr)
9169 ))
9170 }
9171 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9172 b"vkCmdCopyAccelerationStructureToMemoryKHR\0",
9173 );
9174 let val = _f(cname);
9175 if val.is_null() {
9176 cmd_copy_acceleration_structure_to_memory_khr
9177 } else {
9178 ::std::mem::transmute(val)
9179 }
9180 },
9181 cmd_copy_memory_to_acceleration_structure_khr: unsafe {
9182 unsafe extern "system" fn cmd_copy_memory_to_acceleration_structure_khr(
9183 _command_buffer: CommandBuffer,
9184 _p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
9185 ) {
9186 panic!(concat!(
9187 "Unable to load ",
9188 stringify!(cmd_copy_memory_to_acceleration_structure_khr)
9189 ))
9190 }
9191 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9192 b"vkCmdCopyMemoryToAccelerationStructureKHR\0",
9193 );
9194 let val = _f(cname);
9195 if val.is_null() {
9196 cmd_copy_memory_to_acceleration_structure_khr
9197 } else {
9198 ::std::mem::transmute(val)
9199 }
9200 },
9201 get_acceleration_structure_device_address_khr: unsafe {
9202 unsafe extern "system" fn get_acceleration_structure_device_address_khr(
9203 _device: Device,
9204 _p_info: *const AccelerationStructureDeviceAddressInfoKHR,
9205 ) -> DeviceAddress {
9206 panic!(concat!(
9207 "Unable to load ",
9208 stringify!(get_acceleration_structure_device_address_khr)
9209 ))
9210 }
9211 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9212 b"vkGetAccelerationStructureDeviceAddressKHR\0",
9213 );
9214 let val = _f(cname);
9215 if val.is_null() {
9216 get_acceleration_structure_device_address_khr
9217 } else {
9218 ::std::mem::transmute(val)
9219 }
9220 },
9221 cmd_write_acceleration_structures_properties_khr: unsafe {
9222 unsafe extern "system" fn cmd_write_acceleration_structures_properties_khr(
9223 _command_buffer: CommandBuffer,
9224 _acceleration_structure_count: u32,
9225 _p_acceleration_structures: *const AccelerationStructureKHR,
9226 _query_type: QueryType,
9227 _query_pool: QueryPool,
9228 _first_query: u32,
9229 ) {
9230 panic!(concat!(
9231 "Unable to load ",
9232 stringify!(cmd_write_acceleration_structures_properties_khr)
9233 ))
9234 }
9235 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9236 b"vkCmdWriteAccelerationStructuresPropertiesKHR\0",
9237 );
9238 let val = _f(cname);
9239 if val.is_null() {
9240 cmd_write_acceleration_structures_properties_khr
9241 } else {
9242 ::std::mem::transmute(val)
9243 }
9244 },
9245 get_device_acceleration_structure_compatibility_khr: unsafe {
9246 unsafe extern "system" fn get_device_acceleration_structure_compatibility_khr(
9247 _device: Device,
9248 _p_version_info: *const AccelerationStructureVersionInfoKHR,
9249 _p_compatibility: *mut AccelerationStructureCompatibilityKHR,
9250 ) {
9251 panic!(concat!(
9252 "Unable to load ",
9253 stringify!(get_device_acceleration_structure_compatibility_khr)
9254 ))
9255 }
9256 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9257 b"vkGetDeviceAccelerationStructureCompatibilityKHR\0",
9258 );
9259 let val = _f(cname);
9260 if val.is_null() {
9261 get_device_acceleration_structure_compatibility_khr
9262 } else {
9263 ::std::mem::transmute(val)
9264 }
9265 },
9266 get_acceleration_structure_build_sizes_khr: unsafe {
9267 unsafe extern "system" fn get_acceleration_structure_build_sizes_khr(
9268 _device: Device,
9269 _build_type: AccelerationStructureBuildTypeKHR,
9270 _p_build_info: *const AccelerationStructureBuildGeometryInfoKHR,
9271 _p_max_primitive_counts: *const u32,
9272 _p_size_info: *mut AccelerationStructureBuildSizesInfoKHR,
9273 ) {
9274 panic!(concat!(
9275 "Unable to load ",
9276 stringify!(get_acceleration_structure_build_sizes_khr)
9277 ))
9278 }
9279 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9280 b"vkGetAccelerationStructureBuildSizesKHR\0",
9281 );
9282 let val = _f(cname);
9283 if val.is_null() {
9284 get_acceleration_structure_build_sizes_khr
9285 } else {
9286 ::std::mem::transmute(val)
9287 }
9288 },
9289 }
9290 }
9291}
9292#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9293impl AccessFlags {
9294 pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
9295 pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
9296}
9297#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9298impl BufferUsageFlags {
9299 pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR: Self =
9300 Self(0b1000_0000_0000_0000_0000);
9301 pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000);
9302}
9303#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9304impl DebugReportObjectTypeEXT {
9305 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
9306}
9307#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9308impl DescriptorType {
9309 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
9310}
9311#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9312impl FormatFeatureFlags {
9313 pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self =
9314 Self(0b10_0000_0000_0000_0000_0000_0000_0000);
9315}
9316#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9317impl FormatFeatureFlags2 {
9318 pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self =
9319 Self(0b10_0000_0000_0000_0000_0000_0000_0000);
9320}
9321#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9322impl IndexType {
9323 pub const NONE_KHR: Self = Self(1_000_165_000);
9324}
9325#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9326impl ObjectType {
9327 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
9328}
9329#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9330impl PipelineStageFlags {
9331 pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
9332}
9333#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9334impl QueryType {
9335 pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_150_000);
9336 pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_001);
9337}
9338#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9339impl StructureType {
9340 pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_007);
9341 pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1_000_150_000);
9342 pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1_000_150_002);
9343 pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1_000_150_003);
9344 pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1_000_150_004);
9345 pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1_000_150_005);
9346 pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1_000_150_006);
9347 pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1_000_150_009);
9348 pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_010);
9349 pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1_000_150_011);
9350 pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_012);
9351 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: Self = Self(1_000_150_013);
9352 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: Self = Self(1_000_150_014);
9353 pub const ACCELERATION_STRUCTURE_CREATE_INFO_KHR: Self = Self(1_000_150_017);
9354 pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: Self = Self(1_000_150_020);
9355}
9356impl KhrRayTracingPipelineFn {
9357 #[inline]
9358 pub const fn name() -> &'static ::std::ffi::CStr {
9359 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_pipeline\0") }
9360 }
9361 pub const SPEC_VERSION: u32 = 1u32;
9362}
9363#[allow(non_camel_case_types)]
9364pub type PFN_vkCmdTraceRaysKHR = unsafe extern "system" fn(
9365 command_buffer: CommandBuffer,
9366 p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9367 p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9368 p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9369 p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9370 width: u32,
9371 height: u32,
9372 depth: u32,
9373);
9374#[allow(non_camel_case_types)]
9375pub type PFN_vkCreateRayTracingPipelinesKHR = unsafe extern "system" fn(
9376 device: Device,
9377 deferred_operation: DeferredOperationKHR,
9378 pipeline_cache: PipelineCache,
9379 create_info_count: u32,
9380 p_create_infos: *const RayTracingPipelineCreateInfoKHR,
9381 p_allocator: *const AllocationCallbacks,
9382 p_pipelines: *mut Pipeline,
9383) -> Result;
9384#[allow(non_camel_case_types)]
9385pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn(
9386 device: Device,
9387 pipeline: Pipeline,
9388 first_group: u32,
9389 group_count: u32,
9390 data_size: usize,
9391 p_data: *mut c_void,
9392) -> Result;
9393#[allow(non_camel_case_types)]
9394pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
9395 unsafe extern "system" fn(
9396 device: Device,
9397 pipeline: Pipeline,
9398 first_group: u32,
9399 group_count: u32,
9400 data_size: usize,
9401 p_data: *mut c_void,
9402 ) -> Result;
9403#[allow(non_camel_case_types)]
9404pub type PFN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn(
9405 command_buffer: CommandBuffer,
9406 p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9407 p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9408 p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9409 p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9410 indirect_device_address: DeviceAddress,
9411);
9412#[allow(non_camel_case_types)]
9413pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn(
9414 device: Device,
9415 pipeline: Pipeline,
9416 group: u32,
9417 group_shader: ShaderGroupShaderKHR,
9418) -> DeviceSize;
9419#[allow(non_camel_case_types)]
9420pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR =
9421 unsafe extern "system" fn(command_buffer: CommandBuffer, pipeline_stack_size: u32);
9422#[derive(Clone)]
9423pub struct KhrRayTracingPipelineFn {
9424 pub cmd_trace_rays_khr: PFN_vkCmdTraceRaysKHR,
9425 pub create_ray_tracing_pipelines_khr: PFN_vkCreateRayTracingPipelinesKHR,
9426 pub get_ray_tracing_shader_group_handles_khr: PFN_vkGetRayTracingShaderGroupHandlesKHR,
9427 pub get_ray_tracing_capture_replay_shader_group_handles_khr:
9428 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
9429 pub cmd_trace_rays_indirect_khr: PFN_vkCmdTraceRaysIndirectKHR,
9430 pub get_ray_tracing_shader_group_stack_size_khr: PFN_vkGetRayTracingShaderGroupStackSizeKHR,
9431 pub cmd_set_ray_tracing_pipeline_stack_size_khr: PFN_vkCmdSetRayTracingPipelineStackSizeKHR,
9432}
9433unsafe impl Send for KhrRayTracingPipelineFn {}
9434unsafe impl Sync for KhrRayTracingPipelineFn {}
9435impl KhrRayTracingPipelineFn {
9436 pub fn load<F>(mut _f: F) -> Self
9437 where
9438 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9439 {
9440 Self {
9441 cmd_trace_rays_khr: unsafe {
9442 unsafe extern "system" fn cmd_trace_rays_khr(
9443 _command_buffer: CommandBuffer,
9444 _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9445 _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9446 _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9447 _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9448 _width: u32,
9449 _height: u32,
9450 _depth: u32,
9451 ) {
9452 panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_khr)))
9453 }
9454 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysKHR\0");
9455 let val = _f(cname);
9456 if val.is_null() {
9457 cmd_trace_rays_khr
9458 } else {
9459 ::std::mem::transmute(val)
9460 }
9461 },
9462 create_ray_tracing_pipelines_khr: unsafe {
9463 unsafe extern "system" fn create_ray_tracing_pipelines_khr(
9464 _device: Device,
9465 _deferred_operation: DeferredOperationKHR,
9466 _pipeline_cache: PipelineCache,
9467 _create_info_count: u32,
9468 _p_create_infos: *const RayTracingPipelineCreateInfoKHR,
9469 _p_allocator: *const AllocationCallbacks,
9470 _p_pipelines: *mut Pipeline,
9471 ) -> Result {
9472 panic!(concat!(
9473 "Unable to load ",
9474 stringify!(create_ray_tracing_pipelines_khr)
9475 ))
9476 }
9477 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9478 b"vkCreateRayTracingPipelinesKHR\0",
9479 );
9480 let val = _f(cname);
9481 if val.is_null() {
9482 create_ray_tracing_pipelines_khr
9483 } else {
9484 ::std::mem::transmute(val)
9485 }
9486 },
9487 get_ray_tracing_shader_group_handles_khr: unsafe {
9488 unsafe extern "system" fn get_ray_tracing_shader_group_handles_khr(
9489 _device: Device,
9490 _pipeline: Pipeline,
9491 _first_group: u32,
9492 _group_count: u32,
9493 _data_size: usize,
9494 _p_data: *mut c_void,
9495 ) -> Result {
9496 panic!(concat!(
9497 "Unable to load ",
9498 stringify!(get_ray_tracing_shader_group_handles_khr)
9499 ))
9500 }
9501 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9502 b"vkGetRayTracingShaderGroupHandlesKHR\0",
9503 );
9504 let val = _f(cname);
9505 if val.is_null() {
9506 get_ray_tracing_shader_group_handles_khr
9507 } else {
9508 ::std::mem::transmute(val)
9509 }
9510 },
9511 get_ray_tracing_capture_replay_shader_group_handles_khr: unsafe {
9512 unsafe extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr(
9513 _device: Device,
9514 _pipeline: Pipeline,
9515 _first_group: u32,
9516 _group_count: u32,
9517 _data_size: usize,
9518 _p_data: *mut c_void,
9519 ) -> Result {
9520 panic!(concat!(
9521 "Unable to load ",
9522 stringify!(get_ray_tracing_capture_replay_shader_group_handles_khr)
9523 ))
9524 }
9525 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9526 b"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR\0",
9527 );
9528 let val = _f(cname);
9529 if val.is_null() {
9530 get_ray_tracing_capture_replay_shader_group_handles_khr
9531 } else {
9532 ::std::mem::transmute(val)
9533 }
9534 },
9535 cmd_trace_rays_indirect_khr: unsafe {
9536 unsafe extern "system" fn cmd_trace_rays_indirect_khr(
9537 _command_buffer: CommandBuffer,
9538 _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9539 _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9540 _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9541 _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9542 _indirect_device_address: DeviceAddress,
9543 ) {
9544 panic!(concat!(
9545 "Unable to load ",
9546 stringify!(cmd_trace_rays_indirect_khr)
9547 ))
9548 }
9549 let cname =
9550 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysIndirectKHR\0");
9551 let val = _f(cname);
9552 if val.is_null() {
9553 cmd_trace_rays_indirect_khr
9554 } else {
9555 ::std::mem::transmute(val)
9556 }
9557 },
9558 get_ray_tracing_shader_group_stack_size_khr: unsafe {
9559 unsafe extern "system" fn get_ray_tracing_shader_group_stack_size_khr(
9560 _device: Device,
9561 _pipeline: Pipeline,
9562 _group: u32,
9563 _group_shader: ShaderGroupShaderKHR,
9564 ) -> DeviceSize {
9565 panic!(concat!(
9566 "Unable to load ",
9567 stringify!(get_ray_tracing_shader_group_stack_size_khr)
9568 ))
9569 }
9570 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9571 b"vkGetRayTracingShaderGroupStackSizeKHR\0",
9572 );
9573 let val = _f(cname);
9574 if val.is_null() {
9575 get_ray_tracing_shader_group_stack_size_khr
9576 } else {
9577 ::std::mem::transmute(val)
9578 }
9579 },
9580 cmd_set_ray_tracing_pipeline_stack_size_khr: unsafe {
9581 unsafe extern "system" fn cmd_set_ray_tracing_pipeline_stack_size_khr(
9582 _command_buffer: CommandBuffer,
9583 _pipeline_stack_size: u32,
9584 ) {
9585 panic!(concat!(
9586 "Unable to load ",
9587 stringify!(cmd_set_ray_tracing_pipeline_stack_size_khr)
9588 ))
9589 }
9590 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9591 b"vkCmdSetRayTracingPipelineStackSizeKHR\0",
9592 );
9593 let val = _f(cname);
9594 if val.is_null() {
9595 cmd_set_ray_tracing_pipeline_stack_size_khr
9596 } else {
9597 ::std::mem::transmute(val)
9598 }
9599 },
9600 }
9601 }
9602}
9603#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9604impl BufferUsageFlags {
9605 pub const SHADER_BINDING_TABLE_KHR: Self = Self(0b100_0000_0000);
9606}
9607#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9608impl DynamicState {
9609 pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1_000_347_000);
9610}
9611#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9612impl PipelineBindPoint {
9613 pub const RAY_TRACING_KHR: Self = Self(1_000_165_000);
9614}
9615#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9616impl PipelineCreateFlags {
9617 pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR: Self = Self(0b100_0000_0000_0000);
9618 pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR: Self = Self(0b1000_0000_0000_0000);
9619 pub const RAY_TRACING_NO_NULL_MISS_SHADERS_KHR: Self = Self(0b1_0000_0000_0000_0000);
9620 pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR: Self = Self(0b10_0000_0000_0000_0000);
9621 pub const RAY_TRACING_SKIP_TRIANGLES_KHR: Self = Self(0b1_0000_0000_0000);
9622 pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000);
9623 pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR: Self =
9624 Self(0b1000_0000_0000_0000_0000);
9625}
9626#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9627impl PipelineStageFlags {
9628 pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
9629}
9630#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9631impl ShaderStageFlags {
9632 pub const RAYGEN_KHR: Self = Self(0b1_0000_0000);
9633 pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000);
9634 pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000);
9635 pub const MISS_KHR: Self = Self(0b1000_0000_0000);
9636 pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000);
9637 pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000);
9638}
9639#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9640impl StructureType {
9641 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1_000_347_000);
9642 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1_000_347_001);
9643 pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015);
9644 pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016);
9645 pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018);
9646}
9647impl KhrRayQueryFn {
9648 #[inline]
9649 pub const fn name() -> &'static ::std::ffi::CStr {
9650 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_query\0") }
9651 }
9652 pub const SPEC_VERSION: u32 = 1u32;
9653}
9654#[derive(Clone)]
9655pub struct KhrRayQueryFn {}
9656unsafe impl Send for KhrRayQueryFn {}
9657unsafe impl Sync for KhrRayQueryFn {}
9658impl KhrRayQueryFn {
9659 pub fn load<F>(mut _f: F) -> Self
9660 where
9661 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9662 {
9663 Self {}
9664 }
9665}
9666#[doc = "Generated from 'VK_KHR_ray_query'"]
9667impl StructureType {
9668 pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1_000_348_013);
9669}
9670impl NvExtension152Fn {
9671 #[inline]
9672 pub const fn name() -> &'static ::std::ffi::CStr {
9673 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_152\0") }
9674 }
9675 pub const SPEC_VERSION: u32 = 0u32;
9676}
9677#[derive(Clone)]
9678pub struct NvExtension152Fn {}
9679unsafe impl Send for NvExtension152Fn {}
9680unsafe impl Sync for NvExtension152Fn {}
9681impl NvExtension152Fn {
9682 pub fn load<F>(mut _f: F) -> Self
9683 where
9684 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9685 {
9686 Self {}
9687 }
9688}
9689impl NvFramebufferMixedSamplesFn {
9690 #[inline]
9691 pub const fn name() -> &'static ::std::ffi::CStr {
9692 unsafe {
9693 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_framebuffer_mixed_samples\0")
9694 }
9695 }
9696 pub const SPEC_VERSION: u32 = 1u32;
9697}
9698#[derive(Clone)]
9699pub struct NvFramebufferMixedSamplesFn {}
9700unsafe impl Send for NvFramebufferMixedSamplesFn {}
9701unsafe impl Sync for NvFramebufferMixedSamplesFn {}
9702impl NvFramebufferMixedSamplesFn {
9703 pub fn load<F>(mut _f: F) -> Self
9704 where
9705 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9706 {
9707 Self {}
9708 }
9709}
9710#[doc = "Generated from 'VK_NV_framebuffer_mixed_samples'"]
9711impl StructureType {
9712 pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1_000_152_000);
9713}
9714impl NvFillRectangleFn {
9715 #[inline]
9716 pub const fn name() -> &'static ::std::ffi::CStr {
9717 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fill_rectangle\0") }
9718 }
9719 pub const SPEC_VERSION: u32 = 1u32;
9720}
9721#[derive(Clone)]
9722pub struct NvFillRectangleFn {}
9723unsafe impl Send for NvFillRectangleFn {}
9724unsafe impl Sync for NvFillRectangleFn {}
9725impl NvFillRectangleFn {
9726 pub fn load<F>(mut _f: F) -> Self
9727 where
9728 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9729 {
9730 Self {}
9731 }
9732}
9733#[doc = "Generated from 'VK_NV_fill_rectangle'"]
9734impl PolygonMode {
9735 pub const FILL_RECTANGLE_NV: Self = Self(1_000_153_000);
9736}
9737impl NvShaderSmBuiltinsFn {
9738 #[inline]
9739 pub const fn name() -> &'static ::std::ffi::CStr {
9740 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_sm_builtins\0") }
9741 }
9742 pub const SPEC_VERSION: u32 = 1u32;
9743}
9744#[derive(Clone)]
9745pub struct NvShaderSmBuiltinsFn {}
9746unsafe impl Send for NvShaderSmBuiltinsFn {}
9747unsafe impl Sync for NvShaderSmBuiltinsFn {}
9748impl NvShaderSmBuiltinsFn {
9749 pub fn load<F>(mut _f: F) -> Self
9750 where
9751 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9752 {
9753 Self {}
9754 }
9755}
9756#[doc = "Generated from 'VK_NV_shader_sm_builtins'"]
9757impl StructureType {
9758 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1_000_154_000);
9759 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1_000_154_001);
9760}
9761impl ExtPostDepthCoverageFn {
9762 #[inline]
9763 pub const fn name() -> &'static ::std::ffi::CStr {
9764 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_post_depth_coverage\0") }
9765 }
9766 pub const SPEC_VERSION: u32 = 1u32;
9767}
9768#[derive(Clone)]
9769pub struct ExtPostDepthCoverageFn {}
9770unsafe impl Send for ExtPostDepthCoverageFn {}
9771unsafe impl Sync for ExtPostDepthCoverageFn {}
9772impl ExtPostDepthCoverageFn {
9773 pub fn load<F>(mut _f: F) -> Self
9774 where
9775 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9776 {
9777 Self {}
9778 }
9779}
9780impl KhrSamplerYcbcrConversionFn {
9781 #[inline]
9782 pub const fn name() -> &'static ::std::ffi::CStr {
9783 unsafe {
9784 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_sampler_ycbcr_conversion\0")
9785 }
9786 }
9787 pub const SPEC_VERSION: u32 = 14u32;
9788}
9789#[allow(non_camel_case_types)]
9790pub type PFN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn(
9791 device: Device,
9792 p_create_info: *const SamplerYcbcrConversionCreateInfo,
9793 p_allocator: *const AllocationCallbacks,
9794 p_ycbcr_conversion: *mut SamplerYcbcrConversion,
9795) -> Result;
9796#[allow(non_camel_case_types)]
9797pub type PFN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn(
9798 device: Device,
9799 ycbcr_conversion: SamplerYcbcrConversion,
9800 p_allocator: *const AllocationCallbacks,
9801);
9802#[derive(Clone)]
9803pub struct KhrSamplerYcbcrConversionFn {
9804 pub create_sampler_ycbcr_conversion_khr: PFN_vkCreateSamplerYcbcrConversion,
9805 pub destroy_sampler_ycbcr_conversion_khr: PFN_vkDestroySamplerYcbcrConversion,
9806}
9807unsafe impl Send for KhrSamplerYcbcrConversionFn {}
9808unsafe impl Sync for KhrSamplerYcbcrConversionFn {}
9809impl KhrSamplerYcbcrConversionFn {
9810 pub fn load<F>(mut _f: F) -> Self
9811 where
9812 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9813 {
9814 Self {
9815 create_sampler_ycbcr_conversion_khr: unsafe {
9816 unsafe extern "system" fn create_sampler_ycbcr_conversion_khr(
9817 _device: Device,
9818 _p_create_info: *const SamplerYcbcrConversionCreateInfo,
9819 _p_allocator: *const AllocationCallbacks,
9820 _p_ycbcr_conversion: *mut SamplerYcbcrConversion,
9821 ) -> Result {
9822 panic!(concat!(
9823 "Unable to load ",
9824 stringify!(create_sampler_ycbcr_conversion_khr)
9825 ))
9826 }
9827 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9828 b"vkCreateSamplerYcbcrConversionKHR\0",
9829 );
9830 let val = _f(cname);
9831 if val.is_null() {
9832 create_sampler_ycbcr_conversion_khr
9833 } else {
9834 ::std::mem::transmute(val)
9835 }
9836 },
9837 destroy_sampler_ycbcr_conversion_khr: unsafe {
9838 unsafe extern "system" fn destroy_sampler_ycbcr_conversion_khr(
9839 _device: Device,
9840 _ycbcr_conversion: SamplerYcbcrConversion,
9841 _p_allocator: *const AllocationCallbacks,
9842 ) {
9843 panic!(concat!(
9844 "Unable to load ",
9845 stringify!(destroy_sampler_ycbcr_conversion_khr)
9846 ))
9847 }
9848 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9849 b"vkDestroySamplerYcbcrConversionKHR\0",
9850 );
9851 let val = _f(cname);
9852 if val.is_null() {
9853 destroy_sampler_ycbcr_conversion_khr
9854 } else {
9855 ::std::mem::transmute(val)
9856 }
9857 },
9858 }
9859 }
9860}
9861#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9862impl ChromaLocation {
9863 pub const COSITED_EVEN_KHR: Self = Self::COSITED_EVEN;
9864 pub const MIDPOINT_KHR: Self = Self::MIDPOINT;
9865}
9866#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9867impl DebugReportObjectTypeEXT {
9868 pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION;
9869}
9870#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9871impl Format {
9872 pub const G8B8G8R8_422_UNORM_KHR: Self = Self::G8B8G8R8_422_UNORM;
9873 pub const B8G8R8G8_422_UNORM_KHR: Self = Self::B8G8R8G8_422_UNORM;
9874 pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_420_UNORM;
9875 pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_420_UNORM;
9876 pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_422_UNORM;
9877 pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_422_UNORM;
9878 pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_444_UNORM;
9879 pub const R10X6_UNORM_PACK16_KHR: Self = Self::R10X6_UNORM_PACK16;
9880 pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Self::R10X6G10X6_UNORM_2PACK16;
9881 pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self =
9882 Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16;
9883 pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self =
9884 Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
9885 pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self =
9886 Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
9887 pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self =
9888 Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
9889 pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self =
9890 Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
9891 pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self =
9892 Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
9893 pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self =
9894 Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
9895 pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self =
9896 Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
9897 pub const R12X4_UNORM_PACK16_KHR: Self = Self::R12X4_UNORM_PACK16;
9898 pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Self::R12X4G12X4_UNORM_2PACK16;
9899 pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self =
9900 Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16;
9901 pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self =
9902 Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
9903 pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self =
9904 Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
9905 pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self =
9906 Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
9907 pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self =
9908 Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
9909 pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self =
9910 Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
9911 pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self =
9912 Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
9913 pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self =
9914 Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
9915 pub const G16B16G16R16_422_UNORM_KHR: Self = Self::G16B16G16R16_422_UNORM;
9916 pub const B16G16R16G16_422_UNORM_KHR: Self = Self::B16G16R16G16_422_UNORM;
9917 pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_420_UNORM;
9918 pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_420_UNORM;
9919 pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_422_UNORM;
9920 pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_422_UNORM;
9921 pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_444_UNORM;
9922}
9923#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9924impl FormatFeatureFlags {
9925 pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES;
9926 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self =
9927 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER;
9928 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self =
9929 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER;
9930 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self =
9931 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT;
9932 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self =
9933 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE;
9934 pub const DISJOINT_KHR: Self = Self::DISJOINT;
9935 pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES;
9936}
9937#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9938impl ImageAspectFlags {
9939 pub const PLANE_0_KHR: Self = Self::PLANE_0;
9940 pub const PLANE_1_KHR: Self = Self::PLANE_1;
9941 pub const PLANE_2_KHR: Self = Self::PLANE_2;
9942}
9943#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9944impl ImageCreateFlags {
9945 pub const DISJOINT_KHR: Self = Self::DISJOINT;
9946}
9947#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9948impl ObjectType {
9949 pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION;
9950}
9951#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9952impl SamplerYcbcrModelConversion {
9953 pub const RGB_IDENTITY_KHR: Self = Self::RGB_IDENTITY;
9954 pub const YCBCR_IDENTITY_KHR: Self = Self::YCBCR_IDENTITY;
9955 pub const YCBCR_709_KHR: Self = Self::YCBCR_709;
9956 pub const YCBCR_601_KHR: Self = Self::YCBCR_601;
9957 pub const YCBCR_2020_KHR: Self = Self::YCBCR_2020;
9958}
9959#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9960impl SamplerYcbcrRange {
9961 pub const ITU_FULL_KHR: Self = Self::ITU_FULL;
9962 pub const ITU_NARROW_KHR: Self = Self::ITU_NARROW;
9963}
9964#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9965impl StructureType {
9966 pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self =
9967 Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
9968 pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION_INFO;
9969 pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_PLANE_MEMORY_INFO;
9970 pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self =
9971 Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
9972 pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self =
9973 Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
9974 pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self =
9975 Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
9976}
9977impl KhrBindMemory2Fn {
9978 #[inline]
9979 pub const fn name() -> &'static ::std::ffi::CStr {
9980 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_bind_memory2\0") }
9981 }
9982 pub const SPEC_VERSION: u32 = 1u32;
9983}
9984#[allow(non_camel_case_types)]
9985pub type PFN_vkBindBufferMemory2 = unsafe extern "system" fn(
9986 device: Device,
9987 bind_info_count: u32,
9988 p_bind_infos: *const BindBufferMemoryInfo,
9989) -> Result;
9990#[allow(non_camel_case_types)]
9991pub type PFN_vkBindImageMemory2 = unsafe extern "system" fn(
9992 device: Device,
9993 bind_info_count: u32,
9994 p_bind_infos: *const BindImageMemoryInfo,
9995) -> Result;
9996#[derive(Clone)]
9997pub struct KhrBindMemory2Fn {
9998 pub bind_buffer_memory2_khr: PFN_vkBindBufferMemory2,
9999 pub bind_image_memory2_khr: PFN_vkBindImageMemory2,
10000}
10001unsafe impl Send for KhrBindMemory2Fn {}
10002unsafe impl Sync for KhrBindMemory2Fn {}
10003impl KhrBindMemory2Fn {
10004 pub fn load<F>(mut _f: F) -> Self
10005 where
10006 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10007 {
10008 Self {
10009 bind_buffer_memory2_khr: unsafe {
10010 unsafe extern "system" fn bind_buffer_memory2_khr(
10011 _device: Device,
10012 _bind_info_count: u32,
10013 _p_bind_infos: *const BindBufferMemoryInfo,
10014 ) -> Result {
10015 panic!(concat!(
10016 "Unable to load ",
10017 stringify!(bind_buffer_memory2_khr)
10018 ))
10019 }
10020 let cname =
10021 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2KHR\0");
10022 let val = _f(cname);
10023 if val.is_null() {
10024 bind_buffer_memory2_khr
10025 } else {
10026 ::std::mem::transmute(val)
10027 }
10028 },
10029 bind_image_memory2_khr: unsafe {
10030 unsafe extern "system" fn bind_image_memory2_khr(
10031 _device: Device,
10032 _bind_info_count: u32,
10033 _p_bind_infos: *const BindImageMemoryInfo,
10034 ) -> Result {
10035 panic!(concat!(
10036 "Unable to load ",
10037 stringify!(bind_image_memory2_khr)
10038 ))
10039 }
10040 let cname =
10041 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2KHR\0");
10042 let val = _f(cname);
10043 if val.is_null() {
10044 bind_image_memory2_khr
10045 } else {
10046 ::std::mem::transmute(val)
10047 }
10048 },
10049 }
10050 }
10051}
10052#[doc = "Generated from 'VK_KHR_bind_memory2'"]
10053impl ImageCreateFlags {
10054 pub const ALIAS_KHR: Self = Self::ALIAS;
10055}
10056#[doc = "Generated from 'VK_KHR_bind_memory2'"]
10057impl StructureType {
10058 pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = Self::BIND_BUFFER_MEMORY_INFO;
10059 pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_MEMORY_INFO;
10060}
10061impl ExtImageDrmFormatModifierFn {
10062 #[inline]
10063 pub const fn name() -> &'static ::std::ffi::CStr {
10064 unsafe {
10065 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_drm_format_modifier\0")
10066 }
10067 }
10068 pub const SPEC_VERSION: u32 = 2u32;
10069}
10070#[allow(non_camel_case_types)]
10071pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn(
10072 device: Device,
10073 image: Image,
10074 p_properties: *mut ImageDrmFormatModifierPropertiesEXT,
10075) -> Result;
10076#[derive(Clone)]
10077pub struct ExtImageDrmFormatModifierFn {
10078 pub get_image_drm_format_modifier_properties_ext: PFN_vkGetImageDrmFormatModifierPropertiesEXT,
10079}
10080unsafe impl Send for ExtImageDrmFormatModifierFn {}
10081unsafe impl Sync for ExtImageDrmFormatModifierFn {}
10082impl ExtImageDrmFormatModifierFn {
10083 pub fn load<F>(mut _f: F) -> Self
10084 where
10085 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10086 {
10087 Self {
10088 get_image_drm_format_modifier_properties_ext: unsafe {
10089 unsafe extern "system" fn get_image_drm_format_modifier_properties_ext(
10090 _device: Device,
10091 _image: Image,
10092 _p_properties: *mut ImageDrmFormatModifierPropertiesEXT,
10093 ) -> Result {
10094 panic!(concat!(
10095 "Unable to load ",
10096 stringify!(get_image_drm_format_modifier_properties_ext)
10097 ))
10098 }
10099 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10100 b"vkGetImageDrmFormatModifierPropertiesEXT\0",
10101 );
10102 let val = _f(cname);
10103 if val.is_null() {
10104 get_image_drm_format_modifier_properties_ext
10105 } else {
10106 ::std::mem::transmute(val)
10107 }
10108 },
10109 }
10110 }
10111}
10112#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
10113impl ImageAspectFlags {
10114 pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000);
10115 pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000);
10116 pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000);
10117 pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000);
10118}
10119#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
10120impl ImageTiling {
10121 pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000);
10122}
10123#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
10124impl Result {
10125 pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1_000_158_000);
10126}
10127#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
10128impl StructureType {
10129 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000);
10130 pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002);
10131 pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1_000_158_003);
10132 pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1_000_158_004);
10133 pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_005);
10134 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: Self = Self(1_000_158_006);
10135}
10136impl ExtExtension160Fn {
10137 #[inline]
10138 pub const fn name() -> &'static ::std::ffi::CStr {
10139 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_160\0") }
10140 }
10141 pub const SPEC_VERSION: u32 = 0u32;
10142}
10143#[derive(Clone)]
10144pub struct ExtExtension160Fn {}
10145unsafe impl Send for ExtExtension160Fn {}
10146unsafe impl Sync for ExtExtension160Fn {}
10147impl ExtExtension160Fn {
10148 pub fn load<F>(mut _f: F) -> Self
10149 where
10150 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10151 {
10152 Self {}
10153 }
10154}
10155impl ExtValidationCacheFn {
10156 #[inline]
10157 pub const fn name() -> &'static ::std::ffi::CStr {
10158 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_cache\0") }
10159 }
10160 pub const SPEC_VERSION: u32 = 1u32;
10161}
10162#[allow(non_camel_case_types)]
10163pub type PFN_vkCreateValidationCacheEXT = unsafe extern "system" fn(
10164 device: Device,
10165 p_create_info: *const ValidationCacheCreateInfoEXT,
10166 p_allocator: *const AllocationCallbacks,
10167 p_validation_cache: *mut ValidationCacheEXT,
10168) -> Result;
10169#[allow(non_camel_case_types)]
10170pub type PFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn(
10171 device: Device,
10172 validation_cache: ValidationCacheEXT,
10173 p_allocator: *const AllocationCallbacks,
10174);
10175#[allow(non_camel_case_types)]
10176pub type PFN_vkMergeValidationCachesEXT = unsafe extern "system" fn(
10177 device: Device,
10178 dst_cache: ValidationCacheEXT,
10179 src_cache_count: u32,
10180 p_src_caches: *const ValidationCacheEXT,
10181) -> Result;
10182#[allow(non_camel_case_types)]
10183pub type PFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn(
10184 device: Device,
10185 validation_cache: ValidationCacheEXT,
10186 p_data_size: *mut usize,
10187 p_data: *mut c_void,
10188) -> Result;
10189#[derive(Clone)]
10190pub struct ExtValidationCacheFn {
10191 pub create_validation_cache_ext: PFN_vkCreateValidationCacheEXT,
10192 pub destroy_validation_cache_ext: PFN_vkDestroyValidationCacheEXT,
10193 pub merge_validation_caches_ext: PFN_vkMergeValidationCachesEXT,
10194 pub get_validation_cache_data_ext: PFN_vkGetValidationCacheDataEXT,
10195}
10196unsafe impl Send for ExtValidationCacheFn {}
10197unsafe impl Sync for ExtValidationCacheFn {}
10198impl ExtValidationCacheFn {
10199 pub fn load<F>(mut _f: F) -> Self
10200 where
10201 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10202 {
10203 Self {
10204 create_validation_cache_ext: unsafe {
10205 unsafe extern "system" fn create_validation_cache_ext(
10206 _device: Device,
10207 _p_create_info: *const ValidationCacheCreateInfoEXT,
10208 _p_allocator: *const AllocationCallbacks,
10209 _p_validation_cache: *mut ValidationCacheEXT,
10210 ) -> Result {
10211 panic!(concat!(
10212 "Unable to load ",
10213 stringify!(create_validation_cache_ext)
10214 ))
10215 }
10216 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10217 b"vkCreateValidationCacheEXT\0",
10218 );
10219 let val = _f(cname);
10220 if val.is_null() {
10221 create_validation_cache_ext
10222 } else {
10223 ::std::mem::transmute(val)
10224 }
10225 },
10226 destroy_validation_cache_ext: unsafe {
10227 unsafe extern "system" fn destroy_validation_cache_ext(
10228 _device: Device,
10229 _validation_cache: ValidationCacheEXT,
10230 _p_allocator: *const AllocationCallbacks,
10231 ) {
10232 panic!(concat!(
10233 "Unable to load ",
10234 stringify!(destroy_validation_cache_ext)
10235 ))
10236 }
10237 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10238 b"vkDestroyValidationCacheEXT\0",
10239 );
10240 let val = _f(cname);
10241 if val.is_null() {
10242 destroy_validation_cache_ext
10243 } else {
10244 ::std::mem::transmute(val)
10245 }
10246 },
10247 merge_validation_caches_ext: unsafe {
10248 unsafe extern "system" fn merge_validation_caches_ext(
10249 _device: Device,
10250 _dst_cache: ValidationCacheEXT,
10251 _src_cache_count: u32,
10252 _p_src_caches: *const ValidationCacheEXT,
10253 ) -> Result {
10254 panic!(concat!(
10255 "Unable to load ",
10256 stringify!(merge_validation_caches_ext)
10257 ))
10258 }
10259 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10260 b"vkMergeValidationCachesEXT\0",
10261 );
10262 let val = _f(cname);
10263 if val.is_null() {
10264 merge_validation_caches_ext
10265 } else {
10266 ::std::mem::transmute(val)
10267 }
10268 },
10269 get_validation_cache_data_ext: unsafe {
10270 unsafe extern "system" fn get_validation_cache_data_ext(
10271 _device: Device,
10272 _validation_cache: ValidationCacheEXT,
10273 _p_data_size: *mut usize,
10274 _p_data: *mut c_void,
10275 ) -> Result {
10276 panic!(concat!(
10277 "Unable to load ",
10278 stringify!(get_validation_cache_data_ext)
10279 ))
10280 }
10281 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10282 b"vkGetValidationCacheDataEXT\0",
10283 );
10284 let val = _f(cname);
10285 if val.is_null() {
10286 get_validation_cache_data_ext
10287 } else {
10288 ::std::mem::transmute(val)
10289 }
10290 },
10291 }
10292 }
10293}
10294#[doc = "Generated from 'VK_EXT_validation_cache'"]
10295impl ObjectType {
10296 pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000);
10297}
10298#[doc = "Generated from 'VK_EXT_validation_cache'"]
10299impl StructureType {
10300 pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000);
10301 pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_001);
10302}
10303impl ExtDescriptorIndexingFn {
10304 #[inline]
10305 pub const fn name() -> &'static ::std::ffi::CStr {
10306 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_indexing\0") }
10307 }
10308 pub const SPEC_VERSION: u32 = 2u32;
10309}
10310#[derive(Clone)]
10311pub struct ExtDescriptorIndexingFn {}
10312unsafe impl Send for ExtDescriptorIndexingFn {}
10313unsafe impl Sync for ExtDescriptorIndexingFn {}
10314impl ExtDescriptorIndexingFn {
10315 pub fn load<F>(mut _f: F) -> Self
10316 where
10317 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10318 {
10319 Self {}
10320 }
10321}
10322#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10323impl DescriptorBindingFlags {
10324 pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND;
10325 pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = Self::UPDATE_UNUSED_WHILE_PENDING;
10326 pub const PARTIALLY_BOUND_EXT: Self = Self::PARTIALLY_BOUND;
10327 pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = Self::VARIABLE_DESCRIPTOR_COUNT;
10328}
10329#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10330impl DescriptorPoolCreateFlags {
10331 pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND;
10332}
10333#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10334impl DescriptorSetLayoutCreateFlags {
10335 pub const UPDATE_AFTER_BIND_POOL_EXT: Self = Self::UPDATE_AFTER_BIND_POOL;
10336}
10337#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10338impl Result {
10339 pub const ERROR_FRAGMENTATION_EXT: Self = Self::ERROR_FRAGMENTATION;
10340}
10341#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10342impl StructureType {
10343 pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self =
10344 Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
10345 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self =
10346 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
10347 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self =
10348 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
10349 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self =
10350 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
10351 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self =
10352 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
10353}
10354impl ExtShaderViewportIndexLayerFn {
10355 #[inline]
10356 pub const fn name() -> &'static ::std::ffi::CStr {
10357 unsafe {
10358 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_viewport_index_layer\0")
10359 }
10360 }
10361 pub const SPEC_VERSION: u32 = 1u32;
10362}
10363#[derive(Clone)]
10364pub struct ExtShaderViewportIndexLayerFn {}
10365unsafe impl Send for ExtShaderViewportIndexLayerFn {}
10366unsafe impl Sync for ExtShaderViewportIndexLayerFn {}
10367impl ExtShaderViewportIndexLayerFn {
10368 pub fn load<F>(mut _f: F) -> Self
10369 where
10370 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10371 {
10372 Self {}
10373 }
10374}
10375impl KhrPortabilitySubsetFn {
10376 #[inline]
10377 pub const fn name() -> &'static ::std::ffi::CStr {
10378 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_subset\0") }
10379 }
10380 pub const SPEC_VERSION: u32 = 1u32;
10381}
10382#[derive(Clone)]
10383pub struct KhrPortabilitySubsetFn {}
10384unsafe impl Send for KhrPortabilitySubsetFn {}
10385unsafe impl Sync for KhrPortabilitySubsetFn {}
10386impl KhrPortabilitySubsetFn {
10387 pub fn load<F>(mut _f: F) -> Self
10388 where
10389 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10390 {
10391 Self {}
10392 }
10393}
10394#[doc = "Generated from 'VK_KHR_portability_subset'"]
10395impl StructureType {
10396 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1_000_163_000);
10397 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: Self = Self(1_000_163_001);
10398}
10399impl NvShadingRateImageFn {
10400 #[inline]
10401 pub const fn name() -> &'static ::std::ffi::CStr {
10402 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shading_rate_image\0") }
10403 }
10404 pub const SPEC_VERSION: u32 = 3u32;
10405}
10406#[allow(non_camel_case_types)]
10407pub type PFN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn(
10408 command_buffer: CommandBuffer,
10409 image_view: ImageView,
10410 image_layout: ImageLayout,
10411);
10412#[allow(non_camel_case_types)]
10413pub type PFN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn(
10414 command_buffer: CommandBuffer,
10415 first_viewport: u32,
10416 viewport_count: u32,
10417 p_shading_rate_palettes: *const ShadingRatePaletteNV,
10418);
10419#[allow(non_camel_case_types)]
10420pub type PFN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn(
10421 command_buffer: CommandBuffer,
10422 sample_order_type: CoarseSampleOrderTypeNV,
10423 custom_sample_order_count: u32,
10424 p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
10425);
10426#[derive(Clone)]
10427pub struct NvShadingRateImageFn {
10428 pub cmd_bind_shading_rate_image_nv: PFN_vkCmdBindShadingRateImageNV,
10429 pub cmd_set_viewport_shading_rate_palette_nv: PFN_vkCmdSetViewportShadingRatePaletteNV,
10430 pub cmd_set_coarse_sample_order_nv: PFN_vkCmdSetCoarseSampleOrderNV,
10431}
10432unsafe impl Send for NvShadingRateImageFn {}
10433unsafe impl Sync for NvShadingRateImageFn {}
10434impl NvShadingRateImageFn {
10435 pub fn load<F>(mut _f: F) -> Self
10436 where
10437 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10438 {
10439 Self {
10440 cmd_bind_shading_rate_image_nv: unsafe {
10441 unsafe extern "system" fn cmd_bind_shading_rate_image_nv(
10442 _command_buffer: CommandBuffer,
10443 _image_view: ImageView,
10444 _image_layout: ImageLayout,
10445 ) {
10446 panic!(concat!(
10447 "Unable to load ",
10448 stringify!(cmd_bind_shading_rate_image_nv)
10449 ))
10450 }
10451 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10452 b"vkCmdBindShadingRateImageNV\0",
10453 );
10454 let val = _f(cname);
10455 if val.is_null() {
10456 cmd_bind_shading_rate_image_nv
10457 } else {
10458 ::std::mem::transmute(val)
10459 }
10460 },
10461 cmd_set_viewport_shading_rate_palette_nv: unsafe {
10462 unsafe extern "system" fn cmd_set_viewport_shading_rate_palette_nv(
10463 _command_buffer: CommandBuffer,
10464 _first_viewport: u32,
10465 _viewport_count: u32,
10466 _p_shading_rate_palettes: *const ShadingRatePaletteNV,
10467 ) {
10468 panic!(concat!(
10469 "Unable to load ",
10470 stringify!(cmd_set_viewport_shading_rate_palette_nv)
10471 ))
10472 }
10473 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10474 b"vkCmdSetViewportShadingRatePaletteNV\0",
10475 );
10476 let val = _f(cname);
10477 if val.is_null() {
10478 cmd_set_viewport_shading_rate_palette_nv
10479 } else {
10480 ::std::mem::transmute(val)
10481 }
10482 },
10483 cmd_set_coarse_sample_order_nv: unsafe {
10484 unsafe extern "system" fn cmd_set_coarse_sample_order_nv(
10485 _command_buffer: CommandBuffer,
10486 _sample_order_type: CoarseSampleOrderTypeNV,
10487 _custom_sample_order_count: u32,
10488 _p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
10489 ) {
10490 panic!(concat!(
10491 "Unable to load ",
10492 stringify!(cmd_set_coarse_sample_order_nv)
10493 ))
10494 }
10495 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10496 b"vkCmdSetCoarseSampleOrderNV\0",
10497 );
10498 let val = _f(cname);
10499 if val.is_null() {
10500 cmd_set_coarse_sample_order_nv
10501 } else {
10502 ::std::mem::transmute(val)
10503 }
10504 },
10505 }
10506 }
10507}
10508#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10509impl AccessFlags {
10510 pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR;
10511}
10512#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10513impl DynamicState {
10514 pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1_000_164_004);
10515 pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006);
10516}
10517#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10518impl ImageLayout {
10519 pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
10520}
10521#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10522impl ImageUsageFlags {
10523 pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR;
10524}
10525#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10526impl PipelineStageFlags {
10527 pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR;
10528}
10529#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10530impl StructureType {
10531 pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000);
10532 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001);
10533 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002);
10534 pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self =
10535 Self(1_000_164_005);
10536}
10537impl NvRayTracingFn {
10538 #[inline]
10539 pub const fn name() -> &'static ::std::ffi::CStr {
10540 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing\0") }
10541 }
10542 pub const SPEC_VERSION: u32 = 3u32;
10543}
10544#[allow(non_camel_case_types)]
10545pub type PFN_vkCreateAccelerationStructureNV = unsafe extern "system" fn(
10546 device: Device,
10547 p_create_info: *const AccelerationStructureCreateInfoNV,
10548 p_allocator: *const AllocationCallbacks,
10549 p_acceleration_structure: *mut AccelerationStructureNV,
10550) -> Result;
10551#[allow(non_camel_case_types)]
10552pub type PFN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn(
10553 device: Device,
10554 acceleration_structure: AccelerationStructureNV,
10555 p_allocator: *const AllocationCallbacks,
10556);
10557#[allow(non_camel_case_types)]
10558pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn(
10559 device: Device,
10560 p_info: *const AccelerationStructureMemoryRequirementsInfoNV,
10561 p_memory_requirements: *mut MemoryRequirements2KHR,
10562);
10563#[allow(non_camel_case_types)]
10564pub type PFN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn(
10565 device: Device,
10566 bind_info_count: u32,
10567 p_bind_infos: *const BindAccelerationStructureMemoryInfoNV,
10568) -> Result;
10569#[allow(non_camel_case_types)]
10570pub type PFN_vkCmdBuildAccelerationStructureNV = unsafe extern "system" fn(
10571 command_buffer: CommandBuffer,
10572 p_info: *const AccelerationStructureInfoNV,
10573 instance_data: Buffer,
10574 instance_offset: DeviceSize,
10575 update: Bool32,
10576 dst: AccelerationStructureNV,
10577 src: AccelerationStructureNV,
10578 scratch: Buffer,
10579 scratch_offset: DeviceSize,
10580);
10581#[allow(non_camel_case_types)]
10582pub type PFN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn(
10583 command_buffer: CommandBuffer,
10584 dst: AccelerationStructureNV,
10585 src: AccelerationStructureNV,
10586 mode: CopyAccelerationStructureModeKHR,
10587);
10588#[allow(non_camel_case_types)]
10589pub type PFN_vkCmdTraceRaysNV = unsafe extern "system" fn(
10590 command_buffer: CommandBuffer,
10591 raygen_shader_binding_table_buffer: Buffer,
10592 raygen_shader_binding_offset: DeviceSize,
10593 miss_shader_binding_table_buffer: Buffer,
10594 miss_shader_binding_offset: DeviceSize,
10595 miss_shader_binding_stride: DeviceSize,
10596 hit_shader_binding_table_buffer: Buffer,
10597 hit_shader_binding_offset: DeviceSize,
10598 hit_shader_binding_stride: DeviceSize,
10599 callable_shader_binding_table_buffer: Buffer,
10600 callable_shader_binding_offset: DeviceSize,
10601 callable_shader_binding_stride: DeviceSize,
10602 width: u32,
10603 height: u32,
10604 depth: u32,
10605);
10606#[allow(non_camel_case_types)]
10607pub type PFN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn(
10608 device: Device,
10609 pipeline_cache: PipelineCache,
10610 create_info_count: u32,
10611 p_create_infos: *const RayTracingPipelineCreateInfoNV,
10612 p_allocator: *const AllocationCallbacks,
10613 p_pipelines: *mut Pipeline,
10614) -> Result;
10615#[allow(non_camel_case_types)]
10616pub type PFN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn(
10617 device: Device,
10618 acceleration_structure: AccelerationStructureNV,
10619 data_size: usize,
10620 p_data: *mut c_void,
10621) -> Result;
10622#[allow(non_camel_case_types)]
10623pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn(
10624 command_buffer: CommandBuffer,
10625 acceleration_structure_count: u32,
10626 p_acceleration_structures: *const AccelerationStructureNV,
10627 query_type: QueryType,
10628 query_pool: QueryPool,
10629 first_query: u32,
10630);
10631#[allow(non_camel_case_types)]
10632pub type PFN_vkCompileDeferredNV =
10633 unsafe extern "system" fn(device: Device, pipeline: Pipeline, shader: u32) -> Result;
10634#[derive(Clone)]
10635pub struct NvRayTracingFn {
10636 pub create_acceleration_structure_nv: PFN_vkCreateAccelerationStructureNV,
10637 pub destroy_acceleration_structure_nv: PFN_vkDestroyAccelerationStructureNV,
10638 pub get_acceleration_structure_memory_requirements_nv:
10639 PFN_vkGetAccelerationStructureMemoryRequirementsNV,
10640 pub bind_acceleration_structure_memory_nv: PFN_vkBindAccelerationStructureMemoryNV,
10641 pub cmd_build_acceleration_structure_nv: PFN_vkCmdBuildAccelerationStructureNV,
10642 pub cmd_copy_acceleration_structure_nv: PFN_vkCmdCopyAccelerationStructureNV,
10643 pub cmd_trace_rays_nv: PFN_vkCmdTraceRaysNV,
10644 pub create_ray_tracing_pipelines_nv: PFN_vkCreateRayTracingPipelinesNV,
10645 pub get_ray_tracing_shader_group_handles_nv:
10646 crate::vk::PFN_vkGetRayTracingShaderGroupHandlesKHR,
10647 pub get_acceleration_structure_handle_nv: PFN_vkGetAccelerationStructureHandleNV,
10648 pub cmd_write_acceleration_structures_properties_nv:
10649 PFN_vkCmdWriteAccelerationStructuresPropertiesNV,
10650 pub compile_deferred_nv: PFN_vkCompileDeferredNV,
10651}
10652unsafe impl Send for NvRayTracingFn {}
10653unsafe impl Sync for NvRayTracingFn {}
10654impl NvRayTracingFn {
10655 pub fn load<F>(mut _f: F) -> Self
10656 where
10657 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10658 {
10659 Self {
10660 create_acceleration_structure_nv: unsafe {
10661 unsafe extern "system" fn create_acceleration_structure_nv(
10662 _device: Device,
10663 _p_create_info: *const AccelerationStructureCreateInfoNV,
10664 _p_allocator: *const AllocationCallbacks,
10665 _p_acceleration_structure: *mut AccelerationStructureNV,
10666 ) -> Result {
10667 panic!(concat!(
10668 "Unable to load ",
10669 stringify!(create_acceleration_structure_nv)
10670 ))
10671 }
10672 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10673 b"vkCreateAccelerationStructureNV\0",
10674 );
10675 let val = _f(cname);
10676 if val.is_null() {
10677 create_acceleration_structure_nv
10678 } else {
10679 ::std::mem::transmute(val)
10680 }
10681 },
10682 destroy_acceleration_structure_nv: unsafe {
10683 unsafe extern "system" fn destroy_acceleration_structure_nv(
10684 _device: Device,
10685 _acceleration_structure: AccelerationStructureNV,
10686 _p_allocator: *const AllocationCallbacks,
10687 ) {
10688 panic!(concat!(
10689 "Unable to load ",
10690 stringify!(destroy_acceleration_structure_nv)
10691 ))
10692 }
10693 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10694 b"vkDestroyAccelerationStructureNV\0",
10695 );
10696 let val = _f(cname);
10697 if val.is_null() {
10698 destroy_acceleration_structure_nv
10699 } else {
10700 ::std::mem::transmute(val)
10701 }
10702 },
10703 get_acceleration_structure_memory_requirements_nv: unsafe {
10704 unsafe extern "system" fn get_acceleration_structure_memory_requirements_nv(
10705 _device: Device,
10706 _p_info: *const AccelerationStructureMemoryRequirementsInfoNV,
10707 _p_memory_requirements: *mut MemoryRequirements2KHR,
10708 ) {
10709 panic!(concat!(
10710 "Unable to load ",
10711 stringify!(get_acceleration_structure_memory_requirements_nv)
10712 ))
10713 }
10714 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10715 b"vkGetAccelerationStructureMemoryRequirementsNV\0",
10716 );
10717 let val = _f(cname);
10718 if val.is_null() {
10719 get_acceleration_structure_memory_requirements_nv
10720 } else {
10721 ::std::mem::transmute(val)
10722 }
10723 },
10724 bind_acceleration_structure_memory_nv: unsafe {
10725 unsafe extern "system" fn bind_acceleration_structure_memory_nv(
10726 _device: Device,
10727 _bind_info_count: u32,
10728 _p_bind_infos: *const BindAccelerationStructureMemoryInfoNV,
10729 ) -> Result {
10730 panic!(concat!(
10731 "Unable to load ",
10732 stringify!(bind_acceleration_structure_memory_nv)
10733 ))
10734 }
10735 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10736 b"vkBindAccelerationStructureMemoryNV\0",
10737 );
10738 let val = _f(cname);
10739 if val.is_null() {
10740 bind_acceleration_structure_memory_nv
10741 } else {
10742 ::std::mem::transmute(val)
10743 }
10744 },
10745 cmd_build_acceleration_structure_nv: unsafe {
10746 unsafe extern "system" fn cmd_build_acceleration_structure_nv(
10747 _command_buffer: CommandBuffer,
10748 _p_info: *const AccelerationStructureInfoNV,
10749 _instance_data: Buffer,
10750 _instance_offset: DeviceSize,
10751 _update: Bool32,
10752 _dst: AccelerationStructureNV,
10753 _src: AccelerationStructureNV,
10754 _scratch: Buffer,
10755 _scratch_offset: DeviceSize,
10756 ) {
10757 panic!(concat!(
10758 "Unable to load ",
10759 stringify!(cmd_build_acceleration_structure_nv)
10760 ))
10761 }
10762 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10763 b"vkCmdBuildAccelerationStructureNV\0",
10764 );
10765 let val = _f(cname);
10766 if val.is_null() {
10767 cmd_build_acceleration_structure_nv
10768 } else {
10769 ::std::mem::transmute(val)
10770 }
10771 },
10772 cmd_copy_acceleration_structure_nv: unsafe {
10773 unsafe extern "system" fn cmd_copy_acceleration_structure_nv(
10774 _command_buffer: CommandBuffer,
10775 _dst: AccelerationStructureNV,
10776 _src: AccelerationStructureNV,
10777 _mode: CopyAccelerationStructureModeKHR,
10778 ) {
10779 panic!(concat!(
10780 "Unable to load ",
10781 stringify!(cmd_copy_acceleration_structure_nv)
10782 ))
10783 }
10784 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10785 b"vkCmdCopyAccelerationStructureNV\0",
10786 );
10787 let val = _f(cname);
10788 if val.is_null() {
10789 cmd_copy_acceleration_structure_nv
10790 } else {
10791 ::std::mem::transmute(val)
10792 }
10793 },
10794 cmd_trace_rays_nv: unsafe {
10795 unsafe extern "system" fn cmd_trace_rays_nv(
10796 _command_buffer: CommandBuffer,
10797 _raygen_shader_binding_table_buffer: Buffer,
10798 _raygen_shader_binding_offset: DeviceSize,
10799 _miss_shader_binding_table_buffer: Buffer,
10800 _miss_shader_binding_offset: DeviceSize,
10801 _miss_shader_binding_stride: DeviceSize,
10802 _hit_shader_binding_table_buffer: Buffer,
10803 _hit_shader_binding_offset: DeviceSize,
10804 _hit_shader_binding_stride: DeviceSize,
10805 _callable_shader_binding_table_buffer: Buffer,
10806 _callable_shader_binding_offset: DeviceSize,
10807 _callable_shader_binding_stride: DeviceSize,
10808 _width: u32,
10809 _height: u32,
10810 _depth: u32,
10811 ) {
10812 panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_nv)))
10813 }
10814 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysNV\0");
10815 let val = _f(cname);
10816 if val.is_null() {
10817 cmd_trace_rays_nv
10818 } else {
10819 ::std::mem::transmute(val)
10820 }
10821 },
10822 create_ray_tracing_pipelines_nv: unsafe {
10823 unsafe extern "system" fn create_ray_tracing_pipelines_nv(
10824 _device: Device,
10825 _pipeline_cache: PipelineCache,
10826 _create_info_count: u32,
10827 _p_create_infos: *const RayTracingPipelineCreateInfoNV,
10828 _p_allocator: *const AllocationCallbacks,
10829 _p_pipelines: *mut Pipeline,
10830 ) -> Result {
10831 panic!(concat!(
10832 "Unable to load ",
10833 stringify!(create_ray_tracing_pipelines_nv)
10834 ))
10835 }
10836 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10837 b"vkCreateRayTracingPipelinesNV\0",
10838 );
10839 let val = _f(cname);
10840 if val.is_null() {
10841 create_ray_tracing_pipelines_nv
10842 } else {
10843 ::std::mem::transmute(val)
10844 }
10845 },
10846 get_ray_tracing_shader_group_handles_nv: unsafe {
10847 unsafe extern "system" fn get_ray_tracing_shader_group_handles_nv(
10848 _device: Device,
10849 _pipeline: Pipeline,
10850 _first_group: u32,
10851 _group_count: u32,
10852 _data_size: usize,
10853 _p_data: *mut c_void,
10854 ) -> Result {
10855 panic!(concat!(
10856 "Unable to load ",
10857 stringify!(get_ray_tracing_shader_group_handles_nv)
10858 ))
10859 }
10860 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10861 b"vkGetRayTracingShaderGroupHandlesNV\0",
10862 );
10863 let val = _f(cname);
10864 if val.is_null() {
10865 get_ray_tracing_shader_group_handles_nv
10866 } else {
10867 ::std::mem::transmute(val)
10868 }
10869 },
10870 get_acceleration_structure_handle_nv: unsafe {
10871 unsafe extern "system" fn get_acceleration_structure_handle_nv(
10872 _device: Device,
10873 _acceleration_structure: AccelerationStructureNV,
10874 _data_size: usize,
10875 _p_data: *mut c_void,
10876 ) -> Result {
10877 panic!(concat!(
10878 "Unable to load ",
10879 stringify!(get_acceleration_structure_handle_nv)
10880 ))
10881 }
10882 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10883 b"vkGetAccelerationStructureHandleNV\0",
10884 );
10885 let val = _f(cname);
10886 if val.is_null() {
10887 get_acceleration_structure_handle_nv
10888 } else {
10889 ::std::mem::transmute(val)
10890 }
10891 },
10892 cmd_write_acceleration_structures_properties_nv: unsafe {
10893 unsafe extern "system" fn cmd_write_acceleration_structures_properties_nv(
10894 _command_buffer: CommandBuffer,
10895 _acceleration_structure_count: u32,
10896 _p_acceleration_structures: *const AccelerationStructureNV,
10897 _query_type: QueryType,
10898 _query_pool: QueryPool,
10899 _first_query: u32,
10900 ) {
10901 panic!(concat!(
10902 "Unable to load ",
10903 stringify!(cmd_write_acceleration_structures_properties_nv)
10904 ))
10905 }
10906 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10907 b"vkCmdWriteAccelerationStructuresPropertiesNV\0",
10908 );
10909 let val = _f(cname);
10910 if val.is_null() {
10911 cmd_write_acceleration_structures_properties_nv
10912 } else {
10913 ::std::mem::transmute(val)
10914 }
10915 },
10916 compile_deferred_nv: unsafe {
10917 unsafe extern "system" fn compile_deferred_nv(
10918 _device: Device,
10919 _pipeline: Pipeline,
10920 _shader: u32,
10921 ) -> Result {
10922 panic!(concat!("Unable to load ", stringify!(compile_deferred_nv)))
10923 }
10924 let cname =
10925 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCompileDeferredNV\0");
10926 let val = _f(cname);
10927 if val.is_null() {
10928 compile_deferred_nv
10929 } else {
10930 ::std::mem::transmute(val)
10931 }
10932 },
10933 }
10934 }
10935}
10936#[doc = "Generated from 'VK_NV_ray_tracing'"]
10937impl AccelerationStructureTypeKHR {
10938 pub const TOP_LEVEL_NV: Self = Self::TOP_LEVEL;
10939 pub const BOTTOM_LEVEL_NV: Self = Self::BOTTOM_LEVEL;
10940}
10941#[doc = "Generated from 'VK_NV_ray_tracing'"]
10942impl AccessFlags {
10943 pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR;
10944 pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR;
10945}
10946#[doc = "Generated from 'VK_NV_ray_tracing'"]
10947impl BufferUsageFlags {
10948 pub const RAY_TRACING_NV: Self = Self::SHADER_BINDING_TABLE_KHR;
10949}
10950#[doc = "Generated from 'VK_NV_ray_tracing'"]
10951impl BuildAccelerationStructureFlagsKHR {
10952 pub const ALLOW_UPDATE_NV: Self = Self::ALLOW_UPDATE;
10953 pub const ALLOW_COMPACTION_NV: Self = Self::ALLOW_COMPACTION;
10954 pub const PREFER_FAST_TRACE_NV: Self = Self::PREFER_FAST_TRACE;
10955 pub const PREFER_FAST_BUILD_NV: Self = Self::PREFER_FAST_BUILD;
10956 pub const LOW_MEMORY_NV: Self = Self::LOW_MEMORY;
10957}
10958#[doc = "Generated from 'VK_NV_ray_tracing'"]
10959impl CopyAccelerationStructureModeKHR {
10960 pub const CLONE_NV: Self = Self::CLONE;
10961 pub const COMPACT_NV: Self = Self::COMPACT;
10962}
10963#[doc = "Generated from 'VK_NV_ray_tracing'"]
10964impl DebugReportObjectTypeEXT {
10965 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
10966}
10967#[doc = "Generated from 'VK_NV_ray_tracing'"]
10968impl DescriptorType {
10969 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
10970}
10971#[doc = "Generated from 'VK_NV_ray_tracing'"]
10972impl GeometryFlagsKHR {
10973 pub const OPAQUE_NV: Self = Self::OPAQUE;
10974 pub const NO_DUPLICATE_ANY_HIT_INVOCATION_NV: Self = Self::NO_DUPLICATE_ANY_HIT_INVOCATION;
10975}
10976#[doc = "Generated from 'VK_NV_ray_tracing'"]
10977impl GeometryInstanceFlagsKHR {
10978 pub const TRIANGLE_CULL_DISABLE_NV: Self = Self::TRIANGLE_FACING_CULL_DISABLE;
10979 pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = Self::TRIANGLE_FRONT_COUNTERCLOCKWISE;
10980 pub const FORCE_OPAQUE_NV: Self = Self::FORCE_OPAQUE;
10981 pub const FORCE_NO_OPAQUE_NV: Self = Self::FORCE_NO_OPAQUE;
10982}
10983#[doc = "Generated from 'VK_NV_ray_tracing'"]
10984impl GeometryTypeKHR {
10985 pub const TRIANGLES_NV: Self = Self::TRIANGLES;
10986 pub const AABBS_NV: Self = Self::AABBS;
10987}
10988#[doc = "Generated from 'VK_NV_ray_tracing'"]
10989impl IndexType {
10990 pub const NONE_NV: Self = Self::NONE_KHR;
10991}
10992#[doc = "Generated from 'VK_NV_ray_tracing'"]
10993impl ObjectType {
10994 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
10995}
10996#[doc = "Generated from 'VK_NV_ray_tracing'"]
10997impl PipelineBindPoint {
10998 pub const RAY_TRACING_NV: Self = Self::RAY_TRACING_KHR;
10999}
11000#[doc = "Generated from 'VK_NV_ray_tracing'"]
11001impl PipelineCreateFlags {
11002 pub const DEFER_COMPILE_NV: Self = Self(0b10_0000);
11003}
11004#[doc = "Generated from 'VK_NV_ray_tracing'"]
11005impl PipelineStageFlags {
11006 pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR;
11007 pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR;
11008}
11009#[doc = "Generated from 'VK_NV_ray_tracing'"]
11010impl QueryType {
11011 pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1_000_165_000);
11012}
11013#[doc = "Generated from 'VK_NV_ray_tracing'"]
11014impl RayTracingShaderGroupTypeKHR {
11015 pub const GENERAL_NV: Self = Self::GENERAL;
11016 pub const TRIANGLES_HIT_GROUP_NV: Self = Self::TRIANGLES_HIT_GROUP;
11017 pub const PROCEDURAL_HIT_GROUP_NV: Self = Self::PROCEDURAL_HIT_GROUP;
11018}
11019#[doc = "Generated from 'VK_NV_ray_tracing'"]
11020impl ShaderStageFlags {
11021 pub const RAYGEN_NV: Self = Self::RAYGEN_KHR;
11022 pub const ANY_HIT_NV: Self = Self::ANY_HIT_KHR;
11023 pub const CLOSEST_HIT_NV: Self = Self::CLOSEST_HIT_KHR;
11024 pub const MISS_NV: Self = Self::MISS_KHR;
11025 pub const INTERSECTION_NV: Self = Self::INTERSECTION_KHR;
11026 pub const CALLABLE_NV: Self = Self::CALLABLE_KHR;
11027}
11028#[doc = "Generated from 'VK_NV_ray_tracing'"]
11029impl StructureType {
11030 pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000);
11031 pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001);
11032 pub const GEOMETRY_NV: Self = Self(1_000_165_003);
11033 pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004);
11034 pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005);
11035 pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1_000_165_006);
11036 pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_007);
11037 pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008);
11038 pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009);
11039 pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011);
11040 pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012);
11041}
11042impl NvRepresentativeFragmentTestFn {
11043 #[inline]
11044 pub const fn name() -> &'static ::std::ffi::CStr {
11045 unsafe {
11046 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_representative_fragment_test\0")
11047 }
11048 }
11049 pub const SPEC_VERSION: u32 = 2u32;
11050}
11051#[derive(Clone)]
11052pub struct NvRepresentativeFragmentTestFn {}
11053unsafe impl Send for NvRepresentativeFragmentTestFn {}
11054unsafe impl Sync for NvRepresentativeFragmentTestFn {}
11055impl NvRepresentativeFragmentTestFn {
11056 pub fn load<F>(mut _f: F) -> Self
11057 where
11058 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11059 {
11060 Self {}
11061 }
11062}
11063#[doc = "Generated from 'VK_NV_representative_fragment_test'"]
11064impl StructureType {
11065 pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1_000_166_000);
11066 pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self =
11067 Self(1_000_166_001);
11068}
11069impl NvExtension168Fn {
11070 #[inline]
11071 pub const fn name() -> &'static ::std::ffi::CStr {
11072 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_168\0") }
11073 }
11074 pub const SPEC_VERSION: u32 = 0u32;
11075}
11076#[derive(Clone)]
11077pub struct NvExtension168Fn {}
11078unsafe impl Send for NvExtension168Fn {}
11079unsafe impl Sync for NvExtension168Fn {}
11080impl NvExtension168Fn {
11081 pub fn load<F>(mut _f: F) -> Self
11082 where
11083 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11084 {
11085 Self {}
11086 }
11087}
11088impl KhrMaintenance3Fn {
11089 #[inline]
11090 pub const fn name() -> &'static ::std::ffi::CStr {
11091 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance3\0") }
11092 }
11093 pub const SPEC_VERSION: u32 = 1u32;
11094}
11095#[allow(non_camel_case_types)]
11096pub type PFN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn(
11097 device: Device,
11098 p_create_info: *const DescriptorSetLayoutCreateInfo,
11099 p_support: *mut DescriptorSetLayoutSupport,
11100);
11101#[derive(Clone)]
11102pub struct KhrMaintenance3Fn {
11103 pub get_descriptor_set_layout_support_khr: PFN_vkGetDescriptorSetLayoutSupport,
11104}
11105unsafe impl Send for KhrMaintenance3Fn {}
11106unsafe impl Sync for KhrMaintenance3Fn {}
11107impl KhrMaintenance3Fn {
11108 pub fn load<F>(mut _f: F) -> Self
11109 where
11110 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11111 {
11112 Self {
11113 get_descriptor_set_layout_support_khr: unsafe {
11114 unsafe extern "system" fn get_descriptor_set_layout_support_khr(
11115 _device: Device,
11116 _p_create_info: *const DescriptorSetLayoutCreateInfo,
11117 _p_support: *mut DescriptorSetLayoutSupport,
11118 ) {
11119 panic!(concat!(
11120 "Unable to load ",
11121 stringify!(get_descriptor_set_layout_support_khr)
11122 ))
11123 }
11124 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11125 b"vkGetDescriptorSetLayoutSupportKHR\0",
11126 );
11127 let val = _f(cname);
11128 if val.is_null() {
11129 get_descriptor_set_layout_support_khr
11130 } else {
11131 ::std::mem::transmute(val)
11132 }
11133 },
11134 }
11135 }
11136}
11137#[doc = "Generated from 'VK_KHR_maintenance3'"]
11138impl StructureType {
11139 pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self =
11140 Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
11141 pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = Self::DESCRIPTOR_SET_LAYOUT_SUPPORT;
11142}
11143impl KhrDrawIndirectCountFn {
11144 #[inline]
11145 pub const fn name() -> &'static ::std::ffi::CStr {
11146 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_draw_indirect_count\0") }
11147 }
11148 pub const SPEC_VERSION: u32 = 1u32;
11149}
11150#[derive(Clone)]
11151pub struct KhrDrawIndirectCountFn {
11152 pub cmd_draw_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndirectCount,
11153 pub cmd_draw_indexed_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndexedIndirectCount,
11154}
11155unsafe impl Send for KhrDrawIndirectCountFn {}
11156unsafe impl Sync for KhrDrawIndirectCountFn {}
11157impl KhrDrawIndirectCountFn {
11158 pub fn load<F>(mut _f: F) -> Self
11159 where
11160 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11161 {
11162 Self {
11163 cmd_draw_indirect_count_khr: unsafe {
11164 unsafe extern "system" fn cmd_draw_indirect_count_khr(
11165 _command_buffer: CommandBuffer,
11166 _buffer: Buffer,
11167 _offset: DeviceSize,
11168 _count_buffer: Buffer,
11169 _count_buffer_offset: DeviceSize,
11170 _max_draw_count: u32,
11171 _stride: u32,
11172 ) {
11173 panic!(concat!(
11174 "Unable to load ",
11175 stringify!(cmd_draw_indirect_count_khr)
11176 ))
11177 }
11178 let cname =
11179 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountKHR\0");
11180 let val = _f(cname);
11181 if val.is_null() {
11182 cmd_draw_indirect_count_khr
11183 } else {
11184 ::std::mem::transmute(val)
11185 }
11186 },
11187 cmd_draw_indexed_indirect_count_khr: unsafe {
11188 unsafe extern "system" fn cmd_draw_indexed_indirect_count_khr(
11189 _command_buffer: CommandBuffer,
11190 _buffer: Buffer,
11191 _offset: DeviceSize,
11192 _count_buffer: Buffer,
11193 _count_buffer_offset: DeviceSize,
11194 _max_draw_count: u32,
11195 _stride: u32,
11196 ) {
11197 panic!(concat!(
11198 "Unable to load ",
11199 stringify!(cmd_draw_indexed_indirect_count_khr)
11200 ))
11201 }
11202 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11203 b"vkCmdDrawIndexedIndirectCountKHR\0",
11204 );
11205 let val = _f(cname);
11206 if val.is_null() {
11207 cmd_draw_indexed_indirect_count_khr
11208 } else {
11209 ::std::mem::transmute(val)
11210 }
11211 },
11212 }
11213 }
11214}
11215impl ExtFilterCubicFn {
11216 #[inline]
11217 pub const fn name() -> &'static ::std::ffi::CStr {
11218 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_filter_cubic\0") }
11219 }
11220 pub const SPEC_VERSION: u32 = 3u32;
11221}
11222#[derive(Clone)]
11223pub struct ExtFilterCubicFn {}
11224unsafe impl Send for ExtFilterCubicFn {}
11225unsafe impl Sync for ExtFilterCubicFn {}
11226impl ExtFilterCubicFn {
11227 pub fn load<F>(mut _f: F) -> Self
11228 where
11229 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11230 {
11231 Self {}
11232 }
11233}
11234#[doc = "Generated from 'VK_EXT_filter_cubic'"]
11235impl Filter {
11236 pub const CUBIC_EXT: Self = Self(1_000_015_000);
11237}
11238#[doc = "Generated from 'VK_EXT_filter_cubic'"]
11239impl FormatFeatureFlags {
11240 pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self(0b10_0000_0000_0000);
11241}
11242#[doc = "Generated from 'VK_EXT_filter_cubic'"]
11243impl StructureType {
11244 pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1_000_170_000);
11245 pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1_000_170_001);
11246}
11247impl QcomRenderPassShaderResolveFn {
11248 #[inline]
11249 pub const fn name() -> &'static ::std::ffi::CStr {
11250 unsafe {
11251 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_shader_resolve\0")
11252 }
11253 }
11254 pub const SPEC_VERSION: u32 = 4u32;
11255}
11256#[derive(Clone)]
11257pub struct QcomRenderPassShaderResolveFn {}
11258unsafe impl Send for QcomRenderPassShaderResolveFn {}
11259unsafe impl Sync for QcomRenderPassShaderResolveFn {}
11260impl QcomRenderPassShaderResolveFn {
11261 pub fn load<F>(mut _f: F) -> Self
11262 where
11263 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11264 {
11265 Self {}
11266 }
11267}
11268#[doc = "Generated from 'VK_QCOM_render_pass_shader_resolve'"]
11269impl SubpassDescriptionFlags {
11270 pub const FRAGMENT_REGION_QCOM: Self = Self(0b100);
11271 pub const SHADER_RESOLVE_QCOM: Self = Self(0b1000);
11272}
11273impl QcomExtension173Fn {
11274 #[inline]
11275 pub const fn name() -> &'static ::std::ffi::CStr {
11276 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_173\0") }
11277 }
11278 pub const SPEC_VERSION: u32 = 0u32;
11279}
11280#[derive(Clone)]
11281pub struct QcomExtension173Fn {}
11282unsafe impl Send for QcomExtension173Fn {}
11283unsafe impl Sync for QcomExtension173Fn {}
11284impl QcomExtension173Fn {
11285 pub fn load<F>(mut _f: F) -> Self
11286 where
11287 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11288 {
11289 Self {}
11290 }
11291}
11292#[doc = "Generated from 'VK_QCOM_extension_173'"]
11293impl BufferUsageFlags {
11294 pub const RESERVED_18_QCOM: Self = Self(0b100_0000_0000_0000_0000);
11295}
11296#[doc = "Generated from 'VK_QCOM_extension_173'"]
11297impl ImageUsageFlags {
11298 pub const RESERVED_16_QCOM: Self = Self(0b1_0000_0000_0000_0000);
11299 pub const RESERVED_17_QCOM: Self = Self(0b10_0000_0000_0000_0000);
11300}
11301impl QcomExtension174Fn {
11302 #[inline]
11303 pub const fn name() -> &'static ::std::ffi::CStr {
11304 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_174\0") }
11305 }
11306 pub const SPEC_VERSION: u32 = 0u32;
11307}
11308#[derive(Clone)]
11309pub struct QcomExtension174Fn {}
11310unsafe impl Send for QcomExtension174Fn {}
11311unsafe impl Sync for QcomExtension174Fn {}
11312impl QcomExtension174Fn {
11313 pub fn load<F>(mut _f: F) -> Self
11314 where
11315 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11316 {
11317 Self {}
11318 }
11319}
11320impl ExtGlobalPriorityFn {
11321 #[inline]
11322 pub const fn name() -> &'static ::std::ffi::CStr {
11323 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority\0") }
11324 }
11325 pub const SPEC_VERSION: u32 = 2u32;
11326}
11327#[derive(Clone)]
11328pub struct ExtGlobalPriorityFn {}
11329unsafe impl Send for ExtGlobalPriorityFn {}
11330unsafe impl Sync for ExtGlobalPriorityFn {}
11331impl ExtGlobalPriorityFn {
11332 pub fn load<F>(mut _f: F) -> Self
11333 where
11334 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11335 {
11336 Self {}
11337 }
11338}
11339#[doc = "Generated from 'VK_EXT_global_priority'"]
11340impl Result {
11341 pub const ERROR_NOT_PERMITTED_EXT: Self = Self::ERROR_NOT_PERMITTED_KHR;
11342}
11343#[doc = "Generated from 'VK_EXT_global_priority'"]
11344impl StructureType {
11345 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self =
11346 Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
11347}
11348impl KhrShaderSubgroupExtendedTypesFn {
11349 #[inline]
11350 pub const fn name() -> &'static ::std::ffi::CStr {
11351 unsafe {
11352 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11353 b"VK_KHR_shader_subgroup_extended_types\0",
11354 )
11355 }
11356 }
11357 pub const SPEC_VERSION: u32 = 1u32;
11358}
11359#[derive(Clone)]
11360pub struct KhrShaderSubgroupExtendedTypesFn {}
11361unsafe impl Send for KhrShaderSubgroupExtendedTypesFn {}
11362unsafe impl Sync for KhrShaderSubgroupExtendedTypesFn {}
11363impl KhrShaderSubgroupExtendedTypesFn {
11364 pub fn load<F>(mut _f: F) -> Self
11365 where
11366 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11367 {
11368 Self {}
11369 }
11370}
11371#[doc = "Generated from 'VK_KHR_shader_subgroup_extended_types'"]
11372impl StructureType {
11373 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: Self =
11374 Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
11375}
11376impl ExtExtension177Fn {
11377 #[inline]
11378 pub const fn name() -> &'static ::std::ffi::CStr {
11379 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_177\0") }
11380 }
11381 pub const SPEC_VERSION: u32 = 0u32;
11382}
11383#[derive(Clone)]
11384pub struct ExtExtension177Fn {}
11385unsafe impl Send for ExtExtension177Fn {}
11386unsafe impl Sync for ExtExtension177Fn {}
11387impl ExtExtension177Fn {
11388 pub fn load<F>(mut _f: F) -> Self
11389 where
11390 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11391 {
11392 Self {}
11393 }
11394}
11395impl Khr8bitStorageFn {
11396 #[inline]
11397 pub const fn name() -> &'static ::std::ffi::CStr {
11398 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_8bit_storage\0") }
11399 }
11400 pub const SPEC_VERSION: u32 = 1u32;
11401}
11402#[derive(Clone)]
11403pub struct Khr8bitStorageFn {}
11404unsafe impl Send for Khr8bitStorageFn {}
11405unsafe impl Sync for Khr8bitStorageFn {}
11406impl Khr8bitStorageFn {
11407 pub fn load<F>(mut _f: F) -> Self
11408 where
11409 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11410 {
11411 Self {}
11412 }
11413}
11414#[doc = "Generated from 'VK_KHR_8bit_storage'"]
11415impl StructureType {
11416 pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: Self =
11417 Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
11418}
11419impl ExtExternalMemoryHostFn {
11420 #[inline]
11421 pub const fn name() -> &'static ::std::ffi::CStr {
11422 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_host\0") }
11423 }
11424 pub const SPEC_VERSION: u32 = 1u32;
11425}
11426#[allow(non_camel_case_types)]
11427pub type PFN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn(
11428 device: Device,
11429 handle_type: ExternalMemoryHandleTypeFlags,
11430 p_host_pointer: *const c_void,
11431 p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT,
11432) -> Result;
11433#[derive(Clone)]
11434pub struct ExtExternalMemoryHostFn {
11435 pub get_memory_host_pointer_properties_ext: PFN_vkGetMemoryHostPointerPropertiesEXT,
11436}
11437unsafe impl Send for ExtExternalMemoryHostFn {}
11438unsafe impl Sync for ExtExternalMemoryHostFn {}
11439impl ExtExternalMemoryHostFn {
11440 pub fn load<F>(mut _f: F) -> Self
11441 where
11442 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11443 {
11444 Self {
11445 get_memory_host_pointer_properties_ext: unsafe {
11446 unsafe extern "system" fn get_memory_host_pointer_properties_ext(
11447 _device: Device,
11448 _handle_type: ExternalMemoryHandleTypeFlags,
11449 _p_host_pointer: *const c_void,
11450 _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT,
11451 ) -> Result {
11452 panic!(concat!(
11453 "Unable to load ",
11454 stringify!(get_memory_host_pointer_properties_ext)
11455 ))
11456 }
11457 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11458 b"vkGetMemoryHostPointerPropertiesEXT\0",
11459 );
11460 let val = _f(cname);
11461 if val.is_null() {
11462 get_memory_host_pointer_properties_ext
11463 } else {
11464 ::std::mem::transmute(val)
11465 }
11466 },
11467 }
11468 }
11469}
11470#[doc = "Generated from 'VK_EXT_external_memory_host'"]
11471impl ExternalMemoryHandleTypeFlags {
11472 pub const HOST_ALLOCATION_EXT: Self = Self(0b1000_0000);
11473 pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = Self(0b1_0000_0000);
11474}
11475#[doc = "Generated from 'VK_EXT_external_memory_host'"]
11476impl StructureType {
11477 pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000);
11478 pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1_000_178_001);
11479 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1_000_178_002);
11480}
11481impl AmdBufferMarkerFn {
11482 #[inline]
11483 pub const fn name() -> &'static ::std::ffi::CStr {
11484 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_buffer_marker\0") }
11485 }
11486 pub const SPEC_VERSION: u32 = 1u32;
11487}
11488#[allow(non_camel_case_types)]
11489pub type PFN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn(
11490 command_buffer: CommandBuffer,
11491 pipeline_stage: PipelineStageFlags,
11492 dst_buffer: Buffer,
11493 dst_offset: DeviceSize,
11494 marker: u32,
11495);
11496#[derive(Clone)]
11497pub struct AmdBufferMarkerFn {
11498 pub cmd_write_buffer_marker_amd: PFN_vkCmdWriteBufferMarkerAMD,
11499}
11500unsafe impl Send for AmdBufferMarkerFn {}
11501unsafe impl Sync for AmdBufferMarkerFn {}
11502impl AmdBufferMarkerFn {
11503 pub fn load<F>(mut _f: F) -> Self
11504 where
11505 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11506 {
11507 Self {
11508 cmd_write_buffer_marker_amd: unsafe {
11509 unsafe extern "system" fn cmd_write_buffer_marker_amd(
11510 _command_buffer: CommandBuffer,
11511 _pipeline_stage: PipelineStageFlags,
11512 _dst_buffer: Buffer,
11513 _dst_offset: DeviceSize,
11514 _marker: u32,
11515 ) {
11516 panic!(concat!(
11517 "Unable to load ",
11518 stringify!(cmd_write_buffer_marker_amd)
11519 ))
11520 }
11521 let cname =
11522 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarkerAMD\0");
11523 let val = _f(cname);
11524 if val.is_null() {
11525 cmd_write_buffer_marker_amd
11526 } else {
11527 ::std::mem::transmute(val)
11528 }
11529 },
11530 }
11531 }
11532}
11533impl KhrShaderAtomicInt64Fn {
11534 #[inline]
11535 pub const fn name() -> &'static ::std::ffi::CStr {
11536 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_atomic_int64\0") }
11537 }
11538 pub const SPEC_VERSION: u32 = 1u32;
11539}
11540#[derive(Clone)]
11541pub struct KhrShaderAtomicInt64Fn {}
11542unsafe impl Send for KhrShaderAtomicInt64Fn {}
11543unsafe impl Sync for KhrShaderAtomicInt64Fn {}
11544impl KhrShaderAtomicInt64Fn {
11545 pub fn load<F>(mut _f: F) -> Self
11546 where
11547 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11548 {
11549 Self {}
11550 }
11551}
11552#[doc = "Generated from 'VK_KHR_shader_atomic_int64'"]
11553impl StructureType {
11554 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: Self =
11555 Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
11556}
11557impl KhrShaderClockFn {
11558 #[inline]
11559 pub const fn name() -> &'static ::std::ffi::CStr {
11560 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_clock\0") }
11561 }
11562 pub const SPEC_VERSION: u32 = 1u32;
11563}
11564#[derive(Clone)]
11565pub struct KhrShaderClockFn {}
11566unsafe impl Send for KhrShaderClockFn {}
11567unsafe impl Sync for KhrShaderClockFn {}
11568impl KhrShaderClockFn {
11569 pub fn load<F>(mut _f: F) -> Self
11570 where
11571 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11572 {
11573 Self {}
11574 }
11575}
11576#[doc = "Generated from 'VK_KHR_shader_clock'"]
11577impl StructureType {
11578 pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1_000_181_000);
11579}
11580impl AmdExtension183Fn {
11581 #[inline]
11582 pub const fn name() -> &'static ::std::ffi::CStr {
11583 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_183\0") }
11584 }
11585 pub const SPEC_VERSION: u32 = 0u32;
11586}
11587#[derive(Clone)]
11588pub struct AmdExtension183Fn {}
11589unsafe impl Send for AmdExtension183Fn {}
11590unsafe impl Sync for AmdExtension183Fn {}
11591impl AmdExtension183Fn {
11592 pub fn load<F>(mut _f: F) -> Self
11593 where
11594 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11595 {
11596 Self {}
11597 }
11598}
11599impl AmdPipelineCompilerControlFn {
11600 #[inline]
11601 pub const fn name() -> &'static ::std::ffi::CStr {
11602 unsafe {
11603 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_pipeline_compiler_control\0")
11604 }
11605 }
11606 pub const SPEC_VERSION: u32 = 1u32;
11607}
11608#[derive(Clone)]
11609pub struct AmdPipelineCompilerControlFn {}
11610unsafe impl Send for AmdPipelineCompilerControlFn {}
11611unsafe impl Sync for AmdPipelineCompilerControlFn {}
11612impl AmdPipelineCompilerControlFn {
11613 pub fn load<F>(mut _f: F) -> Self
11614 where
11615 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11616 {
11617 Self {}
11618 }
11619}
11620#[doc = "Generated from 'VK_AMD_pipeline_compiler_control'"]
11621impl StructureType {
11622 pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1_000_183_000);
11623}
11624impl ExtCalibratedTimestampsFn {
11625 #[inline]
11626 pub const fn name() -> &'static ::std::ffi::CStr {
11627 unsafe {
11628 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_calibrated_timestamps\0")
11629 }
11630 }
11631 pub const SPEC_VERSION: u32 = 2u32;
11632}
11633#[allow(non_camel_case_types)]
11634pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn(
11635 physical_device: PhysicalDevice,
11636 p_time_domain_count: *mut u32,
11637 p_time_domains: *mut TimeDomainEXT,
11638) -> Result;
11639#[allow(non_camel_case_types)]
11640pub type PFN_vkGetCalibratedTimestampsEXT = unsafe extern "system" fn(
11641 device: Device,
11642 timestamp_count: u32,
11643 p_timestamp_infos: *const CalibratedTimestampInfoEXT,
11644 p_timestamps: *mut u64,
11645 p_max_deviation: *mut u64,
11646) -> Result;
11647#[derive(Clone)]
11648pub struct ExtCalibratedTimestampsFn {
11649 pub get_physical_device_calibrateable_time_domains_ext:
11650 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
11651 pub get_calibrated_timestamps_ext: PFN_vkGetCalibratedTimestampsEXT,
11652}
11653unsafe impl Send for ExtCalibratedTimestampsFn {}
11654unsafe impl Sync for ExtCalibratedTimestampsFn {}
11655impl ExtCalibratedTimestampsFn {
11656 pub fn load<F>(mut _f: F) -> Self
11657 where
11658 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11659 {
11660 Self {
11661 get_physical_device_calibrateable_time_domains_ext: unsafe {
11662 unsafe extern "system" fn get_physical_device_calibrateable_time_domains_ext(
11663 _physical_device: PhysicalDevice,
11664 _p_time_domain_count: *mut u32,
11665 _p_time_domains: *mut TimeDomainEXT,
11666 ) -> Result {
11667 panic!(concat!(
11668 "Unable to load ",
11669 stringify!(get_physical_device_calibrateable_time_domains_ext)
11670 ))
11671 }
11672 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11673 b"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\0",
11674 );
11675 let val = _f(cname);
11676 if val.is_null() {
11677 get_physical_device_calibrateable_time_domains_ext
11678 } else {
11679 ::std::mem::transmute(val)
11680 }
11681 },
11682 get_calibrated_timestamps_ext: unsafe {
11683 unsafe extern "system" fn get_calibrated_timestamps_ext(
11684 _device: Device,
11685 _timestamp_count: u32,
11686 _p_timestamp_infos: *const CalibratedTimestampInfoEXT,
11687 _p_timestamps: *mut u64,
11688 _p_max_deviation: *mut u64,
11689 ) -> Result {
11690 panic!(concat!(
11691 "Unable to load ",
11692 stringify!(get_calibrated_timestamps_ext)
11693 ))
11694 }
11695 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11696 b"vkGetCalibratedTimestampsEXT\0",
11697 );
11698 let val = _f(cname);
11699 if val.is_null() {
11700 get_calibrated_timestamps_ext
11701 } else {
11702 ::std::mem::transmute(val)
11703 }
11704 },
11705 }
11706 }
11707}
11708#[doc = "Generated from 'VK_EXT_calibrated_timestamps'"]
11709impl StructureType {
11710 pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1_000_184_000);
11711}
11712impl AmdShaderCorePropertiesFn {
11713 #[inline]
11714 pub const fn name() -> &'static ::std::ffi::CStr {
11715 unsafe {
11716 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties\0")
11717 }
11718 }
11719 pub const SPEC_VERSION: u32 = 2u32;
11720}
11721#[derive(Clone)]
11722pub struct AmdShaderCorePropertiesFn {}
11723unsafe impl Send for AmdShaderCorePropertiesFn {}
11724unsafe impl Sync for AmdShaderCorePropertiesFn {}
11725impl AmdShaderCorePropertiesFn {
11726 pub fn load<F>(mut _f: F) -> Self
11727 where
11728 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11729 {
11730 Self {}
11731 }
11732}
11733#[doc = "Generated from 'VK_AMD_shader_core_properties'"]
11734impl StructureType {
11735 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000);
11736}
11737impl AmdExtension187Fn {
11738 #[inline]
11739 pub const fn name() -> &'static ::std::ffi::CStr {
11740 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_187\0") }
11741 }
11742 pub const SPEC_VERSION: u32 = 0u32;
11743}
11744#[derive(Clone)]
11745pub struct AmdExtension187Fn {}
11746unsafe impl Send for AmdExtension187Fn {}
11747unsafe impl Sync for AmdExtension187Fn {}
11748impl AmdExtension187Fn {
11749 pub fn load<F>(mut _f: F) -> Self
11750 where
11751 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11752 {
11753 Self {}
11754 }
11755}
11756impl KhrVideoDecodeH265Fn {
11757 #[inline]
11758 pub const fn name() -> &'static ::std::ffi::CStr {
11759 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_h265\0") }
11760 }
11761 pub const SPEC_VERSION: u32 = 7u32;
11762}
11763#[derive(Clone)]
11764pub struct KhrVideoDecodeH265Fn {}
11765unsafe impl Send for KhrVideoDecodeH265Fn {}
11766unsafe impl Sync for KhrVideoDecodeH265Fn {}
11767impl KhrVideoDecodeH265Fn {
11768 pub fn load<F>(mut _f: F) -> Self
11769 where
11770 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11771 {
11772 Self {}
11773 }
11774}
11775#[doc = "Generated from 'VK_KHR_video_decode_h265'"]
11776impl StructureType {
11777 pub const VIDEO_DECODE_H265_CAPABILITIES_KHR: Self = Self(1_000_187_000);
11778 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_187_001);
11779 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: Self = Self(1_000_187_002);
11780 pub const VIDEO_DECODE_H265_PROFILE_INFO_KHR: Self = Self(1_000_187_003);
11781 pub const VIDEO_DECODE_H265_PICTURE_INFO_KHR: Self = Self(1_000_187_004);
11782 pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: Self = Self(1_000_187_005);
11783}
11784#[doc = "Generated from 'VK_KHR_video_decode_h265'"]
11785impl VideoCodecOperationFlagsKHR {
11786 pub const DECODE_H265: Self = Self(0b10);
11787}
11788impl KhrGlobalPriorityFn {
11789 #[inline]
11790 pub const fn name() -> &'static ::std::ffi::CStr {
11791 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_global_priority\0") }
11792 }
11793 pub const SPEC_VERSION: u32 = 1u32;
11794}
11795#[derive(Clone)]
11796pub struct KhrGlobalPriorityFn {}
11797unsafe impl Send for KhrGlobalPriorityFn {}
11798unsafe impl Sync for KhrGlobalPriorityFn {}
11799impl KhrGlobalPriorityFn {
11800 pub fn load<F>(mut _f: F) -> Self
11801 where
11802 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11803 {
11804 Self {}
11805 }
11806}
11807#[doc = "Generated from 'VK_KHR_global_priority'"]
11808impl Result {
11809 pub const ERROR_NOT_PERMITTED_KHR: Self = Self(-1_000_174_001);
11810}
11811#[doc = "Generated from 'VK_KHR_global_priority'"]
11812impl StructureType {
11813 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: Self = Self(1_000_174_000);
11814 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: Self = Self(1_000_388_000);
11815 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: Self = Self(1_000_388_001);
11816}
11817impl AmdMemoryOverallocationBehaviorFn {
11818 #[inline]
11819 pub const fn name() -> &'static ::std::ffi::CStr {
11820 unsafe {
11821 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11822 b"VK_AMD_memory_overallocation_behavior\0",
11823 )
11824 }
11825 }
11826 pub const SPEC_VERSION: u32 = 1u32;
11827}
11828#[derive(Clone)]
11829pub struct AmdMemoryOverallocationBehaviorFn {}
11830unsafe impl Send for AmdMemoryOverallocationBehaviorFn {}
11831unsafe impl Sync for AmdMemoryOverallocationBehaviorFn {}
11832impl AmdMemoryOverallocationBehaviorFn {
11833 pub fn load<F>(mut _f: F) -> Self
11834 where
11835 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11836 {
11837 Self {}
11838 }
11839}
11840#[doc = "Generated from 'VK_AMD_memory_overallocation_behavior'"]
11841impl StructureType {
11842 pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1_000_189_000);
11843}
11844impl ExtVertexAttributeDivisorFn {
11845 #[inline]
11846 pub const fn name() -> &'static ::std::ffi::CStr {
11847 unsafe {
11848 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_attribute_divisor\0")
11849 }
11850 }
11851 pub const SPEC_VERSION: u32 = 3u32;
11852}
11853#[derive(Clone)]
11854pub struct ExtVertexAttributeDivisorFn {}
11855unsafe impl Send for ExtVertexAttributeDivisorFn {}
11856unsafe impl Sync for ExtVertexAttributeDivisorFn {}
11857impl ExtVertexAttributeDivisorFn {
11858 pub fn load<F>(mut _f: F) -> Self
11859 where
11860 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11861 {
11862 Self {}
11863 }
11864}
11865#[doc = "Generated from 'VK_EXT_vertex_attribute_divisor'"]
11866impl StructureType {
11867 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1_000_190_000);
11868 pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1_000_190_001);
11869 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1_000_190_002);
11870}
11871impl GgpFrameTokenFn {
11872 #[inline]
11873 pub const fn name() -> &'static ::std::ffi::CStr {
11874 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_frame_token\0") }
11875 }
11876 pub const SPEC_VERSION: u32 = 1u32;
11877}
11878#[derive(Clone)]
11879pub struct GgpFrameTokenFn {}
11880unsafe impl Send for GgpFrameTokenFn {}
11881unsafe impl Sync for GgpFrameTokenFn {}
11882impl GgpFrameTokenFn {
11883 pub fn load<F>(mut _f: F) -> Self
11884 where
11885 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11886 {
11887 Self {}
11888 }
11889}
11890#[doc = "Generated from 'VK_GGP_frame_token'"]
11891impl StructureType {
11892 pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1_000_191_000);
11893}
11894impl ExtPipelineCreationFeedbackFn {
11895 #[inline]
11896 pub const fn name() -> &'static ::std::ffi::CStr {
11897 unsafe {
11898 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_creation_feedback\0")
11899 }
11900 }
11901 pub const SPEC_VERSION: u32 = 1u32;
11902}
11903#[derive(Clone)]
11904pub struct ExtPipelineCreationFeedbackFn {}
11905unsafe impl Send for ExtPipelineCreationFeedbackFn {}
11906unsafe impl Sync for ExtPipelineCreationFeedbackFn {}
11907impl ExtPipelineCreationFeedbackFn {
11908 pub fn load<F>(mut _f: F) -> Self
11909 where
11910 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11911 {
11912 Self {}
11913 }
11914}
11915#[doc = "Generated from 'VK_EXT_pipeline_creation_feedback'"]
11916impl StructureType {
11917 pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self =
11918 Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
11919}
11920impl GoogleExtension194Fn {
11921 #[inline]
11922 pub const fn name() -> &'static ::std::ffi::CStr {
11923 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_194\0") }
11924 }
11925 pub const SPEC_VERSION: u32 = 0u32;
11926}
11927#[derive(Clone)]
11928pub struct GoogleExtension194Fn {}
11929unsafe impl Send for GoogleExtension194Fn {}
11930unsafe impl Sync for GoogleExtension194Fn {}
11931impl GoogleExtension194Fn {
11932 pub fn load<F>(mut _f: F) -> Self
11933 where
11934 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11935 {
11936 Self {}
11937 }
11938}
11939impl GoogleExtension195Fn {
11940 #[inline]
11941 pub const fn name() -> &'static ::std::ffi::CStr {
11942 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_195\0") }
11943 }
11944 pub const SPEC_VERSION: u32 = 0u32;
11945}
11946#[derive(Clone)]
11947pub struct GoogleExtension195Fn {}
11948unsafe impl Send for GoogleExtension195Fn {}
11949unsafe impl Sync for GoogleExtension195Fn {}
11950impl GoogleExtension195Fn {
11951 pub fn load<F>(mut _f: F) -> Self
11952 where
11953 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11954 {
11955 Self {}
11956 }
11957}
11958impl KhrDriverPropertiesFn {
11959 #[inline]
11960 pub const fn name() -> &'static ::std::ffi::CStr {
11961 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_driver_properties\0") }
11962 }
11963 pub const SPEC_VERSION: u32 = 1u32;
11964}
11965#[derive(Clone)]
11966pub struct KhrDriverPropertiesFn {}
11967unsafe impl Send for KhrDriverPropertiesFn {}
11968unsafe impl Sync for KhrDriverPropertiesFn {}
11969impl KhrDriverPropertiesFn {
11970 pub fn load<F>(mut _f: F) -> Self
11971 where
11972 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11973 {
11974 Self {}
11975 }
11976}
11977#[doc = "Generated from 'VK_KHR_driver_properties'"]
11978impl DriverId {
11979 pub const AMD_PROPRIETARY_KHR: Self = Self::AMD_PROPRIETARY;
11980 pub const AMD_OPEN_SOURCE_KHR: Self = Self::AMD_OPEN_SOURCE;
11981 pub const MESA_RADV_KHR: Self = Self::MESA_RADV;
11982 pub const NVIDIA_PROPRIETARY_KHR: Self = Self::NVIDIA_PROPRIETARY;
11983 pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = Self::INTEL_PROPRIETARY_WINDOWS;
11984 pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = Self::INTEL_OPEN_SOURCE_MESA;
11985 pub const IMAGINATION_PROPRIETARY_KHR: Self = Self::IMAGINATION_PROPRIETARY;
11986 pub const QUALCOMM_PROPRIETARY_KHR: Self = Self::QUALCOMM_PROPRIETARY;
11987 pub const ARM_PROPRIETARY_KHR: Self = Self::ARM_PROPRIETARY;
11988 pub const GOOGLE_SWIFTSHADER_KHR: Self = Self::GOOGLE_SWIFTSHADER;
11989 pub const GGP_PROPRIETARY_KHR: Self = Self::GGP_PROPRIETARY;
11990 pub const BROADCOM_PROPRIETARY_KHR: Self = Self::BROADCOM_PROPRIETARY;
11991}
11992#[doc = "Generated from 'VK_KHR_driver_properties'"]
11993impl StructureType {
11994 pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES;
11995}
11996impl KhrShaderFloatControlsFn {
11997 #[inline]
11998 pub const fn name() -> &'static ::std::ffi::CStr {
11999 unsafe {
12000 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float_controls\0")
12001 }
12002 }
12003 pub const SPEC_VERSION: u32 = 4u32;
12004}
12005#[derive(Clone)]
12006pub struct KhrShaderFloatControlsFn {}
12007unsafe impl Send for KhrShaderFloatControlsFn {}
12008unsafe impl Sync for KhrShaderFloatControlsFn {}
12009impl KhrShaderFloatControlsFn {
12010 pub fn load<F>(mut _f: F) -> Self
12011 where
12012 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12013 {
12014 Self {}
12015 }
12016}
12017#[doc = "Generated from 'VK_KHR_shader_float_controls'"]
12018impl ShaderFloatControlsIndependence {
12019 pub const TYPE_32_ONLY_KHR: Self = Self::TYPE_32_ONLY;
12020 pub const ALL_KHR: Self = Self::ALL;
12021 pub const NONE_KHR: Self = Self::NONE;
12022}
12023#[doc = "Generated from 'VK_KHR_shader_float_controls'"]
12024impl StructureType {
12025 pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self =
12026 Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
12027}
12028impl NvShaderSubgroupPartitionedFn {
12029 #[inline]
12030 pub const fn name() -> &'static ::std::ffi::CStr {
12031 unsafe {
12032 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_subgroup_partitioned\0")
12033 }
12034 }
12035 pub const SPEC_VERSION: u32 = 1u32;
12036}
12037#[derive(Clone)]
12038pub struct NvShaderSubgroupPartitionedFn {}
12039unsafe impl Send for NvShaderSubgroupPartitionedFn {}
12040unsafe impl Sync for NvShaderSubgroupPartitionedFn {}
12041impl NvShaderSubgroupPartitionedFn {
12042 pub fn load<F>(mut _f: F) -> Self
12043 where
12044 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12045 {
12046 Self {}
12047 }
12048}
12049#[doc = "Generated from 'VK_NV_shader_subgroup_partitioned'"]
12050impl SubgroupFeatureFlags {
12051 pub const PARTITIONED_NV: Self = Self(0b1_0000_0000);
12052}
12053impl KhrDepthStencilResolveFn {
12054 #[inline]
12055 pub const fn name() -> &'static ::std::ffi::CStr {
12056 unsafe {
12057 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_depth_stencil_resolve\0")
12058 }
12059 }
12060 pub const SPEC_VERSION: u32 = 1u32;
12061}
12062#[derive(Clone)]
12063pub struct KhrDepthStencilResolveFn {}
12064unsafe impl Send for KhrDepthStencilResolveFn {}
12065unsafe impl Sync for KhrDepthStencilResolveFn {}
12066impl KhrDepthStencilResolveFn {
12067 pub fn load<F>(mut _f: F) -> Self
12068 where
12069 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12070 {
12071 Self {}
12072 }
12073}
12074#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
12075impl ResolveModeFlags {
12076 pub const NONE_KHR: Self = Self::NONE;
12077 pub const SAMPLE_ZERO_KHR: Self = Self::SAMPLE_ZERO;
12078 pub const AVERAGE_KHR: Self = Self::AVERAGE;
12079 pub const MIN_KHR: Self = Self::MIN;
12080 pub const MAX_KHR: Self = Self::MAX;
12081}
12082#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
12083impl StructureType {
12084 pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self =
12085 Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
12086 pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self =
12087 Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
12088}
12089impl KhrSwapchainMutableFormatFn {
12090 #[inline]
12091 pub const fn name() -> &'static ::std::ffi::CStr {
12092 unsafe {
12093 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain_mutable_format\0")
12094 }
12095 }
12096 pub const SPEC_VERSION: u32 = 1u32;
12097}
12098#[derive(Clone)]
12099pub struct KhrSwapchainMutableFormatFn {}
12100unsafe impl Send for KhrSwapchainMutableFormatFn {}
12101unsafe impl Sync for KhrSwapchainMutableFormatFn {}
12102impl KhrSwapchainMutableFormatFn {
12103 pub fn load<F>(mut _f: F) -> Self
12104 where
12105 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12106 {
12107 Self {}
12108 }
12109}
12110#[doc = "Generated from 'VK_KHR_swapchain_mutable_format'"]
12111impl SwapchainCreateFlagsKHR {
12112 pub const MUTABLE_FORMAT: Self = Self(0b100);
12113}
12114impl NvComputeShaderDerivativesFn {
12115 #[inline]
12116 pub const fn name() -> &'static ::std::ffi::CStr {
12117 unsafe {
12118 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_compute_shader_derivatives\0")
12119 }
12120 }
12121 pub const SPEC_VERSION: u32 = 1u32;
12122}
12123#[derive(Clone)]
12124pub struct NvComputeShaderDerivativesFn {}
12125unsafe impl Send for NvComputeShaderDerivativesFn {}
12126unsafe impl Sync for NvComputeShaderDerivativesFn {}
12127impl NvComputeShaderDerivativesFn {
12128 pub fn load<F>(mut _f: F) -> Self
12129 where
12130 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12131 {
12132 Self {}
12133 }
12134}
12135#[doc = "Generated from 'VK_NV_compute_shader_derivatives'"]
12136impl StructureType {
12137 pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1_000_201_000);
12138}
12139impl NvMeshShaderFn {
12140 #[inline]
12141 pub const fn name() -> &'static ::std::ffi::CStr {
12142 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_mesh_shader\0") }
12143 }
12144 pub const SPEC_VERSION: u32 = 1u32;
12145}
12146#[allow(non_camel_case_types)]
12147pub type PFN_vkCmdDrawMeshTasksNV =
12148 unsafe extern "system" fn(command_buffer: CommandBuffer, task_count: u32, first_task: u32);
12149#[allow(non_camel_case_types)]
12150pub type PFN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn(
12151 command_buffer: CommandBuffer,
12152 buffer: Buffer,
12153 offset: DeviceSize,
12154 draw_count: u32,
12155 stride: u32,
12156);
12157#[allow(non_camel_case_types)]
12158pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn(
12159 command_buffer: CommandBuffer,
12160 buffer: Buffer,
12161 offset: DeviceSize,
12162 count_buffer: Buffer,
12163 count_buffer_offset: DeviceSize,
12164 max_draw_count: u32,
12165 stride: u32,
12166);
12167#[derive(Clone)]
12168pub struct NvMeshShaderFn {
12169 pub cmd_draw_mesh_tasks_nv: PFN_vkCmdDrawMeshTasksNV,
12170 pub cmd_draw_mesh_tasks_indirect_nv: PFN_vkCmdDrawMeshTasksIndirectNV,
12171 pub cmd_draw_mesh_tasks_indirect_count_nv: PFN_vkCmdDrawMeshTasksIndirectCountNV,
12172}
12173unsafe impl Send for NvMeshShaderFn {}
12174unsafe impl Sync for NvMeshShaderFn {}
12175impl NvMeshShaderFn {
12176 pub fn load<F>(mut _f: F) -> Self
12177 where
12178 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12179 {
12180 Self {
12181 cmd_draw_mesh_tasks_nv: unsafe {
12182 unsafe extern "system" fn cmd_draw_mesh_tasks_nv(
12183 _command_buffer: CommandBuffer,
12184 _task_count: u32,
12185 _first_task: u32,
12186 ) {
12187 panic!(concat!(
12188 "Unable to load ",
12189 stringify!(cmd_draw_mesh_tasks_nv)
12190 ))
12191 }
12192 let cname =
12193 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksNV\0");
12194 let val = _f(cname);
12195 if val.is_null() {
12196 cmd_draw_mesh_tasks_nv
12197 } else {
12198 ::std::mem::transmute(val)
12199 }
12200 },
12201 cmd_draw_mesh_tasks_indirect_nv: unsafe {
12202 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_nv(
12203 _command_buffer: CommandBuffer,
12204 _buffer: Buffer,
12205 _offset: DeviceSize,
12206 _draw_count: u32,
12207 _stride: u32,
12208 ) {
12209 panic!(concat!(
12210 "Unable to load ",
12211 stringify!(cmd_draw_mesh_tasks_indirect_nv)
12212 ))
12213 }
12214 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12215 b"vkCmdDrawMeshTasksIndirectNV\0",
12216 );
12217 let val = _f(cname);
12218 if val.is_null() {
12219 cmd_draw_mesh_tasks_indirect_nv
12220 } else {
12221 ::std::mem::transmute(val)
12222 }
12223 },
12224 cmd_draw_mesh_tasks_indirect_count_nv: unsafe {
12225 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv(
12226 _command_buffer: CommandBuffer,
12227 _buffer: Buffer,
12228 _offset: DeviceSize,
12229 _count_buffer: Buffer,
12230 _count_buffer_offset: DeviceSize,
12231 _max_draw_count: u32,
12232 _stride: u32,
12233 ) {
12234 panic!(concat!(
12235 "Unable to load ",
12236 stringify!(cmd_draw_mesh_tasks_indirect_count_nv)
12237 ))
12238 }
12239 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12240 b"vkCmdDrawMeshTasksIndirectCountNV\0",
12241 );
12242 let val = _f(cname);
12243 if val.is_null() {
12244 cmd_draw_mesh_tasks_indirect_count_nv
12245 } else {
12246 ::std::mem::transmute(val)
12247 }
12248 },
12249 }
12250 }
12251}
12252#[doc = "Generated from 'VK_NV_mesh_shader'"]
12253impl PipelineStageFlags {
12254 pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT;
12255 pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT;
12256}
12257#[doc = "Generated from 'VK_NV_mesh_shader'"]
12258impl ShaderStageFlags {
12259 pub const TASK_NV: Self = Self::TASK_EXT;
12260 pub const MESH_NV: Self = Self::MESH_EXT;
12261}
12262#[doc = "Generated from 'VK_NV_mesh_shader'"]
12263impl StructureType {
12264 pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000);
12265 pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001);
12266}
12267impl NvFragmentShaderBarycentricFn {
12268 #[inline]
12269 pub const fn name() -> &'static ::std::ffi::CStr {
12270 unsafe {
12271 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shader_barycentric\0")
12272 }
12273 }
12274 pub const SPEC_VERSION: u32 = 1u32;
12275}
12276#[derive(Clone)]
12277pub struct NvFragmentShaderBarycentricFn {}
12278unsafe impl Send for NvFragmentShaderBarycentricFn {}
12279unsafe impl Sync for NvFragmentShaderBarycentricFn {}
12280impl NvFragmentShaderBarycentricFn {
12281 pub fn load<F>(mut _f: F) -> Self
12282 where
12283 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12284 {
12285 Self {}
12286 }
12287}
12288#[doc = "Generated from 'VK_NV_fragment_shader_barycentric'"]
12289impl StructureType {
12290 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self =
12291 Self::PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
12292}
12293impl NvShaderImageFootprintFn {
12294 #[inline]
12295 pub const fn name() -> &'static ::std::ffi::CStr {
12296 unsafe {
12297 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_image_footprint\0")
12298 }
12299 }
12300 pub const SPEC_VERSION: u32 = 2u32;
12301}
12302#[derive(Clone)]
12303pub struct NvShaderImageFootprintFn {}
12304unsafe impl Send for NvShaderImageFootprintFn {}
12305unsafe impl Sync for NvShaderImageFootprintFn {}
12306impl NvShaderImageFootprintFn {
12307 pub fn load<F>(mut _f: F) -> Self
12308 where
12309 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12310 {
12311 Self {}
12312 }
12313}
12314#[doc = "Generated from 'VK_NV_shader_image_footprint'"]
12315impl StructureType {
12316 pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1_000_204_000);
12317}
12318impl NvScissorExclusiveFn {
12319 #[inline]
12320 pub const fn name() -> &'static ::std::ffi::CStr {
12321 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_scissor_exclusive\0") }
12322 }
12323 pub const SPEC_VERSION: u32 = 2u32;
12324}
12325#[allow(non_camel_case_types)]
12326pub type PFN_vkCmdSetExclusiveScissorEnableNV = unsafe extern "system" fn(
12327 command_buffer: CommandBuffer,
12328 first_exclusive_scissor: u32,
12329 exclusive_scissor_count: u32,
12330 p_exclusive_scissor_enables: *const Bool32,
12331);
12332#[allow(non_camel_case_types)]
12333pub type PFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(
12334 command_buffer: CommandBuffer,
12335 first_exclusive_scissor: u32,
12336 exclusive_scissor_count: u32,
12337 p_exclusive_scissors: *const Rect2D,
12338);
12339#[derive(Clone)]
12340pub struct NvScissorExclusiveFn {
12341 pub cmd_set_exclusive_scissor_enable_nv: PFN_vkCmdSetExclusiveScissorEnableNV,
12342 pub cmd_set_exclusive_scissor_nv: PFN_vkCmdSetExclusiveScissorNV,
12343}
12344unsafe impl Send for NvScissorExclusiveFn {}
12345unsafe impl Sync for NvScissorExclusiveFn {}
12346impl NvScissorExclusiveFn {
12347 pub fn load<F>(mut _f: F) -> Self
12348 where
12349 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12350 {
12351 Self {
12352 cmd_set_exclusive_scissor_enable_nv: unsafe {
12353 unsafe extern "system" fn cmd_set_exclusive_scissor_enable_nv(
12354 _command_buffer: CommandBuffer,
12355 _first_exclusive_scissor: u32,
12356 _exclusive_scissor_count: u32,
12357 _p_exclusive_scissor_enables: *const Bool32,
12358 ) {
12359 panic!(concat!(
12360 "Unable to load ",
12361 stringify!(cmd_set_exclusive_scissor_enable_nv)
12362 ))
12363 }
12364 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12365 b"vkCmdSetExclusiveScissorEnableNV\0",
12366 );
12367 let val = _f(cname);
12368 if val.is_null() {
12369 cmd_set_exclusive_scissor_enable_nv
12370 } else {
12371 ::std::mem::transmute(val)
12372 }
12373 },
12374 cmd_set_exclusive_scissor_nv: unsafe {
12375 unsafe extern "system" fn cmd_set_exclusive_scissor_nv(
12376 _command_buffer: CommandBuffer,
12377 _first_exclusive_scissor: u32,
12378 _exclusive_scissor_count: u32,
12379 _p_exclusive_scissors: *const Rect2D,
12380 ) {
12381 panic!(concat!(
12382 "Unable to load ",
12383 stringify!(cmd_set_exclusive_scissor_nv)
12384 ))
12385 }
12386 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12387 b"vkCmdSetExclusiveScissorNV\0",
12388 );
12389 let val = _f(cname);
12390 if val.is_null() {
12391 cmd_set_exclusive_scissor_nv
12392 } else {
12393 ::std::mem::transmute(val)
12394 }
12395 },
12396 }
12397 }
12398}
12399#[doc = "Generated from 'VK_NV_scissor_exclusive'"]
12400impl DynamicState {
12401 pub const EXCLUSIVE_SCISSOR_ENABLE_NV: Self = Self(1_000_205_000);
12402 pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1_000_205_001);
12403}
12404#[doc = "Generated from 'VK_NV_scissor_exclusive'"]
12405impl StructureType {
12406 pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000);
12407 pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1_000_205_002);
12408}
12409impl NvDeviceDiagnosticCheckpointsFn {
12410 #[inline]
12411 pub const fn name() -> &'static ::std::ffi::CStr {
12412 unsafe {
12413 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12414 b"VK_NV_device_diagnostic_checkpoints\0",
12415 )
12416 }
12417 }
12418 pub const SPEC_VERSION: u32 = 2u32;
12419}
12420#[allow(non_camel_case_types)]
12421pub type PFN_vkCmdSetCheckpointNV =
12422 unsafe extern "system" fn(command_buffer: CommandBuffer, p_checkpoint_marker: *const c_void);
12423#[allow(non_camel_case_types)]
12424pub type PFN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn(
12425 queue: Queue,
12426 p_checkpoint_data_count: *mut u32,
12427 p_checkpoint_data: *mut CheckpointDataNV,
12428);
12429#[derive(Clone)]
12430pub struct NvDeviceDiagnosticCheckpointsFn {
12431 pub cmd_set_checkpoint_nv: PFN_vkCmdSetCheckpointNV,
12432 pub get_queue_checkpoint_data_nv: PFN_vkGetQueueCheckpointDataNV,
12433}
12434unsafe impl Send for NvDeviceDiagnosticCheckpointsFn {}
12435unsafe impl Sync for NvDeviceDiagnosticCheckpointsFn {}
12436impl NvDeviceDiagnosticCheckpointsFn {
12437 pub fn load<F>(mut _f: F) -> Self
12438 where
12439 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12440 {
12441 Self {
12442 cmd_set_checkpoint_nv: unsafe {
12443 unsafe extern "system" fn cmd_set_checkpoint_nv(
12444 _command_buffer: CommandBuffer,
12445 _p_checkpoint_marker: *const c_void,
12446 ) {
12447 panic!(concat!(
12448 "Unable to load ",
12449 stringify!(cmd_set_checkpoint_nv)
12450 ))
12451 }
12452 let cname =
12453 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCheckpointNV\0");
12454 let val = _f(cname);
12455 if val.is_null() {
12456 cmd_set_checkpoint_nv
12457 } else {
12458 ::std::mem::transmute(val)
12459 }
12460 },
12461 get_queue_checkpoint_data_nv: unsafe {
12462 unsafe extern "system" fn get_queue_checkpoint_data_nv(
12463 _queue: Queue,
12464 _p_checkpoint_data_count: *mut u32,
12465 _p_checkpoint_data: *mut CheckpointDataNV,
12466 ) {
12467 panic!(concat!(
12468 "Unable to load ",
12469 stringify!(get_queue_checkpoint_data_nv)
12470 ))
12471 }
12472 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12473 b"vkGetQueueCheckpointDataNV\0",
12474 );
12475 let val = _f(cname);
12476 if val.is_null() {
12477 get_queue_checkpoint_data_nv
12478 } else {
12479 ::std::mem::transmute(val)
12480 }
12481 },
12482 }
12483 }
12484}
12485#[doc = "Generated from 'VK_NV_device_diagnostic_checkpoints'"]
12486impl StructureType {
12487 pub const CHECKPOINT_DATA_NV: Self = Self(1_000_206_000);
12488 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1_000_206_001);
12489}
12490impl KhrTimelineSemaphoreFn {
12491 #[inline]
12492 pub const fn name() -> &'static ::std::ffi::CStr {
12493 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_timeline_semaphore\0") }
12494 }
12495 pub const SPEC_VERSION: u32 = 2u32;
12496}
12497#[allow(non_camel_case_types)]
12498pub type PFN_vkGetSemaphoreCounterValue =
12499 unsafe extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result;
12500#[allow(non_camel_case_types)]
12501pub type PFN_vkWaitSemaphores = unsafe extern "system" fn(
12502 device: Device,
12503 p_wait_info: *const SemaphoreWaitInfo,
12504 timeout: u64,
12505) -> Result;
12506#[allow(non_camel_case_types)]
12507pub type PFN_vkSignalSemaphore =
12508 unsafe extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result;
12509#[derive(Clone)]
12510pub struct KhrTimelineSemaphoreFn {
12511 pub get_semaphore_counter_value_khr: PFN_vkGetSemaphoreCounterValue,
12512 pub wait_semaphores_khr: PFN_vkWaitSemaphores,
12513 pub signal_semaphore_khr: PFN_vkSignalSemaphore,
12514}
12515unsafe impl Send for KhrTimelineSemaphoreFn {}
12516unsafe impl Sync for KhrTimelineSemaphoreFn {}
12517impl KhrTimelineSemaphoreFn {
12518 pub fn load<F>(mut _f: F) -> Self
12519 where
12520 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12521 {
12522 Self {
12523 get_semaphore_counter_value_khr: unsafe {
12524 unsafe extern "system" fn get_semaphore_counter_value_khr(
12525 _device: Device,
12526 _semaphore: Semaphore,
12527 _p_value: *mut u64,
12528 ) -> Result {
12529 panic!(concat!(
12530 "Unable to load ",
12531 stringify!(get_semaphore_counter_value_khr)
12532 ))
12533 }
12534 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12535 b"vkGetSemaphoreCounterValueKHR\0",
12536 );
12537 let val = _f(cname);
12538 if val.is_null() {
12539 get_semaphore_counter_value_khr
12540 } else {
12541 ::std::mem::transmute(val)
12542 }
12543 },
12544 wait_semaphores_khr: unsafe {
12545 unsafe extern "system" fn wait_semaphores_khr(
12546 _device: Device,
12547 _p_wait_info: *const SemaphoreWaitInfo,
12548 _timeout: u64,
12549 ) -> Result {
12550 panic!(concat!("Unable to load ", stringify!(wait_semaphores_khr)))
12551 }
12552 let cname =
12553 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphoresKHR\0");
12554 let val = _f(cname);
12555 if val.is_null() {
12556 wait_semaphores_khr
12557 } else {
12558 ::std::mem::transmute(val)
12559 }
12560 },
12561 signal_semaphore_khr: unsafe {
12562 unsafe extern "system" fn signal_semaphore_khr(
12563 _device: Device,
12564 _p_signal_info: *const SemaphoreSignalInfo,
12565 ) -> Result {
12566 panic!(concat!("Unable to load ", stringify!(signal_semaphore_khr)))
12567 }
12568 let cname =
12569 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphoreKHR\0");
12570 let val = _f(cname);
12571 if val.is_null() {
12572 signal_semaphore_khr
12573 } else {
12574 ::std::mem::transmute(val)
12575 }
12576 },
12577 }
12578 }
12579}
12580#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
12581impl SemaphoreType {
12582 pub const BINARY_KHR: Self = Self::BINARY;
12583 pub const TIMELINE_KHR: Self = Self::TIMELINE;
12584}
12585#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
12586impl SemaphoreWaitFlags {
12587 pub const ANY_KHR: Self = Self::ANY;
12588}
12589#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
12590impl StructureType {
12591 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self =
12592 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
12593 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self =
12594 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
12595 pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = Self::SEMAPHORE_TYPE_CREATE_INFO;
12596 pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::TIMELINE_SEMAPHORE_SUBMIT_INFO;
12597 pub const SEMAPHORE_WAIT_INFO_KHR: Self = Self::SEMAPHORE_WAIT_INFO;
12598 pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = Self::SEMAPHORE_SIGNAL_INFO;
12599}
12600impl KhrExtension209Fn {
12601 #[inline]
12602 pub const fn name() -> &'static ::std::ffi::CStr {
12603 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_209\0") }
12604 }
12605 pub const SPEC_VERSION: u32 = 0u32;
12606}
12607#[derive(Clone)]
12608pub struct KhrExtension209Fn {}
12609unsafe impl Send for KhrExtension209Fn {}
12610unsafe impl Sync for KhrExtension209Fn {}
12611impl KhrExtension209Fn {
12612 pub fn load<F>(mut _f: F) -> Self
12613 where
12614 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12615 {
12616 Self {}
12617 }
12618}
12619impl IntelShaderIntegerFunctions2Fn {
12620 #[inline]
12621 pub const fn name() -> &'static ::std::ffi::CStr {
12622 unsafe {
12623 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_shader_integer_functions2\0")
12624 }
12625 }
12626 pub const SPEC_VERSION: u32 = 1u32;
12627}
12628#[derive(Clone)]
12629pub struct IntelShaderIntegerFunctions2Fn {}
12630unsafe impl Send for IntelShaderIntegerFunctions2Fn {}
12631unsafe impl Sync for IntelShaderIntegerFunctions2Fn {}
12632impl IntelShaderIntegerFunctions2Fn {
12633 pub fn load<F>(mut _f: F) -> Self
12634 where
12635 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12636 {
12637 Self {}
12638 }
12639}
12640#[doc = "Generated from 'VK_INTEL_shader_integer_functions2'"]
12641impl StructureType {
12642 pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1_000_209_000);
12643}
12644impl IntelPerformanceQueryFn {
12645 #[inline]
12646 pub const fn name() -> &'static ::std::ffi::CStr {
12647 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_performance_query\0") }
12648 }
12649 pub const SPEC_VERSION: u32 = 2u32;
12650}
12651#[allow(non_camel_case_types)]
12652pub type PFN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn(
12653 device: Device,
12654 p_initialize_info: *const InitializePerformanceApiInfoINTEL,
12655) -> Result;
12656#[allow(non_camel_case_types)]
12657pub type PFN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: Device);
12658#[allow(non_camel_case_types)]
12659pub type PFN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn(
12660 command_buffer: CommandBuffer,
12661 p_marker_info: *const PerformanceMarkerInfoINTEL,
12662) -> Result;
12663#[allow(non_camel_case_types)]
12664pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn(
12665 command_buffer: CommandBuffer,
12666 p_marker_info: *const PerformanceStreamMarkerInfoINTEL,
12667) -> Result;
12668#[allow(non_camel_case_types)]
12669pub type PFN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn(
12670 command_buffer: CommandBuffer,
12671 p_override_info: *const PerformanceOverrideInfoINTEL,
12672) -> Result;
12673#[allow(non_camel_case_types)]
12674pub type PFN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn(
12675 device: Device,
12676 p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL,
12677 p_configuration: *mut PerformanceConfigurationINTEL,
12678) -> Result;
12679#[allow(non_camel_case_types)]
12680pub type PFN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn(
12681 device: Device,
12682 configuration: PerformanceConfigurationINTEL,
12683) -> Result;
12684#[allow(non_camel_case_types)]
12685pub type PFN_vkQueueSetPerformanceConfigurationINTEL =
12686 unsafe extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result;
12687#[allow(non_camel_case_types)]
12688pub type PFN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn(
12689 device: Device,
12690 parameter: PerformanceParameterTypeINTEL,
12691 p_value: *mut PerformanceValueINTEL,
12692) -> Result;
12693#[derive(Clone)]
12694pub struct IntelPerformanceQueryFn {
12695 pub initialize_performance_api_intel: PFN_vkInitializePerformanceApiINTEL,
12696 pub uninitialize_performance_api_intel: PFN_vkUninitializePerformanceApiINTEL,
12697 pub cmd_set_performance_marker_intel: PFN_vkCmdSetPerformanceMarkerINTEL,
12698 pub cmd_set_performance_stream_marker_intel: PFN_vkCmdSetPerformanceStreamMarkerINTEL,
12699 pub cmd_set_performance_override_intel: PFN_vkCmdSetPerformanceOverrideINTEL,
12700 pub acquire_performance_configuration_intel: PFN_vkAcquirePerformanceConfigurationINTEL,
12701 pub release_performance_configuration_intel: PFN_vkReleasePerformanceConfigurationINTEL,
12702 pub queue_set_performance_configuration_intel: PFN_vkQueueSetPerformanceConfigurationINTEL,
12703 pub get_performance_parameter_intel: PFN_vkGetPerformanceParameterINTEL,
12704}
12705unsafe impl Send for IntelPerformanceQueryFn {}
12706unsafe impl Sync for IntelPerformanceQueryFn {}
12707impl IntelPerformanceQueryFn {
12708 pub fn load<F>(mut _f: F) -> Self
12709 where
12710 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12711 {
12712 Self {
12713 initialize_performance_api_intel: unsafe {
12714 unsafe extern "system" fn initialize_performance_api_intel(
12715 _device: Device,
12716 _p_initialize_info: *const InitializePerformanceApiInfoINTEL,
12717 ) -> Result {
12718 panic!(concat!(
12719 "Unable to load ",
12720 stringify!(initialize_performance_api_intel)
12721 ))
12722 }
12723 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12724 b"vkInitializePerformanceApiINTEL\0",
12725 );
12726 let val = _f(cname);
12727 if val.is_null() {
12728 initialize_performance_api_intel
12729 } else {
12730 ::std::mem::transmute(val)
12731 }
12732 },
12733 uninitialize_performance_api_intel: unsafe {
12734 unsafe extern "system" fn uninitialize_performance_api_intel(_device: Device) {
12735 panic!(concat!(
12736 "Unable to load ",
12737 stringify!(uninitialize_performance_api_intel)
12738 ))
12739 }
12740 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12741 b"vkUninitializePerformanceApiINTEL\0",
12742 );
12743 let val = _f(cname);
12744 if val.is_null() {
12745 uninitialize_performance_api_intel
12746 } else {
12747 ::std::mem::transmute(val)
12748 }
12749 },
12750 cmd_set_performance_marker_intel: unsafe {
12751 unsafe extern "system" fn cmd_set_performance_marker_intel(
12752 _command_buffer: CommandBuffer,
12753 _p_marker_info: *const PerformanceMarkerInfoINTEL,
12754 ) -> Result {
12755 panic!(concat!(
12756 "Unable to load ",
12757 stringify!(cmd_set_performance_marker_intel)
12758 ))
12759 }
12760 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12761 b"vkCmdSetPerformanceMarkerINTEL\0",
12762 );
12763 let val = _f(cname);
12764 if val.is_null() {
12765 cmd_set_performance_marker_intel
12766 } else {
12767 ::std::mem::transmute(val)
12768 }
12769 },
12770 cmd_set_performance_stream_marker_intel: unsafe {
12771 unsafe extern "system" fn cmd_set_performance_stream_marker_intel(
12772 _command_buffer: CommandBuffer,
12773 _p_marker_info: *const PerformanceStreamMarkerInfoINTEL,
12774 ) -> Result {
12775 panic!(concat!(
12776 "Unable to load ",
12777 stringify!(cmd_set_performance_stream_marker_intel)
12778 ))
12779 }
12780 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12781 b"vkCmdSetPerformanceStreamMarkerINTEL\0",
12782 );
12783 let val = _f(cname);
12784 if val.is_null() {
12785 cmd_set_performance_stream_marker_intel
12786 } else {
12787 ::std::mem::transmute(val)
12788 }
12789 },
12790 cmd_set_performance_override_intel: unsafe {
12791 unsafe extern "system" fn cmd_set_performance_override_intel(
12792 _command_buffer: CommandBuffer,
12793 _p_override_info: *const PerformanceOverrideInfoINTEL,
12794 ) -> Result {
12795 panic!(concat!(
12796 "Unable to load ",
12797 stringify!(cmd_set_performance_override_intel)
12798 ))
12799 }
12800 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12801 b"vkCmdSetPerformanceOverrideINTEL\0",
12802 );
12803 let val = _f(cname);
12804 if val.is_null() {
12805 cmd_set_performance_override_intel
12806 } else {
12807 ::std::mem::transmute(val)
12808 }
12809 },
12810 acquire_performance_configuration_intel: unsafe {
12811 unsafe extern "system" fn acquire_performance_configuration_intel(
12812 _device: Device,
12813 _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL,
12814 _p_configuration: *mut PerformanceConfigurationINTEL,
12815 ) -> Result {
12816 panic!(concat!(
12817 "Unable to load ",
12818 stringify!(acquire_performance_configuration_intel)
12819 ))
12820 }
12821 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12822 b"vkAcquirePerformanceConfigurationINTEL\0",
12823 );
12824 let val = _f(cname);
12825 if val.is_null() {
12826 acquire_performance_configuration_intel
12827 } else {
12828 ::std::mem::transmute(val)
12829 }
12830 },
12831 release_performance_configuration_intel: unsafe {
12832 unsafe extern "system" fn release_performance_configuration_intel(
12833 _device: Device,
12834 _configuration: PerformanceConfigurationINTEL,
12835 ) -> Result {
12836 panic!(concat!(
12837 "Unable to load ",
12838 stringify!(release_performance_configuration_intel)
12839 ))
12840 }
12841 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12842 b"vkReleasePerformanceConfigurationINTEL\0",
12843 );
12844 let val = _f(cname);
12845 if val.is_null() {
12846 release_performance_configuration_intel
12847 } else {
12848 ::std::mem::transmute(val)
12849 }
12850 },
12851 queue_set_performance_configuration_intel: unsafe {
12852 unsafe extern "system" fn queue_set_performance_configuration_intel(
12853 _queue: Queue,
12854 _configuration: PerformanceConfigurationINTEL,
12855 ) -> Result {
12856 panic!(concat!(
12857 "Unable to load ",
12858 stringify!(queue_set_performance_configuration_intel)
12859 ))
12860 }
12861 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12862 b"vkQueueSetPerformanceConfigurationINTEL\0",
12863 );
12864 let val = _f(cname);
12865 if val.is_null() {
12866 queue_set_performance_configuration_intel
12867 } else {
12868 ::std::mem::transmute(val)
12869 }
12870 },
12871 get_performance_parameter_intel: unsafe {
12872 unsafe extern "system" fn get_performance_parameter_intel(
12873 _device: Device,
12874 _parameter: PerformanceParameterTypeINTEL,
12875 _p_value: *mut PerformanceValueINTEL,
12876 ) -> Result {
12877 panic!(concat!(
12878 "Unable to load ",
12879 stringify!(get_performance_parameter_intel)
12880 ))
12881 }
12882 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12883 b"vkGetPerformanceParameterINTEL\0",
12884 );
12885 let val = _f(cname);
12886 if val.is_null() {
12887 get_performance_parameter_intel
12888 } else {
12889 ::std::mem::transmute(val)
12890 }
12891 },
12892 }
12893 }
12894}
12895#[doc = "Generated from 'VK_INTEL_performance_query'"]
12896impl ObjectType {
12897 pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000);
12898}
12899#[doc = "Generated from 'VK_INTEL_performance_query'"]
12900impl QueryType {
12901 pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000);
12902}
12903#[doc = "Generated from 'VK_INTEL_performance_query'"]
12904impl StructureType {
12905 pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1_000_210_000);
12906 pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1_000_210_001);
12907 pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1_000_210_002);
12908 pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1_000_210_003);
12909 pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1_000_210_004);
12910 pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1_000_210_005);
12911}
12912impl KhrVulkanMemoryModelFn {
12913 #[inline]
12914 pub const fn name() -> &'static ::std::ffi::CStr {
12915 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_vulkan_memory_model\0") }
12916 }
12917 pub const SPEC_VERSION: u32 = 3u32;
12918}
12919#[derive(Clone)]
12920pub struct KhrVulkanMemoryModelFn {}
12921unsafe impl Send for KhrVulkanMemoryModelFn {}
12922unsafe impl Sync for KhrVulkanMemoryModelFn {}
12923impl KhrVulkanMemoryModelFn {
12924 pub fn load<F>(mut _f: F) -> Self
12925 where
12926 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12927 {
12928 Self {}
12929 }
12930}
12931#[doc = "Generated from 'VK_KHR_vulkan_memory_model'"]
12932impl StructureType {
12933 pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: Self =
12934 Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
12935}
12936impl ExtPciBusInfoFn {
12937 #[inline]
12938 pub const fn name() -> &'static ::std::ffi::CStr {
12939 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pci_bus_info\0") }
12940 }
12941 pub const SPEC_VERSION: u32 = 2u32;
12942}
12943#[derive(Clone)]
12944pub struct ExtPciBusInfoFn {}
12945unsafe impl Send for ExtPciBusInfoFn {}
12946unsafe impl Sync for ExtPciBusInfoFn {}
12947impl ExtPciBusInfoFn {
12948 pub fn load<F>(mut _f: F) -> Self
12949 where
12950 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12951 {
12952 Self {}
12953 }
12954}
12955#[doc = "Generated from 'VK_EXT_pci_bus_info'"]
12956impl StructureType {
12957 pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1_000_212_000);
12958}
12959impl AmdDisplayNativeHdrFn {
12960 #[inline]
12961 pub const fn name() -> &'static ::std::ffi::CStr {
12962 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_display_native_hdr\0") }
12963 }
12964 pub const SPEC_VERSION: u32 = 1u32;
12965}
12966#[allow(non_camel_case_types)]
12967pub type PFN_vkSetLocalDimmingAMD = unsafe extern "system" fn(
12968 device: Device,
12969 swap_chain: SwapchainKHR,
12970 local_dimming_enable: Bool32,
12971);
12972#[derive(Clone)]
12973pub struct AmdDisplayNativeHdrFn {
12974 pub set_local_dimming_amd: PFN_vkSetLocalDimmingAMD,
12975}
12976unsafe impl Send for AmdDisplayNativeHdrFn {}
12977unsafe impl Sync for AmdDisplayNativeHdrFn {}
12978impl AmdDisplayNativeHdrFn {
12979 pub fn load<F>(mut _f: F) -> Self
12980 where
12981 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12982 {
12983 Self {
12984 set_local_dimming_amd: unsafe {
12985 unsafe extern "system" fn set_local_dimming_amd(
12986 _device: Device,
12987 _swap_chain: SwapchainKHR,
12988 _local_dimming_enable: Bool32,
12989 ) {
12990 panic!(concat!(
12991 "Unable to load ",
12992 stringify!(set_local_dimming_amd)
12993 ))
12994 }
12995 let cname =
12996 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetLocalDimmingAMD\0");
12997 let val = _f(cname);
12998 if val.is_null() {
12999 set_local_dimming_amd
13000 } else {
13001 ::std::mem::transmute(val)
13002 }
13003 },
13004 }
13005 }
13006}
13007#[doc = "Generated from 'VK_AMD_display_native_hdr'"]
13008impl ColorSpaceKHR {
13009 pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000);
13010}
13011#[doc = "Generated from 'VK_AMD_display_native_hdr'"]
13012impl StructureType {
13013 pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000);
13014 pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1_000_213_001);
13015}
13016impl FuchsiaImagepipeSurfaceFn {
13017 #[inline]
13018 pub const fn name() -> &'static ::std::ffi::CStr {
13019 unsafe {
13020 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_imagepipe_surface\0")
13021 }
13022 }
13023 pub const SPEC_VERSION: u32 = 1u32;
13024}
13025#[allow(non_camel_case_types)]
13026pub type PFN_vkCreateImagePipeSurfaceFUCHSIA = unsafe extern "system" fn(
13027 instance: Instance,
13028 p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA,
13029 p_allocator: *const AllocationCallbacks,
13030 p_surface: *mut SurfaceKHR,
13031) -> Result;
13032#[derive(Clone)]
13033pub struct FuchsiaImagepipeSurfaceFn {
13034 pub create_image_pipe_surface_fuchsia: PFN_vkCreateImagePipeSurfaceFUCHSIA,
13035}
13036unsafe impl Send for FuchsiaImagepipeSurfaceFn {}
13037unsafe impl Sync for FuchsiaImagepipeSurfaceFn {}
13038impl FuchsiaImagepipeSurfaceFn {
13039 pub fn load<F>(mut _f: F) -> Self
13040 where
13041 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13042 {
13043 Self {
13044 create_image_pipe_surface_fuchsia: unsafe {
13045 unsafe extern "system" fn create_image_pipe_surface_fuchsia(
13046 _instance: Instance,
13047 _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA,
13048 _p_allocator: *const AllocationCallbacks,
13049 _p_surface: *mut SurfaceKHR,
13050 ) -> Result {
13051 panic!(concat!(
13052 "Unable to load ",
13053 stringify!(create_image_pipe_surface_fuchsia)
13054 ))
13055 }
13056 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13057 b"vkCreateImagePipeSurfaceFUCHSIA\0",
13058 );
13059 let val = _f(cname);
13060 if val.is_null() {
13061 create_image_pipe_surface_fuchsia
13062 } else {
13063 ::std::mem::transmute(val)
13064 }
13065 },
13066 }
13067 }
13068}
13069#[doc = "Generated from 'VK_FUCHSIA_imagepipe_surface'"]
13070impl StructureType {
13071 pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1_000_214_000);
13072}
13073impl KhrShaderTerminateInvocationFn {
13074 #[inline]
13075 pub const fn name() -> &'static ::std::ffi::CStr {
13076 unsafe {
13077 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_terminate_invocation\0")
13078 }
13079 }
13080 pub const SPEC_VERSION: u32 = 1u32;
13081}
13082#[derive(Clone)]
13083pub struct KhrShaderTerminateInvocationFn {}
13084unsafe impl Send for KhrShaderTerminateInvocationFn {}
13085unsafe impl Sync for KhrShaderTerminateInvocationFn {}
13086impl KhrShaderTerminateInvocationFn {
13087 pub fn load<F>(mut _f: F) -> Self
13088 where
13089 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13090 {
13091 Self {}
13092 }
13093}
13094#[doc = "Generated from 'VK_KHR_shader_terminate_invocation'"]
13095impl StructureType {
13096 pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self =
13097 Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
13098}
13099impl GoogleExtension217Fn {
13100 #[inline]
13101 pub const fn name() -> &'static ::std::ffi::CStr {
13102 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_217\0") }
13103 }
13104 pub const SPEC_VERSION: u32 = 0u32;
13105}
13106#[derive(Clone)]
13107pub struct GoogleExtension217Fn {}
13108unsafe impl Send for GoogleExtension217Fn {}
13109unsafe impl Sync for GoogleExtension217Fn {}
13110impl GoogleExtension217Fn {
13111 pub fn load<F>(mut _f: F) -> Self
13112 where
13113 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13114 {
13115 Self {}
13116 }
13117}
13118impl ExtMetalSurfaceFn {
13119 #[inline]
13120 pub const fn name() -> &'static ::std::ffi::CStr {
13121 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_surface\0") }
13122 }
13123 pub const SPEC_VERSION: u32 = 1u32;
13124}
13125#[allow(non_camel_case_types)]
13126pub type PFN_vkCreateMetalSurfaceEXT = unsafe extern "system" fn(
13127 instance: Instance,
13128 p_create_info: *const MetalSurfaceCreateInfoEXT,
13129 p_allocator: *const AllocationCallbacks,
13130 p_surface: *mut SurfaceKHR,
13131) -> Result;
13132#[derive(Clone)]
13133pub struct ExtMetalSurfaceFn {
13134 pub create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT,
13135}
13136unsafe impl Send for ExtMetalSurfaceFn {}
13137unsafe impl Sync for ExtMetalSurfaceFn {}
13138impl ExtMetalSurfaceFn {
13139 pub fn load<F>(mut _f: F) -> Self
13140 where
13141 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13142 {
13143 Self {
13144 create_metal_surface_ext: unsafe {
13145 unsafe extern "system" fn create_metal_surface_ext(
13146 _instance: Instance,
13147 _p_create_info: *const MetalSurfaceCreateInfoEXT,
13148 _p_allocator: *const AllocationCallbacks,
13149 _p_surface: *mut SurfaceKHR,
13150 ) -> Result {
13151 panic!(concat!(
13152 "Unable to load ",
13153 stringify!(create_metal_surface_ext)
13154 ))
13155 }
13156 let cname =
13157 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMetalSurfaceEXT\0");
13158 let val = _f(cname);
13159 if val.is_null() {
13160 create_metal_surface_ext
13161 } else {
13162 ::std::mem::transmute(val)
13163 }
13164 },
13165 }
13166 }
13167}
13168#[doc = "Generated from 'VK_EXT_metal_surface'"]
13169impl StructureType {
13170 pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_217_000);
13171}
13172impl ExtFragmentDensityMapFn {
13173 #[inline]
13174 pub const fn name() -> &'static ::std::ffi::CStr {
13175 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map\0") }
13176 }
13177 pub const SPEC_VERSION: u32 = 2u32;
13178}
13179#[derive(Clone)]
13180pub struct ExtFragmentDensityMapFn {}
13181unsafe impl Send for ExtFragmentDensityMapFn {}
13182unsafe impl Sync for ExtFragmentDensityMapFn {}
13183impl ExtFragmentDensityMapFn {
13184 pub fn load<F>(mut _f: F) -> Self
13185 where
13186 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13187 {
13188 Self {}
13189 }
13190}
13191#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13192impl AccessFlags {
13193 pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
13194}
13195#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13196impl FormatFeatureFlags {
13197 pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
13198}
13199#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13200impl FormatFeatureFlags2 {
13201 pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
13202}
13203#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13204impl ImageCreateFlags {
13205 pub const SUBSAMPLED_EXT: Self = Self(0b100_0000_0000_0000);
13206}
13207#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13208impl ImageLayout {
13209 pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1_000_218_000);
13210}
13211#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13212impl ImageUsageFlags {
13213 pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b10_0000_0000);
13214}
13215#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13216impl ImageViewCreateFlags {
13217 pub const FRAGMENT_DENSITY_MAP_DYNAMIC_EXT: Self = Self(0b1);
13218}
13219#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13220impl PipelineStageFlags {
13221 pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
13222}
13223#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13224impl SamplerCreateFlags {
13225 pub const SUBSAMPLED_EXT: Self = Self(0b1);
13226 pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10);
13227}
13228#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
13229impl StructureType {
13230 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000);
13231 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001);
13232 pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002);
13233}
13234impl ExtExtension220Fn {
13235 #[inline]
13236 pub const fn name() -> &'static ::std::ffi::CStr {
13237 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_220\0") }
13238 }
13239 pub const SPEC_VERSION: u32 = 0u32;
13240}
13241#[derive(Clone)]
13242pub struct ExtExtension220Fn {}
13243unsafe impl Send for ExtExtension220Fn {}
13244unsafe impl Sync for ExtExtension220Fn {}
13245impl ExtExtension220Fn {
13246 pub fn load<F>(mut _f: F) -> Self
13247 where
13248 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13249 {
13250 Self {}
13251 }
13252}
13253impl KhrExtension221Fn {
13254 #[inline]
13255 pub const fn name() -> &'static ::std::ffi::CStr {
13256 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_221\0") }
13257 }
13258 pub const SPEC_VERSION: u32 = 0u32;
13259}
13260#[derive(Clone)]
13261pub struct KhrExtension221Fn {}
13262unsafe impl Send for KhrExtension221Fn {}
13263unsafe impl Sync for KhrExtension221Fn {}
13264impl KhrExtension221Fn {
13265 pub fn load<F>(mut _f: F) -> Self
13266 where
13267 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13268 {
13269 Self {}
13270 }
13271}
13272#[doc = "Generated from 'VK_KHR_extension_221'"]
13273impl RenderPassCreateFlags {
13274 pub const RESERVED_0_KHR: Self = Self(0b1);
13275}
13276impl ExtScalarBlockLayoutFn {
13277 #[inline]
13278 pub const fn name() -> &'static ::std::ffi::CStr {
13279 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_scalar_block_layout\0") }
13280 }
13281 pub const SPEC_VERSION: u32 = 1u32;
13282}
13283#[derive(Clone)]
13284pub struct ExtScalarBlockLayoutFn {}
13285unsafe impl Send for ExtScalarBlockLayoutFn {}
13286unsafe impl Sync for ExtScalarBlockLayoutFn {}
13287impl ExtScalarBlockLayoutFn {
13288 pub fn load<F>(mut _f: F) -> Self
13289 where
13290 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13291 {
13292 Self {}
13293 }
13294}
13295#[doc = "Generated from 'VK_EXT_scalar_block_layout'"]
13296impl StructureType {
13297 pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: Self =
13298 Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
13299}
13300impl ExtExtension223Fn {
13301 #[inline]
13302 pub const fn name() -> &'static ::std::ffi::CStr {
13303 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_223\0") }
13304 }
13305 pub const SPEC_VERSION: u32 = 0u32;
13306}
13307#[derive(Clone)]
13308pub struct ExtExtension223Fn {}
13309unsafe impl Send for ExtExtension223Fn {}
13310unsafe impl Sync for ExtExtension223Fn {}
13311impl ExtExtension223Fn {
13312 pub fn load<F>(mut _f: F) -> Self
13313 where
13314 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13315 {
13316 Self {}
13317 }
13318}
13319impl GoogleHlslFunctionality1Fn {
13320 #[inline]
13321 pub const fn name() -> &'static ::std::ffi::CStr {
13322 unsafe {
13323 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_hlsl_functionality1\0")
13324 }
13325 }
13326 pub const SPEC_VERSION: u32 = 1u32;
13327}
13328#[derive(Clone)]
13329pub struct GoogleHlslFunctionality1Fn {}
13330unsafe impl Send for GoogleHlslFunctionality1Fn {}
13331unsafe impl Sync for GoogleHlslFunctionality1Fn {}
13332impl GoogleHlslFunctionality1Fn {
13333 pub fn load<F>(mut _f: F) -> Self
13334 where
13335 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13336 {
13337 Self {}
13338 }
13339}
13340impl GoogleDecorateStringFn {
13341 #[inline]
13342 pub const fn name() -> &'static ::std::ffi::CStr {
13343 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_decorate_string\0") }
13344 }
13345 pub const SPEC_VERSION: u32 = 1u32;
13346}
13347#[derive(Clone)]
13348pub struct GoogleDecorateStringFn {}
13349unsafe impl Send for GoogleDecorateStringFn {}
13350unsafe impl Sync for GoogleDecorateStringFn {}
13351impl GoogleDecorateStringFn {
13352 pub fn load<F>(mut _f: F) -> Self
13353 where
13354 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13355 {
13356 Self {}
13357 }
13358}
13359impl ExtSubgroupSizeControlFn {
13360 #[inline]
13361 pub const fn name() -> &'static ::std::ffi::CStr {
13362 unsafe {
13363 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subgroup_size_control\0")
13364 }
13365 }
13366 pub const SPEC_VERSION: u32 = 2u32;
13367}
13368#[derive(Clone)]
13369pub struct ExtSubgroupSizeControlFn {}
13370unsafe impl Send for ExtSubgroupSizeControlFn {}
13371unsafe impl Sync for ExtSubgroupSizeControlFn {}
13372impl ExtSubgroupSizeControlFn {
13373 pub fn load<F>(mut _f: F) -> Self
13374 where
13375 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13376 {
13377 Self {}
13378 }
13379}
13380#[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
13381impl PipelineShaderStageCreateFlags {
13382 pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self::ALLOW_VARYING_SUBGROUP_SIZE;
13383 pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self::REQUIRE_FULL_SUBGROUPS;
13384}
13385#[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
13386impl StructureType {
13387 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self =
13388 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
13389 pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self =
13390 Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
13391 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self =
13392 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
13393}
13394impl KhrFragmentShadingRateFn {
13395 #[inline]
13396 pub const fn name() -> &'static ::std::ffi::CStr {
13397 unsafe {
13398 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shading_rate\0")
13399 }
13400 }
13401 pub const SPEC_VERSION: u32 = 2u32;
13402}
13403#[allow(non_camel_case_types)]
13404pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn(
13405 physical_device: PhysicalDevice,
13406 p_fragment_shading_rate_count: *mut u32,
13407 p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR,
13408) -> Result;
13409#[allow(non_camel_case_types)]
13410pub type PFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn(
13411 command_buffer: CommandBuffer,
13412 p_fragment_size: *const Extent2D,
13413 combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
13414);
13415#[derive(Clone)]
13416pub struct KhrFragmentShadingRateFn {
13417 pub get_physical_device_fragment_shading_rates_khr:
13418 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR,
13419 pub cmd_set_fragment_shading_rate_khr: PFN_vkCmdSetFragmentShadingRateKHR,
13420}
13421unsafe impl Send for KhrFragmentShadingRateFn {}
13422unsafe impl Sync for KhrFragmentShadingRateFn {}
13423impl KhrFragmentShadingRateFn {
13424 pub fn load<F>(mut _f: F) -> Self
13425 where
13426 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13427 {
13428 Self {
13429 get_physical_device_fragment_shading_rates_khr: unsafe {
13430 unsafe extern "system" fn get_physical_device_fragment_shading_rates_khr(
13431 _physical_device: PhysicalDevice,
13432 _p_fragment_shading_rate_count: *mut u32,
13433 _p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR,
13434 ) -> Result {
13435 panic!(concat!(
13436 "Unable to load ",
13437 stringify!(get_physical_device_fragment_shading_rates_khr)
13438 ))
13439 }
13440 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13441 b"vkGetPhysicalDeviceFragmentShadingRatesKHR\0",
13442 );
13443 let val = _f(cname);
13444 if val.is_null() {
13445 get_physical_device_fragment_shading_rates_khr
13446 } else {
13447 ::std::mem::transmute(val)
13448 }
13449 },
13450 cmd_set_fragment_shading_rate_khr: unsafe {
13451 unsafe extern "system" fn cmd_set_fragment_shading_rate_khr(
13452 _command_buffer: CommandBuffer,
13453 _p_fragment_size: *const Extent2D,
13454 _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
13455 ) {
13456 panic!(concat!(
13457 "Unable to load ",
13458 stringify!(cmd_set_fragment_shading_rate_khr)
13459 ))
13460 }
13461 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13462 b"vkCmdSetFragmentShadingRateKHR\0",
13463 );
13464 let val = _f(cname);
13465 if val.is_null() {
13466 cmd_set_fragment_shading_rate_khr
13467 } else {
13468 ::std::mem::transmute(val)
13469 }
13470 },
13471 }
13472 }
13473}
13474#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13475impl AccessFlags {
13476 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self =
13477 Self(0b1000_0000_0000_0000_0000_0000);
13478}
13479#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13480impl DynamicState {
13481 pub const FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_000);
13482}
13483#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13484impl FormatFeatureFlags {
13485 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
13486 Self(0b100_0000_0000_0000_0000_0000_0000_0000);
13487}
13488#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13489impl FormatFeatureFlags2 {
13490 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
13491 Self(0b100_0000_0000_0000_0000_0000_0000_0000);
13492}
13493#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13494impl ImageLayout {
13495 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_164_003);
13496}
13497#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13498impl ImageUsageFlags {
13499 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b1_0000_0000);
13500}
13501#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13502impl PipelineStageFlags {
13503 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
13504}
13505#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13506impl StructureType {
13507 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_226_000);
13508 pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1_000_226_001);
13509 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1_000_226_002);
13510 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1_000_226_003);
13511 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_004);
13512}
13513impl AmdShaderCoreProperties2Fn {
13514 #[inline]
13515 pub const fn name() -> &'static ::std::ffi::CStr {
13516 unsafe {
13517 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties2\0")
13518 }
13519 }
13520 pub const SPEC_VERSION: u32 = 1u32;
13521}
13522#[derive(Clone)]
13523pub struct AmdShaderCoreProperties2Fn {}
13524unsafe impl Send for AmdShaderCoreProperties2Fn {}
13525unsafe impl Sync for AmdShaderCoreProperties2Fn {}
13526impl AmdShaderCoreProperties2Fn {
13527 pub fn load<F>(mut _f: F) -> Self
13528 where
13529 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13530 {
13531 Self {}
13532 }
13533}
13534#[doc = "Generated from 'VK_AMD_shader_core_properties2'"]
13535impl StructureType {
13536 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1_000_227_000);
13537}
13538impl AmdExtension229Fn {
13539 #[inline]
13540 pub const fn name() -> &'static ::std::ffi::CStr {
13541 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_229\0") }
13542 }
13543 pub const SPEC_VERSION: u32 = 0u32;
13544}
13545#[derive(Clone)]
13546pub struct AmdExtension229Fn {}
13547unsafe impl Send for AmdExtension229Fn {}
13548unsafe impl Sync for AmdExtension229Fn {}
13549impl AmdExtension229Fn {
13550 pub fn load<F>(mut _f: F) -> Self
13551 where
13552 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13553 {
13554 Self {}
13555 }
13556}
13557impl AmdDeviceCoherentMemoryFn {
13558 #[inline]
13559 pub const fn name() -> &'static ::std::ffi::CStr {
13560 unsafe {
13561 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_device_coherent_memory\0")
13562 }
13563 }
13564 pub const SPEC_VERSION: u32 = 1u32;
13565}
13566#[derive(Clone)]
13567pub struct AmdDeviceCoherentMemoryFn {}
13568unsafe impl Send for AmdDeviceCoherentMemoryFn {}
13569unsafe impl Sync for AmdDeviceCoherentMemoryFn {}
13570impl AmdDeviceCoherentMemoryFn {
13571 pub fn load<F>(mut _f: F) -> Self
13572 where
13573 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13574 {
13575 Self {}
13576 }
13577}
13578#[doc = "Generated from 'VK_AMD_device_coherent_memory'"]
13579impl MemoryPropertyFlags {
13580 pub const DEVICE_COHERENT_AMD: Self = Self(0b100_0000);
13581 pub const DEVICE_UNCACHED_AMD: Self = Self(0b1000_0000);
13582}
13583#[doc = "Generated from 'VK_AMD_device_coherent_memory'"]
13584impl StructureType {
13585 pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1_000_229_000);
13586}
13587impl AmdExtension231Fn {
13588 #[inline]
13589 pub const fn name() -> &'static ::std::ffi::CStr {
13590 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_231\0") }
13591 }
13592 pub const SPEC_VERSION: u32 = 0u32;
13593}
13594#[derive(Clone)]
13595pub struct AmdExtension231Fn {}
13596unsafe impl Send for AmdExtension231Fn {}
13597unsafe impl Sync for AmdExtension231Fn {}
13598impl AmdExtension231Fn {
13599 pub fn load<F>(mut _f: F) -> Self
13600 where
13601 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13602 {
13603 Self {}
13604 }
13605}
13606impl AmdExtension232Fn {
13607 #[inline]
13608 pub const fn name() -> &'static ::std::ffi::CStr {
13609 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_232\0") }
13610 }
13611 pub const SPEC_VERSION: u32 = 0u32;
13612}
13613#[derive(Clone)]
13614pub struct AmdExtension232Fn {}
13615unsafe impl Send for AmdExtension232Fn {}
13616unsafe impl Sync for AmdExtension232Fn {}
13617impl AmdExtension232Fn {
13618 pub fn load<F>(mut _f: F) -> Self
13619 where
13620 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13621 {
13622 Self {}
13623 }
13624}
13625impl AmdExtension233Fn {
13626 #[inline]
13627 pub const fn name() -> &'static ::std::ffi::CStr {
13628 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_233\0") }
13629 }
13630 pub const SPEC_VERSION: u32 = 0u32;
13631}
13632#[derive(Clone)]
13633pub struct AmdExtension233Fn {}
13634unsafe impl Send for AmdExtension233Fn {}
13635unsafe impl Sync for AmdExtension233Fn {}
13636impl AmdExtension233Fn {
13637 pub fn load<F>(mut _f: F) -> Self
13638 where
13639 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13640 {
13641 Self {}
13642 }
13643}
13644impl AmdExtension234Fn {
13645 #[inline]
13646 pub const fn name() -> &'static ::std::ffi::CStr {
13647 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_234\0") }
13648 }
13649 pub const SPEC_VERSION: u32 = 0u32;
13650}
13651#[derive(Clone)]
13652pub struct AmdExtension234Fn {}
13653unsafe impl Send for AmdExtension234Fn {}
13654unsafe impl Sync for AmdExtension234Fn {}
13655impl AmdExtension234Fn {
13656 pub fn load<F>(mut _f: F) -> Self
13657 where
13658 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13659 {
13660 Self {}
13661 }
13662}
13663impl ExtShaderImageAtomicInt64Fn {
13664 #[inline]
13665 pub const fn name() -> &'static ::std::ffi::CStr {
13666 unsafe {
13667 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_image_atomic_int64\0")
13668 }
13669 }
13670 pub const SPEC_VERSION: u32 = 1u32;
13671}
13672#[derive(Clone)]
13673pub struct ExtShaderImageAtomicInt64Fn {}
13674unsafe impl Send for ExtShaderImageAtomicInt64Fn {}
13675unsafe impl Sync for ExtShaderImageAtomicInt64Fn {}
13676impl ExtShaderImageAtomicInt64Fn {
13677 pub fn load<F>(mut _f: F) -> Self
13678 where
13679 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13680 {
13681 Self {}
13682 }
13683}
13684#[doc = "Generated from 'VK_EXT_shader_image_atomic_int64'"]
13685impl StructureType {
13686 pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self(1_000_234_000);
13687}
13688impl AmdExtension236Fn {
13689 #[inline]
13690 pub const fn name() -> &'static ::std::ffi::CStr {
13691 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_236\0") }
13692 }
13693 pub const SPEC_VERSION: u32 = 0u32;
13694}
13695#[derive(Clone)]
13696pub struct AmdExtension236Fn {}
13697unsafe impl Send for AmdExtension236Fn {}
13698unsafe impl Sync for AmdExtension236Fn {}
13699impl AmdExtension236Fn {
13700 pub fn load<F>(mut _f: F) -> Self
13701 where
13702 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13703 {
13704 Self {}
13705 }
13706}
13707impl KhrSpirv14Fn {
13708 #[inline]
13709 pub const fn name() -> &'static ::std::ffi::CStr {
13710 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_spirv_1_4\0") }
13711 }
13712 pub const SPEC_VERSION: u32 = 1u32;
13713}
13714#[derive(Clone)]
13715pub struct KhrSpirv14Fn {}
13716unsafe impl Send for KhrSpirv14Fn {}
13717unsafe impl Sync for KhrSpirv14Fn {}
13718impl KhrSpirv14Fn {
13719 pub fn load<F>(mut _f: F) -> Self
13720 where
13721 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13722 {
13723 Self {}
13724 }
13725}
13726impl ExtMemoryBudgetFn {
13727 #[inline]
13728 pub const fn name() -> &'static ::std::ffi::CStr {
13729 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_budget\0") }
13730 }
13731 pub const SPEC_VERSION: u32 = 1u32;
13732}
13733#[derive(Clone)]
13734pub struct ExtMemoryBudgetFn {}
13735unsafe impl Send for ExtMemoryBudgetFn {}
13736unsafe impl Sync for ExtMemoryBudgetFn {}
13737impl ExtMemoryBudgetFn {
13738 pub fn load<F>(mut _f: F) -> Self
13739 where
13740 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13741 {
13742 Self {}
13743 }
13744}
13745#[doc = "Generated from 'VK_EXT_memory_budget'"]
13746impl StructureType {
13747 pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1_000_237_000);
13748}
13749impl ExtMemoryPriorityFn {
13750 #[inline]
13751 pub const fn name() -> &'static ::std::ffi::CStr {
13752 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_priority\0") }
13753 }
13754 pub const SPEC_VERSION: u32 = 1u32;
13755}
13756#[derive(Clone)]
13757pub struct ExtMemoryPriorityFn {}
13758unsafe impl Send for ExtMemoryPriorityFn {}
13759unsafe impl Sync for ExtMemoryPriorityFn {}
13760impl ExtMemoryPriorityFn {
13761 pub fn load<F>(mut _f: F) -> Self
13762 where
13763 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13764 {
13765 Self {}
13766 }
13767}
13768#[doc = "Generated from 'VK_EXT_memory_priority'"]
13769impl StructureType {
13770 pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1_000_238_000);
13771 pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1_000_238_001);
13772}
13773impl KhrSurfaceProtectedCapabilitiesFn {
13774 #[inline]
13775 pub const fn name() -> &'static ::std::ffi::CStr {
13776 unsafe {
13777 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13778 b"VK_KHR_surface_protected_capabilities\0",
13779 )
13780 }
13781 }
13782 pub const SPEC_VERSION: u32 = 1u32;
13783}
13784#[derive(Clone)]
13785pub struct KhrSurfaceProtectedCapabilitiesFn {}
13786unsafe impl Send for KhrSurfaceProtectedCapabilitiesFn {}
13787unsafe impl Sync for KhrSurfaceProtectedCapabilitiesFn {}
13788impl KhrSurfaceProtectedCapabilitiesFn {
13789 pub fn load<F>(mut _f: F) -> Self
13790 where
13791 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13792 {
13793 Self {}
13794 }
13795}
13796#[doc = "Generated from 'VK_KHR_surface_protected_capabilities'"]
13797impl StructureType {
13798 pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1_000_239_000);
13799}
13800impl NvDedicatedAllocationImageAliasingFn {
13801 #[inline]
13802 pub const fn name() -> &'static ::std::ffi::CStr {
13803 unsafe {
13804 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13805 b"VK_NV_dedicated_allocation_image_aliasing\0",
13806 )
13807 }
13808 }
13809 pub const SPEC_VERSION: u32 = 1u32;
13810}
13811#[derive(Clone)]
13812pub struct NvDedicatedAllocationImageAliasingFn {}
13813unsafe impl Send for NvDedicatedAllocationImageAliasingFn {}
13814unsafe impl Sync for NvDedicatedAllocationImageAliasingFn {}
13815impl NvDedicatedAllocationImageAliasingFn {
13816 pub fn load<F>(mut _f: F) -> Self
13817 where
13818 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13819 {
13820 Self {}
13821 }
13822}
13823#[doc = "Generated from 'VK_NV_dedicated_allocation_image_aliasing'"]
13824impl StructureType {
13825 pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self =
13826 Self(1_000_240_000);
13827}
13828impl KhrSeparateDepthStencilLayoutsFn {
13829 #[inline]
13830 pub const fn name() -> &'static ::std::ffi::CStr {
13831 unsafe {
13832 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13833 b"VK_KHR_separate_depth_stencil_layouts\0",
13834 )
13835 }
13836 }
13837 pub const SPEC_VERSION: u32 = 1u32;
13838}
13839#[derive(Clone)]
13840pub struct KhrSeparateDepthStencilLayoutsFn {}
13841unsafe impl Send for KhrSeparateDepthStencilLayoutsFn {}
13842unsafe impl Sync for KhrSeparateDepthStencilLayoutsFn {}
13843impl KhrSeparateDepthStencilLayoutsFn {
13844 pub fn load<F>(mut _f: F) -> Self
13845 where
13846 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13847 {
13848 Self {}
13849 }
13850}
13851#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
13852impl ImageLayout {
13853 pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = Self::DEPTH_ATTACHMENT_OPTIMAL;
13854 pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = Self::DEPTH_READ_ONLY_OPTIMAL;
13855 pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self::STENCIL_ATTACHMENT_OPTIMAL;
13856 pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self::STENCIL_READ_ONLY_OPTIMAL;
13857}
13858#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
13859impl StructureType {
13860 pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self =
13861 Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
13862 pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self =
13863 Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
13864 pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self =
13865 Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
13866}
13867impl IntelExtension243Fn {
13868 #[inline]
13869 pub const fn name() -> &'static ::std::ffi::CStr {
13870 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_243\0") }
13871 }
13872 pub const SPEC_VERSION: u32 = 0u32;
13873}
13874#[derive(Clone)]
13875pub struct IntelExtension243Fn {}
13876unsafe impl Send for IntelExtension243Fn {}
13877unsafe impl Sync for IntelExtension243Fn {}
13878impl IntelExtension243Fn {
13879 pub fn load<F>(mut _f: F) -> Self
13880 where
13881 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13882 {
13883 Self {}
13884 }
13885}
13886#[doc = "Generated from 'VK_INTEL_extension_243'"]
13887impl AccessFlags2 {
13888 pub const RESERVED_46_EXT: Self =
13889 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
13890}
13891impl MesaExtension244Fn {
13892 #[inline]
13893 pub const fn name() -> &'static ::std::ffi::CStr {
13894 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_244\0") }
13895 }
13896 pub const SPEC_VERSION: u32 = 0u32;
13897}
13898#[derive(Clone)]
13899pub struct MesaExtension244Fn {}
13900unsafe impl Send for MesaExtension244Fn {}
13901unsafe impl Sync for MesaExtension244Fn {}
13902impl MesaExtension244Fn {
13903 pub fn load<F>(mut _f: F) -> Self
13904 where
13905 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13906 {
13907 Self {}
13908 }
13909}
13910impl ExtBufferDeviceAddressFn {
13911 #[inline]
13912 pub const fn name() -> &'static ::std::ffi::CStr {
13913 unsafe {
13914 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_buffer_device_address\0")
13915 }
13916 }
13917 pub const SPEC_VERSION: u32 = 2u32;
13918}
13919#[allow(non_camel_case_types)]
13920pub type PFN_vkGetBufferDeviceAddress = unsafe extern "system" fn(
13921 device: Device,
13922 p_info: *const BufferDeviceAddressInfo,
13923) -> DeviceAddress;
13924#[derive(Clone)]
13925pub struct ExtBufferDeviceAddressFn {
13926 pub get_buffer_device_address_ext: PFN_vkGetBufferDeviceAddress,
13927}
13928unsafe impl Send for ExtBufferDeviceAddressFn {}
13929unsafe impl Sync for ExtBufferDeviceAddressFn {}
13930impl ExtBufferDeviceAddressFn {
13931 pub fn load<F>(mut _f: F) -> Self
13932 where
13933 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13934 {
13935 Self {
13936 get_buffer_device_address_ext: unsafe {
13937 unsafe extern "system" fn get_buffer_device_address_ext(
13938 _device: Device,
13939 _p_info: *const BufferDeviceAddressInfo,
13940 ) -> DeviceAddress {
13941 panic!(concat!(
13942 "Unable to load ",
13943 stringify!(get_buffer_device_address_ext)
13944 ))
13945 }
13946 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13947 b"vkGetBufferDeviceAddressEXT\0",
13948 );
13949 let val = _f(cname);
13950 if val.is_null() {
13951 get_buffer_device_address_ext
13952 } else {
13953 ::std::mem::transmute(val)
13954 }
13955 },
13956 }
13957 }
13958}
13959#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13960impl BufferCreateFlags {
13961 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
13962}
13963#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13964impl BufferUsageFlags {
13965 pub const SHADER_DEVICE_ADDRESS_EXT: Self = Self::SHADER_DEVICE_ADDRESS;
13966}
13967#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13968impl Result {
13969 pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
13970}
13971#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13972impl StructureType {
13973 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000);
13974 pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self =
13975 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
13976 pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
13977 pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002);
13978}
13979impl ExtToolingInfoFn {
13980 #[inline]
13981 pub const fn name() -> &'static ::std::ffi::CStr {
13982 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_tooling_info\0") }
13983 }
13984 pub const SPEC_VERSION: u32 = 1u32;
13985}
13986#[allow(non_camel_case_types)]
13987pub type PFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn(
13988 physical_device: PhysicalDevice,
13989 p_tool_count: *mut u32,
13990 p_tool_properties: *mut PhysicalDeviceToolProperties,
13991) -> Result;
13992#[derive(Clone)]
13993pub struct ExtToolingInfoFn {
13994 pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties,
13995}
13996unsafe impl Send for ExtToolingInfoFn {}
13997unsafe impl Sync for ExtToolingInfoFn {}
13998impl ExtToolingInfoFn {
13999 pub fn load<F>(mut _f: F) -> Self
14000 where
14001 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14002 {
14003 Self {
14004 get_physical_device_tool_properties_ext: unsafe {
14005 unsafe extern "system" fn get_physical_device_tool_properties_ext(
14006 _physical_device: PhysicalDevice,
14007 _p_tool_count: *mut u32,
14008 _p_tool_properties: *mut PhysicalDeviceToolProperties,
14009 ) -> Result {
14010 panic!(concat!(
14011 "Unable to load ",
14012 stringify!(get_physical_device_tool_properties_ext)
14013 ))
14014 }
14015 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14016 b"vkGetPhysicalDeviceToolPropertiesEXT\0",
14017 );
14018 let val = _f(cname);
14019 if val.is_null() {
14020 get_physical_device_tool_properties_ext
14021 } else {
14022 ::std::mem::transmute(val)
14023 }
14024 },
14025 }
14026 }
14027}
14028#[doc = "Generated from 'VK_EXT_tooling_info'"]
14029impl StructureType {
14030 pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self::PHYSICAL_DEVICE_TOOL_PROPERTIES;
14031}
14032#[doc = "Generated from 'VK_EXT_tooling_info'"]
14033impl ToolPurposeFlags {
14034 pub const DEBUG_REPORTING_EXT: Self = Self(0b10_0000);
14035 pub const DEBUG_MARKERS_EXT: Self = Self(0b100_0000);
14036}
14037impl ExtSeparateStencilUsageFn {
14038 #[inline]
14039 pub const fn name() -> &'static ::std::ffi::CStr {
14040 unsafe {
14041 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_separate_stencil_usage\0")
14042 }
14043 }
14044 pub const SPEC_VERSION: u32 = 1u32;
14045}
14046#[derive(Clone)]
14047pub struct ExtSeparateStencilUsageFn {}
14048unsafe impl Send for ExtSeparateStencilUsageFn {}
14049unsafe impl Sync for ExtSeparateStencilUsageFn {}
14050impl ExtSeparateStencilUsageFn {
14051 pub fn load<F>(mut _f: F) -> Self
14052 where
14053 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14054 {
14055 Self {}
14056 }
14057}
14058#[doc = "Generated from 'VK_EXT_separate_stencil_usage'"]
14059impl StructureType {
14060 pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = Self::IMAGE_STENCIL_USAGE_CREATE_INFO;
14061}
14062impl ExtValidationFeaturesFn {
14063 #[inline]
14064 pub const fn name() -> &'static ::std::ffi::CStr {
14065 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_features\0") }
14066 }
14067 pub const SPEC_VERSION: u32 = 5u32;
14068}
14069#[derive(Clone)]
14070pub struct ExtValidationFeaturesFn {}
14071unsafe impl Send for ExtValidationFeaturesFn {}
14072unsafe impl Sync for ExtValidationFeaturesFn {}
14073impl ExtValidationFeaturesFn {
14074 pub fn load<F>(mut _f: F) -> Self
14075 where
14076 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14077 {
14078 Self {}
14079 }
14080}
14081#[doc = "Generated from 'VK_EXT_validation_features'"]
14082impl StructureType {
14083 pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000);
14084}
14085impl KhrPresentWaitFn {
14086 #[inline]
14087 pub const fn name() -> &'static ::std::ffi::CStr {
14088 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_wait\0") }
14089 }
14090 pub const SPEC_VERSION: u32 = 1u32;
14091}
14092#[allow(non_camel_case_types)]
14093pub type PFN_vkWaitForPresentKHR = unsafe extern "system" fn(
14094 device: Device,
14095 swapchain: SwapchainKHR,
14096 present_id: u64,
14097 timeout: u64,
14098) -> Result;
14099#[derive(Clone)]
14100pub struct KhrPresentWaitFn {
14101 pub wait_for_present_khr: PFN_vkWaitForPresentKHR,
14102}
14103unsafe impl Send for KhrPresentWaitFn {}
14104unsafe impl Sync for KhrPresentWaitFn {}
14105impl KhrPresentWaitFn {
14106 pub fn load<F>(mut _f: F) -> Self
14107 where
14108 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14109 {
14110 Self {
14111 wait_for_present_khr: unsafe {
14112 unsafe extern "system" fn wait_for_present_khr(
14113 _device: Device,
14114 _swapchain: SwapchainKHR,
14115 _present_id: u64,
14116 _timeout: u64,
14117 ) -> Result {
14118 panic!(concat!("Unable to load ", stringify!(wait_for_present_khr)))
14119 }
14120 let cname =
14121 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0");
14122 let val = _f(cname);
14123 if val.is_null() {
14124 wait_for_present_khr
14125 } else {
14126 ::std::mem::transmute(val)
14127 }
14128 },
14129 }
14130 }
14131}
14132#[doc = "Generated from 'VK_KHR_present_wait'"]
14133impl StructureType {
14134 pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000);
14135}
14136impl NvCooperativeMatrixFn {
14137 #[inline]
14138 pub const fn name() -> &'static ::std::ffi::CStr {
14139 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_cooperative_matrix\0") }
14140 }
14141 pub const SPEC_VERSION: u32 = 1u32;
14142}
14143#[allow(non_camel_case_types)]
14144pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn(
14145 physical_device: PhysicalDevice,
14146 p_property_count: *mut u32,
14147 p_properties: *mut CooperativeMatrixPropertiesNV,
14148)
14149 -> Result;
14150#[derive(Clone)]
14151pub struct NvCooperativeMatrixFn {
14152 pub get_physical_device_cooperative_matrix_properties_nv:
14153 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
14154}
14155unsafe impl Send for NvCooperativeMatrixFn {}
14156unsafe impl Sync for NvCooperativeMatrixFn {}
14157impl NvCooperativeMatrixFn {
14158 pub fn load<F>(mut _f: F) -> Self
14159 where
14160 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14161 {
14162 Self {
14163 get_physical_device_cooperative_matrix_properties_nv: unsafe {
14164 unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_nv(
14165 _physical_device: PhysicalDevice,
14166 _p_property_count: *mut u32,
14167 _p_properties: *mut CooperativeMatrixPropertiesNV,
14168 ) -> Result {
14169 panic!(concat!(
14170 "Unable to load ",
14171 stringify!(get_physical_device_cooperative_matrix_properties_nv)
14172 ))
14173 }
14174 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14175 b"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV\0",
14176 );
14177 let val = _f(cname);
14178 if val.is_null() {
14179 get_physical_device_cooperative_matrix_properties_nv
14180 } else {
14181 ::std::mem::transmute(val)
14182 }
14183 },
14184 }
14185 }
14186}
14187#[doc = "Generated from 'VK_NV_cooperative_matrix'"]
14188impl StructureType {
14189 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000);
14190 pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001);
14191 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_002);
14192}
14193impl NvCoverageReductionModeFn {
14194 #[inline]
14195 pub const fn name() -> &'static ::std::ffi::CStr {
14196 unsafe {
14197 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_coverage_reduction_mode\0")
14198 }
14199 }
14200 pub const SPEC_VERSION: u32 = 1u32;
14201}
14202#[allow(non_camel_case_types)]
14203pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV =
14204 unsafe extern "system" fn(
14205 physical_device: PhysicalDevice,
14206 p_combination_count: *mut u32,
14207 p_combinations: *mut FramebufferMixedSamplesCombinationNV,
14208 ) -> Result;
14209#[derive(Clone)]
14210pub struct NvCoverageReductionModeFn {
14211 pub get_physical_device_supported_framebuffer_mixed_samples_combinations_nv:
14212 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
14213}
14214unsafe impl Send for NvCoverageReductionModeFn {}
14215unsafe impl Sync for NvCoverageReductionModeFn {}
14216impl NvCoverageReductionModeFn {
14217 pub fn load<F>(mut _f: F) -> Self
14218 where
14219 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14220 {
14221 Self {
14222 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe {
14223 unsafe extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
14224 _physical_device: PhysicalDevice,
14225 _p_combination_count: *mut u32,
14226 _p_combinations: *mut FramebufferMixedSamplesCombinationNV,
14227 ) -> Result {
14228 panic!(concat!(
14229 "Unable to load ",
14230 stringify!(
14231 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv
14232 )
14233 ))
14234 }
14235 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14236 b"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV\0",
14237 );
14238 let val = _f(cname);
14239 if val.is_null() {
14240 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv
14241 } else {
14242 ::std::mem::transmute(val)
14243 }
14244 },
14245 }
14246 }
14247}
14248#[doc = "Generated from 'VK_NV_coverage_reduction_mode'"]
14249impl StructureType {
14250 pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1_000_250_000);
14251 pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1_000_250_001);
14252 pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1_000_250_002);
14253}
14254impl ExtFragmentShaderInterlockFn {
14255 #[inline]
14256 pub const fn name() -> &'static ::std::ffi::CStr {
14257 unsafe {
14258 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_shader_interlock\0")
14259 }
14260 }
14261 pub const SPEC_VERSION: u32 = 1u32;
14262}
14263#[derive(Clone)]
14264pub struct ExtFragmentShaderInterlockFn {}
14265unsafe impl Send for ExtFragmentShaderInterlockFn {}
14266unsafe impl Sync for ExtFragmentShaderInterlockFn {}
14267impl ExtFragmentShaderInterlockFn {
14268 pub fn load<F>(mut _f: F) -> Self
14269 where
14270 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14271 {
14272 Self {}
14273 }
14274}
14275#[doc = "Generated from 'VK_EXT_fragment_shader_interlock'"]
14276impl StructureType {
14277 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1_000_251_000);
14278}
14279impl ExtYcbcrImageArraysFn {
14280 #[inline]
14281 pub const fn name() -> &'static ::std::ffi::CStr {
14282 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_image_arrays\0") }
14283 }
14284 pub const SPEC_VERSION: u32 = 1u32;
14285}
14286#[derive(Clone)]
14287pub struct ExtYcbcrImageArraysFn {}
14288unsafe impl Send for ExtYcbcrImageArraysFn {}
14289unsafe impl Sync for ExtYcbcrImageArraysFn {}
14290impl ExtYcbcrImageArraysFn {
14291 pub fn load<F>(mut _f: F) -> Self
14292 where
14293 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14294 {
14295 Self {}
14296 }
14297}
14298#[doc = "Generated from 'VK_EXT_ycbcr_image_arrays'"]
14299impl StructureType {
14300 pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1_000_252_000);
14301}
14302impl KhrUniformBufferStandardLayoutFn {
14303 #[inline]
14304 pub const fn name() -> &'static ::std::ffi::CStr {
14305 unsafe {
14306 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14307 b"VK_KHR_uniform_buffer_standard_layout\0",
14308 )
14309 }
14310 }
14311 pub const SPEC_VERSION: u32 = 1u32;
14312}
14313#[derive(Clone)]
14314pub struct KhrUniformBufferStandardLayoutFn {}
14315unsafe impl Send for KhrUniformBufferStandardLayoutFn {}
14316unsafe impl Sync for KhrUniformBufferStandardLayoutFn {}
14317impl KhrUniformBufferStandardLayoutFn {
14318 pub fn load<F>(mut _f: F) -> Self
14319 where
14320 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14321 {
14322 Self {}
14323 }
14324}
14325#[doc = "Generated from 'VK_KHR_uniform_buffer_standard_layout'"]
14326impl StructureType {
14327 pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self =
14328 Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
14329}
14330impl ExtProvokingVertexFn {
14331 #[inline]
14332 pub const fn name() -> &'static ::std::ffi::CStr {
14333 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_provoking_vertex\0") }
14334 }
14335 pub const SPEC_VERSION: u32 = 1u32;
14336}
14337#[derive(Clone)]
14338pub struct ExtProvokingVertexFn {}
14339unsafe impl Send for ExtProvokingVertexFn {}
14340unsafe impl Sync for ExtProvokingVertexFn {}
14341impl ExtProvokingVertexFn {
14342 pub fn load<F>(mut _f: F) -> Self
14343 where
14344 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14345 {
14346 Self {}
14347 }
14348}
14349#[doc = "Generated from 'VK_EXT_provoking_vertex'"]
14350impl StructureType {
14351 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1_000_254_000);
14352 pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: Self =
14353 Self(1_000_254_001);
14354 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: Self = Self(1_000_254_002);
14355}
14356impl ExtFullScreenExclusiveFn {
14357 #[inline]
14358 pub const fn name() -> &'static ::std::ffi::CStr {
14359 unsafe {
14360 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_full_screen_exclusive\0")
14361 }
14362 }
14363 pub const SPEC_VERSION: u32 = 4u32;
14364}
14365#[allow(non_camel_case_types)]
14366pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = unsafe extern "system" fn(
14367 physical_device: PhysicalDevice,
14368 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14369 p_present_mode_count: *mut u32,
14370 p_present_modes: *mut PresentModeKHR,
14371) -> Result;
14372#[allow(non_camel_case_types)]
14373pub type PFN_vkAcquireFullScreenExclusiveModeEXT =
14374 unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result;
14375#[allow(non_camel_case_types)]
14376pub type PFN_vkReleaseFullScreenExclusiveModeEXT =
14377 unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result;
14378#[allow(non_camel_case_types)]
14379pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = unsafe extern "system" fn(
14380 device: Device,
14381 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14382 p_modes: *mut DeviceGroupPresentModeFlagsKHR,
14383) -> Result;
14384#[derive(Clone)]
14385pub struct ExtFullScreenExclusiveFn {
14386 pub get_physical_device_surface_present_modes2_ext:
14387 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT,
14388 pub acquire_full_screen_exclusive_mode_ext: PFN_vkAcquireFullScreenExclusiveModeEXT,
14389 pub release_full_screen_exclusive_mode_ext: PFN_vkReleaseFullScreenExclusiveModeEXT,
14390 pub get_device_group_surface_present_modes2_ext: PFN_vkGetDeviceGroupSurfacePresentModes2EXT,
14391}
14392unsafe impl Send for ExtFullScreenExclusiveFn {}
14393unsafe impl Sync for ExtFullScreenExclusiveFn {}
14394impl ExtFullScreenExclusiveFn {
14395 pub fn load<F>(mut _f: F) -> Self
14396 where
14397 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14398 {
14399 Self {
14400 get_physical_device_surface_present_modes2_ext: unsafe {
14401 unsafe extern "system" fn get_physical_device_surface_present_modes2_ext(
14402 _physical_device: PhysicalDevice,
14403 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14404 _p_present_mode_count: *mut u32,
14405 _p_present_modes: *mut PresentModeKHR,
14406 ) -> Result {
14407 panic!(concat!(
14408 "Unable to load ",
14409 stringify!(get_physical_device_surface_present_modes2_ext)
14410 ))
14411 }
14412 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14413 b"vkGetPhysicalDeviceSurfacePresentModes2EXT\0",
14414 );
14415 let val = _f(cname);
14416 if val.is_null() {
14417 get_physical_device_surface_present_modes2_ext
14418 } else {
14419 ::std::mem::transmute(val)
14420 }
14421 },
14422 acquire_full_screen_exclusive_mode_ext: unsafe {
14423 unsafe extern "system" fn acquire_full_screen_exclusive_mode_ext(
14424 _device: Device,
14425 _swapchain: SwapchainKHR,
14426 ) -> Result {
14427 panic!(concat!(
14428 "Unable to load ",
14429 stringify!(acquire_full_screen_exclusive_mode_ext)
14430 ))
14431 }
14432 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14433 b"vkAcquireFullScreenExclusiveModeEXT\0",
14434 );
14435 let val = _f(cname);
14436 if val.is_null() {
14437 acquire_full_screen_exclusive_mode_ext
14438 } else {
14439 ::std::mem::transmute(val)
14440 }
14441 },
14442 release_full_screen_exclusive_mode_ext: unsafe {
14443 unsafe extern "system" fn release_full_screen_exclusive_mode_ext(
14444 _device: Device,
14445 _swapchain: SwapchainKHR,
14446 ) -> Result {
14447 panic!(concat!(
14448 "Unable to load ",
14449 stringify!(release_full_screen_exclusive_mode_ext)
14450 ))
14451 }
14452 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14453 b"vkReleaseFullScreenExclusiveModeEXT\0",
14454 );
14455 let val = _f(cname);
14456 if val.is_null() {
14457 release_full_screen_exclusive_mode_ext
14458 } else {
14459 ::std::mem::transmute(val)
14460 }
14461 },
14462 get_device_group_surface_present_modes2_ext: unsafe {
14463 unsafe extern "system" fn get_device_group_surface_present_modes2_ext(
14464 _device: Device,
14465 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14466 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
14467 ) -> Result {
14468 panic!(concat!(
14469 "Unable to load ",
14470 stringify!(get_device_group_surface_present_modes2_ext)
14471 ))
14472 }
14473 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14474 b"vkGetDeviceGroupSurfacePresentModes2EXT\0",
14475 );
14476 let val = _f(cname);
14477 if val.is_null() {
14478 get_device_group_surface_present_modes2_ext
14479 } else {
14480 ::std::mem::transmute(val)
14481 }
14482 },
14483 }
14484 }
14485}
14486#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
14487impl Result {
14488 pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1_000_255_000);
14489}
14490#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
14491impl StructureType {
14492 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000);
14493 pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002);
14494 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1_000_255_001);
14495}
14496impl ExtHeadlessSurfaceFn {
14497 #[inline]
14498 pub const fn name() -> &'static ::std::ffi::CStr {
14499 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_headless_surface\0") }
14500 }
14501 pub const SPEC_VERSION: u32 = 1u32;
14502}
14503#[allow(non_camel_case_types)]
14504pub type PFN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn(
14505 instance: Instance,
14506 p_create_info: *const HeadlessSurfaceCreateInfoEXT,
14507 p_allocator: *const AllocationCallbacks,
14508 p_surface: *mut SurfaceKHR,
14509) -> Result;
14510#[derive(Clone)]
14511pub struct ExtHeadlessSurfaceFn {
14512 pub create_headless_surface_ext: PFN_vkCreateHeadlessSurfaceEXT,
14513}
14514unsafe impl Send for ExtHeadlessSurfaceFn {}
14515unsafe impl Sync for ExtHeadlessSurfaceFn {}
14516impl ExtHeadlessSurfaceFn {
14517 pub fn load<F>(mut _f: F) -> Self
14518 where
14519 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14520 {
14521 Self {
14522 create_headless_surface_ext: unsafe {
14523 unsafe extern "system" fn create_headless_surface_ext(
14524 _instance: Instance,
14525 _p_create_info: *const HeadlessSurfaceCreateInfoEXT,
14526 _p_allocator: *const AllocationCallbacks,
14527 _p_surface: *mut SurfaceKHR,
14528 ) -> Result {
14529 panic!(concat!(
14530 "Unable to load ",
14531 stringify!(create_headless_surface_ext)
14532 ))
14533 }
14534 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14535 b"vkCreateHeadlessSurfaceEXT\0",
14536 );
14537 let val = _f(cname);
14538 if val.is_null() {
14539 create_headless_surface_ext
14540 } else {
14541 ::std::mem::transmute(val)
14542 }
14543 },
14544 }
14545 }
14546}
14547#[doc = "Generated from 'VK_EXT_headless_surface'"]
14548impl StructureType {
14549 pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_256_000);
14550}
14551impl KhrBufferDeviceAddressFn {
14552 #[inline]
14553 pub const fn name() -> &'static ::std::ffi::CStr {
14554 unsafe {
14555 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_buffer_device_address\0")
14556 }
14557 }
14558 pub const SPEC_VERSION: u32 = 1u32;
14559}
14560#[allow(non_camel_case_types)]
14561pub type PFN_vkGetBufferOpaqueCaptureAddress =
14562 unsafe extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64;
14563#[allow(non_camel_case_types)]
14564pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn(
14565 device: Device,
14566 p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
14567) -> u64;
14568#[derive(Clone)]
14569pub struct KhrBufferDeviceAddressFn {
14570 pub get_buffer_device_address_khr: crate::vk::PFN_vkGetBufferDeviceAddress,
14571 pub get_buffer_opaque_capture_address_khr: PFN_vkGetBufferOpaqueCaptureAddress,
14572 pub get_device_memory_opaque_capture_address_khr: PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
14573}
14574unsafe impl Send for KhrBufferDeviceAddressFn {}
14575unsafe impl Sync for KhrBufferDeviceAddressFn {}
14576impl KhrBufferDeviceAddressFn {
14577 pub fn load<F>(mut _f: F) -> Self
14578 where
14579 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14580 {
14581 Self {
14582 get_buffer_device_address_khr: unsafe {
14583 unsafe extern "system" fn get_buffer_device_address_khr(
14584 _device: Device,
14585 _p_info: *const BufferDeviceAddressInfo,
14586 ) -> DeviceAddress {
14587 panic!(concat!(
14588 "Unable to load ",
14589 stringify!(get_buffer_device_address_khr)
14590 ))
14591 }
14592 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14593 b"vkGetBufferDeviceAddressKHR\0",
14594 );
14595 let val = _f(cname);
14596 if val.is_null() {
14597 get_buffer_device_address_khr
14598 } else {
14599 ::std::mem::transmute(val)
14600 }
14601 },
14602 get_buffer_opaque_capture_address_khr: unsafe {
14603 unsafe extern "system" fn get_buffer_opaque_capture_address_khr(
14604 _device: Device,
14605 _p_info: *const BufferDeviceAddressInfo,
14606 ) -> u64 {
14607 panic!(concat!(
14608 "Unable to load ",
14609 stringify!(get_buffer_opaque_capture_address_khr)
14610 ))
14611 }
14612 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14613 b"vkGetBufferOpaqueCaptureAddressKHR\0",
14614 );
14615 let val = _f(cname);
14616 if val.is_null() {
14617 get_buffer_opaque_capture_address_khr
14618 } else {
14619 ::std::mem::transmute(val)
14620 }
14621 },
14622 get_device_memory_opaque_capture_address_khr: unsafe {
14623 unsafe extern "system" fn get_device_memory_opaque_capture_address_khr(
14624 _device: Device,
14625 _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
14626 ) -> u64 {
14627 panic!(concat!(
14628 "Unable to load ",
14629 stringify!(get_device_memory_opaque_capture_address_khr)
14630 ))
14631 }
14632 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14633 b"vkGetDeviceMemoryOpaqueCaptureAddressKHR\0",
14634 );
14635 let val = _f(cname);
14636 if val.is_null() {
14637 get_device_memory_opaque_capture_address_khr
14638 } else {
14639 ::std::mem::transmute(val)
14640 }
14641 },
14642 }
14643 }
14644}
14645#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14646impl BufferCreateFlags {
14647 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
14648}
14649#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14650impl BufferUsageFlags {
14651 pub const SHADER_DEVICE_ADDRESS_KHR: Self = Self::SHADER_DEVICE_ADDRESS;
14652}
14653#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14654impl MemoryAllocateFlags {
14655 pub const DEVICE_ADDRESS_KHR: Self = Self::DEVICE_ADDRESS;
14656 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
14657}
14658#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14659impl Result {
14660 pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self =
14661 Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
14662}
14663#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14664impl StructureType {
14665 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self =
14666 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
14667 pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
14668 pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self =
14669 Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
14670 pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self =
14671 Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
14672 pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self =
14673 Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
14674}
14675impl ExtExtension259Fn {
14676 #[inline]
14677 pub const fn name() -> &'static ::std::ffi::CStr {
14678 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_259\0") }
14679 }
14680 pub const SPEC_VERSION: u32 = 0u32;
14681}
14682#[derive(Clone)]
14683pub struct ExtExtension259Fn {}
14684unsafe impl Send for ExtExtension259Fn {}
14685unsafe impl Sync for ExtExtension259Fn {}
14686impl ExtExtension259Fn {
14687 pub fn load<F>(mut _f: F) -> Self
14688 where
14689 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14690 {
14691 Self {}
14692 }
14693}
14694#[doc = "Generated from 'VK_EXT_extension_259'"]
14695impl FormatFeatureFlags2 {
14696 pub const RESERVED_44_EXT: Self =
14697 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
14698 pub const RESERVED_45_EXT: Self =
14699 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
14700}
14701#[doc = "Generated from 'VK_EXT_extension_259'"]
14702impl ImageCreateFlags {
14703 pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000);
14704}
14705#[doc = "Generated from 'VK_EXT_extension_259'"]
14706impl QueueFlags {
14707 pub const RESERVED_9_EXT: Self = Self(0b10_0000_0000);
14708}
14709impl ExtLineRasterizationFn {
14710 #[inline]
14711 pub const fn name() -> &'static ::std::ffi::CStr {
14712 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_line_rasterization\0") }
14713 }
14714 pub const SPEC_VERSION: u32 = 1u32;
14715}
14716#[allow(non_camel_case_types)]
14717pub type PFN_vkCmdSetLineStippleEXT = unsafe extern "system" fn(
14718 command_buffer: CommandBuffer,
14719 line_stipple_factor: u32,
14720 line_stipple_pattern: u16,
14721);
14722#[derive(Clone)]
14723pub struct ExtLineRasterizationFn {
14724 pub cmd_set_line_stipple_ext: PFN_vkCmdSetLineStippleEXT,
14725}
14726unsafe impl Send for ExtLineRasterizationFn {}
14727unsafe impl Sync for ExtLineRasterizationFn {}
14728impl ExtLineRasterizationFn {
14729 pub fn load<F>(mut _f: F) -> Self
14730 where
14731 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14732 {
14733 Self {
14734 cmd_set_line_stipple_ext: unsafe {
14735 unsafe extern "system" fn cmd_set_line_stipple_ext(
14736 _command_buffer: CommandBuffer,
14737 _line_stipple_factor: u32,
14738 _line_stipple_pattern: u16,
14739 ) {
14740 panic!(concat!(
14741 "Unable to load ",
14742 stringify!(cmd_set_line_stipple_ext)
14743 ))
14744 }
14745 let cname =
14746 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEXT\0");
14747 let val = _f(cname);
14748 if val.is_null() {
14749 cmd_set_line_stipple_ext
14750 } else {
14751 ::std::mem::transmute(val)
14752 }
14753 },
14754 }
14755 }
14756}
14757#[doc = "Generated from 'VK_EXT_line_rasterization'"]
14758impl DynamicState {
14759 pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000);
14760}
14761#[doc = "Generated from 'VK_EXT_line_rasterization'"]
14762impl StructureType {
14763 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000);
14764 pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1_000_259_001);
14765 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_259_002);
14766}
14767impl ExtShaderAtomicFloatFn {
14768 #[inline]
14769 pub const fn name() -> &'static ::std::ffi::CStr {
14770 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float\0") }
14771 }
14772 pub const SPEC_VERSION: u32 = 1u32;
14773}
14774#[derive(Clone)]
14775pub struct ExtShaderAtomicFloatFn {}
14776unsafe impl Send for ExtShaderAtomicFloatFn {}
14777unsafe impl Sync for ExtShaderAtomicFloatFn {}
14778impl ExtShaderAtomicFloatFn {
14779 pub fn load<F>(mut _f: F) -> Self
14780 where
14781 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14782 {
14783 Self {}
14784 }
14785}
14786#[doc = "Generated from 'VK_EXT_shader_atomic_float'"]
14787impl StructureType {
14788 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1_000_260_000);
14789}
14790impl ExtHostQueryResetFn {
14791 #[inline]
14792 pub const fn name() -> &'static ::std::ffi::CStr {
14793 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_host_query_reset\0") }
14794 }
14795 pub const SPEC_VERSION: u32 = 1u32;
14796}
14797#[allow(non_camel_case_types)]
14798pub type PFN_vkResetQueryPool = unsafe extern "system" fn(
14799 device: Device,
14800 query_pool: QueryPool,
14801 first_query: u32,
14802 query_count: u32,
14803);
14804#[derive(Clone)]
14805pub struct ExtHostQueryResetFn {
14806 pub reset_query_pool_ext: PFN_vkResetQueryPool,
14807}
14808unsafe impl Send for ExtHostQueryResetFn {}
14809unsafe impl Sync for ExtHostQueryResetFn {}
14810impl ExtHostQueryResetFn {
14811 pub fn load<F>(mut _f: F) -> Self
14812 where
14813 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14814 {
14815 Self {
14816 reset_query_pool_ext: unsafe {
14817 unsafe extern "system" fn reset_query_pool_ext(
14818 _device: Device,
14819 _query_pool: QueryPool,
14820 _first_query: u32,
14821 _query_count: u32,
14822 ) {
14823 panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext)))
14824 }
14825 let cname =
14826 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0");
14827 let val = _f(cname);
14828 if val.is_null() {
14829 reset_query_pool_ext
14830 } else {
14831 ::std::mem::transmute(val)
14832 }
14833 },
14834 }
14835 }
14836}
14837#[doc = "Generated from 'VK_EXT_host_query_reset'"]
14838impl StructureType {
14839 pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: Self =
14840 Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
14841}
14842impl GgpExtension263Fn {
14843 #[inline]
14844 pub const fn name() -> &'static ::std::ffi::CStr {
14845 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_263\0") }
14846 }
14847 pub const SPEC_VERSION: u32 = 0u32;
14848}
14849#[derive(Clone)]
14850pub struct GgpExtension263Fn {}
14851unsafe impl Send for GgpExtension263Fn {}
14852unsafe impl Sync for GgpExtension263Fn {}
14853impl GgpExtension263Fn {
14854 pub fn load<F>(mut _f: F) -> Self
14855 where
14856 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14857 {
14858 Self {}
14859 }
14860}
14861impl BrcmExtension264Fn {
14862 #[inline]
14863 pub const fn name() -> &'static ::std::ffi::CStr {
14864 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_264\0") }
14865 }
14866 pub const SPEC_VERSION: u32 = 0u32;
14867}
14868#[derive(Clone)]
14869pub struct BrcmExtension264Fn {}
14870unsafe impl Send for BrcmExtension264Fn {}
14871unsafe impl Sync for BrcmExtension264Fn {}
14872impl BrcmExtension264Fn {
14873 pub fn load<F>(mut _f: F) -> Self
14874 where
14875 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14876 {
14877 Self {}
14878 }
14879}
14880impl BrcmExtension265Fn {
14881 #[inline]
14882 pub const fn name() -> &'static ::std::ffi::CStr {
14883 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_265\0") }
14884 }
14885 pub const SPEC_VERSION: u32 = 0u32;
14886}
14887#[derive(Clone)]
14888pub struct BrcmExtension265Fn {}
14889unsafe impl Send for BrcmExtension265Fn {}
14890unsafe impl Sync for BrcmExtension265Fn {}
14891impl BrcmExtension265Fn {
14892 pub fn load<F>(mut _f: F) -> Self
14893 where
14894 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14895 {
14896 Self {}
14897 }
14898}
14899impl ExtIndexTypeUint8Fn {
14900 #[inline]
14901 pub const fn name() -> &'static ::std::ffi::CStr {
14902 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_index_type_uint8\0") }
14903 }
14904 pub const SPEC_VERSION: u32 = 1u32;
14905}
14906#[derive(Clone)]
14907pub struct ExtIndexTypeUint8Fn {}
14908unsafe impl Send for ExtIndexTypeUint8Fn {}
14909unsafe impl Sync for ExtIndexTypeUint8Fn {}
14910impl ExtIndexTypeUint8Fn {
14911 pub fn load<F>(mut _f: F) -> Self
14912 where
14913 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14914 {
14915 Self {}
14916 }
14917}
14918#[doc = "Generated from 'VK_EXT_index_type_uint8'"]
14919impl IndexType {
14920 pub const UINT8_EXT: Self = Self(1_000_265_000);
14921}
14922#[doc = "Generated from 'VK_EXT_index_type_uint8'"]
14923impl StructureType {
14924 pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000);
14925}
14926impl ExtExtension267Fn {
14927 #[inline]
14928 pub const fn name() -> &'static ::std::ffi::CStr {
14929 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_267\0") }
14930 }
14931 pub const SPEC_VERSION: u32 = 0u32;
14932}
14933#[derive(Clone)]
14934pub struct ExtExtension267Fn {}
14935unsafe impl Send for ExtExtension267Fn {}
14936unsafe impl Sync for ExtExtension267Fn {}
14937impl ExtExtension267Fn {
14938 pub fn load<F>(mut _f: F) -> Self
14939 where
14940 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14941 {
14942 Self {}
14943 }
14944}
14945impl ExtExtendedDynamicStateFn {
14946 #[inline]
14947 pub const fn name() -> &'static ::std::ffi::CStr {
14948 unsafe {
14949 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state\0")
14950 }
14951 }
14952 pub const SPEC_VERSION: u32 = 1u32;
14953}
14954#[allow(non_camel_case_types)]
14955pub type PFN_vkCmdSetCullMode =
14956 unsafe extern "system" fn(command_buffer: CommandBuffer, cull_mode: CullModeFlags);
14957#[allow(non_camel_case_types)]
14958pub type PFN_vkCmdSetFrontFace =
14959 unsafe extern "system" fn(command_buffer: CommandBuffer, front_face: FrontFace);
14960#[allow(non_camel_case_types)]
14961pub type PFN_vkCmdSetPrimitiveTopology =
14962 unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_topology: PrimitiveTopology);
14963#[allow(non_camel_case_types)]
14964pub type PFN_vkCmdSetViewportWithCount = unsafe extern "system" fn(
14965 command_buffer: CommandBuffer,
14966 viewport_count: u32,
14967 p_viewports: *const Viewport,
14968);
14969#[allow(non_camel_case_types)]
14970pub type PFN_vkCmdSetScissorWithCount = unsafe extern "system" fn(
14971 command_buffer: CommandBuffer,
14972 scissor_count: u32,
14973 p_scissors: *const Rect2D,
14974);
14975#[allow(non_camel_case_types)]
14976pub type PFN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn(
14977 command_buffer: CommandBuffer,
14978 first_binding: u32,
14979 binding_count: u32,
14980 p_buffers: *const Buffer,
14981 p_offsets: *const DeviceSize,
14982 p_sizes: *const DeviceSize,
14983 p_strides: *const DeviceSize,
14984);
14985#[allow(non_camel_case_types)]
14986pub type PFN_vkCmdSetDepthTestEnable =
14987 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_test_enable: Bool32);
14988#[allow(non_camel_case_types)]
14989pub type PFN_vkCmdSetDepthWriteEnable =
14990 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_write_enable: Bool32);
14991#[allow(non_camel_case_types)]
14992pub type PFN_vkCmdSetDepthCompareOp =
14993 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_compare_op: CompareOp);
14994#[allow(non_camel_case_types)]
14995pub type PFN_vkCmdSetDepthBoundsTestEnable =
14996 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bounds_test_enable: Bool32);
14997#[allow(non_camel_case_types)]
14998pub type PFN_vkCmdSetStencilTestEnable =
14999 unsafe extern "system" fn(command_buffer: CommandBuffer, stencil_test_enable: Bool32);
15000#[allow(non_camel_case_types)]
15001pub type PFN_vkCmdSetStencilOp = unsafe extern "system" fn(
15002 command_buffer: CommandBuffer,
15003 face_mask: StencilFaceFlags,
15004 fail_op: StencilOp,
15005 pass_op: StencilOp,
15006 depth_fail_op: StencilOp,
15007 compare_op: CompareOp,
15008);
15009#[derive(Clone)]
15010pub struct ExtExtendedDynamicStateFn {
15011 pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode,
15012 pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace,
15013 pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology,
15014 pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount,
15015 pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount,
15016 pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2,
15017 pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable,
15018 pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable,
15019 pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp,
15020 pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable,
15021 pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable,
15022 pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp,
15023}
15024unsafe impl Send for ExtExtendedDynamicStateFn {}
15025unsafe impl Sync for ExtExtendedDynamicStateFn {}
15026impl ExtExtendedDynamicStateFn {
15027 pub fn load<F>(mut _f: F) -> Self
15028 where
15029 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15030 {
15031 Self {
15032 cmd_set_cull_mode_ext: unsafe {
15033 unsafe extern "system" fn cmd_set_cull_mode_ext(
15034 _command_buffer: CommandBuffer,
15035 _cull_mode: CullModeFlags,
15036 ) {
15037 panic!(concat!(
15038 "Unable to load ",
15039 stringify!(cmd_set_cull_mode_ext)
15040 ))
15041 }
15042 let cname =
15043 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
15044 let val = _f(cname);
15045 if val.is_null() {
15046 cmd_set_cull_mode_ext
15047 } else {
15048 ::std::mem::transmute(val)
15049 }
15050 },
15051 cmd_set_front_face_ext: unsafe {
15052 unsafe extern "system" fn cmd_set_front_face_ext(
15053 _command_buffer: CommandBuffer,
15054 _front_face: FrontFace,
15055 ) {
15056 panic!(concat!(
15057 "Unable to load ",
15058 stringify!(cmd_set_front_face_ext)
15059 ))
15060 }
15061 let cname =
15062 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
15063 let val = _f(cname);
15064 if val.is_null() {
15065 cmd_set_front_face_ext
15066 } else {
15067 ::std::mem::transmute(val)
15068 }
15069 },
15070 cmd_set_primitive_topology_ext: unsafe {
15071 unsafe extern "system" fn cmd_set_primitive_topology_ext(
15072 _command_buffer: CommandBuffer,
15073 _primitive_topology: PrimitiveTopology,
15074 ) {
15075 panic!(concat!(
15076 "Unable to load ",
15077 stringify!(cmd_set_primitive_topology_ext)
15078 ))
15079 }
15080 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15081 b"vkCmdSetPrimitiveTopologyEXT\0",
15082 );
15083 let val = _f(cname);
15084 if val.is_null() {
15085 cmd_set_primitive_topology_ext
15086 } else {
15087 ::std::mem::transmute(val)
15088 }
15089 },
15090 cmd_set_viewport_with_count_ext: unsafe {
15091 unsafe extern "system" fn cmd_set_viewport_with_count_ext(
15092 _command_buffer: CommandBuffer,
15093 _viewport_count: u32,
15094 _p_viewports: *const Viewport,
15095 ) {
15096 panic!(concat!(
15097 "Unable to load ",
15098 stringify!(cmd_set_viewport_with_count_ext)
15099 ))
15100 }
15101 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15102 b"vkCmdSetViewportWithCountEXT\0",
15103 );
15104 let val = _f(cname);
15105 if val.is_null() {
15106 cmd_set_viewport_with_count_ext
15107 } else {
15108 ::std::mem::transmute(val)
15109 }
15110 },
15111 cmd_set_scissor_with_count_ext: unsafe {
15112 unsafe extern "system" fn cmd_set_scissor_with_count_ext(
15113 _command_buffer: CommandBuffer,
15114 _scissor_count: u32,
15115 _p_scissors: *const Rect2D,
15116 ) {
15117 panic!(concat!(
15118 "Unable to load ",
15119 stringify!(cmd_set_scissor_with_count_ext)
15120 ))
15121 }
15122 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15123 b"vkCmdSetScissorWithCountEXT\0",
15124 );
15125 let val = _f(cname);
15126 if val.is_null() {
15127 cmd_set_scissor_with_count_ext
15128 } else {
15129 ::std::mem::transmute(val)
15130 }
15131 },
15132 cmd_bind_vertex_buffers2_ext: unsafe {
15133 unsafe extern "system" fn cmd_bind_vertex_buffers2_ext(
15134 _command_buffer: CommandBuffer,
15135 _first_binding: u32,
15136 _binding_count: u32,
15137 _p_buffers: *const Buffer,
15138 _p_offsets: *const DeviceSize,
15139 _p_sizes: *const DeviceSize,
15140 _p_strides: *const DeviceSize,
15141 ) {
15142 panic!(concat!(
15143 "Unable to load ",
15144 stringify!(cmd_bind_vertex_buffers2_ext)
15145 ))
15146 }
15147 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15148 b"vkCmdBindVertexBuffers2EXT\0",
15149 );
15150 let val = _f(cname);
15151 if val.is_null() {
15152 cmd_bind_vertex_buffers2_ext
15153 } else {
15154 ::std::mem::transmute(val)
15155 }
15156 },
15157 cmd_set_depth_test_enable_ext: unsafe {
15158 unsafe extern "system" fn cmd_set_depth_test_enable_ext(
15159 _command_buffer: CommandBuffer,
15160 _depth_test_enable: Bool32,
15161 ) {
15162 panic!(concat!(
15163 "Unable to load ",
15164 stringify!(cmd_set_depth_test_enable_ext)
15165 ))
15166 }
15167 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15168 b"vkCmdSetDepthTestEnableEXT\0",
15169 );
15170 let val = _f(cname);
15171 if val.is_null() {
15172 cmd_set_depth_test_enable_ext
15173 } else {
15174 ::std::mem::transmute(val)
15175 }
15176 },
15177 cmd_set_depth_write_enable_ext: unsafe {
15178 unsafe extern "system" fn cmd_set_depth_write_enable_ext(
15179 _command_buffer: CommandBuffer,
15180 _depth_write_enable: Bool32,
15181 ) {
15182 panic!(concat!(
15183 "Unable to load ",
15184 stringify!(cmd_set_depth_write_enable_ext)
15185 ))
15186 }
15187 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15188 b"vkCmdSetDepthWriteEnableEXT\0",
15189 );
15190 let val = _f(cname);
15191 if val.is_null() {
15192 cmd_set_depth_write_enable_ext
15193 } else {
15194 ::std::mem::transmute(val)
15195 }
15196 },
15197 cmd_set_depth_compare_op_ext: unsafe {
15198 unsafe extern "system" fn cmd_set_depth_compare_op_ext(
15199 _command_buffer: CommandBuffer,
15200 _depth_compare_op: CompareOp,
15201 ) {
15202 panic!(concat!(
15203 "Unable to load ",
15204 stringify!(cmd_set_depth_compare_op_ext)
15205 ))
15206 }
15207 let cname =
15208 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
15209 let val = _f(cname);
15210 if val.is_null() {
15211 cmd_set_depth_compare_op_ext
15212 } else {
15213 ::std::mem::transmute(val)
15214 }
15215 },
15216 cmd_set_depth_bounds_test_enable_ext: unsafe {
15217 unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext(
15218 _command_buffer: CommandBuffer,
15219 _depth_bounds_test_enable: Bool32,
15220 ) {
15221 panic!(concat!(
15222 "Unable to load ",
15223 stringify!(cmd_set_depth_bounds_test_enable_ext)
15224 ))
15225 }
15226 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15227 b"vkCmdSetDepthBoundsTestEnableEXT\0",
15228 );
15229 let val = _f(cname);
15230 if val.is_null() {
15231 cmd_set_depth_bounds_test_enable_ext
15232 } else {
15233 ::std::mem::transmute(val)
15234 }
15235 },
15236 cmd_set_stencil_test_enable_ext: unsafe {
15237 unsafe extern "system" fn cmd_set_stencil_test_enable_ext(
15238 _command_buffer: CommandBuffer,
15239 _stencil_test_enable: Bool32,
15240 ) {
15241 panic!(concat!(
15242 "Unable to load ",
15243 stringify!(cmd_set_stencil_test_enable_ext)
15244 ))
15245 }
15246 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15247 b"vkCmdSetStencilTestEnableEXT\0",
15248 );
15249 let val = _f(cname);
15250 if val.is_null() {
15251 cmd_set_stencil_test_enable_ext
15252 } else {
15253 ::std::mem::transmute(val)
15254 }
15255 },
15256 cmd_set_stencil_op_ext: unsafe {
15257 unsafe extern "system" fn cmd_set_stencil_op_ext(
15258 _command_buffer: CommandBuffer,
15259 _face_mask: StencilFaceFlags,
15260 _fail_op: StencilOp,
15261 _pass_op: StencilOp,
15262 _depth_fail_op: StencilOp,
15263 _compare_op: CompareOp,
15264 ) {
15265 panic!(concat!(
15266 "Unable to load ",
15267 stringify!(cmd_set_stencil_op_ext)
15268 ))
15269 }
15270 let cname =
15271 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
15272 let val = _f(cname);
15273 if val.is_null() {
15274 cmd_set_stencil_op_ext
15275 } else {
15276 ::std::mem::transmute(val)
15277 }
15278 },
15279 }
15280 }
15281}
15282#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
15283impl DynamicState {
15284 pub const CULL_MODE_EXT: Self = Self::CULL_MODE;
15285 pub const FRONT_FACE_EXT: Self = Self::FRONT_FACE;
15286 pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self::PRIMITIVE_TOPOLOGY;
15287 pub const VIEWPORT_WITH_COUNT_EXT: Self = Self::VIEWPORT_WITH_COUNT;
15288 pub const SCISSOR_WITH_COUNT_EXT: Self = Self::SCISSOR_WITH_COUNT;
15289 pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self::VERTEX_INPUT_BINDING_STRIDE;
15290 pub const DEPTH_TEST_ENABLE_EXT: Self = Self::DEPTH_TEST_ENABLE;
15291 pub const DEPTH_WRITE_ENABLE_EXT: Self = Self::DEPTH_WRITE_ENABLE;
15292 pub const DEPTH_COMPARE_OP_EXT: Self = Self::DEPTH_COMPARE_OP;
15293 pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self::DEPTH_BOUNDS_TEST_ENABLE;
15294 pub const STENCIL_TEST_ENABLE_EXT: Self = Self::STENCIL_TEST_ENABLE;
15295 pub const STENCIL_OP_EXT: Self = Self::STENCIL_OP;
15296}
15297#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
15298impl StructureType {
15299 #[doc = "Not promoted to 1.3"]
15300 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_267_000);
15301}
15302impl KhrDeferredHostOperationsFn {
15303 #[inline]
15304 pub const fn name() -> &'static ::std::ffi::CStr {
15305 unsafe {
15306 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_deferred_host_operations\0")
15307 }
15308 }
15309 pub const SPEC_VERSION: u32 = 4u32;
15310}
15311#[allow(non_camel_case_types)]
15312pub type PFN_vkCreateDeferredOperationKHR = unsafe extern "system" fn(
15313 device: Device,
15314 p_allocator: *const AllocationCallbacks,
15315 p_deferred_operation: *mut DeferredOperationKHR,
15316) -> Result;
15317#[allow(non_camel_case_types)]
15318pub type PFN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn(
15319 device: Device,
15320 operation: DeferredOperationKHR,
15321 p_allocator: *const AllocationCallbacks,
15322);
15323#[allow(non_camel_case_types)]
15324pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR =
15325 unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32;
15326#[allow(non_camel_case_types)]
15327pub type PFN_vkGetDeferredOperationResultKHR =
15328 unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result;
15329#[allow(non_camel_case_types)]
15330pub type PFN_vkDeferredOperationJoinKHR =
15331 unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result;
15332#[derive(Clone)]
15333pub struct KhrDeferredHostOperationsFn {
15334 pub create_deferred_operation_khr: PFN_vkCreateDeferredOperationKHR,
15335 pub destroy_deferred_operation_khr: PFN_vkDestroyDeferredOperationKHR,
15336 pub get_deferred_operation_max_concurrency_khr: PFN_vkGetDeferredOperationMaxConcurrencyKHR,
15337 pub get_deferred_operation_result_khr: PFN_vkGetDeferredOperationResultKHR,
15338 pub deferred_operation_join_khr: PFN_vkDeferredOperationJoinKHR,
15339}
15340unsafe impl Send for KhrDeferredHostOperationsFn {}
15341unsafe impl Sync for KhrDeferredHostOperationsFn {}
15342impl KhrDeferredHostOperationsFn {
15343 pub fn load<F>(mut _f: F) -> Self
15344 where
15345 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15346 {
15347 Self {
15348 create_deferred_operation_khr: unsafe {
15349 unsafe extern "system" fn create_deferred_operation_khr(
15350 _device: Device,
15351 _p_allocator: *const AllocationCallbacks,
15352 _p_deferred_operation: *mut DeferredOperationKHR,
15353 ) -> Result {
15354 panic!(concat!(
15355 "Unable to load ",
15356 stringify!(create_deferred_operation_khr)
15357 ))
15358 }
15359 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15360 b"vkCreateDeferredOperationKHR\0",
15361 );
15362 let val = _f(cname);
15363 if val.is_null() {
15364 create_deferred_operation_khr
15365 } else {
15366 ::std::mem::transmute(val)
15367 }
15368 },
15369 destroy_deferred_operation_khr: unsafe {
15370 unsafe extern "system" fn destroy_deferred_operation_khr(
15371 _device: Device,
15372 _operation: DeferredOperationKHR,
15373 _p_allocator: *const AllocationCallbacks,
15374 ) {
15375 panic!(concat!(
15376 "Unable to load ",
15377 stringify!(destroy_deferred_operation_khr)
15378 ))
15379 }
15380 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15381 b"vkDestroyDeferredOperationKHR\0",
15382 );
15383 let val = _f(cname);
15384 if val.is_null() {
15385 destroy_deferred_operation_khr
15386 } else {
15387 ::std::mem::transmute(val)
15388 }
15389 },
15390 get_deferred_operation_max_concurrency_khr: unsafe {
15391 unsafe extern "system" fn get_deferred_operation_max_concurrency_khr(
15392 _device: Device,
15393 _operation: DeferredOperationKHR,
15394 ) -> u32 {
15395 panic!(concat!(
15396 "Unable to load ",
15397 stringify!(get_deferred_operation_max_concurrency_khr)
15398 ))
15399 }
15400 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15401 b"vkGetDeferredOperationMaxConcurrencyKHR\0",
15402 );
15403 let val = _f(cname);
15404 if val.is_null() {
15405 get_deferred_operation_max_concurrency_khr
15406 } else {
15407 ::std::mem::transmute(val)
15408 }
15409 },
15410 get_deferred_operation_result_khr: unsafe {
15411 unsafe extern "system" fn get_deferred_operation_result_khr(
15412 _device: Device,
15413 _operation: DeferredOperationKHR,
15414 ) -> Result {
15415 panic!(concat!(
15416 "Unable to load ",
15417 stringify!(get_deferred_operation_result_khr)
15418 ))
15419 }
15420 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15421 b"vkGetDeferredOperationResultKHR\0",
15422 );
15423 let val = _f(cname);
15424 if val.is_null() {
15425 get_deferred_operation_result_khr
15426 } else {
15427 ::std::mem::transmute(val)
15428 }
15429 },
15430 deferred_operation_join_khr: unsafe {
15431 unsafe extern "system" fn deferred_operation_join_khr(
15432 _device: Device,
15433 _operation: DeferredOperationKHR,
15434 ) -> Result {
15435 panic!(concat!(
15436 "Unable to load ",
15437 stringify!(deferred_operation_join_khr)
15438 ))
15439 }
15440 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15441 b"vkDeferredOperationJoinKHR\0",
15442 );
15443 let val = _f(cname);
15444 if val.is_null() {
15445 deferred_operation_join_khr
15446 } else {
15447 ::std::mem::transmute(val)
15448 }
15449 },
15450 }
15451 }
15452}
15453#[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
15454impl ObjectType {
15455 pub const DEFERRED_OPERATION_KHR: Self = Self(1_000_268_000);
15456}
15457#[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
15458impl Result {
15459 pub const THREAD_IDLE_KHR: Self = Self(1_000_268_000);
15460 pub const THREAD_DONE_KHR: Self = Self(1_000_268_001);
15461 pub const OPERATION_DEFERRED_KHR: Self = Self(1_000_268_002);
15462 pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1_000_268_003);
15463}
15464impl KhrPipelineExecutablePropertiesFn {
15465 #[inline]
15466 pub const fn name() -> &'static ::std::ffi::CStr {
15467 unsafe {
15468 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15469 b"VK_KHR_pipeline_executable_properties\0",
15470 )
15471 }
15472 }
15473 pub const SPEC_VERSION: u32 = 1u32;
15474}
15475#[allow(non_camel_case_types)]
15476pub type PFN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn(
15477 device: Device,
15478 p_pipeline_info: *const PipelineInfoKHR,
15479 p_executable_count: *mut u32,
15480 p_properties: *mut PipelineExecutablePropertiesKHR,
15481) -> Result;
15482#[allow(non_camel_case_types)]
15483pub type PFN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn(
15484 device: Device,
15485 p_executable_info: *const PipelineExecutableInfoKHR,
15486 p_statistic_count: *mut u32,
15487 p_statistics: *mut PipelineExecutableStatisticKHR,
15488) -> Result;
15489#[allow(non_camel_case_types)]
15490pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR =
15491 unsafe extern "system" fn(
15492 device: Device,
15493 p_executable_info: *const PipelineExecutableInfoKHR,
15494 p_internal_representation_count: *mut u32,
15495 p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR,
15496 ) -> Result;
15497#[derive(Clone)]
15498pub struct KhrPipelineExecutablePropertiesFn {
15499 pub get_pipeline_executable_properties_khr: PFN_vkGetPipelineExecutablePropertiesKHR,
15500 pub get_pipeline_executable_statistics_khr: PFN_vkGetPipelineExecutableStatisticsKHR,
15501 pub get_pipeline_executable_internal_representations_khr:
15502 PFN_vkGetPipelineExecutableInternalRepresentationsKHR,
15503}
15504unsafe impl Send for KhrPipelineExecutablePropertiesFn {}
15505unsafe impl Sync for KhrPipelineExecutablePropertiesFn {}
15506impl KhrPipelineExecutablePropertiesFn {
15507 pub fn load<F>(mut _f: F) -> Self
15508 where
15509 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15510 {
15511 Self {
15512 get_pipeline_executable_properties_khr: unsafe {
15513 unsafe extern "system" fn get_pipeline_executable_properties_khr(
15514 _device: Device,
15515 _p_pipeline_info: *const PipelineInfoKHR,
15516 _p_executable_count: *mut u32,
15517 _p_properties: *mut PipelineExecutablePropertiesKHR,
15518 ) -> Result {
15519 panic!(concat!(
15520 "Unable to load ",
15521 stringify!(get_pipeline_executable_properties_khr)
15522 ))
15523 }
15524 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15525 b"vkGetPipelineExecutablePropertiesKHR\0",
15526 );
15527 let val = _f(cname);
15528 if val.is_null() {
15529 get_pipeline_executable_properties_khr
15530 } else {
15531 ::std::mem::transmute(val)
15532 }
15533 },
15534 get_pipeline_executable_statistics_khr: unsafe {
15535 unsafe extern "system" fn get_pipeline_executable_statistics_khr(
15536 _device: Device,
15537 _p_executable_info: *const PipelineExecutableInfoKHR,
15538 _p_statistic_count: *mut u32,
15539 _p_statistics: *mut PipelineExecutableStatisticKHR,
15540 ) -> Result {
15541 panic!(concat!(
15542 "Unable to load ",
15543 stringify!(get_pipeline_executable_statistics_khr)
15544 ))
15545 }
15546 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15547 b"vkGetPipelineExecutableStatisticsKHR\0",
15548 );
15549 let val = _f(cname);
15550 if val.is_null() {
15551 get_pipeline_executable_statistics_khr
15552 } else {
15553 ::std::mem::transmute(val)
15554 }
15555 },
15556 get_pipeline_executable_internal_representations_khr: unsafe {
15557 unsafe extern "system" fn get_pipeline_executable_internal_representations_khr(
15558 _device: Device,
15559 _p_executable_info: *const PipelineExecutableInfoKHR,
15560 _p_internal_representation_count: *mut u32,
15561 _p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR,
15562 ) -> Result {
15563 panic!(concat!(
15564 "Unable to load ",
15565 stringify!(get_pipeline_executable_internal_representations_khr)
15566 ))
15567 }
15568 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15569 b"vkGetPipelineExecutableInternalRepresentationsKHR\0",
15570 );
15571 let val = _f(cname);
15572 if val.is_null() {
15573 get_pipeline_executable_internal_representations_khr
15574 } else {
15575 ::std::mem::transmute(val)
15576 }
15577 },
15578 }
15579 }
15580}
15581#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
15582impl PipelineCreateFlags {
15583 pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000);
15584 pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000);
15585}
15586#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
15587impl StructureType {
15588 pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self =
15589 Self(1_000_269_000);
15590 pub const PIPELINE_INFO_KHR: Self = Self(1_000_269_001);
15591 pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1_000_269_002);
15592 pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1_000_269_003);
15593 pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004);
15594 pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005);
15595}
15596impl IntelExtension271Fn {
15597 #[inline]
15598 pub const fn name() -> &'static ::std::ffi::CStr {
15599 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_271\0") }
15600 }
15601 pub const SPEC_VERSION: u32 = 0u32;
15602}
15603#[derive(Clone)]
15604pub struct IntelExtension271Fn {}
15605unsafe impl Send for IntelExtension271Fn {}
15606unsafe impl Sync for IntelExtension271Fn {}
15607impl IntelExtension271Fn {
15608 pub fn load<F>(mut _f: F) -> Self
15609 where
15610 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15611 {
15612 Self {}
15613 }
15614}
15615#[doc = "Generated from 'VK_INTEL_extension_271'"]
15616impl FormatFeatureFlags2 {
15617 pub const RESERVED_46_EXT: Self =
15618 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
15619}
15620#[doc = "Generated from 'VK_INTEL_extension_271'"]
15621impl ImageUsageFlags {
15622 pub const RESERVED_22_EXT: Self = Self(0b100_0000_0000_0000_0000_0000);
15623}
15624impl KhrMapMemory2Fn {
15625 #[inline]
15626 pub const fn name() -> &'static ::std::ffi::CStr {
15627 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_map_memory2\0") }
15628 }
15629 pub const SPEC_VERSION: u32 = 1u32;
15630}
15631#[allow(non_camel_case_types)]
15632pub type PFN_vkMapMemory2KHR = unsafe extern "system" fn(
15633 device: Device,
15634 p_memory_map_info: *const MemoryMapInfoKHR,
15635 pp_data: *mut *mut c_void,
15636) -> Result;
15637#[allow(non_camel_case_types)]
15638pub type PFN_vkUnmapMemory2KHR = unsafe extern "system" fn(
15639 device: Device,
15640 p_memory_unmap_info: *const MemoryUnmapInfoKHR,
15641) -> Result;
15642#[derive(Clone)]
15643pub struct KhrMapMemory2Fn {
15644 pub map_memory2_khr: PFN_vkMapMemory2KHR,
15645 pub unmap_memory2_khr: PFN_vkUnmapMemory2KHR,
15646}
15647unsafe impl Send for KhrMapMemory2Fn {}
15648unsafe impl Sync for KhrMapMemory2Fn {}
15649impl KhrMapMemory2Fn {
15650 pub fn load<F>(mut _f: F) -> Self
15651 where
15652 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15653 {
15654 Self {
15655 map_memory2_khr: unsafe {
15656 unsafe extern "system" fn map_memory2_khr(
15657 _device: Device,
15658 _p_memory_map_info: *const MemoryMapInfoKHR,
15659 _pp_data: *mut *mut c_void,
15660 ) -> Result {
15661 panic!(concat!("Unable to load ", stringify!(map_memory2_khr)))
15662 }
15663 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkMapMemory2KHR\0");
15664 let val = _f(cname);
15665 if val.is_null() {
15666 map_memory2_khr
15667 } else {
15668 ::std::mem::transmute(val)
15669 }
15670 },
15671 unmap_memory2_khr: unsafe {
15672 unsafe extern "system" fn unmap_memory2_khr(
15673 _device: Device,
15674 _p_memory_unmap_info: *const MemoryUnmapInfoKHR,
15675 ) -> Result {
15676 panic!(concat!("Unable to load ", stringify!(unmap_memory2_khr)))
15677 }
15678 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkUnmapMemory2KHR\0");
15679 let val = _f(cname);
15680 if val.is_null() {
15681 unmap_memory2_khr
15682 } else {
15683 ::std::mem::transmute(val)
15684 }
15685 },
15686 }
15687 }
15688}
15689#[doc = "Generated from 'VK_KHR_map_memory2'"]
15690impl StructureType {
15691 pub const MEMORY_MAP_INFO_KHR: Self = Self(1_000_271_000);
15692 pub const MEMORY_UNMAP_INFO_KHR: Self = Self(1_000_271_001);
15693}
15694impl IntelExtension273Fn {
15695 #[inline]
15696 pub const fn name() -> &'static ::std::ffi::CStr {
15697 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_273\0") }
15698 }
15699 pub const SPEC_VERSION: u32 = 0u32;
15700}
15701#[derive(Clone)]
15702pub struct IntelExtension273Fn {}
15703unsafe impl Send for IntelExtension273Fn {}
15704unsafe impl Sync for IntelExtension273Fn {}
15705impl IntelExtension273Fn {
15706 pub fn load<F>(mut _f: F) -> Self
15707 where
15708 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15709 {
15710 Self {}
15711 }
15712}
15713impl ExtShaderAtomicFloat2Fn {
15714 #[inline]
15715 pub const fn name() -> &'static ::std::ffi::CStr {
15716 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float2\0") }
15717 }
15718 pub const SPEC_VERSION: u32 = 1u32;
15719}
15720#[derive(Clone)]
15721pub struct ExtShaderAtomicFloat2Fn {}
15722unsafe impl Send for ExtShaderAtomicFloat2Fn {}
15723unsafe impl Sync for ExtShaderAtomicFloat2Fn {}
15724impl ExtShaderAtomicFloat2Fn {
15725 pub fn load<F>(mut _f: F) -> Self
15726 where
15727 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15728 {
15729 Self {}
15730 }
15731}
15732#[doc = "Generated from 'VK_EXT_shader_atomic_float2'"]
15733impl StructureType {
15734 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000);
15735}
15736impl ExtSurfaceMaintenance1Fn {
15737 #[inline]
15738 pub const fn name() -> &'static ::std::ffi::CStr {
15739 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_surface_maintenance1\0") }
15740 }
15741 pub const SPEC_VERSION: u32 = 1u32;
15742}
15743#[derive(Clone)]
15744pub struct ExtSurfaceMaintenance1Fn {}
15745unsafe impl Send for ExtSurfaceMaintenance1Fn {}
15746unsafe impl Sync for ExtSurfaceMaintenance1Fn {}
15747impl ExtSurfaceMaintenance1Fn {
15748 pub fn load<F>(mut _f: F) -> Self
15749 where
15750 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15751 {
15752 Self {}
15753 }
15754}
15755#[doc = "Generated from 'VK_EXT_surface_maintenance1'"]
15756impl StructureType {
15757 pub const SURFACE_PRESENT_MODE_EXT: Self = Self(1_000_274_000);
15758 pub const SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: Self = Self(1_000_274_001);
15759 pub const SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: Self = Self(1_000_274_002);
15760}
15761impl ExtSwapchainMaintenance1Fn {
15762 #[inline]
15763 pub const fn name() -> &'static ::std::ffi::CStr {
15764 unsafe {
15765 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_maintenance1\0")
15766 }
15767 }
15768 pub const SPEC_VERSION: u32 = 1u32;
15769}
15770#[allow(non_camel_case_types)]
15771pub type PFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn(
15772 device: Device,
15773 p_release_info: *const ReleaseSwapchainImagesInfoEXT,
15774) -> Result;
15775#[derive(Clone)]
15776pub struct ExtSwapchainMaintenance1Fn {
15777 pub release_swapchain_images_ext: PFN_vkReleaseSwapchainImagesEXT,
15778}
15779unsafe impl Send for ExtSwapchainMaintenance1Fn {}
15780unsafe impl Sync for ExtSwapchainMaintenance1Fn {}
15781impl ExtSwapchainMaintenance1Fn {
15782 pub fn load<F>(mut _f: F) -> Self
15783 where
15784 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15785 {
15786 Self {
15787 release_swapchain_images_ext: unsafe {
15788 unsafe extern "system" fn release_swapchain_images_ext(
15789 _device: Device,
15790 _p_release_info: *const ReleaseSwapchainImagesInfoEXT,
15791 ) -> Result {
15792 panic!(concat!(
15793 "Unable to load ",
15794 stringify!(release_swapchain_images_ext)
15795 ))
15796 }
15797 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15798 b"vkReleaseSwapchainImagesEXT\0",
15799 );
15800 let val = _f(cname);
15801 if val.is_null() {
15802 release_swapchain_images_ext
15803 } else {
15804 ::std::mem::transmute(val)
15805 }
15806 },
15807 }
15808 }
15809}
15810#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"]
15811impl StructureType {
15812 pub const PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: Self = Self(1_000_275_000);
15813 pub const SWAPCHAIN_PRESENT_FENCE_INFO_EXT: Self = Self(1_000_275_001);
15814 pub const SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: Self = Self(1_000_275_002);
15815 pub const SWAPCHAIN_PRESENT_MODE_INFO_EXT: Self = Self(1_000_275_003);
15816 pub const SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: Self = Self(1_000_275_004);
15817 pub const RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: Self = Self(1_000_275_005);
15818}
15819#[doc = "Generated from 'VK_EXT_swapchain_maintenance1'"]
15820impl SwapchainCreateFlagsKHR {
15821 pub const DEFERRED_MEMORY_ALLOCATION_EXT: Self = Self(0b1000);
15822}
15823impl ExtShaderDemoteToHelperInvocationFn {
15824 #[inline]
15825 pub const fn name() -> &'static ::std::ffi::CStr {
15826 unsafe {
15827 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15828 b"VK_EXT_shader_demote_to_helper_invocation\0",
15829 )
15830 }
15831 }
15832 pub const SPEC_VERSION: u32 = 1u32;
15833}
15834#[derive(Clone)]
15835pub struct ExtShaderDemoteToHelperInvocationFn {}
15836unsafe impl Send for ExtShaderDemoteToHelperInvocationFn {}
15837unsafe impl Sync for ExtShaderDemoteToHelperInvocationFn {}
15838impl ExtShaderDemoteToHelperInvocationFn {
15839 pub fn load<F>(mut _f: F) -> Self
15840 where
15841 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15842 {
15843 Self {}
15844 }
15845}
15846#[doc = "Generated from 'VK_EXT_shader_demote_to_helper_invocation'"]
15847impl StructureType {
15848 pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self =
15849 Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
15850}
15851impl NvDeviceGeneratedCommandsFn {
15852 #[inline]
15853 pub const fn name() -> &'static ::std::ffi::CStr {
15854 unsafe {
15855 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_generated_commands\0")
15856 }
15857 }
15858 pub const SPEC_VERSION: u32 = 3u32;
15859}
15860#[allow(non_camel_case_types)]
15861pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn(
15862 device: Device,
15863 p_info: *const GeneratedCommandsMemoryRequirementsInfoNV,
15864 p_memory_requirements: *mut MemoryRequirements2,
15865);
15866#[allow(non_camel_case_types)]
15867pub type PFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn(
15868 command_buffer: CommandBuffer,
15869 p_generated_commands_info: *const GeneratedCommandsInfoNV,
15870);
15871#[allow(non_camel_case_types)]
15872pub type PFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn(
15873 command_buffer: CommandBuffer,
15874 is_preprocessed: Bool32,
15875 p_generated_commands_info: *const GeneratedCommandsInfoNV,
15876);
15877#[allow(non_camel_case_types)]
15878pub type PFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn(
15879 command_buffer: CommandBuffer,
15880 pipeline_bind_point: PipelineBindPoint,
15881 pipeline: Pipeline,
15882 group_index: u32,
15883);
15884#[allow(non_camel_case_types)]
15885pub type PFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn(
15886 device: Device,
15887 p_create_info: *const IndirectCommandsLayoutCreateInfoNV,
15888 p_allocator: *const AllocationCallbacks,
15889 p_indirect_commands_layout: *mut IndirectCommandsLayoutNV,
15890) -> Result;
15891#[allow(non_camel_case_types)]
15892pub type PFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn(
15893 device: Device,
15894 indirect_commands_layout: IndirectCommandsLayoutNV,
15895 p_allocator: *const AllocationCallbacks,
15896);
15897#[derive(Clone)]
15898pub struct NvDeviceGeneratedCommandsFn {
15899 pub get_generated_commands_memory_requirements_nv:
15900 PFN_vkGetGeneratedCommandsMemoryRequirementsNV,
15901 pub cmd_preprocess_generated_commands_nv: PFN_vkCmdPreprocessGeneratedCommandsNV,
15902 pub cmd_execute_generated_commands_nv: PFN_vkCmdExecuteGeneratedCommandsNV,
15903 pub cmd_bind_pipeline_shader_group_nv: PFN_vkCmdBindPipelineShaderGroupNV,
15904 pub create_indirect_commands_layout_nv: PFN_vkCreateIndirectCommandsLayoutNV,
15905 pub destroy_indirect_commands_layout_nv: PFN_vkDestroyIndirectCommandsLayoutNV,
15906}
15907unsafe impl Send for NvDeviceGeneratedCommandsFn {}
15908unsafe impl Sync for NvDeviceGeneratedCommandsFn {}
15909impl NvDeviceGeneratedCommandsFn {
15910 pub fn load<F>(mut _f: F) -> Self
15911 where
15912 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15913 {
15914 Self {
15915 get_generated_commands_memory_requirements_nv: unsafe {
15916 unsafe extern "system" fn get_generated_commands_memory_requirements_nv(
15917 _device: Device,
15918 _p_info: *const GeneratedCommandsMemoryRequirementsInfoNV,
15919 _p_memory_requirements: *mut MemoryRequirements2,
15920 ) {
15921 panic!(concat!(
15922 "Unable to load ",
15923 stringify!(get_generated_commands_memory_requirements_nv)
15924 ))
15925 }
15926 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15927 b"vkGetGeneratedCommandsMemoryRequirementsNV\0",
15928 );
15929 let val = _f(cname);
15930 if val.is_null() {
15931 get_generated_commands_memory_requirements_nv
15932 } else {
15933 ::std::mem::transmute(val)
15934 }
15935 },
15936 cmd_preprocess_generated_commands_nv: unsafe {
15937 unsafe extern "system" fn cmd_preprocess_generated_commands_nv(
15938 _command_buffer: CommandBuffer,
15939 _p_generated_commands_info: *const GeneratedCommandsInfoNV,
15940 ) {
15941 panic!(concat!(
15942 "Unable to load ",
15943 stringify!(cmd_preprocess_generated_commands_nv)
15944 ))
15945 }
15946 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15947 b"vkCmdPreprocessGeneratedCommandsNV\0",
15948 );
15949 let val = _f(cname);
15950 if val.is_null() {
15951 cmd_preprocess_generated_commands_nv
15952 } else {
15953 ::std::mem::transmute(val)
15954 }
15955 },
15956 cmd_execute_generated_commands_nv: unsafe {
15957 unsafe extern "system" fn cmd_execute_generated_commands_nv(
15958 _command_buffer: CommandBuffer,
15959 _is_preprocessed: Bool32,
15960 _p_generated_commands_info: *const GeneratedCommandsInfoNV,
15961 ) {
15962 panic!(concat!(
15963 "Unable to load ",
15964 stringify!(cmd_execute_generated_commands_nv)
15965 ))
15966 }
15967 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15968 b"vkCmdExecuteGeneratedCommandsNV\0",
15969 );
15970 let val = _f(cname);
15971 if val.is_null() {
15972 cmd_execute_generated_commands_nv
15973 } else {
15974 ::std::mem::transmute(val)
15975 }
15976 },
15977 cmd_bind_pipeline_shader_group_nv: unsafe {
15978 unsafe extern "system" fn cmd_bind_pipeline_shader_group_nv(
15979 _command_buffer: CommandBuffer,
15980 _pipeline_bind_point: PipelineBindPoint,
15981 _pipeline: Pipeline,
15982 _group_index: u32,
15983 ) {
15984 panic!(concat!(
15985 "Unable to load ",
15986 stringify!(cmd_bind_pipeline_shader_group_nv)
15987 ))
15988 }
15989 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15990 b"vkCmdBindPipelineShaderGroupNV\0",
15991 );
15992 let val = _f(cname);
15993 if val.is_null() {
15994 cmd_bind_pipeline_shader_group_nv
15995 } else {
15996 ::std::mem::transmute(val)
15997 }
15998 },
15999 create_indirect_commands_layout_nv: unsafe {
16000 unsafe extern "system" fn create_indirect_commands_layout_nv(
16001 _device: Device,
16002 _p_create_info: *const IndirectCommandsLayoutCreateInfoNV,
16003 _p_allocator: *const AllocationCallbacks,
16004 _p_indirect_commands_layout: *mut IndirectCommandsLayoutNV,
16005 ) -> Result {
16006 panic!(concat!(
16007 "Unable to load ",
16008 stringify!(create_indirect_commands_layout_nv)
16009 ))
16010 }
16011 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16012 b"vkCreateIndirectCommandsLayoutNV\0",
16013 );
16014 let val = _f(cname);
16015 if val.is_null() {
16016 create_indirect_commands_layout_nv
16017 } else {
16018 ::std::mem::transmute(val)
16019 }
16020 },
16021 destroy_indirect_commands_layout_nv: unsafe {
16022 unsafe extern "system" fn destroy_indirect_commands_layout_nv(
16023 _device: Device,
16024 _indirect_commands_layout: IndirectCommandsLayoutNV,
16025 _p_allocator: *const AllocationCallbacks,
16026 ) {
16027 panic!(concat!(
16028 "Unable to load ",
16029 stringify!(destroy_indirect_commands_layout_nv)
16030 ))
16031 }
16032 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16033 b"vkDestroyIndirectCommandsLayoutNV\0",
16034 );
16035 let val = _f(cname);
16036 if val.is_null() {
16037 destroy_indirect_commands_layout_nv
16038 } else {
16039 ::std::mem::transmute(val)
16040 }
16041 },
16042 }
16043 }
16044}
16045#[doc = "Generated from 'VK_NV_device_generated_commands'"]
16046impl AccessFlags {
16047 pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000);
16048 pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000);
16049}
16050#[doc = "Generated from 'VK_NV_device_generated_commands'"]
16051impl ObjectType {
16052 pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000);
16053}
16054#[doc = "Generated from 'VK_NV_device_generated_commands'"]
16055impl PipelineCreateFlags {
16056 pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000);
16057}
16058#[doc = "Generated from 'VK_NV_device_generated_commands'"]
16059impl PipelineStageFlags {
16060 pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
16061}
16062#[doc = "Generated from 'VK_NV_device_generated_commands'"]
16063impl StructureType {
16064 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000);
16065 pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001);
16066 pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002);
16067 pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003);
16068 pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1_000_277_004);
16069 pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1_000_277_005);
16070 pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_277_006);
16071 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1_000_277_007);
16072}
16073impl NvInheritedViewportScissorFn {
16074 #[inline]
16075 pub const fn name() -> &'static ::std::ffi::CStr {
16076 unsafe {
16077 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_inherited_viewport_scissor\0")
16078 }
16079 }
16080 pub const SPEC_VERSION: u32 = 1u32;
16081}
16082#[derive(Clone)]
16083pub struct NvInheritedViewportScissorFn {}
16084unsafe impl Send for NvInheritedViewportScissorFn {}
16085unsafe impl Sync for NvInheritedViewportScissorFn {}
16086impl NvInheritedViewportScissorFn {
16087 pub fn load<F>(mut _f: F) -> Self
16088 where
16089 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16090 {
16091 Self {}
16092 }
16093}
16094#[doc = "Generated from 'VK_NV_inherited_viewport_scissor'"]
16095impl StructureType {
16096 pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: Self = Self(1_000_278_000);
16097 pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: Self = Self(1_000_278_001);
16098}
16099impl KhrExtension280Fn {
16100 #[inline]
16101 pub const fn name() -> &'static ::std::ffi::CStr {
16102 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_280\0") }
16103 }
16104 pub const SPEC_VERSION: u32 = 0u32;
16105}
16106#[derive(Clone)]
16107pub struct KhrExtension280Fn {}
16108unsafe impl Send for KhrExtension280Fn {}
16109unsafe impl Sync for KhrExtension280Fn {}
16110impl KhrExtension280Fn {
16111 pub fn load<F>(mut _f: F) -> Self
16112 where
16113 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16114 {
16115 Self {}
16116 }
16117}
16118impl KhrShaderIntegerDotProductFn {
16119 #[inline]
16120 pub const fn name() -> &'static ::std::ffi::CStr {
16121 unsafe {
16122 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_integer_dot_product\0")
16123 }
16124 }
16125 pub const SPEC_VERSION: u32 = 1u32;
16126}
16127#[derive(Clone)]
16128pub struct KhrShaderIntegerDotProductFn {}
16129unsafe impl Send for KhrShaderIntegerDotProductFn {}
16130unsafe impl Sync for KhrShaderIntegerDotProductFn {}
16131impl KhrShaderIntegerDotProductFn {
16132 pub fn load<F>(mut _f: F) -> Self
16133 where
16134 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16135 {
16136 Self {}
16137 }
16138}
16139#[doc = "Generated from 'VK_KHR_shader_integer_dot_product'"]
16140impl StructureType {
16141 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: Self =
16142 Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
16143 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: Self =
16144 Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
16145}
16146impl ExtTexelBufferAlignmentFn {
16147 #[inline]
16148 pub const fn name() -> &'static ::std::ffi::CStr {
16149 unsafe {
16150 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_texel_buffer_alignment\0")
16151 }
16152 }
16153 pub const SPEC_VERSION: u32 = 1u32;
16154}
16155#[derive(Clone)]
16156pub struct ExtTexelBufferAlignmentFn {}
16157unsafe impl Send for ExtTexelBufferAlignmentFn {}
16158unsafe impl Sync for ExtTexelBufferAlignmentFn {}
16159impl ExtTexelBufferAlignmentFn {
16160 pub fn load<F>(mut _f: F) -> Self
16161 where
16162 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16163 {
16164 Self {}
16165 }
16166}
16167#[doc = "Generated from 'VK_EXT_texel_buffer_alignment'"]
16168impl StructureType {
16169 #[doc = "Not promoted to 1.3"]
16170 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1_000_281_000);
16171 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self =
16172 Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
16173}
16174impl QcomRenderPassTransformFn {
16175 #[inline]
16176 pub const fn name() -> &'static ::std::ffi::CStr {
16177 unsafe {
16178 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_transform\0")
16179 }
16180 }
16181 pub const SPEC_VERSION: u32 = 3u32;
16182}
16183#[derive(Clone)]
16184pub struct QcomRenderPassTransformFn {}
16185unsafe impl Send for QcomRenderPassTransformFn {}
16186unsafe impl Sync for QcomRenderPassTransformFn {}
16187impl QcomRenderPassTransformFn {
16188 pub fn load<F>(mut _f: F) -> Self
16189 where
16190 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16191 {
16192 Self {}
16193 }
16194}
16195#[doc = "Generated from 'VK_QCOM_render_pass_transform'"]
16196impl RenderPassCreateFlags {
16197 pub const TRANSFORM_QCOM: Self = Self(0b10);
16198}
16199#[doc = "Generated from 'VK_QCOM_render_pass_transform'"]
16200impl StructureType {
16201 pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self =
16202 Self(1_000_282_000);
16203 pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001);
16204}
16205impl ExtExtension284Fn {
16206 #[inline]
16207 pub const fn name() -> &'static ::std::ffi::CStr {
16208 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_284\0") }
16209 }
16210 pub const SPEC_VERSION: u32 = 0u32;
16211}
16212#[derive(Clone)]
16213pub struct ExtExtension284Fn {}
16214unsafe impl Send for ExtExtension284Fn {}
16215unsafe impl Sync for ExtExtension284Fn {}
16216impl ExtExtension284Fn {
16217 pub fn load<F>(mut _f: F) -> Self
16218 where
16219 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16220 {
16221 Self {}
16222 }
16223}
16224impl ExtDeviceMemoryReportFn {
16225 #[inline]
16226 pub const fn name() -> &'static ::std::ffi::CStr {
16227 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0") }
16228 }
16229 pub const SPEC_VERSION: u32 = 2u32;
16230}
16231#[derive(Clone)]
16232pub struct ExtDeviceMemoryReportFn {}
16233unsafe impl Send for ExtDeviceMemoryReportFn {}
16234unsafe impl Sync for ExtDeviceMemoryReportFn {}
16235impl ExtDeviceMemoryReportFn {
16236 pub fn load<F>(mut _f: F) -> Self
16237 where
16238 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16239 {
16240 Self {}
16241 }
16242}
16243#[doc = "Generated from 'VK_EXT_device_memory_report'"]
16244impl StructureType {
16245 pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1_000_284_000);
16246 pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: Self = Self(1_000_284_001);
16247 pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: Self = Self(1_000_284_002);
16248}
16249impl ExtAcquireDrmDisplayFn {
16250 #[inline]
16251 pub const fn name() -> &'static ::std::ffi::CStr {
16252 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_drm_display\0") }
16253 }
16254 pub const SPEC_VERSION: u32 = 1u32;
16255}
16256#[allow(non_camel_case_types)]
16257pub type PFN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn(
16258 physical_device: PhysicalDevice,
16259 drm_fd: i32,
16260 display: DisplayKHR,
16261) -> Result;
16262#[allow(non_camel_case_types)]
16263pub type PFN_vkGetDrmDisplayEXT = unsafe extern "system" fn(
16264 physical_device: PhysicalDevice,
16265 drm_fd: i32,
16266 connector_id: u32,
16267 display: *mut DisplayKHR,
16268) -> Result;
16269#[derive(Clone)]
16270pub struct ExtAcquireDrmDisplayFn {
16271 pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXT,
16272 pub get_drm_display_ext: PFN_vkGetDrmDisplayEXT,
16273}
16274unsafe impl Send for ExtAcquireDrmDisplayFn {}
16275unsafe impl Sync for ExtAcquireDrmDisplayFn {}
16276impl ExtAcquireDrmDisplayFn {
16277 pub fn load<F>(mut _f: F) -> Self
16278 where
16279 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16280 {
16281 Self {
16282 acquire_drm_display_ext: unsafe {
16283 unsafe extern "system" fn acquire_drm_display_ext(
16284 _physical_device: PhysicalDevice,
16285 _drm_fd: i32,
16286 _display: DisplayKHR,
16287 ) -> Result {
16288 panic!(concat!(
16289 "Unable to load ",
16290 stringify!(acquire_drm_display_ext)
16291 ))
16292 }
16293 let cname =
16294 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireDrmDisplayEXT\0");
16295 let val = _f(cname);
16296 if val.is_null() {
16297 acquire_drm_display_ext
16298 } else {
16299 ::std::mem::transmute(val)
16300 }
16301 },
16302 get_drm_display_ext: unsafe {
16303 unsafe extern "system" fn get_drm_display_ext(
16304 _physical_device: PhysicalDevice,
16305 _drm_fd: i32,
16306 _connector_id: u32,
16307 _display: *mut DisplayKHR,
16308 ) -> Result {
16309 panic!(concat!("Unable to load ", stringify!(get_drm_display_ext)))
16310 }
16311 let cname =
16312 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDrmDisplayEXT\0");
16313 let val = _f(cname);
16314 if val.is_null() {
16315 get_drm_display_ext
16316 } else {
16317 ::std::mem::transmute(val)
16318 }
16319 },
16320 }
16321 }
16322}
16323impl ExtRobustness2Fn {
16324 #[inline]
16325 pub const fn name() -> &'static ::std::ffi::CStr {
16326 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_robustness2\0") }
16327 }
16328 pub const SPEC_VERSION: u32 = 1u32;
16329}
16330#[derive(Clone)]
16331pub struct ExtRobustness2Fn {}
16332unsafe impl Send for ExtRobustness2Fn {}
16333unsafe impl Sync for ExtRobustness2Fn {}
16334impl ExtRobustness2Fn {
16335 pub fn load<F>(mut _f: F) -> Self
16336 where
16337 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16338 {
16339 Self {}
16340 }
16341}
16342#[doc = "Generated from 'VK_EXT_robustness2'"]
16343impl StructureType {
16344 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: Self = Self(1_000_286_000);
16345 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: Self = Self(1_000_286_001);
16346}
16347impl ExtCustomBorderColorFn {
16348 #[inline]
16349 pub const fn name() -> &'static ::std::ffi::CStr {
16350 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_custom_border_color\0") }
16351 }
16352 pub const SPEC_VERSION: u32 = 12u32;
16353}
16354#[derive(Clone)]
16355pub struct ExtCustomBorderColorFn {}
16356unsafe impl Send for ExtCustomBorderColorFn {}
16357unsafe impl Sync for ExtCustomBorderColorFn {}
16358impl ExtCustomBorderColorFn {
16359 pub fn load<F>(mut _f: F) -> Self
16360 where
16361 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16362 {
16363 Self {}
16364 }
16365}
16366#[doc = "Generated from 'VK_EXT_custom_border_color'"]
16367impl BorderColor {
16368 pub const FLOAT_CUSTOM_EXT: Self = Self(1_000_287_003);
16369 pub const INT_CUSTOM_EXT: Self = Self(1_000_287_004);
16370}
16371#[doc = "Generated from 'VK_EXT_custom_border_color'"]
16372impl StructureType {
16373 pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1_000_287_000);
16374 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: Self = Self(1_000_287_001);
16375 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: Self = Self(1_000_287_002);
16376}
16377impl ExtExtension289Fn {
16378 #[inline]
16379 pub const fn name() -> &'static ::std::ffi::CStr {
16380 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_289\0") }
16381 }
16382 pub const SPEC_VERSION: u32 = 0u32;
16383}
16384#[derive(Clone)]
16385pub struct ExtExtension289Fn {}
16386unsafe impl Send for ExtExtension289Fn {}
16387unsafe impl Sync for ExtExtension289Fn {}
16388impl ExtExtension289Fn {
16389 pub fn load<F>(mut _f: F) -> Self
16390 where
16391 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16392 {
16393 Self {}
16394 }
16395}
16396#[doc = "Generated from 'VK_EXT_extension_289'"]
16397impl Format {
16398 pub const ASTC_3X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_000);
16399 pub const ASTC_3X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_001);
16400 pub const ASTC_3X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_002);
16401 pub const ASTC_4X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_003);
16402 pub const ASTC_4X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_004);
16403 pub const ASTC_4X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_005);
16404 pub const ASTC_4X4X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_006);
16405 pub const ASTC_4X4X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_007);
16406 pub const ASTC_4X4X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_008);
16407 pub const ASTC_4X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_009);
16408 pub const ASTC_4X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_010);
16409 pub const ASTC_4X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_011);
16410 pub const ASTC_5X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_012);
16411 pub const ASTC_5X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_013);
16412 pub const ASTC_5X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_014);
16413 pub const ASTC_5X5X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_015);
16414 pub const ASTC_5X5X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_016);
16415 pub const ASTC_5X5X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_017);
16416 pub const ASTC_5X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_018);
16417 pub const ASTC_5X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_019);
16418 pub const ASTC_5X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_020);
16419 pub const ASTC_6X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_021);
16420 pub const ASTC_6X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_022);
16421 pub const ASTC_6X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_023);
16422 pub const ASTC_6X6X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_024);
16423 pub const ASTC_6X6X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_025);
16424 pub const ASTC_6X6X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_026);
16425 pub const ASTC_6X6X6_UNORM_BLOCK_EXT: Self = Self(1_000_288_027);
16426 pub const ASTC_6X6X6_SRGB_BLOCK_EXT: Self = Self(1_000_288_028);
16427 pub const ASTC_6X6X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_029);
16428}
16429impl GoogleUserTypeFn {
16430 #[inline]
16431 pub const fn name() -> &'static ::std::ffi::CStr {
16432 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_user_type\0") }
16433 }
16434 pub const SPEC_VERSION: u32 = 1u32;
16435}
16436#[derive(Clone)]
16437pub struct GoogleUserTypeFn {}
16438unsafe impl Send for GoogleUserTypeFn {}
16439unsafe impl Sync for GoogleUserTypeFn {}
16440impl GoogleUserTypeFn {
16441 pub fn load<F>(mut _f: F) -> Self
16442 where
16443 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16444 {
16445 Self {}
16446 }
16447}
16448impl KhrPipelineLibraryFn {
16449 #[inline]
16450 pub const fn name() -> &'static ::std::ffi::CStr {
16451 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_pipeline_library\0") }
16452 }
16453 pub const SPEC_VERSION: u32 = 1u32;
16454}
16455#[derive(Clone)]
16456pub struct KhrPipelineLibraryFn {}
16457unsafe impl Send for KhrPipelineLibraryFn {}
16458unsafe impl Sync for KhrPipelineLibraryFn {}
16459impl KhrPipelineLibraryFn {
16460 pub fn load<F>(mut _f: F) -> Self
16461 where
16462 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16463 {
16464 Self {}
16465 }
16466}
16467#[doc = "Generated from 'VK_KHR_pipeline_library'"]
16468impl PipelineCreateFlags {
16469 pub const LIBRARY_KHR: Self = Self(0b1000_0000_0000);
16470}
16471#[doc = "Generated from 'VK_KHR_pipeline_library'"]
16472impl StructureType {
16473 pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1_000_290_000);
16474}
16475impl NvExtension292Fn {
16476 #[inline]
16477 pub const fn name() -> &'static ::std::ffi::CStr {
16478 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_292\0") }
16479 }
16480 pub const SPEC_VERSION: u32 = 0u32;
16481}
16482#[derive(Clone)]
16483pub struct NvExtension292Fn {}
16484unsafe impl Send for NvExtension292Fn {}
16485unsafe impl Sync for NvExtension292Fn {}
16486impl NvExtension292Fn {
16487 pub fn load<F>(mut _f: F) -> Self
16488 where
16489 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16490 {
16491 Self {}
16492 }
16493}
16494impl NvPresentBarrierFn {
16495 #[inline]
16496 pub const fn name() -> &'static ::std::ffi::CStr {
16497 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_present_barrier\0") }
16498 }
16499 pub const SPEC_VERSION: u32 = 1u32;
16500}
16501#[derive(Clone)]
16502pub struct NvPresentBarrierFn {}
16503unsafe impl Send for NvPresentBarrierFn {}
16504unsafe impl Sync for NvPresentBarrierFn {}
16505impl NvPresentBarrierFn {
16506 pub fn load<F>(mut _f: F) -> Self
16507 where
16508 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16509 {
16510 Self {}
16511 }
16512}
16513#[doc = "Generated from 'VK_NV_present_barrier'"]
16514impl StructureType {
16515 pub const PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: Self = Self(1_000_292_000);
16516 pub const SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: Self = Self(1_000_292_001);
16517 pub const SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: Self = Self(1_000_292_002);
16518}
16519impl KhrShaderNonSemanticInfoFn {
16520 #[inline]
16521 pub const fn name() -> &'static ::std::ffi::CStr {
16522 unsafe {
16523 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_non_semantic_info\0")
16524 }
16525 }
16526 pub const SPEC_VERSION: u32 = 1u32;
16527}
16528#[derive(Clone)]
16529pub struct KhrShaderNonSemanticInfoFn {}
16530unsafe impl Send for KhrShaderNonSemanticInfoFn {}
16531unsafe impl Sync for KhrShaderNonSemanticInfoFn {}
16532impl KhrShaderNonSemanticInfoFn {
16533 pub fn load<F>(mut _f: F) -> Self
16534 where
16535 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16536 {
16537 Self {}
16538 }
16539}
16540impl KhrPresentIdFn {
16541 #[inline]
16542 pub const fn name() -> &'static ::std::ffi::CStr {
16543 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_id\0") }
16544 }
16545 pub const SPEC_VERSION: u32 = 1u32;
16546}
16547#[derive(Clone)]
16548pub struct KhrPresentIdFn {}
16549unsafe impl Send for KhrPresentIdFn {}
16550unsafe impl Sync for KhrPresentIdFn {}
16551impl KhrPresentIdFn {
16552 pub fn load<F>(mut _f: F) -> Self
16553 where
16554 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16555 {
16556 Self {}
16557 }
16558}
16559#[doc = "Generated from 'VK_KHR_present_id'"]
16560impl StructureType {
16561 pub const PRESENT_ID_KHR: Self = Self(1_000_294_000);
16562 pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001);
16563}
16564impl ExtPrivateDataFn {
16565 #[inline]
16566 pub const fn name() -> &'static ::std::ffi::CStr {
16567 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_private_data\0") }
16568 }
16569 pub const SPEC_VERSION: u32 = 1u32;
16570}
16571#[allow(non_camel_case_types)]
16572pub type PFN_vkCreatePrivateDataSlot = unsafe extern "system" fn(
16573 device: Device,
16574 p_create_info: *const PrivateDataSlotCreateInfo,
16575 p_allocator: *const AllocationCallbacks,
16576 p_private_data_slot: *mut PrivateDataSlot,
16577) -> Result;
16578#[allow(non_camel_case_types)]
16579pub type PFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn(
16580 device: Device,
16581 private_data_slot: PrivateDataSlot,
16582 p_allocator: *const AllocationCallbacks,
16583);
16584#[allow(non_camel_case_types)]
16585pub type PFN_vkSetPrivateData = unsafe extern "system" fn(
16586 device: Device,
16587 object_type: ObjectType,
16588 object_handle: u64,
16589 private_data_slot: PrivateDataSlot,
16590 data: u64,
16591) -> Result;
16592#[allow(non_camel_case_types)]
16593pub type PFN_vkGetPrivateData = unsafe extern "system" fn(
16594 device: Device,
16595 object_type: ObjectType,
16596 object_handle: u64,
16597 private_data_slot: PrivateDataSlot,
16598 p_data: *mut u64,
16599);
16600#[derive(Clone)]
16601pub struct ExtPrivateDataFn {
16602 pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot,
16603 pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlot,
16604 pub set_private_data_ext: PFN_vkSetPrivateData,
16605 pub get_private_data_ext: PFN_vkGetPrivateData,
16606}
16607unsafe impl Send for ExtPrivateDataFn {}
16608unsafe impl Sync for ExtPrivateDataFn {}
16609impl ExtPrivateDataFn {
16610 pub fn load<F>(mut _f: F) -> Self
16611 where
16612 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16613 {
16614 Self {
16615 create_private_data_slot_ext: unsafe {
16616 unsafe extern "system" fn create_private_data_slot_ext(
16617 _device: Device,
16618 _p_create_info: *const PrivateDataSlotCreateInfo,
16619 _p_allocator: *const AllocationCallbacks,
16620 _p_private_data_slot: *mut PrivateDataSlot,
16621 ) -> Result {
16622 panic!(concat!(
16623 "Unable to load ",
16624 stringify!(create_private_data_slot_ext)
16625 ))
16626 }
16627 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16628 b"vkCreatePrivateDataSlotEXT\0",
16629 );
16630 let val = _f(cname);
16631 if val.is_null() {
16632 create_private_data_slot_ext
16633 } else {
16634 ::std::mem::transmute(val)
16635 }
16636 },
16637 destroy_private_data_slot_ext: unsafe {
16638 unsafe extern "system" fn destroy_private_data_slot_ext(
16639 _device: Device,
16640 _private_data_slot: PrivateDataSlot,
16641 _p_allocator: *const AllocationCallbacks,
16642 ) {
16643 panic!(concat!(
16644 "Unable to load ",
16645 stringify!(destroy_private_data_slot_ext)
16646 ))
16647 }
16648 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16649 b"vkDestroyPrivateDataSlotEXT\0",
16650 );
16651 let val = _f(cname);
16652 if val.is_null() {
16653 destroy_private_data_slot_ext
16654 } else {
16655 ::std::mem::transmute(val)
16656 }
16657 },
16658 set_private_data_ext: unsafe {
16659 unsafe extern "system" fn set_private_data_ext(
16660 _device: Device,
16661 _object_type: ObjectType,
16662 _object_handle: u64,
16663 _private_data_slot: PrivateDataSlot,
16664 _data: u64,
16665 ) -> Result {
16666 panic!(concat!("Unable to load ", stringify!(set_private_data_ext)))
16667 }
16668 let cname =
16669 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateDataEXT\0");
16670 let val = _f(cname);
16671 if val.is_null() {
16672 set_private_data_ext
16673 } else {
16674 ::std::mem::transmute(val)
16675 }
16676 },
16677 get_private_data_ext: unsafe {
16678 unsafe extern "system" fn get_private_data_ext(
16679 _device: Device,
16680 _object_type: ObjectType,
16681 _object_handle: u64,
16682 _private_data_slot: PrivateDataSlot,
16683 _p_data: *mut u64,
16684 ) {
16685 panic!(concat!("Unable to load ", stringify!(get_private_data_ext)))
16686 }
16687 let cname =
16688 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0");
16689 let val = _f(cname);
16690 if val.is_null() {
16691 get_private_data_ext
16692 } else {
16693 ::std::mem::transmute(val)
16694 }
16695 },
16696 }
16697 }
16698}
16699#[doc = "Generated from 'VK_EXT_private_data'"]
16700impl ObjectType {
16701 pub const PRIVATE_DATA_SLOT_EXT: Self = Self::PRIVATE_DATA_SLOT;
16702}
16703#[doc = "Generated from 'VK_EXT_private_data'"]
16704impl StructureType {
16705 pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self =
16706 Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
16707 pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self::DEVICE_PRIVATE_DATA_CREATE_INFO;
16708 pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self::PRIVATE_DATA_SLOT_CREATE_INFO;
16709}
16710impl KhrExtension297Fn {
16711 #[inline]
16712 pub const fn name() -> &'static ::std::ffi::CStr {
16713 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_297\0") }
16714 }
16715 pub const SPEC_VERSION: u32 = 0u32;
16716}
16717#[derive(Clone)]
16718pub struct KhrExtension297Fn {}
16719unsafe impl Send for KhrExtension297Fn {}
16720unsafe impl Sync for KhrExtension297Fn {}
16721impl KhrExtension297Fn {
16722 pub fn load<F>(mut _f: F) -> Self
16723 where
16724 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16725 {
16726 Self {}
16727 }
16728}
16729#[doc = "Generated from 'VK_KHR_extension_297'"]
16730impl PipelineShaderStageCreateFlags {
16731 pub const RESERVED_3_KHR: Self = Self(0b1000);
16732}
16733impl ExtPipelineCreationCacheControlFn {
16734 #[inline]
16735 pub const fn name() -> &'static ::std::ffi::CStr {
16736 unsafe {
16737 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16738 b"VK_EXT_pipeline_creation_cache_control\0",
16739 )
16740 }
16741 }
16742 pub const SPEC_VERSION: u32 = 3u32;
16743}
16744#[derive(Clone)]
16745pub struct ExtPipelineCreationCacheControlFn {}
16746unsafe impl Send for ExtPipelineCreationCacheControlFn {}
16747unsafe impl Sync for ExtPipelineCreationCacheControlFn {}
16748impl ExtPipelineCreationCacheControlFn {
16749 pub fn load<F>(mut _f: F) -> Self
16750 where
16751 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16752 {
16753 Self {}
16754 }
16755}
16756#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16757impl PipelineCacheCreateFlags {
16758 pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self::EXTERNALLY_SYNCHRONIZED;
16759}
16760#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16761impl PipelineCreateFlags {
16762 pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED;
16763 pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self::EARLY_RETURN_ON_FAILURE;
16764}
16765#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16766impl Result {
16767 pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED;
16768 pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED;
16769}
16770#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16771impl StructureType {
16772 pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self =
16773 Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
16774}
16775impl KhrExtension299Fn {
16776 #[inline]
16777 pub const fn name() -> &'static ::std::ffi::CStr {
16778 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_299\0") }
16779 }
16780 pub const SPEC_VERSION: u32 = 0u32;
16781}
16782#[derive(Clone)]
16783pub struct KhrExtension299Fn {}
16784unsafe impl Send for KhrExtension299Fn {}
16785unsafe impl Sync for KhrExtension299Fn {}
16786impl KhrExtension299Fn {
16787 pub fn load<F>(mut _f: F) -> Self
16788 where
16789 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16790 {
16791 Self {}
16792 }
16793}
16794impl KhrVideoEncodeQueueFn {
16795 #[inline]
16796 pub const fn name() -> &'static ::std::ffi::CStr {
16797 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") }
16798 }
16799 pub const SPEC_VERSION: u32 = 8u32;
16800}
16801#[allow(non_camel_case_types)]
16802pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(
16803 command_buffer: CommandBuffer,
16804 p_encode_info: *const VideoEncodeInfoKHR,
16805);
16806#[derive(Clone)]
16807pub struct KhrVideoEncodeQueueFn {
16808 pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR,
16809}
16810unsafe impl Send for KhrVideoEncodeQueueFn {}
16811unsafe impl Sync for KhrVideoEncodeQueueFn {}
16812impl KhrVideoEncodeQueueFn {
16813 pub fn load<F>(mut _f: F) -> Self
16814 where
16815 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16816 {
16817 Self {
16818 cmd_encode_video_khr: unsafe {
16819 unsafe extern "system" fn cmd_encode_video_khr(
16820 _command_buffer: CommandBuffer,
16821 _p_encode_info: *const VideoEncodeInfoKHR,
16822 ) {
16823 panic!(concat!("Unable to load ", stringify!(cmd_encode_video_khr)))
16824 }
16825 let cname =
16826 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEncodeVideoKHR\0");
16827 let val = _f(cname);
16828 if val.is_null() {
16829 cmd_encode_video_khr
16830 } else {
16831 ::std::mem::transmute(val)
16832 }
16833 },
16834 }
16835 }
16836}
16837#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16838impl AccessFlags2 {
16839 pub const VIDEO_ENCODE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
16840 pub const VIDEO_ENCODE_WRITE_KHR: Self =
16841 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
16842}
16843#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16844impl BufferUsageFlags {
16845 pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b1000_0000_0000_0000);
16846 pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000);
16847}
16848#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16849impl FormatFeatureFlags {
16850 pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
16851 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
16852}
16853#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16854impl FormatFeatureFlags2 {
16855 pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
16856 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
16857}
16858#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16859impl ImageLayout {
16860 pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000);
16861 pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001);
16862 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002);
16863}
16864#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16865impl ImageUsageFlags {
16866 pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000);
16867 pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000);
16868 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1000_0000_0000_0000);
16869}
16870#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16871impl PipelineStageFlags2 {
16872 pub const VIDEO_ENCODE_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
16873}
16874#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16875impl QueryType {
16876 pub const VIDEO_ENCODE_FEEDBACK_KHR: Self = Self(1_000_299_000);
16877}
16878#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16879impl QueueFlags {
16880 pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000);
16881}
16882#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16883impl Result {
16884 pub const ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: Self = Self(-1_000_299_000);
16885}
16886#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16887impl StructureType {
16888 pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000);
16889 pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001);
16890 pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1_000_299_002);
16891 pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003);
16892 pub const VIDEO_ENCODE_USAGE_INFO_KHR: Self = Self(1_000_299_004);
16893 pub const QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: Self = Self(1_000_299_005);
16894}
16895#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16896impl VideoCodingControlFlagsKHR {
16897 pub const ENCODE_RATE_CONTROL: Self = Self(0b10);
16898 pub const ENCODE_RATE_CONTROL_LAYER: Self = Self(0b100);
16899}
16900impl NvDeviceDiagnosticsConfigFn {
16901 #[inline]
16902 pub const fn name() -> &'static ::std::ffi::CStr {
16903 unsafe {
16904 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_diagnostics_config\0")
16905 }
16906 }
16907 pub const SPEC_VERSION: u32 = 2u32;
16908}
16909#[derive(Clone)]
16910pub struct NvDeviceDiagnosticsConfigFn {}
16911unsafe impl Send for NvDeviceDiagnosticsConfigFn {}
16912unsafe impl Sync for NvDeviceDiagnosticsConfigFn {}
16913impl NvDeviceDiagnosticsConfigFn {
16914 pub fn load<F>(mut _f: F) -> Self
16915 where
16916 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16917 {
16918 Self {}
16919 }
16920}
16921#[doc = "Generated from 'VK_NV_device_diagnostics_config'"]
16922impl StructureType {
16923 pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1_000_300_000);
16924 pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1_000_300_001);
16925}
16926impl QcomRenderPassStoreOpsFn {
16927 #[inline]
16928 pub const fn name() -> &'static ::std::ffi::CStr {
16929 unsafe {
16930 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_store_ops\0")
16931 }
16932 }
16933 pub const SPEC_VERSION: u32 = 2u32;
16934}
16935#[derive(Clone)]
16936pub struct QcomRenderPassStoreOpsFn {}
16937unsafe impl Send for QcomRenderPassStoreOpsFn {}
16938unsafe impl Sync for QcomRenderPassStoreOpsFn {}
16939impl QcomRenderPassStoreOpsFn {
16940 pub fn load<F>(mut _f: F) -> Self
16941 where
16942 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16943 {
16944 Self {}
16945 }
16946}
16947#[doc = "Generated from 'VK_QCOM_render_pass_store_ops'"]
16948impl AttachmentStoreOp {
16949 pub const NONE_QCOM: Self = Self::NONE;
16950}
16951impl QcomExtension303Fn {
16952 #[inline]
16953 pub const fn name() -> &'static ::std::ffi::CStr {
16954 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_303\0") }
16955 }
16956 pub const SPEC_VERSION: u32 = 0u32;
16957}
16958#[derive(Clone)]
16959pub struct QcomExtension303Fn {}
16960unsafe impl Send for QcomExtension303Fn {}
16961unsafe impl Sync for QcomExtension303Fn {}
16962impl QcomExtension303Fn {
16963 pub fn load<F>(mut _f: F) -> Self
16964 where
16965 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16966 {
16967 Self {}
16968 }
16969}
16970impl QcomExtension304Fn {
16971 #[inline]
16972 pub const fn name() -> &'static ::std::ffi::CStr {
16973 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_304\0") }
16974 }
16975 pub const SPEC_VERSION: u32 = 0u32;
16976}
16977#[derive(Clone)]
16978pub struct QcomExtension304Fn {}
16979unsafe impl Send for QcomExtension304Fn {}
16980unsafe impl Sync for QcomExtension304Fn {}
16981impl QcomExtension304Fn {
16982 pub fn load<F>(mut _f: F) -> Self
16983 where
16984 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16985 {
16986 Self {}
16987 }
16988}
16989impl QcomExtension305Fn {
16990 #[inline]
16991 pub const fn name() -> &'static ::std::ffi::CStr {
16992 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_305\0") }
16993 }
16994 pub const SPEC_VERSION: u32 = 0u32;
16995}
16996#[derive(Clone)]
16997pub struct QcomExtension305Fn {}
16998unsafe impl Send for QcomExtension305Fn {}
16999unsafe impl Sync for QcomExtension305Fn {}
17000impl QcomExtension305Fn {
17001 pub fn load<F>(mut _f: F) -> Self
17002 where
17003 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17004 {
17005 Self {}
17006 }
17007}
17008impl QcomExtension306Fn {
17009 #[inline]
17010 pub const fn name() -> &'static ::std::ffi::CStr {
17011 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_306\0") }
17012 }
17013 pub const SPEC_VERSION: u32 = 0u32;
17014}
17015#[derive(Clone)]
17016pub struct QcomExtension306Fn {}
17017unsafe impl Send for QcomExtension306Fn {}
17018unsafe impl Sync for QcomExtension306Fn {}
17019impl QcomExtension306Fn {
17020 pub fn load<F>(mut _f: F) -> Self
17021 where
17022 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17023 {
17024 Self {}
17025 }
17026}
17027impl QcomExtension307Fn {
17028 #[inline]
17029 pub const fn name() -> &'static ::std::ffi::CStr {
17030 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_307\0") }
17031 }
17032 pub const SPEC_VERSION: u32 = 0u32;
17033}
17034#[derive(Clone)]
17035pub struct QcomExtension307Fn {}
17036unsafe impl Send for QcomExtension307Fn {}
17037unsafe impl Sync for QcomExtension307Fn {}
17038impl QcomExtension307Fn {
17039 pub fn load<F>(mut _f: F) -> Self
17040 where
17041 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17042 {
17043 Self {}
17044 }
17045}
17046impl NvExtension308Fn {
17047 #[inline]
17048 pub const fn name() -> &'static ::std::ffi::CStr {
17049 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_308\0") }
17050 }
17051 pub const SPEC_VERSION: u32 = 0u32;
17052}
17053#[derive(Clone)]
17054pub struct NvExtension308Fn {}
17055unsafe impl Send for NvExtension308Fn {}
17056unsafe impl Sync for NvExtension308Fn {}
17057impl NvExtension308Fn {
17058 pub fn load<F>(mut _f: F) -> Self
17059 where
17060 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17061 {
17062 Self {}
17063 }
17064}
17065impl QcomExtension310Fn {
17066 #[inline]
17067 pub const fn name() -> &'static ::std::ffi::CStr {
17068 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_310\0") }
17069 }
17070 pub const SPEC_VERSION: u32 = 0u32;
17071}
17072#[derive(Clone)]
17073pub struct QcomExtension310Fn {}
17074unsafe impl Send for QcomExtension310Fn {}
17075unsafe impl Sync for QcomExtension310Fn {}
17076impl QcomExtension310Fn {
17077 pub fn load<F>(mut _f: F) -> Self
17078 where
17079 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17080 {
17081 Self {}
17082 }
17083}
17084#[doc = "Generated from 'VK_QCOM_extension_310'"]
17085impl StructureType {
17086 pub const RESERVED_QCOM: Self = Self(1_000_309_000);
17087}
17088impl NvLowLatencyFn {
17089 #[inline]
17090 pub const fn name() -> &'static ::std::ffi::CStr {
17091 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_low_latency\0") }
17092 }
17093 pub const SPEC_VERSION: u32 = 1u32;
17094}
17095#[derive(Clone)]
17096pub struct NvLowLatencyFn {}
17097unsafe impl Send for NvLowLatencyFn {}
17098unsafe impl Sync for NvLowLatencyFn {}
17099impl NvLowLatencyFn {
17100 pub fn load<F>(mut _f: F) -> Self
17101 where
17102 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17103 {
17104 Self {}
17105 }
17106}
17107#[doc = "Generated from 'VK_NV_low_latency'"]
17108impl StructureType {
17109 pub const QUERY_LOW_LATENCY_SUPPORT_NV: Self = Self(1_000_310_000);
17110}
17111impl ExtMetalObjectsFn {
17112 #[inline]
17113 pub const fn name() -> &'static ::std::ffi::CStr {
17114 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_objects\0") }
17115 }
17116 pub const SPEC_VERSION: u32 = 1u32;
17117}
17118#[allow(non_camel_case_types)]
17119pub type PFN_vkExportMetalObjectsEXT =
17120 unsafe extern "system" fn(device: Device, p_metal_objects_info: *mut ExportMetalObjectsInfoEXT);
17121#[derive(Clone)]
17122pub struct ExtMetalObjectsFn {
17123 pub export_metal_objects_ext: PFN_vkExportMetalObjectsEXT,
17124}
17125unsafe impl Send for ExtMetalObjectsFn {}
17126unsafe impl Sync for ExtMetalObjectsFn {}
17127impl ExtMetalObjectsFn {
17128 pub fn load<F>(mut _f: F) -> Self
17129 where
17130 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17131 {
17132 Self {
17133 export_metal_objects_ext: unsafe {
17134 unsafe extern "system" fn export_metal_objects_ext(
17135 _device: Device,
17136 _p_metal_objects_info: *mut ExportMetalObjectsInfoEXT,
17137 ) {
17138 panic!(concat!(
17139 "Unable to load ",
17140 stringify!(export_metal_objects_ext)
17141 ))
17142 }
17143 let cname =
17144 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkExportMetalObjectsEXT\0");
17145 let val = _f(cname);
17146 if val.is_null() {
17147 export_metal_objects_ext
17148 } else {
17149 ::std::mem::transmute(val)
17150 }
17151 },
17152 }
17153 }
17154}
17155#[doc = "Generated from 'VK_EXT_metal_objects'"]
17156impl StructureType {
17157 pub const EXPORT_METAL_OBJECT_CREATE_INFO_EXT: Self = Self(1_000_311_000);
17158 pub const EXPORT_METAL_OBJECTS_INFO_EXT: Self = Self(1_000_311_001);
17159 pub const EXPORT_METAL_DEVICE_INFO_EXT: Self = Self(1_000_311_002);
17160 pub const EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: Self = Self(1_000_311_003);
17161 pub const EXPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_004);
17162 pub const IMPORT_METAL_BUFFER_INFO_EXT: Self = Self(1_000_311_005);
17163 pub const EXPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_006);
17164 pub const IMPORT_METAL_TEXTURE_INFO_EXT: Self = Self(1_000_311_007);
17165 pub const EXPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_008);
17166 pub const IMPORT_METAL_IO_SURFACE_INFO_EXT: Self = Self(1_000_311_009);
17167 pub const EXPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_010);
17168 pub const IMPORT_METAL_SHARED_EVENT_INFO_EXT: Self = Self(1_000_311_011);
17169}
17170impl ExtExtension313Fn {
17171 #[inline]
17172 pub const fn name() -> &'static ::std::ffi::CStr {
17173 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_313\0") }
17174 }
17175 pub const SPEC_VERSION: u32 = 0u32;
17176}
17177#[derive(Clone)]
17178pub struct ExtExtension313Fn {}
17179unsafe impl Send for ExtExtension313Fn {}
17180unsafe impl Sync for ExtExtension313Fn {}
17181impl ExtExtension313Fn {
17182 pub fn load<F>(mut _f: F) -> Self
17183 where
17184 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17185 {
17186 Self {}
17187 }
17188}
17189impl AmdExtension314Fn {
17190 #[inline]
17191 pub const fn name() -> &'static ::std::ffi::CStr {
17192 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_314\0") }
17193 }
17194 pub const SPEC_VERSION: u32 = 0u32;
17195}
17196#[derive(Clone)]
17197pub struct AmdExtension314Fn {}
17198unsafe impl Send for AmdExtension314Fn {}
17199unsafe impl Sync for AmdExtension314Fn {}
17200impl AmdExtension314Fn {
17201 pub fn load<F>(mut _f: F) -> Self
17202 where
17203 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17204 {
17205 Self {}
17206 }
17207}
17208impl KhrSynchronization2Fn {
17209 #[inline]
17210 pub const fn name() -> &'static ::std::ffi::CStr {
17211 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_synchronization2\0") }
17212 }
17213 pub const SPEC_VERSION: u32 = 1u32;
17214}
17215#[allow(non_camel_case_types)]
17216pub type PFN_vkCmdSetEvent2 = unsafe extern "system" fn(
17217 command_buffer: CommandBuffer,
17218 event: Event,
17219 p_dependency_info: *const DependencyInfo,
17220);
17221#[allow(non_camel_case_types)]
17222pub type PFN_vkCmdResetEvent2 = unsafe extern "system" fn(
17223 command_buffer: CommandBuffer,
17224 event: Event,
17225 stage_mask: PipelineStageFlags2,
17226);
17227#[allow(non_camel_case_types)]
17228pub type PFN_vkCmdWaitEvents2 = unsafe extern "system" fn(
17229 command_buffer: CommandBuffer,
17230 event_count: u32,
17231 p_events: *const Event,
17232 p_dependency_infos: *const DependencyInfo,
17233);
17234#[allow(non_camel_case_types)]
17235pub type PFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn(
17236 command_buffer: CommandBuffer,
17237 p_dependency_info: *const DependencyInfo,
17238);
17239#[allow(non_camel_case_types)]
17240pub type PFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn(
17241 command_buffer: CommandBuffer,
17242 stage: PipelineStageFlags2,
17243 query_pool: QueryPool,
17244 query: u32,
17245);
17246#[allow(non_camel_case_types)]
17247pub type PFN_vkQueueSubmit2 = unsafe extern "system" fn(
17248 queue: Queue,
17249 submit_count: u32,
17250 p_submits: *const SubmitInfo2,
17251 fence: Fence,
17252) -> Result;
17253#[allow(non_camel_case_types)]
17254pub type PFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn(
17255 command_buffer: CommandBuffer,
17256 stage: PipelineStageFlags2,
17257 dst_buffer: Buffer,
17258 dst_offset: DeviceSize,
17259 marker: u32,
17260);
17261#[allow(non_camel_case_types)]
17262pub type PFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn(
17263 queue: Queue,
17264 p_checkpoint_data_count: *mut u32,
17265 p_checkpoint_data: *mut CheckpointData2NV,
17266);
17267#[derive(Clone)]
17268pub struct KhrSynchronization2Fn {
17269 pub cmd_set_event2_khr: PFN_vkCmdSetEvent2,
17270 pub cmd_reset_event2_khr: PFN_vkCmdResetEvent2,
17271 pub cmd_wait_events2_khr: PFN_vkCmdWaitEvents2,
17272 pub cmd_pipeline_barrier2_khr: PFN_vkCmdPipelineBarrier2,
17273 pub cmd_write_timestamp2_khr: PFN_vkCmdWriteTimestamp2,
17274 pub queue_submit2_khr: PFN_vkQueueSubmit2,
17275 pub cmd_write_buffer_marker2_amd: PFN_vkCmdWriteBufferMarker2AMD,
17276 pub get_queue_checkpoint_data2_nv: PFN_vkGetQueueCheckpointData2NV,
17277}
17278unsafe impl Send for KhrSynchronization2Fn {}
17279unsafe impl Sync for KhrSynchronization2Fn {}
17280impl KhrSynchronization2Fn {
17281 pub fn load<F>(mut _f: F) -> Self
17282 where
17283 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17284 {
17285 Self {
17286 cmd_set_event2_khr: unsafe {
17287 unsafe extern "system" fn cmd_set_event2_khr(
17288 _command_buffer: CommandBuffer,
17289 _event: Event,
17290 _p_dependency_info: *const DependencyInfo,
17291 ) {
17292 panic!(concat!("Unable to load ", stringify!(cmd_set_event2_khr)))
17293 }
17294 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2KHR\0");
17295 let val = _f(cname);
17296 if val.is_null() {
17297 cmd_set_event2_khr
17298 } else {
17299 ::std::mem::transmute(val)
17300 }
17301 },
17302 cmd_reset_event2_khr: unsafe {
17303 unsafe extern "system" fn cmd_reset_event2_khr(
17304 _command_buffer: CommandBuffer,
17305 _event: Event,
17306 _stage_mask: PipelineStageFlags2,
17307 ) {
17308 panic!(concat!("Unable to load ", stringify!(cmd_reset_event2_khr)))
17309 }
17310 let cname =
17311 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2KHR\0");
17312 let val = _f(cname);
17313 if val.is_null() {
17314 cmd_reset_event2_khr
17315 } else {
17316 ::std::mem::transmute(val)
17317 }
17318 },
17319 cmd_wait_events2_khr: unsafe {
17320 unsafe extern "system" fn cmd_wait_events2_khr(
17321 _command_buffer: CommandBuffer,
17322 _event_count: u32,
17323 _p_events: *const Event,
17324 _p_dependency_infos: *const DependencyInfo,
17325 ) {
17326 panic!(concat!("Unable to load ", stringify!(cmd_wait_events2_khr)))
17327 }
17328 let cname =
17329 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2KHR\0");
17330 let val = _f(cname);
17331 if val.is_null() {
17332 cmd_wait_events2_khr
17333 } else {
17334 ::std::mem::transmute(val)
17335 }
17336 },
17337 cmd_pipeline_barrier2_khr: unsafe {
17338 unsafe extern "system" fn cmd_pipeline_barrier2_khr(
17339 _command_buffer: CommandBuffer,
17340 _p_dependency_info: *const DependencyInfo,
17341 ) {
17342 panic!(concat!(
17343 "Unable to load ",
17344 stringify!(cmd_pipeline_barrier2_khr)
17345 ))
17346 }
17347 let cname =
17348 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2KHR\0");
17349 let val = _f(cname);
17350 if val.is_null() {
17351 cmd_pipeline_barrier2_khr
17352 } else {
17353 ::std::mem::transmute(val)
17354 }
17355 },
17356 cmd_write_timestamp2_khr: unsafe {
17357 unsafe extern "system" fn cmd_write_timestamp2_khr(
17358 _command_buffer: CommandBuffer,
17359 _stage: PipelineStageFlags2,
17360 _query_pool: QueryPool,
17361 _query: u32,
17362 ) {
17363 panic!(concat!(
17364 "Unable to load ",
17365 stringify!(cmd_write_timestamp2_khr)
17366 ))
17367 }
17368 let cname =
17369 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2KHR\0");
17370 let val = _f(cname);
17371 if val.is_null() {
17372 cmd_write_timestamp2_khr
17373 } else {
17374 ::std::mem::transmute(val)
17375 }
17376 },
17377 queue_submit2_khr: unsafe {
17378 unsafe extern "system" fn queue_submit2_khr(
17379 _queue: Queue,
17380 _submit_count: u32,
17381 _p_submits: *const SubmitInfo2,
17382 _fence: Fence,
17383 ) -> Result {
17384 panic!(concat!("Unable to load ", stringify!(queue_submit2_khr)))
17385 }
17386 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2KHR\0");
17387 let val = _f(cname);
17388 if val.is_null() {
17389 queue_submit2_khr
17390 } else {
17391 ::std::mem::transmute(val)
17392 }
17393 },
17394 cmd_write_buffer_marker2_amd: unsafe {
17395 unsafe extern "system" fn cmd_write_buffer_marker2_amd(
17396 _command_buffer: CommandBuffer,
17397 _stage: PipelineStageFlags2,
17398 _dst_buffer: Buffer,
17399 _dst_offset: DeviceSize,
17400 _marker: u32,
17401 ) {
17402 panic!(concat!(
17403 "Unable to load ",
17404 stringify!(cmd_write_buffer_marker2_amd)
17405 ))
17406 }
17407 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17408 b"vkCmdWriteBufferMarker2AMD\0",
17409 );
17410 let val = _f(cname);
17411 if val.is_null() {
17412 cmd_write_buffer_marker2_amd
17413 } else {
17414 ::std::mem::transmute(val)
17415 }
17416 },
17417 get_queue_checkpoint_data2_nv: unsafe {
17418 unsafe extern "system" fn get_queue_checkpoint_data2_nv(
17419 _queue: Queue,
17420 _p_checkpoint_data_count: *mut u32,
17421 _p_checkpoint_data: *mut CheckpointData2NV,
17422 ) {
17423 panic!(concat!(
17424 "Unable to load ",
17425 stringify!(get_queue_checkpoint_data2_nv)
17426 ))
17427 }
17428 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17429 b"vkGetQueueCheckpointData2NV\0",
17430 );
17431 let val = _f(cname);
17432 if val.is_null() {
17433 get_queue_checkpoint_data2_nv
17434 } else {
17435 ::std::mem::transmute(val)
17436 }
17437 },
17438 }
17439 }
17440}
17441#[doc = "Generated from 'VK_KHR_synchronization2'"]
17442impl AccessFlags {
17443 pub const NONE_KHR: Self = Self::NONE;
17444}
17445#[doc = "Generated from 'VK_KHR_synchronization2'"]
17446impl AccessFlags2 {
17447 pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
17448 pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
17449 pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self =
17450 Self(0b1000_0000_0000_0000_0000_0000_0000);
17451 #[doc = "read access flag for reading conditional rendering predicate"]
17452 pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
17453 pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000);
17454 pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000);
17455 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self =
17456 Self(0b1000_0000_0000_0000_0000_0000);
17457 pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR;
17458 pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
17459 pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
17460 pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR;
17461 pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR;
17462 pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
17463 pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
17464}
17465#[doc = "Generated from 'VK_KHR_synchronization2'"]
17466impl EventCreateFlags {
17467 pub const DEVICE_ONLY_KHR: Self = Self::DEVICE_ONLY;
17468}
17469#[doc = "Generated from 'VK_KHR_synchronization2'"]
17470impl ImageLayout {
17471 pub const READ_ONLY_OPTIMAL_KHR: Self = Self::READ_ONLY_OPTIMAL;
17472 pub const ATTACHMENT_OPTIMAL_KHR: Self = Self::ATTACHMENT_OPTIMAL;
17473}
17474#[doc = "Generated from 'VK_KHR_synchronization2'"]
17475impl PipelineStageFlags {
17476 pub const NONE_KHR: Self = Self::NONE;
17477}
17478#[doc = "Generated from 'VK_KHR_synchronization2'"]
17479impl PipelineStageFlags2 {
17480 pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
17481 #[doc = "A pipeline stage for conditional rendering predicate fetch"]
17482 pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000);
17483 pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
17484 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
17485 pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR;
17486 pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
17487 pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
17488 pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR;
17489 pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR;
17490 pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
17491 pub const TASK_SHADER_NV: Self = Self::TASK_SHADER_EXT;
17492 pub const MESH_SHADER_NV: Self = Self::MESH_SHADER_EXT;
17493 pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000);
17494 pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
17495}
17496#[doc = "Generated from 'VK_KHR_synchronization2'"]
17497impl StructureType {
17498 pub const MEMORY_BARRIER_2_KHR: Self = Self::MEMORY_BARRIER_2;
17499 pub const BUFFER_MEMORY_BARRIER_2_KHR: Self = Self::BUFFER_MEMORY_BARRIER_2;
17500 pub const IMAGE_MEMORY_BARRIER_2_KHR: Self = Self::IMAGE_MEMORY_BARRIER_2;
17501 pub const DEPENDENCY_INFO_KHR: Self = Self::DEPENDENCY_INFO;
17502 pub const SUBMIT_INFO_2_KHR: Self = Self::SUBMIT_INFO_2;
17503 pub const SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::SEMAPHORE_SUBMIT_INFO;
17504 pub const COMMAND_BUFFER_SUBMIT_INFO_KHR: Self = Self::COMMAND_BUFFER_SUBMIT_INFO;
17505 pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: Self =
17506 Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
17507 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: Self = Self(1_000_314_008);
17508 pub const CHECKPOINT_DATA_2_NV: Self = Self(1_000_314_009);
17509}
17510impl AmdExtension316Fn {
17511 #[inline]
17512 pub const fn name() -> &'static ::std::ffi::CStr {
17513 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_316\0") }
17514 }
17515 pub const SPEC_VERSION: u32 = 0u32;
17516}
17517#[derive(Clone)]
17518pub struct AmdExtension316Fn {}
17519unsafe impl Send for AmdExtension316Fn {}
17520unsafe impl Sync for AmdExtension316Fn {}
17521impl AmdExtension316Fn {
17522 pub fn load<F>(mut _f: F) -> Self
17523 where
17524 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17525 {
17526 Self {}
17527 }
17528}
17529impl ExtDescriptorBufferFn {
17530 #[inline]
17531 pub const fn name() -> &'static ::std::ffi::CStr {
17532 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_buffer\0") }
17533 }
17534 pub const SPEC_VERSION: u32 = 1u32;
17535}
17536#[allow(non_camel_case_types)]
17537pub type PFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn(
17538 device: Device,
17539 layout: DescriptorSetLayout,
17540 p_layout_size_in_bytes: *mut DeviceSize,
17541);
17542#[allow(non_camel_case_types)]
17543pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn(
17544 device: Device,
17545 layout: DescriptorSetLayout,
17546 binding: u32,
17547 p_offset: *mut DeviceSize,
17548);
17549#[allow(non_camel_case_types)]
17550pub type PFN_vkGetDescriptorEXT = unsafe extern "system" fn(
17551 device: Device,
17552 p_descriptor_info: *const DescriptorGetInfoEXT,
17553 data_size: usize,
17554 p_descriptor: *mut c_void,
17555);
17556#[allow(non_camel_case_types)]
17557pub type PFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn(
17558 command_buffer: CommandBuffer,
17559 buffer_count: u32,
17560 p_binding_infos: *const DescriptorBufferBindingInfoEXT,
17561);
17562#[allow(non_camel_case_types)]
17563pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn(
17564 command_buffer: CommandBuffer,
17565 pipeline_bind_point: PipelineBindPoint,
17566 layout: PipelineLayout,
17567 first_set: u32,
17568 set_count: u32,
17569 p_buffer_indices: *const u32,
17570 p_offsets: *const DeviceSize,
17571);
17572#[allow(non_camel_case_types)]
17573pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn(
17574 command_buffer: CommandBuffer,
17575 pipeline_bind_point: PipelineBindPoint,
17576 layout: PipelineLayout,
17577 set: u32,
17578);
17579#[allow(non_camel_case_types)]
17580pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
17581 device: Device,
17582 p_info: *const BufferCaptureDescriptorDataInfoEXT,
17583 p_data: *mut c_void,
17584) -> Result;
17585#[allow(non_camel_case_types)]
17586pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
17587 device: Device,
17588 p_info: *const ImageCaptureDescriptorDataInfoEXT,
17589 p_data: *mut c_void,
17590) -> Result;
17591#[allow(non_camel_case_types)]
17592pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
17593 device: Device,
17594 p_info: *const ImageViewCaptureDescriptorDataInfoEXT,
17595 p_data: *mut c_void,
17596) -> Result;
17597#[allow(non_camel_case_types)]
17598pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(
17599 device: Device,
17600 p_info: *const SamplerCaptureDescriptorDataInfoEXT,
17601 p_data: *mut c_void,
17602) -> Result;
17603#[allow(non_camel_case_types)]
17604pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT =
17605 unsafe extern "system" fn(
17606 device: Device,
17607 p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT,
17608 p_data: *mut c_void,
17609 ) -> Result;
17610#[derive(Clone)]
17611pub struct ExtDescriptorBufferFn {
17612 pub get_descriptor_set_layout_size_ext: PFN_vkGetDescriptorSetLayoutSizeEXT,
17613 pub get_descriptor_set_layout_binding_offset_ext: PFN_vkGetDescriptorSetLayoutBindingOffsetEXT,
17614 pub get_descriptor_ext: PFN_vkGetDescriptorEXT,
17615 pub cmd_bind_descriptor_buffers_ext: PFN_vkCmdBindDescriptorBuffersEXT,
17616 pub cmd_set_descriptor_buffer_offsets_ext: PFN_vkCmdSetDescriptorBufferOffsetsEXT,
17617 pub cmd_bind_descriptor_buffer_embedded_samplers_ext:
17618 PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT,
17619 pub get_buffer_opaque_capture_descriptor_data_ext:
17620 PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT,
17621 pub get_image_opaque_capture_descriptor_data_ext: PFN_vkGetImageOpaqueCaptureDescriptorDataEXT,
17622 pub get_image_view_opaque_capture_descriptor_data_ext:
17623 PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT,
17624 pub get_sampler_opaque_capture_descriptor_data_ext:
17625 PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT,
17626 pub get_acceleration_structure_opaque_capture_descriptor_data_ext:
17627 PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT,
17628}
17629unsafe impl Send for ExtDescriptorBufferFn {}
17630unsafe impl Sync for ExtDescriptorBufferFn {}
17631impl ExtDescriptorBufferFn {
17632 pub fn load<F>(mut _f: F) -> Self
17633 where
17634 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17635 {
17636 Self {
17637 get_descriptor_set_layout_size_ext: unsafe {
17638 unsafe extern "system" fn get_descriptor_set_layout_size_ext(
17639 _device: Device,
17640 _layout: DescriptorSetLayout,
17641 _p_layout_size_in_bytes: *mut DeviceSize,
17642 ) {
17643 panic!(concat!(
17644 "Unable to load ",
17645 stringify!(get_descriptor_set_layout_size_ext)
17646 ))
17647 }
17648 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17649 b"vkGetDescriptorSetLayoutSizeEXT\0",
17650 );
17651 let val = _f(cname);
17652 if val.is_null() {
17653 get_descriptor_set_layout_size_ext
17654 } else {
17655 ::std::mem::transmute(val)
17656 }
17657 },
17658 get_descriptor_set_layout_binding_offset_ext: unsafe {
17659 unsafe extern "system" fn get_descriptor_set_layout_binding_offset_ext(
17660 _device: Device,
17661 _layout: DescriptorSetLayout,
17662 _binding: u32,
17663 _p_offset: *mut DeviceSize,
17664 ) {
17665 panic!(concat!(
17666 "Unable to load ",
17667 stringify!(get_descriptor_set_layout_binding_offset_ext)
17668 ))
17669 }
17670 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17671 b"vkGetDescriptorSetLayoutBindingOffsetEXT\0",
17672 );
17673 let val = _f(cname);
17674 if val.is_null() {
17675 get_descriptor_set_layout_binding_offset_ext
17676 } else {
17677 ::std::mem::transmute(val)
17678 }
17679 },
17680 get_descriptor_ext: unsafe {
17681 unsafe extern "system" fn get_descriptor_ext(
17682 _device: Device,
17683 _p_descriptor_info: *const DescriptorGetInfoEXT,
17684 _data_size: usize,
17685 _p_descriptor: *mut c_void,
17686 ) {
17687 panic!(concat!("Unable to load ", stringify!(get_descriptor_ext)))
17688 }
17689 let cname =
17690 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDescriptorEXT\0");
17691 let val = _f(cname);
17692 if val.is_null() {
17693 get_descriptor_ext
17694 } else {
17695 ::std::mem::transmute(val)
17696 }
17697 },
17698 cmd_bind_descriptor_buffers_ext: unsafe {
17699 unsafe extern "system" fn cmd_bind_descriptor_buffers_ext(
17700 _command_buffer: CommandBuffer,
17701 _buffer_count: u32,
17702 _p_binding_infos: *const DescriptorBufferBindingInfoEXT,
17703 ) {
17704 panic!(concat!(
17705 "Unable to load ",
17706 stringify!(cmd_bind_descriptor_buffers_ext)
17707 ))
17708 }
17709 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17710 b"vkCmdBindDescriptorBuffersEXT\0",
17711 );
17712 let val = _f(cname);
17713 if val.is_null() {
17714 cmd_bind_descriptor_buffers_ext
17715 } else {
17716 ::std::mem::transmute(val)
17717 }
17718 },
17719 cmd_set_descriptor_buffer_offsets_ext: unsafe {
17720 unsafe extern "system" fn cmd_set_descriptor_buffer_offsets_ext(
17721 _command_buffer: CommandBuffer,
17722 _pipeline_bind_point: PipelineBindPoint,
17723 _layout: PipelineLayout,
17724 _first_set: u32,
17725 _set_count: u32,
17726 _p_buffer_indices: *const u32,
17727 _p_offsets: *const DeviceSize,
17728 ) {
17729 panic!(concat!(
17730 "Unable to load ",
17731 stringify!(cmd_set_descriptor_buffer_offsets_ext)
17732 ))
17733 }
17734 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17735 b"vkCmdSetDescriptorBufferOffsetsEXT\0",
17736 );
17737 let val = _f(cname);
17738 if val.is_null() {
17739 cmd_set_descriptor_buffer_offsets_ext
17740 } else {
17741 ::std::mem::transmute(val)
17742 }
17743 },
17744 cmd_bind_descriptor_buffer_embedded_samplers_ext: unsafe {
17745 unsafe extern "system" fn cmd_bind_descriptor_buffer_embedded_samplers_ext(
17746 _command_buffer: CommandBuffer,
17747 _pipeline_bind_point: PipelineBindPoint,
17748 _layout: PipelineLayout,
17749 _set: u32,
17750 ) {
17751 panic!(concat!(
17752 "Unable to load ",
17753 stringify!(cmd_bind_descriptor_buffer_embedded_samplers_ext)
17754 ))
17755 }
17756 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17757 b"vkCmdBindDescriptorBufferEmbeddedSamplersEXT\0",
17758 );
17759 let val = _f(cname);
17760 if val.is_null() {
17761 cmd_bind_descriptor_buffer_embedded_samplers_ext
17762 } else {
17763 ::std::mem::transmute(val)
17764 }
17765 },
17766 get_buffer_opaque_capture_descriptor_data_ext: unsafe {
17767 unsafe extern "system" fn get_buffer_opaque_capture_descriptor_data_ext(
17768 _device: Device,
17769 _p_info: *const BufferCaptureDescriptorDataInfoEXT,
17770 _p_data: *mut c_void,
17771 ) -> Result {
17772 panic!(concat!(
17773 "Unable to load ",
17774 stringify!(get_buffer_opaque_capture_descriptor_data_ext)
17775 ))
17776 }
17777 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17778 b"vkGetBufferOpaqueCaptureDescriptorDataEXT\0",
17779 );
17780 let val = _f(cname);
17781 if val.is_null() {
17782 get_buffer_opaque_capture_descriptor_data_ext
17783 } else {
17784 ::std::mem::transmute(val)
17785 }
17786 },
17787 get_image_opaque_capture_descriptor_data_ext: unsafe {
17788 unsafe extern "system" fn get_image_opaque_capture_descriptor_data_ext(
17789 _device: Device,
17790 _p_info: *const ImageCaptureDescriptorDataInfoEXT,
17791 _p_data: *mut c_void,
17792 ) -> Result {
17793 panic!(concat!(
17794 "Unable to load ",
17795 stringify!(get_image_opaque_capture_descriptor_data_ext)
17796 ))
17797 }
17798 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17799 b"vkGetImageOpaqueCaptureDescriptorDataEXT\0",
17800 );
17801 let val = _f(cname);
17802 if val.is_null() {
17803 get_image_opaque_capture_descriptor_data_ext
17804 } else {
17805 ::std::mem::transmute(val)
17806 }
17807 },
17808 get_image_view_opaque_capture_descriptor_data_ext: unsafe {
17809 unsafe extern "system" fn get_image_view_opaque_capture_descriptor_data_ext(
17810 _device: Device,
17811 _p_info: *const ImageViewCaptureDescriptorDataInfoEXT,
17812 _p_data: *mut c_void,
17813 ) -> Result {
17814 panic!(concat!(
17815 "Unable to load ",
17816 stringify!(get_image_view_opaque_capture_descriptor_data_ext)
17817 ))
17818 }
17819 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17820 b"vkGetImageViewOpaqueCaptureDescriptorDataEXT\0",
17821 );
17822 let val = _f(cname);
17823 if val.is_null() {
17824 get_image_view_opaque_capture_descriptor_data_ext
17825 } else {
17826 ::std::mem::transmute(val)
17827 }
17828 },
17829 get_sampler_opaque_capture_descriptor_data_ext: unsafe {
17830 unsafe extern "system" fn get_sampler_opaque_capture_descriptor_data_ext(
17831 _device: Device,
17832 _p_info: *const SamplerCaptureDescriptorDataInfoEXT,
17833 _p_data: *mut c_void,
17834 ) -> Result {
17835 panic!(concat!(
17836 "Unable to load ",
17837 stringify!(get_sampler_opaque_capture_descriptor_data_ext)
17838 ))
17839 }
17840 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17841 b"vkGetSamplerOpaqueCaptureDescriptorDataEXT\0",
17842 );
17843 let val = _f(cname);
17844 if val.is_null() {
17845 get_sampler_opaque_capture_descriptor_data_ext
17846 } else {
17847 ::std::mem::transmute(val)
17848 }
17849 },
17850 get_acceleration_structure_opaque_capture_descriptor_data_ext: unsafe {
17851 unsafe extern "system" fn get_acceleration_structure_opaque_capture_descriptor_data_ext(
17852 _device: Device,
17853 _p_info: *const AccelerationStructureCaptureDescriptorDataInfoEXT,
17854 _p_data: *mut c_void,
17855 ) -> Result {
17856 panic!(concat!(
17857 "Unable to load ",
17858 stringify!(get_acceleration_structure_opaque_capture_descriptor_data_ext)
17859 ))
17860 }
17861 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17862 b"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT\0",
17863 );
17864 let val = _f(cname);
17865 if val.is_null() {
17866 get_acceleration_structure_opaque_capture_descriptor_data_ext
17867 } else {
17868 ::std::mem::transmute(val)
17869 }
17870 },
17871 }
17872 }
17873}
17874#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17875impl AccelerationStructureCreateFlagsKHR {
17876 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000);
17877}
17878#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17879impl AccessFlags2 {
17880 pub const DESCRIPTOR_BUFFER_READ_EXT: Self =
17881 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
17882}
17883#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17884impl BufferCreateFlags {
17885 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b10_0000);
17886}
17887#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17888impl BufferUsageFlags {
17889 pub const SAMPLER_DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000);
17890 pub const RESOURCE_DESCRIPTOR_BUFFER_EXT: Self = Self(0b100_0000_0000_0000_0000_0000);
17891 pub const PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_EXT: Self =
17892 Self(0b100_0000_0000_0000_0000_0000_0000);
17893}
17894#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17895impl DescriptorSetLayoutCreateFlags {
17896 pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b1_0000);
17897 pub const EMBEDDED_IMMUTABLE_SAMPLERS_EXT: Self = Self(0b10_0000);
17898}
17899#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17900impl ImageCreateFlags {
17901 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1_0000_0000_0000_0000);
17902}
17903#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17904impl ImageViewCreateFlags {
17905 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b100);
17906}
17907#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17908impl PipelineCreateFlags {
17909 pub const DESCRIPTOR_BUFFER_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000);
17910}
17911#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17912impl SamplerCreateFlags {
17913 pub const DESCRIPTOR_BUFFER_CAPTURE_REPLAY_EXT: Self = Self(0b1000);
17914}
17915#[doc = "Generated from 'VK_EXT_descriptor_buffer'"]
17916impl StructureType {
17917 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: Self = Self(1_000_316_000);
17918 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: Self =
17919 Self(1_000_316_001);
17920 pub const PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: Self = Self(1_000_316_002);
17921 pub const DESCRIPTOR_ADDRESS_INFO_EXT: Self = Self(1_000_316_003);
17922 pub const DESCRIPTOR_GET_INFO_EXT: Self = Self(1_000_316_004);
17923 pub const BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_005);
17924 pub const IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_006);
17925 pub const IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_007);
17926 pub const SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_008);
17927 pub const OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: Self = Self(1_000_316_010);
17928 pub const DESCRIPTOR_BUFFER_BINDING_INFO_EXT: Self = Self(1_000_316_011);
17929 pub const DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: Self =
17930 Self(1_000_316_012);
17931 pub const ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: Self = Self(1_000_316_009);
17932}
17933impl AmdExtension318Fn {
17934 #[inline]
17935 pub const fn name() -> &'static ::std::ffi::CStr {
17936 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_318\0") }
17937 }
17938 pub const SPEC_VERSION: u32 = 0u32;
17939}
17940#[derive(Clone)]
17941pub struct AmdExtension318Fn {}
17942unsafe impl Send for AmdExtension318Fn {}
17943unsafe impl Sync for AmdExtension318Fn {}
17944impl AmdExtension318Fn {
17945 pub fn load<F>(mut _f: F) -> Self
17946 where
17947 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17948 {
17949 Self {}
17950 }
17951}
17952impl AmdExtension319Fn {
17953 #[inline]
17954 pub const fn name() -> &'static ::std::ffi::CStr {
17955 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_319\0") }
17956 }
17957 pub const SPEC_VERSION: u32 = 0u32;
17958}
17959#[derive(Clone)]
17960pub struct AmdExtension319Fn {}
17961unsafe impl Send for AmdExtension319Fn {}
17962unsafe impl Sync for AmdExtension319Fn {}
17963impl AmdExtension319Fn {
17964 pub fn load<F>(mut _f: F) -> Self
17965 where
17966 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17967 {
17968 Self {}
17969 }
17970}
17971#[doc = "Generated from 'VK_AMD_extension_319'"]
17972impl DescriptorSetLayoutCreateFlags {
17973 pub const RESERVED_3_AMD: Self = Self(0b1000);
17974}
17975#[doc = "Generated from 'VK_AMD_extension_319'"]
17976impl PipelineLayoutCreateFlags {
17977 pub const RESERVED_0_AMD: Self = Self(0b1);
17978}
17979impl AmdExtension320Fn {
17980 #[inline]
17981 pub const fn name() -> &'static ::std::ffi::CStr {
17982 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_320\0") }
17983 }
17984 pub const SPEC_VERSION: u32 = 0u32;
17985}
17986#[derive(Clone)]
17987pub struct AmdExtension320Fn {}
17988unsafe impl Send for AmdExtension320Fn {}
17989unsafe impl Sync for AmdExtension320Fn {}
17990impl AmdExtension320Fn {
17991 pub fn load<F>(mut _f: F) -> Self
17992 where
17993 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17994 {
17995 Self {}
17996 }
17997}
17998impl ExtGraphicsPipelineLibraryFn {
17999 #[inline]
18000 pub const fn name() -> &'static ::std::ffi::CStr {
18001 unsafe {
18002 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_graphics_pipeline_library\0")
18003 }
18004 }
18005 pub const SPEC_VERSION: u32 = 1u32;
18006}
18007#[derive(Clone)]
18008pub struct ExtGraphicsPipelineLibraryFn {}
18009unsafe impl Send for ExtGraphicsPipelineLibraryFn {}
18010unsafe impl Sync for ExtGraphicsPipelineLibraryFn {}
18011impl ExtGraphicsPipelineLibraryFn {
18012 pub fn load<F>(mut _f: F) -> Self
18013 where
18014 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18015 {
18016 Self {}
18017 }
18018}
18019#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"]
18020impl PipelineCreateFlags {
18021 pub const RETAIN_LINK_TIME_OPTIMIZATION_INFO_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
18022 pub const LINK_TIME_OPTIMIZATION_EXT: Self = Self(0b100_0000_0000);
18023}
18024#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"]
18025impl PipelineLayoutCreateFlags {
18026 pub const INDEPENDENT_SETS_EXT: Self = Self(0b10);
18027}
18028#[doc = "Generated from 'VK_EXT_graphics_pipeline_library'"]
18029impl StructureType {
18030 pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: Self = Self(1_000_320_000);
18031 pub const PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: Self = Self(1_000_320_001);
18032 pub const GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: Self = Self(1_000_320_002);
18033}
18034impl AmdShaderEarlyAndLateFragmentTestsFn {
18035 #[inline]
18036 pub const fn name() -> &'static ::std::ffi::CStr {
18037 unsafe {
18038 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18039 b"VK_AMD_shader_early_and_late_fragment_tests\0",
18040 )
18041 }
18042 }
18043 pub const SPEC_VERSION: u32 = 1u32;
18044}
18045#[derive(Clone)]
18046pub struct AmdShaderEarlyAndLateFragmentTestsFn {}
18047unsafe impl Send for AmdShaderEarlyAndLateFragmentTestsFn {}
18048unsafe impl Sync for AmdShaderEarlyAndLateFragmentTestsFn {}
18049impl AmdShaderEarlyAndLateFragmentTestsFn {
18050 pub fn load<F>(mut _f: F) -> Self
18051 where
18052 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18053 {
18054 Self {}
18055 }
18056}
18057#[doc = "Generated from 'VK_AMD_shader_early_and_late_fragment_tests'"]
18058impl StructureType {
18059 pub const PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: Self =
18060 Self(1_000_321_000);
18061}
18062impl KhrFragmentShaderBarycentricFn {
18063 #[inline]
18064 pub const fn name() -> &'static ::std::ffi::CStr {
18065 unsafe {
18066 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shader_barycentric\0")
18067 }
18068 }
18069 pub const SPEC_VERSION: u32 = 1u32;
18070}
18071#[derive(Clone)]
18072pub struct KhrFragmentShaderBarycentricFn {}
18073unsafe impl Send for KhrFragmentShaderBarycentricFn {}
18074unsafe impl Sync for KhrFragmentShaderBarycentricFn {}
18075impl KhrFragmentShaderBarycentricFn {
18076 pub fn load<F>(mut _f: F) -> Self
18077 where
18078 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18079 {
18080 Self {}
18081 }
18082}
18083#[doc = "Generated from 'VK_KHR_fragment_shader_barycentric'"]
18084impl StructureType {
18085 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: Self = Self(1_000_203_000);
18086 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: Self =
18087 Self(1_000_322_000);
18088}
18089impl KhrShaderSubgroupUniformControlFlowFn {
18090 #[inline]
18091 pub const fn name() -> &'static ::std::ffi::CStr {
18092 unsafe {
18093 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18094 b"VK_KHR_shader_subgroup_uniform_control_flow\0",
18095 )
18096 }
18097 }
18098 pub const SPEC_VERSION: u32 = 1u32;
18099}
18100#[derive(Clone)]
18101pub struct KhrShaderSubgroupUniformControlFlowFn {}
18102unsafe impl Send for KhrShaderSubgroupUniformControlFlowFn {}
18103unsafe impl Sync for KhrShaderSubgroupUniformControlFlowFn {}
18104impl KhrShaderSubgroupUniformControlFlowFn {
18105 pub fn load<F>(mut _f: F) -> Self
18106 where
18107 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18108 {
18109 Self {}
18110 }
18111}
18112#[doc = "Generated from 'VK_KHR_shader_subgroup_uniform_control_flow'"]
18113impl StructureType {
18114 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: Self =
18115 Self(1_000_323_000);
18116}
18117impl KhrExtension325Fn {
18118 #[inline]
18119 pub const fn name() -> &'static ::std::ffi::CStr {
18120 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_325\0") }
18121 }
18122 pub const SPEC_VERSION: u32 = 0u32;
18123}
18124#[derive(Clone)]
18125pub struct KhrExtension325Fn {}
18126unsafe impl Send for KhrExtension325Fn {}
18127unsafe impl Sync for KhrExtension325Fn {}
18128impl KhrExtension325Fn {
18129 pub fn load<F>(mut _f: F) -> Self
18130 where
18131 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18132 {
18133 Self {}
18134 }
18135}
18136impl KhrZeroInitializeWorkgroupMemoryFn {
18137 #[inline]
18138 pub const fn name() -> &'static ::std::ffi::CStr {
18139 unsafe {
18140 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18141 b"VK_KHR_zero_initialize_workgroup_memory\0",
18142 )
18143 }
18144 }
18145 pub const SPEC_VERSION: u32 = 1u32;
18146}
18147#[derive(Clone)]
18148pub struct KhrZeroInitializeWorkgroupMemoryFn {}
18149unsafe impl Send for KhrZeroInitializeWorkgroupMemoryFn {}
18150unsafe impl Sync for KhrZeroInitializeWorkgroupMemoryFn {}
18151impl KhrZeroInitializeWorkgroupMemoryFn {
18152 pub fn load<F>(mut _f: F) -> Self
18153 where
18154 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18155 {
18156 Self {}
18157 }
18158}
18159#[doc = "Generated from 'VK_KHR_zero_initialize_workgroup_memory'"]
18160impl StructureType {
18161 pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: Self =
18162 Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
18163}
18164impl NvFragmentShadingRateEnumsFn {
18165 #[inline]
18166 pub const fn name() -> &'static ::std::ffi::CStr {
18167 unsafe {
18168 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shading_rate_enums\0")
18169 }
18170 }
18171 pub const SPEC_VERSION: u32 = 1u32;
18172}
18173#[allow(non_camel_case_types)]
18174pub type PFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn(
18175 command_buffer: CommandBuffer,
18176 shading_rate: FragmentShadingRateNV,
18177 combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
18178);
18179#[derive(Clone)]
18180pub struct NvFragmentShadingRateEnumsFn {
18181 pub cmd_set_fragment_shading_rate_enum_nv: PFN_vkCmdSetFragmentShadingRateEnumNV,
18182}
18183unsafe impl Send for NvFragmentShadingRateEnumsFn {}
18184unsafe impl Sync for NvFragmentShadingRateEnumsFn {}
18185impl NvFragmentShadingRateEnumsFn {
18186 pub fn load<F>(mut _f: F) -> Self
18187 where
18188 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18189 {
18190 Self {
18191 cmd_set_fragment_shading_rate_enum_nv: unsafe {
18192 unsafe extern "system" fn cmd_set_fragment_shading_rate_enum_nv(
18193 _command_buffer: CommandBuffer,
18194 _shading_rate: FragmentShadingRateNV,
18195 _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2usize],
18196 ) {
18197 panic!(concat!(
18198 "Unable to load ",
18199 stringify!(cmd_set_fragment_shading_rate_enum_nv)
18200 ))
18201 }
18202 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18203 b"vkCmdSetFragmentShadingRateEnumNV\0",
18204 );
18205 let val = _f(cname);
18206 if val.is_null() {
18207 cmd_set_fragment_shading_rate_enum_nv
18208 } else {
18209 ::std::mem::transmute(val)
18210 }
18211 },
18212 }
18213 }
18214}
18215#[doc = "Generated from 'VK_NV_fragment_shading_rate_enums'"]
18216impl StructureType {
18217 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self(1_000_326_000);
18218 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: Self = Self(1_000_326_001);
18219 pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: Self = Self(1_000_326_002);
18220}
18221impl NvRayTracingMotionBlurFn {
18222 #[inline]
18223 pub const fn name() -> &'static ::std::ffi::CStr {
18224 unsafe {
18225 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing_motion_blur\0")
18226 }
18227 }
18228 pub const SPEC_VERSION: u32 = 1u32;
18229}
18230#[derive(Clone)]
18231pub struct NvRayTracingMotionBlurFn {}
18232unsafe impl Send for NvRayTracingMotionBlurFn {}
18233unsafe impl Sync for NvRayTracingMotionBlurFn {}
18234impl NvRayTracingMotionBlurFn {
18235 pub fn load<F>(mut _f: F) -> Self
18236 where
18237 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18238 {
18239 Self {}
18240 }
18241}
18242#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
18243impl AccelerationStructureCreateFlagsKHR {
18244 pub const MOTION_NV: Self = Self(0b100);
18245}
18246#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
18247impl BuildAccelerationStructureFlagsKHR {
18248 pub const MOTION_NV: Self = Self(0b10_0000);
18249}
18250#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
18251impl PipelineCreateFlags {
18252 pub const RAY_TRACING_ALLOW_MOTION_NV: Self = Self(0b1_0000_0000_0000_0000_0000);
18253}
18254#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
18255impl StructureType {
18256 pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self(1_000_327_000);
18257 pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: Self = Self(1_000_327_001);
18258 pub const ACCELERATION_STRUCTURE_MOTION_INFO_NV: Self = Self(1_000_327_002);
18259}
18260impl ExtMeshShaderFn {
18261 #[inline]
18262 pub const fn name() -> &'static ::std::ffi::CStr {
18263 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mesh_shader\0") }
18264 }
18265 pub const SPEC_VERSION: u32 = 1u32;
18266}
18267#[allow(non_camel_case_types)]
18268pub type PFN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn(
18269 command_buffer: CommandBuffer,
18270 group_count_x: u32,
18271 group_count_y: u32,
18272 group_count_z: u32,
18273);
18274#[allow(non_camel_case_types)]
18275pub type PFN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn(
18276 command_buffer: CommandBuffer,
18277 buffer: Buffer,
18278 offset: DeviceSize,
18279 draw_count: u32,
18280 stride: u32,
18281);
18282#[allow(non_camel_case_types)]
18283pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn(
18284 command_buffer: CommandBuffer,
18285 buffer: Buffer,
18286 offset: DeviceSize,
18287 count_buffer: Buffer,
18288 count_buffer_offset: DeviceSize,
18289 max_draw_count: u32,
18290 stride: u32,
18291);
18292#[derive(Clone)]
18293pub struct ExtMeshShaderFn {
18294 pub cmd_draw_mesh_tasks_ext: PFN_vkCmdDrawMeshTasksEXT,
18295 pub cmd_draw_mesh_tasks_indirect_ext: PFN_vkCmdDrawMeshTasksIndirectEXT,
18296 pub cmd_draw_mesh_tasks_indirect_count_ext: PFN_vkCmdDrawMeshTasksIndirectCountEXT,
18297}
18298unsafe impl Send for ExtMeshShaderFn {}
18299unsafe impl Sync for ExtMeshShaderFn {}
18300impl ExtMeshShaderFn {
18301 pub fn load<F>(mut _f: F) -> Self
18302 where
18303 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18304 {
18305 Self {
18306 cmd_draw_mesh_tasks_ext: unsafe {
18307 unsafe extern "system" fn cmd_draw_mesh_tasks_ext(
18308 _command_buffer: CommandBuffer,
18309 _group_count_x: u32,
18310 _group_count_y: u32,
18311 _group_count_z: u32,
18312 ) {
18313 panic!(concat!(
18314 "Unable to load ",
18315 stringify!(cmd_draw_mesh_tasks_ext)
18316 ))
18317 }
18318 let cname =
18319 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksEXT\0");
18320 let val = _f(cname);
18321 if val.is_null() {
18322 cmd_draw_mesh_tasks_ext
18323 } else {
18324 ::std::mem::transmute(val)
18325 }
18326 },
18327 cmd_draw_mesh_tasks_indirect_ext: unsafe {
18328 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_ext(
18329 _command_buffer: CommandBuffer,
18330 _buffer: Buffer,
18331 _offset: DeviceSize,
18332 _draw_count: u32,
18333 _stride: u32,
18334 ) {
18335 panic!(concat!(
18336 "Unable to load ",
18337 stringify!(cmd_draw_mesh_tasks_indirect_ext)
18338 ))
18339 }
18340 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18341 b"vkCmdDrawMeshTasksIndirectEXT\0",
18342 );
18343 let val = _f(cname);
18344 if val.is_null() {
18345 cmd_draw_mesh_tasks_indirect_ext
18346 } else {
18347 ::std::mem::transmute(val)
18348 }
18349 },
18350 cmd_draw_mesh_tasks_indirect_count_ext: unsafe {
18351 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_ext(
18352 _command_buffer: CommandBuffer,
18353 _buffer: Buffer,
18354 _offset: DeviceSize,
18355 _count_buffer: Buffer,
18356 _count_buffer_offset: DeviceSize,
18357 _max_draw_count: u32,
18358 _stride: u32,
18359 ) {
18360 panic!(concat!(
18361 "Unable to load ",
18362 stringify!(cmd_draw_mesh_tasks_indirect_count_ext)
18363 ))
18364 }
18365 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18366 b"vkCmdDrawMeshTasksIndirectCountEXT\0",
18367 );
18368 let val = _f(cname);
18369 if val.is_null() {
18370 cmd_draw_mesh_tasks_indirect_count_ext
18371 } else {
18372 ::std::mem::transmute(val)
18373 }
18374 },
18375 }
18376 }
18377}
18378#[doc = "Generated from 'VK_EXT_mesh_shader'"]
18379impl IndirectCommandsTokenTypeNV {
18380 pub const DRAW_MESH_TASKS: Self = Self(1_000_328_000);
18381}
18382#[doc = "Generated from 'VK_EXT_mesh_shader'"]
18383impl PipelineStageFlags {
18384 pub const TASK_SHADER_EXT: Self = Self(0b1000_0000_0000_0000_0000);
18385 pub const MESH_SHADER_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
18386}
18387#[doc = "Generated from 'VK_EXT_mesh_shader'"]
18388impl QueryPipelineStatisticFlags {
18389 pub const TASK_SHADER_INVOCATIONS_EXT: Self = Self(0b1000_0000_0000);
18390 pub const MESH_SHADER_INVOCATIONS_EXT: Self = Self(0b1_0000_0000_0000);
18391}
18392#[doc = "Generated from 'VK_EXT_mesh_shader'"]
18393impl QueryType {
18394 pub const MESH_PRIMITIVES_GENERATED_EXT: Self = Self(1_000_328_000);
18395}
18396#[doc = "Generated from 'VK_EXT_mesh_shader'"]
18397impl ShaderStageFlags {
18398 pub const TASK_EXT: Self = Self(0b100_0000);
18399 pub const MESH_EXT: Self = Self(0b1000_0000);
18400}
18401#[doc = "Generated from 'VK_EXT_mesh_shader'"]
18402impl StructureType {
18403 pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: Self = Self(1_000_328_000);
18404 pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: Self = Self(1_000_328_001);
18405}
18406impl NvExtension330Fn {
18407 #[inline]
18408 pub const fn name() -> &'static ::std::ffi::CStr {
18409 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_330\0") }
18410 }
18411 pub const SPEC_VERSION: u32 = 0u32;
18412}
18413#[derive(Clone)]
18414pub struct NvExtension330Fn {}
18415unsafe impl Send for NvExtension330Fn {}
18416unsafe impl Sync for NvExtension330Fn {}
18417impl NvExtension330Fn {
18418 pub fn load<F>(mut _f: F) -> Self
18419 where
18420 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18421 {
18422 Self {}
18423 }
18424}
18425impl ExtYcbcr2plane444FormatsFn {
18426 #[inline]
18427 pub const fn name() -> &'static ::std::ffi::CStr {
18428 unsafe {
18429 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_2plane_444_formats\0")
18430 }
18431 }
18432 pub const SPEC_VERSION: u32 = 1u32;
18433}
18434#[derive(Clone)]
18435pub struct ExtYcbcr2plane444FormatsFn {}
18436unsafe impl Send for ExtYcbcr2plane444FormatsFn {}
18437unsafe impl Sync for ExtYcbcr2plane444FormatsFn {}
18438impl ExtYcbcr2plane444FormatsFn {
18439 pub fn load<F>(mut _f: F) -> Self
18440 where
18441 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18442 {
18443 Self {}
18444 }
18445}
18446#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
18447impl Format {
18448 pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self::G8_B8R8_2PLANE_444_UNORM;
18449 pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: Self =
18450 Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16;
18451 pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: Self =
18452 Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16;
18453 pub const G16_B16R16_2PLANE_444_UNORM_EXT: Self = Self::G16_B16R16_2PLANE_444_UNORM;
18454}
18455#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
18456impl StructureType {
18457 pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: Self = Self(1_000_330_000);
18458}
18459impl NvExtension332Fn {
18460 #[inline]
18461 pub const fn name() -> &'static ::std::ffi::CStr {
18462 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_332\0") }
18463 }
18464 pub const SPEC_VERSION: u32 = 0u32;
18465}
18466#[derive(Clone)]
18467pub struct NvExtension332Fn {}
18468unsafe impl Send for NvExtension332Fn {}
18469unsafe impl Sync for NvExtension332Fn {}
18470impl NvExtension332Fn {
18471 pub fn load<F>(mut _f: F) -> Self
18472 where
18473 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18474 {
18475 Self {}
18476 }
18477}
18478impl ExtFragmentDensityMap2Fn {
18479 #[inline]
18480 pub const fn name() -> &'static ::std::ffi::CStr {
18481 unsafe {
18482 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map2\0")
18483 }
18484 }
18485 pub const SPEC_VERSION: u32 = 1u32;
18486}
18487#[derive(Clone)]
18488pub struct ExtFragmentDensityMap2Fn {}
18489unsafe impl Send for ExtFragmentDensityMap2Fn {}
18490unsafe impl Sync for ExtFragmentDensityMap2Fn {}
18491impl ExtFragmentDensityMap2Fn {
18492 pub fn load<F>(mut _f: F) -> Self
18493 where
18494 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18495 {
18496 Self {}
18497 }
18498}
18499#[doc = "Generated from 'VK_EXT_fragment_density_map2'"]
18500impl ImageViewCreateFlags {
18501 pub const FRAGMENT_DENSITY_MAP_DEFERRED_EXT: Self = Self(0b10);
18502}
18503#[doc = "Generated from 'VK_EXT_fragment_density_map2'"]
18504impl StructureType {
18505 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1_000_332_000);
18506 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: Self = Self(1_000_332_001);
18507}
18508impl QcomRotatedCopyCommandsFn {
18509 #[inline]
18510 pub const fn name() -> &'static ::std::ffi::CStr {
18511 unsafe {
18512 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_rotated_copy_commands\0")
18513 }
18514 }
18515 pub const SPEC_VERSION: u32 = 1u32;
18516}
18517#[derive(Clone)]
18518pub struct QcomRotatedCopyCommandsFn {}
18519unsafe impl Send for QcomRotatedCopyCommandsFn {}
18520unsafe impl Sync for QcomRotatedCopyCommandsFn {}
18521impl QcomRotatedCopyCommandsFn {
18522 pub fn load<F>(mut _f: F) -> Self
18523 where
18524 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18525 {
18526 Self {}
18527 }
18528}
18529#[doc = "Generated from 'VK_QCOM_rotated_copy_commands'"]
18530impl StructureType {
18531 pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1_000_333_000);
18532}
18533impl KhrExtension335Fn {
18534 #[inline]
18535 pub const fn name() -> &'static ::std::ffi::CStr {
18536 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_335\0") }
18537 }
18538 pub const SPEC_VERSION: u32 = 0u32;
18539}
18540#[derive(Clone)]
18541pub struct KhrExtension335Fn {}
18542unsafe impl Send for KhrExtension335Fn {}
18543unsafe impl Sync for KhrExtension335Fn {}
18544impl KhrExtension335Fn {
18545 pub fn load<F>(mut _f: F) -> Self
18546 where
18547 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18548 {
18549 Self {}
18550 }
18551}
18552impl ExtImageRobustnessFn {
18553 #[inline]
18554 pub const fn name() -> &'static ::std::ffi::CStr {
18555 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_robustness\0") }
18556 }
18557 pub const SPEC_VERSION: u32 = 1u32;
18558}
18559#[derive(Clone)]
18560pub struct ExtImageRobustnessFn {}
18561unsafe impl Send for ExtImageRobustnessFn {}
18562unsafe impl Sync for ExtImageRobustnessFn {}
18563impl ExtImageRobustnessFn {
18564 pub fn load<F>(mut _f: F) -> Self
18565 where
18566 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18567 {
18568 Self {}
18569 }
18570}
18571#[doc = "Generated from 'VK_EXT_image_robustness'"]
18572impl StructureType {
18573 pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self =
18574 Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
18575}
18576impl KhrWorkgroupMemoryExplicitLayoutFn {
18577 #[inline]
18578 pub const fn name() -> &'static ::std::ffi::CStr {
18579 unsafe {
18580 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18581 b"VK_KHR_workgroup_memory_explicit_layout\0",
18582 )
18583 }
18584 }
18585 pub const SPEC_VERSION: u32 = 1u32;
18586}
18587#[derive(Clone)]
18588pub struct KhrWorkgroupMemoryExplicitLayoutFn {}
18589unsafe impl Send for KhrWorkgroupMemoryExplicitLayoutFn {}
18590unsafe impl Sync for KhrWorkgroupMemoryExplicitLayoutFn {}
18591impl KhrWorkgroupMemoryExplicitLayoutFn {
18592 pub fn load<F>(mut _f: F) -> Self
18593 where
18594 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18595 {
18596 Self {}
18597 }
18598}
18599#[doc = "Generated from 'VK_KHR_workgroup_memory_explicit_layout'"]
18600impl StructureType {
18601 pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: Self =
18602 Self(1_000_336_000);
18603}
18604impl KhrCopyCommands2Fn {
18605 #[inline]
18606 pub const fn name() -> &'static ::std::ffi::CStr {
18607 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_copy_commands2\0") }
18608 }
18609 pub const SPEC_VERSION: u32 = 1u32;
18610}
18611#[allow(non_camel_case_types)]
18612pub type PFN_vkCmdCopyBuffer2 = unsafe extern "system" fn(
18613 command_buffer: CommandBuffer,
18614 p_copy_buffer_info: *const CopyBufferInfo2,
18615);
18616#[allow(non_camel_case_types)]
18617pub type PFN_vkCmdCopyImage2 = unsafe extern "system" fn(
18618 command_buffer: CommandBuffer,
18619 p_copy_image_info: *const CopyImageInfo2,
18620);
18621#[allow(non_camel_case_types)]
18622pub type PFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn(
18623 command_buffer: CommandBuffer,
18624 p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
18625);
18626#[allow(non_camel_case_types)]
18627pub type PFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn(
18628 command_buffer: CommandBuffer,
18629 p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
18630);
18631#[allow(non_camel_case_types)]
18632pub type PFN_vkCmdBlitImage2 = unsafe extern "system" fn(
18633 command_buffer: CommandBuffer,
18634 p_blit_image_info: *const BlitImageInfo2,
18635);
18636#[allow(non_camel_case_types)]
18637pub type PFN_vkCmdResolveImage2 = unsafe extern "system" fn(
18638 command_buffer: CommandBuffer,
18639 p_resolve_image_info: *const ResolveImageInfo2,
18640);
18641#[derive(Clone)]
18642pub struct KhrCopyCommands2Fn {
18643 pub cmd_copy_buffer2_khr: PFN_vkCmdCopyBuffer2,
18644 pub cmd_copy_image2_khr: PFN_vkCmdCopyImage2,
18645 pub cmd_copy_buffer_to_image2_khr: PFN_vkCmdCopyBufferToImage2,
18646 pub cmd_copy_image_to_buffer2_khr: PFN_vkCmdCopyImageToBuffer2,
18647 pub cmd_blit_image2_khr: PFN_vkCmdBlitImage2,
18648 pub cmd_resolve_image2_khr: PFN_vkCmdResolveImage2,
18649}
18650unsafe impl Send for KhrCopyCommands2Fn {}
18651unsafe impl Sync for KhrCopyCommands2Fn {}
18652impl KhrCopyCommands2Fn {
18653 pub fn load<F>(mut _f: F) -> Self
18654 where
18655 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18656 {
18657 Self {
18658 cmd_copy_buffer2_khr: unsafe {
18659 unsafe extern "system" fn cmd_copy_buffer2_khr(
18660 _command_buffer: CommandBuffer,
18661 _p_copy_buffer_info: *const CopyBufferInfo2,
18662 ) {
18663 panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2_khr)))
18664 }
18665 let cname =
18666 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2KHR\0");
18667 let val = _f(cname);
18668 if val.is_null() {
18669 cmd_copy_buffer2_khr
18670 } else {
18671 ::std::mem::transmute(val)
18672 }
18673 },
18674 cmd_copy_image2_khr: unsafe {
18675 unsafe extern "system" fn cmd_copy_image2_khr(
18676 _command_buffer: CommandBuffer,
18677 _p_copy_image_info: *const CopyImageInfo2,
18678 ) {
18679 panic!(concat!("Unable to load ", stringify!(cmd_copy_image2_khr)))
18680 }
18681 let cname =
18682 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2KHR\0");
18683 let val = _f(cname);
18684 if val.is_null() {
18685 cmd_copy_image2_khr
18686 } else {
18687 ::std::mem::transmute(val)
18688 }
18689 },
18690 cmd_copy_buffer_to_image2_khr: unsafe {
18691 unsafe extern "system" fn cmd_copy_buffer_to_image2_khr(
18692 _command_buffer: CommandBuffer,
18693 _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
18694 ) {
18695 panic!(concat!(
18696 "Unable to load ",
18697 stringify!(cmd_copy_buffer_to_image2_khr)
18698 ))
18699 }
18700 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18701 b"vkCmdCopyBufferToImage2KHR\0",
18702 );
18703 let val = _f(cname);
18704 if val.is_null() {
18705 cmd_copy_buffer_to_image2_khr
18706 } else {
18707 ::std::mem::transmute(val)
18708 }
18709 },
18710 cmd_copy_image_to_buffer2_khr: unsafe {
18711 unsafe extern "system" fn cmd_copy_image_to_buffer2_khr(
18712 _command_buffer: CommandBuffer,
18713 _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
18714 ) {
18715 panic!(concat!(
18716 "Unable to load ",
18717 stringify!(cmd_copy_image_to_buffer2_khr)
18718 ))
18719 }
18720 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18721 b"vkCmdCopyImageToBuffer2KHR\0",
18722 );
18723 let val = _f(cname);
18724 if val.is_null() {
18725 cmd_copy_image_to_buffer2_khr
18726 } else {
18727 ::std::mem::transmute(val)
18728 }
18729 },
18730 cmd_blit_image2_khr: unsafe {
18731 unsafe extern "system" fn cmd_blit_image2_khr(
18732 _command_buffer: CommandBuffer,
18733 _p_blit_image_info: *const BlitImageInfo2,
18734 ) {
18735 panic!(concat!("Unable to load ", stringify!(cmd_blit_image2_khr)))
18736 }
18737 let cname =
18738 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2KHR\0");
18739 let val = _f(cname);
18740 if val.is_null() {
18741 cmd_blit_image2_khr
18742 } else {
18743 ::std::mem::transmute(val)
18744 }
18745 },
18746 cmd_resolve_image2_khr: unsafe {
18747 unsafe extern "system" fn cmd_resolve_image2_khr(
18748 _command_buffer: CommandBuffer,
18749 _p_resolve_image_info: *const ResolveImageInfo2,
18750 ) {
18751 panic!(concat!(
18752 "Unable to load ",
18753 stringify!(cmd_resolve_image2_khr)
18754 ))
18755 }
18756 let cname =
18757 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2KHR\0");
18758 let val = _f(cname);
18759 if val.is_null() {
18760 cmd_resolve_image2_khr
18761 } else {
18762 ::std::mem::transmute(val)
18763 }
18764 },
18765 }
18766 }
18767}
18768#[doc = "Generated from 'VK_KHR_copy_commands2'"]
18769impl StructureType {
18770 pub const COPY_BUFFER_INFO_2_KHR: Self = Self::COPY_BUFFER_INFO_2;
18771 pub const COPY_IMAGE_INFO_2_KHR: Self = Self::COPY_IMAGE_INFO_2;
18772 pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self::COPY_BUFFER_TO_IMAGE_INFO_2;
18773 pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self::COPY_IMAGE_TO_BUFFER_INFO_2;
18774 pub const BLIT_IMAGE_INFO_2_KHR: Self = Self::BLIT_IMAGE_INFO_2;
18775 pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self::RESOLVE_IMAGE_INFO_2;
18776 pub const BUFFER_COPY_2_KHR: Self = Self::BUFFER_COPY_2;
18777 pub const IMAGE_COPY_2_KHR: Self = Self::IMAGE_COPY_2;
18778 pub const IMAGE_BLIT_2_KHR: Self = Self::IMAGE_BLIT_2;
18779 pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self::BUFFER_IMAGE_COPY_2;
18780 pub const IMAGE_RESOLVE_2_KHR: Self = Self::IMAGE_RESOLVE_2;
18781}
18782impl ExtImageCompressionControlFn {
18783 #[inline]
18784 pub const fn name() -> &'static ::std::ffi::CStr {
18785 unsafe {
18786 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_compression_control\0")
18787 }
18788 }
18789 pub const SPEC_VERSION: u32 = 1u32;
18790}
18791#[allow(non_camel_case_types)]
18792pub type PFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn(
18793 device: Device,
18794 image: Image,
18795 p_subresource: *const ImageSubresource2EXT,
18796 p_layout: *mut SubresourceLayout2EXT,
18797);
18798#[derive(Clone)]
18799pub struct ExtImageCompressionControlFn {
18800 pub get_image_subresource_layout2_ext: PFN_vkGetImageSubresourceLayout2EXT,
18801}
18802unsafe impl Send for ExtImageCompressionControlFn {}
18803unsafe impl Sync for ExtImageCompressionControlFn {}
18804impl ExtImageCompressionControlFn {
18805 pub fn load<F>(mut _f: F) -> Self
18806 where
18807 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18808 {
18809 Self {
18810 get_image_subresource_layout2_ext: unsafe {
18811 unsafe extern "system" fn get_image_subresource_layout2_ext(
18812 _device: Device,
18813 _image: Image,
18814 _p_subresource: *const ImageSubresource2EXT,
18815 _p_layout: *mut SubresourceLayout2EXT,
18816 ) {
18817 panic!(concat!(
18818 "Unable to load ",
18819 stringify!(get_image_subresource_layout2_ext)
18820 ))
18821 }
18822 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18823 b"vkGetImageSubresourceLayout2EXT\0",
18824 );
18825 let val = _f(cname);
18826 if val.is_null() {
18827 get_image_subresource_layout2_ext
18828 } else {
18829 ::std::mem::transmute(val)
18830 }
18831 },
18832 }
18833 }
18834}
18835#[doc = "Generated from 'VK_EXT_image_compression_control'"]
18836impl Result {
18837 pub const ERROR_COMPRESSION_EXHAUSTED_EXT: Self = Self(-1_000_338_000);
18838}
18839#[doc = "Generated from 'VK_EXT_image_compression_control'"]
18840impl StructureType {
18841 pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: Self = Self(1_000_338_000);
18842 pub const IMAGE_COMPRESSION_CONTROL_EXT: Self = Self(1_000_338_001);
18843 pub const SUBRESOURCE_LAYOUT_2_EXT: Self = Self(1_000_338_002);
18844 pub const IMAGE_SUBRESOURCE_2_EXT: Self = Self(1_000_338_003);
18845 pub const IMAGE_COMPRESSION_PROPERTIES_EXT: Self = Self(1_000_338_004);
18846}
18847impl ExtAttachmentFeedbackLoopLayoutFn {
18848 #[inline]
18849 pub const fn name() -> &'static ::std::ffi::CStr {
18850 unsafe {
18851 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18852 b"VK_EXT_attachment_feedback_loop_layout\0",
18853 )
18854 }
18855 }
18856 pub const SPEC_VERSION: u32 = 2u32;
18857}
18858#[derive(Clone)]
18859pub struct ExtAttachmentFeedbackLoopLayoutFn {}
18860unsafe impl Send for ExtAttachmentFeedbackLoopLayoutFn {}
18861unsafe impl Sync for ExtAttachmentFeedbackLoopLayoutFn {}
18862impl ExtAttachmentFeedbackLoopLayoutFn {
18863 pub fn load<F>(mut _f: F) -> Self
18864 where
18865 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18866 {
18867 Self {}
18868 }
18869}
18870#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
18871impl DependencyFlags {
18872 #[doc = "Dependency may be a feedback loop"]
18873 pub const FEEDBACK_LOOP_EXT: Self = Self(0b1000);
18874}
18875#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
18876impl ImageLayout {
18877 pub const ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: Self = Self(1_000_339_000);
18878}
18879#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
18880impl ImageUsageFlags {
18881 pub const ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b1000_0000_0000_0000_0000);
18882}
18883#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
18884impl PipelineCreateFlags {
18885 pub const COLOR_ATTACHMENT_FEEDBACK_LOOP_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
18886 pub const DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_EXT: Self =
18887 Self(0b100_0000_0000_0000_0000_0000_0000);
18888}
18889#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_layout'"]
18890impl StructureType {
18891 pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: Self =
18892 Self(1_000_339_000);
18893}
18894impl Ext4444FormatsFn {
18895 #[inline]
18896 pub const fn name() -> &'static ::std::ffi::CStr {
18897 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_4444_formats\0") }
18898 }
18899 pub const SPEC_VERSION: u32 = 1u32;
18900}
18901#[derive(Clone)]
18902pub struct Ext4444FormatsFn {}
18903unsafe impl Send for Ext4444FormatsFn {}
18904unsafe impl Sync for Ext4444FormatsFn {}
18905impl Ext4444FormatsFn {
18906 pub fn load<F>(mut _f: F) -> Self
18907 where
18908 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18909 {
18910 Self {}
18911 }
18912}
18913#[doc = "Generated from 'VK_EXT_4444_formats'"]
18914impl Format {
18915 pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self::A4R4G4B4_UNORM_PACK16;
18916 pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self::A4B4G4R4_UNORM_PACK16;
18917}
18918#[doc = "Generated from 'VK_EXT_4444_formats'"]
18919impl StructureType {
18920 pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000);
18921}
18922impl ExtDeviceFaultFn {
18923 #[inline]
18924 pub const fn name() -> &'static ::std::ffi::CStr {
18925 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_fault\0") }
18926 }
18927 pub const SPEC_VERSION: u32 = 2u32;
18928}
18929#[allow(non_camel_case_types)]
18930pub type PFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn(
18931 device: Device,
18932 p_fault_counts: *mut DeviceFaultCountsEXT,
18933 p_fault_info: *mut DeviceFaultInfoEXT,
18934) -> Result;
18935#[derive(Clone)]
18936pub struct ExtDeviceFaultFn {
18937 pub get_device_fault_info_ext: PFN_vkGetDeviceFaultInfoEXT,
18938}
18939unsafe impl Send for ExtDeviceFaultFn {}
18940unsafe impl Sync for ExtDeviceFaultFn {}
18941impl ExtDeviceFaultFn {
18942 pub fn load<F>(mut _f: F) -> Self
18943 where
18944 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18945 {
18946 Self {
18947 get_device_fault_info_ext: unsafe {
18948 unsafe extern "system" fn get_device_fault_info_ext(
18949 _device: Device,
18950 _p_fault_counts: *mut DeviceFaultCountsEXT,
18951 _p_fault_info: *mut DeviceFaultInfoEXT,
18952 ) -> Result {
18953 panic!(concat!(
18954 "Unable to load ",
18955 stringify!(get_device_fault_info_ext)
18956 ))
18957 }
18958 let cname =
18959 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDeviceFaultInfoEXT\0");
18960 let val = _f(cname);
18961 if val.is_null() {
18962 get_device_fault_info_ext
18963 } else {
18964 ::std::mem::transmute(val)
18965 }
18966 },
18967 }
18968 }
18969}
18970#[doc = "Generated from 'VK_EXT_device_fault'"]
18971impl StructureType {
18972 pub const PHYSICAL_DEVICE_FAULT_FEATURES_EXT: Self = Self(1_000_341_000);
18973 pub const DEVICE_FAULT_COUNTS_EXT: Self = Self(1_000_341_001);
18974 pub const DEVICE_FAULT_INFO_EXT: Self = Self(1_000_341_002);
18975}
18976impl ArmRasterizationOrderAttachmentAccessFn {
18977 #[inline]
18978 pub const fn name() -> &'static ::std::ffi::CStr {
18979 unsafe {
18980 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18981 b"VK_ARM_rasterization_order_attachment_access\0",
18982 )
18983 }
18984 }
18985 pub const SPEC_VERSION: u32 = 1u32;
18986}
18987#[derive(Clone)]
18988pub struct ArmRasterizationOrderAttachmentAccessFn {}
18989unsafe impl Send for ArmRasterizationOrderAttachmentAccessFn {}
18990unsafe impl Sync for ArmRasterizationOrderAttachmentAccessFn {}
18991impl ArmRasterizationOrderAttachmentAccessFn {
18992 pub fn load<F>(mut _f: F) -> Self
18993 where
18994 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18995 {
18996 Self {}
18997 }
18998}
18999#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
19000impl PipelineColorBlendStateCreateFlags {
19001 pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM: Self =
19002 Self::RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT;
19003}
19004#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
19005impl PipelineDepthStencilStateCreateFlags {
19006 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self =
19007 Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT;
19008 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self =
19009 Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT;
19010}
19011#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
19012impl StructureType {
19013 pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: Self =
19014 Self::PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
19015}
19016#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
19017impl SubpassDescriptionFlags {
19018 pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM: Self =
19019 Self::RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT;
19020 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self =
19021 Self::RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT;
19022 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self =
19023 Self::RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT;
19024}
19025impl ArmExtension344Fn {
19026 #[inline]
19027 pub const fn name() -> &'static ::std::ffi::CStr {
19028 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_344\0") }
19029 }
19030 pub const SPEC_VERSION: u32 = 0u32;
19031}
19032#[derive(Clone)]
19033pub struct ArmExtension344Fn {}
19034unsafe impl Send for ArmExtension344Fn {}
19035unsafe impl Sync for ArmExtension344Fn {}
19036impl ArmExtension344Fn {
19037 pub fn load<F>(mut _f: F) -> Self
19038 where
19039 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19040 {
19041 Self {}
19042 }
19043}
19044impl ExtRgba10x6FormatsFn {
19045 #[inline]
19046 pub const fn name() -> &'static ::std::ffi::CStr {
19047 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_rgba10x6_formats\0") }
19048 }
19049 pub const SPEC_VERSION: u32 = 1u32;
19050}
19051#[derive(Clone)]
19052pub struct ExtRgba10x6FormatsFn {}
19053unsafe impl Send for ExtRgba10x6FormatsFn {}
19054unsafe impl Sync for ExtRgba10x6FormatsFn {}
19055impl ExtRgba10x6FormatsFn {
19056 pub fn load<F>(mut _f: F) -> Self
19057 where
19058 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19059 {
19060 Self {}
19061 }
19062}
19063#[doc = "Generated from 'VK_EXT_rgba10x6_formats'"]
19064impl StructureType {
19065 pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1_000_344_000);
19066}
19067impl NvAcquireWinrtDisplayFn {
19068 #[inline]
19069 pub const fn name() -> &'static ::std::ffi::CStr {
19070 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_acquire_winrt_display\0") }
19071 }
19072 pub const SPEC_VERSION: u32 = 1u32;
19073}
19074#[allow(non_camel_case_types)]
19075pub type PFN_vkAcquireWinrtDisplayNV =
19076 unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result;
19077#[allow(non_camel_case_types)]
19078pub type PFN_vkGetWinrtDisplayNV = unsafe extern "system" fn(
19079 physical_device: PhysicalDevice,
19080 device_relative_id: u32,
19081 p_display: *mut DisplayKHR,
19082) -> Result;
19083#[derive(Clone)]
19084pub struct NvAcquireWinrtDisplayFn {
19085 pub acquire_winrt_display_nv: PFN_vkAcquireWinrtDisplayNV,
19086 pub get_winrt_display_nv: PFN_vkGetWinrtDisplayNV,
19087}
19088unsafe impl Send for NvAcquireWinrtDisplayFn {}
19089unsafe impl Sync for NvAcquireWinrtDisplayFn {}
19090impl NvAcquireWinrtDisplayFn {
19091 pub fn load<F>(mut _f: F) -> Self
19092 where
19093 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19094 {
19095 Self {
19096 acquire_winrt_display_nv: unsafe {
19097 unsafe extern "system" fn acquire_winrt_display_nv(
19098 _physical_device: PhysicalDevice,
19099 _display: DisplayKHR,
19100 ) -> Result {
19101 panic!(concat!(
19102 "Unable to load ",
19103 stringify!(acquire_winrt_display_nv)
19104 ))
19105 }
19106 let cname =
19107 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireWinrtDisplayNV\0");
19108 let val = _f(cname);
19109 if val.is_null() {
19110 acquire_winrt_display_nv
19111 } else {
19112 ::std::mem::transmute(val)
19113 }
19114 },
19115 get_winrt_display_nv: unsafe {
19116 unsafe extern "system" fn get_winrt_display_nv(
19117 _physical_device: PhysicalDevice,
19118 _device_relative_id: u32,
19119 _p_display: *mut DisplayKHR,
19120 ) -> Result {
19121 panic!(concat!("Unable to load ", stringify!(get_winrt_display_nv)))
19122 }
19123 let cname =
19124 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetWinrtDisplayNV\0");
19125 let val = _f(cname);
19126 if val.is_null() {
19127 get_winrt_display_nv
19128 } else {
19129 ::std::mem::transmute(val)
19130 }
19131 },
19132 }
19133 }
19134}
19135impl ExtDirectfbSurfaceFn {
19136 #[inline]
19137 pub const fn name() -> &'static ::std::ffi::CStr {
19138 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_directfb_surface\0") }
19139 }
19140 pub const SPEC_VERSION: u32 = 1u32;
19141}
19142#[allow(non_camel_case_types)]
19143pub type PFN_vkCreateDirectFBSurfaceEXT = unsafe extern "system" fn(
19144 instance: Instance,
19145 p_create_info: *const DirectFBSurfaceCreateInfoEXT,
19146 p_allocator: *const AllocationCallbacks,
19147 p_surface: *mut SurfaceKHR,
19148) -> Result;
19149#[allow(non_camel_case_types)]
19150pub type PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
19151 unsafe extern "system" fn(
19152 physical_device: PhysicalDevice,
19153 queue_family_index: u32,
19154 dfb: *mut IDirectFB,
19155 ) -> Bool32;
19156#[derive(Clone)]
19157pub struct ExtDirectfbSurfaceFn {
19158 pub create_direct_fb_surface_ext: PFN_vkCreateDirectFBSurfaceEXT,
19159 pub get_physical_device_direct_fb_presentation_support_ext:
19160 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT,
19161}
19162unsafe impl Send for ExtDirectfbSurfaceFn {}
19163unsafe impl Sync for ExtDirectfbSurfaceFn {}
19164impl ExtDirectfbSurfaceFn {
19165 pub fn load<F>(mut _f: F) -> Self
19166 where
19167 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19168 {
19169 Self {
19170 create_direct_fb_surface_ext: unsafe {
19171 unsafe extern "system" fn create_direct_fb_surface_ext(
19172 _instance: Instance,
19173 _p_create_info: *const DirectFBSurfaceCreateInfoEXT,
19174 _p_allocator: *const AllocationCallbacks,
19175 _p_surface: *mut SurfaceKHR,
19176 ) -> Result {
19177 panic!(concat!(
19178 "Unable to load ",
19179 stringify!(create_direct_fb_surface_ext)
19180 ))
19181 }
19182 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19183 b"vkCreateDirectFBSurfaceEXT\0",
19184 );
19185 let val = _f(cname);
19186 if val.is_null() {
19187 create_direct_fb_surface_ext
19188 } else {
19189 ::std::mem::transmute(val)
19190 }
19191 },
19192 get_physical_device_direct_fb_presentation_support_ext: unsafe {
19193 unsafe extern "system" fn get_physical_device_direct_fb_presentation_support_ext(
19194 _physical_device: PhysicalDevice,
19195 _queue_family_index: u32,
19196 _dfb: *mut IDirectFB,
19197 ) -> Bool32 {
19198 panic!(concat!(
19199 "Unable to load ",
19200 stringify!(get_physical_device_direct_fb_presentation_support_ext)
19201 ))
19202 }
19203 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19204 b"vkGetPhysicalDeviceDirectFBPresentationSupportEXT\0",
19205 );
19206 let val = _f(cname);
19207 if val.is_null() {
19208 get_physical_device_direct_fb_presentation_support_ext
19209 } else {
19210 ::std::mem::transmute(val)
19211 }
19212 },
19213 }
19214 }
19215}
19216#[doc = "Generated from 'VK_EXT_directfb_surface'"]
19217impl StructureType {
19218 pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_346_000);
19219}
19220impl KhrExtension350Fn {
19221 #[inline]
19222 pub const fn name() -> &'static ::std::ffi::CStr {
19223 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_350\0") }
19224 }
19225 pub const SPEC_VERSION: u32 = 0u32;
19226}
19227#[derive(Clone)]
19228pub struct KhrExtension350Fn {}
19229unsafe impl Send for KhrExtension350Fn {}
19230unsafe impl Sync for KhrExtension350Fn {}
19231impl KhrExtension350Fn {
19232 pub fn load<F>(mut _f: F) -> Self
19233 where
19234 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19235 {
19236 Self {}
19237 }
19238}
19239impl NvExtension351Fn {
19240 #[inline]
19241 pub const fn name() -> &'static ::std::ffi::CStr {
19242 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_351\0") }
19243 }
19244 pub const SPEC_VERSION: u32 = 0u32;
19245}
19246#[derive(Clone)]
19247pub struct NvExtension351Fn {}
19248unsafe impl Send for NvExtension351Fn {}
19249unsafe impl Sync for NvExtension351Fn {}
19250impl NvExtension351Fn {
19251 pub fn load<F>(mut _f: F) -> Self
19252 where
19253 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19254 {
19255 Self {}
19256 }
19257}
19258impl ValveMutableDescriptorTypeFn {
19259 #[inline]
19260 pub const fn name() -> &'static ::std::ffi::CStr {
19261 unsafe {
19262 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_VALVE_mutable_descriptor_type\0")
19263 }
19264 }
19265 pub const SPEC_VERSION: u32 = 1u32;
19266}
19267#[derive(Clone)]
19268pub struct ValveMutableDescriptorTypeFn {}
19269unsafe impl Send for ValveMutableDescriptorTypeFn {}
19270unsafe impl Sync for ValveMutableDescriptorTypeFn {}
19271impl ValveMutableDescriptorTypeFn {
19272 pub fn load<F>(mut _f: F) -> Self
19273 where
19274 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19275 {
19276 Self {}
19277 }
19278}
19279#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
19280impl DescriptorPoolCreateFlags {
19281 pub const HOST_ONLY_VALVE: Self = Self::HOST_ONLY_EXT;
19282}
19283#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
19284impl DescriptorSetLayoutCreateFlags {
19285 pub const HOST_ONLY_POOL_VALVE: Self = Self::HOST_ONLY_POOL_EXT;
19286}
19287#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
19288impl DescriptorType {
19289 pub const MUTABLE_VALVE: Self = Self::MUTABLE_EXT;
19290}
19291#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
19292impl StructureType {
19293 pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self =
19294 Self::PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
19295 pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self =
19296 Self::MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
19297}
19298impl ExtVertexInputDynamicStateFn {
19299 #[inline]
19300 pub const fn name() -> &'static ::std::ffi::CStr {
19301 unsafe {
19302 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_input_dynamic_state\0")
19303 }
19304 }
19305 pub const SPEC_VERSION: u32 = 2u32;
19306}
19307#[allow(non_camel_case_types)]
19308pub type PFN_vkCmdSetVertexInputEXT = unsafe extern "system" fn(
19309 command_buffer: CommandBuffer,
19310 vertex_binding_description_count: u32,
19311 p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT,
19312 vertex_attribute_description_count: u32,
19313 p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT,
19314);
19315#[derive(Clone)]
19316pub struct ExtVertexInputDynamicStateFn {
19317 pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT,
19318}
19319unsafe impl Send for ExtVertexInputDynamicStateFn {}
19320unsafe impl Sync for ExtVertexInputDynamicStateFn {}
19321impl ExtVertexInputDynamicStateFn {
19322 pub fn load<F>(mut _f: F) -> Self
19323 where
19324 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19325 {
19326 Self {
19327 cmd_set_vertex_input_ext: unsafe {
19328 unsafe extern "system" fn cmd_set_vertex_input_ext(
19329 _command_buffer: CommandBuffer,
19330 _vertex_binding_description_count: u32,
19331 _p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT,
19332 _vertex_attribute_description_count: u32,
19333 _p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT,
19334 ) {
19335 panic!(concat!(
19336 "Unable to load ",
19337 stringify!(cmd_set_vertex_input_ext)
19338 ))
19339 }
19340 let cname =
19341 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
19342 let val = _f(cname);
19343 if val.is_null() {
19344 cmd_set_vertex_input_ext
19345 } else {
19346 ::std::mem::transmute(val)
19347 }
19348 },
19349 }
19350 }
19351}
19352#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
19353impl DynamicState {
19354 pub const VERTEX_INPUT_EXT: Self = Self(1_000_352_000);
19355}
19356#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
19357impl StructureType {
19358 pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_352_000);
19359 pub const VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: Self = Self(1_000_352_001);
19360 pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: Self = Self(1_000_352_002);
19361}
19362impl ExtPhysicalDeviceDrmFn {
19363 #[inline]
19364 pub const fn name() -> &'static ::std::ffi::CStr {
19365 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_physical_device_drm\0") }
19366 }
19367 pub const SPEC_VERSION: u32 = 1u32;
19368}
19369#[derive(Clone)]
19370pub struct ExtPhysicalDeviceDrmFn {}
19371unsafe impl Send for ExtPhysicalDeviceDrmFn {}
19372unsafe impl Sync for ExtPhysicalDeviceDrmFn {}
19373impl ExtPhysicalDeviceDrmFn {
19374 pub fn load<F>(mut _f: F) -> Self
19375 where
19376 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19377 {
19378 Self {}
19379 }
19380}
19381#[doc = "Generated from 'VK_EXT_physical_device_drm'"]
19382impl StructureType {
19383 pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1_000_353_000);
19384}
19385impl ExtDeviceAddressBindingReportFn {
19386 #[inline]
19387 pub const fn name() -> &'static ::std::ffi::CStr {
19388 unsafe {
19389 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19390 b"VK_EXT_device_address_binding_report\0",
19391 )
19392 }
19393 }
19394 pub const SPEC_VERSION: u32 = 1u32;
19395}
19396#[derive(Clone)]
19397pub struct ExtDeviceAddressBindingReportFn {}
19398unsafe impl Send for ExtDeviceAddressBindingReportFn {}
19399unsafe impl Sync for ExtDeviceAddressBindingReportFn {}
19400impl ExtDeviceAddressBindingReportFn {
19401 pub fn load<F>(mut _f: F) -> Self
19402 where
19403 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19404 {
19405 Self {}
19406 }
19407}
19408#[doc = "Generated from 'VK_EXT_device_address_binding_report'"]
19409impl DebugUtilsMessageTypeFlagsEXT {
19410 pub const DEVICE_ADDRESS_BINDING: Self = Self(0b1000);
19411}
19412#[doc = "Generated from 'VK_EXT_device_address_binding_report'"]
19413impl StructureType {
19414 pub const PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: Self = Self(1_000_354_000);
19415 pub const DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: Self = Self(1_000_354_001);
19416}
19417impl ExtDepthClipControlFn {
19418 #[inline]
19419 pub const fn name() -> &'static ::std::ffi::CStr {
19420 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_control\0") }
19421 }
19422 pub const SPEC_VERSION: u32 = 1u32;
19423}
19424#[derive(Clone)]
19425pub struct ExtDepthClipControlFn {}
19426unsafe impl Send for ExtDepthClipControlFn {}
19427unsafe impl Sync for ExtDepthClipControlFn {}
19428impl ExtDepthClipControlFn {
19429 pub fn load<F>(mut _f: F) -> Self
19430 where
19431 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19432 {
19433 Self {}
19434 }
19435}
19436#[doc = "Generated from 'VK_EXT_depth_clip_control'"]
19437impl StructureType {
19438 pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1_000_355_000);
19439 pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: Self = Self(1_000_355_001);
19440}
19441impl ExtPrimitiveTopologyListRestartFn {
19442 #[inline]
19443 pub const fn name() -> &'static ::std::ffi::CStr {
19444 unsafe {
19445 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19446 b"VK_EXT_primitive_topology_list_restart\0",
19447 )
19448 }
19449 }
19450 pub const SPEC_VERSION: u32 = 1u32;
19451}
19452#[derive(Clone)]
19453pub struct ExtPrimitiveTopologyListRestartFn {}
19454unsafe impl Send for ExtPrimitiveTopologyListRestartFn {}
19455unsafe impl Sync for ExtPrimitiveTopologyListRestartFn {}
19456impl ExtPrimitiveTopologyListRestartFn {
19457 pub fn load<F>(mut _f: F) -> Self
19458 where
19459 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19460 {
19461 Self {}
19462 }
19463}
19464#[doc = "Generated from 'VK_EXT_primitive_topology_list_restart'"]
19465impl StructureType {
19466 pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: Self =
19467 Self(1_000_356_000);
19468}
19469impl KhrExtension358Fn {
19470 #[inline]
19471 pub const fn name() -> &'static ::std::ffi::CStr {
19472 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_358\0") }
19473 }
19474 pub const SPEC_VERSION: u32 = 0u32;
19475}
19476#[derive(Clone)]
19477pub struct KhrExtension358Fn {}
19478unsafe impl Send for KhrExtension358Fn {}
19479unsafe impl Sync for KhrExtension358Fn {}
19480impl KhrExtension358Fn {
19481 pub fn load<F>(mut _f: F) -> Self
19482 where
19483 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19484 {
19485 Self {}
19486 }
19487}
19488impl ExtExtension359Fn {
19489 #[inline]
19490 pub const fn name() -> &'static ::std::ffi::CStr {
19491 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_359\0") }
19492 }
19493 pub const SPEC_VERSION: u32 = 0u32;
19494}
19495#[derive(Clone)]
19496pub struct ExtExtension359Fn {}
19497unsafe impl Send for ExtExtension359Fn {}
19498unsafe impl Sync for ExtExtension359Fn {}
19499impl ExtExtension359Fn {
19500 pub fn load<F>(mut _f: F) -> Self
19501 where
19502 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19503 {
19504 Self {}
19505 }
19506}
19507impl ExtExtension360Fn {
19508 #[inline]
19509 pub const fn name() -> &'static ::std::ffi::CStr {
19510 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_360\0") }
19511 }
19512 pub const SPEC_VERSION: u32 = 0u32;
19513}
19514#[derive(Clone)]
19515pub struct ExtExtension360Fn {}
19516unsafe impl Send for ExtExtension360Fn {}
19517unsafe impl Sync for ExtExtension360Fn {}
19518impl ExtExtension360Fn {
19519 pub fn load<F>(mut _f: F) -> Self
19520 where
19521 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19522 {
19523 Self {}
19524 }
19525}
19526impl KhrFormatFeatureFlags2Fn {
19527 #[inline]
19528 pub const fn name() -> &'static ::std::ffi::CStr {
19529 unsafe {
19530 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_format_feature_flags2\0")
19531 }
19532 }
19533 pub const SPEC_VERSION: u32 = 2u32;
19534}
19535#[derive(Clone)]
19536pub struct KhrFormatFeatureFlags2Fn {}
19537unsafe impl Send for KhrFormatFeatureFlags2Fn {}
19538unsafe impl Sync for KhrFormatFeatureFlags2Fn {}
19539impl KhrFormatFeatureFlags2Fn {
19540 pub fn load<F>(mut _f: F) -> Self
19541 where
19542 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19543 {
19544 Self {}
19545 }
19546}
19547#[doc = "Generated from 'VK_KHR_format_feature_flags2'"]
19548impl StructureType {
19549 pub const FORMAT_PROPERTIES_3_KHR: Self = Self::FORMAT_PROPERTIES_3;
19550}
19551impl ExtExtension362Fn {
19552 #[inline]
19553 pub const fn name() -> &'static ::std::ffi::CStr {
19554 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_362\0") }
19555 }
19556 pub const SPEC_VERSION: u32 = 0u32;
19557}
19558#[derive(Clone)]
19559pub struct ExtExtension362Fn {}
19560unsafe impl Send for ExtExtension362Fn {}
19561unsafe impl Sync for ExtExtension362Fn {}
19562impl ExtExtension362Fn {
19563 pub fn load<F>(mut _f: F) -> Self
19564 where
19565 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19566 {
19567 Self {}
19568 }
19569}
19570impl ExtExtension363Fn {
19571 #[inline]
19572 pub const fn name() -> &'static ::std::ffi::CStr {
19573 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_363\0") }
19574 }
19575 pub const SPEC_VERSION: u32 = 0u32;
19576}
19577#[derive(Clone)]
19578pub struct ExtExtension363Fn {}
19579unsafe impl Send for ExtExtension363Fn {}
19580unsafe impl Sync for ExtExtension363Fn {}
19581impl ExtExtension363Fn {
19582 pub fn load<F>(mut _f: F) -> Self
19583 where
19584 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19585 {
19586 Self {}
19587 }
19588}
19589impl FuchsiaExtension364Fn {
19590 #[inline]
19591 pub const fn name() -> &'static ::std::ffi::CStr {
19592 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_364\0") }
19593 }
19594 pub const SPEC_VERSION: u32 = 0u32;
19595}
19596#[derive(Clone)]
19597pub struct FuchsiaExtension364Fn {}
19598unsafe impl Send for FuchsiaExtension364Fn {}
19599unsafe impl Sync for FuchsiaExtension364Fn {}
19600impl FuchsiaExtension364Fn {
19601 pub fn load<F>(mut _f: F) -> Self
19602 where
19603 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19604 {
19605 Self {}
19606 }
19607}
19608impl FuchsiaExternalMemoryFn {
19609 #[inline]
19610 pub const fn name() -> &'static ::std::ffi::CStr {
19611 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_memory\0") }
19612 }
19613 pub const SPEC_VERSION: u32 = 1u32;
19614}
19615#[allow(non_camel_case_types)]
19616pub type PFN_vkGetMemoryZirconHandleFUCHSIA = unsafe extern "system" fn(
19617 device: Device,
19618 p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA,
19619 p_zircon_handle: *mut zx_handle_t,
19620) -> Result;
19621#[allow(non_camel_case_types)]
19622pub type PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = unsafe extern "system" fn(
19623 device: Device,
19624 handle_type: ExternalMemoryHandleTypeFlags,
19625 zircon_handle: zx_handle_t,
19626 p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA,
19627) -> Result;
19628#[derive(Clone)]
19629pub struct FuchsiaExternalMemoryFn {
19630 pub get_memory_zircon_handle_fuchsia: PFN_vkGetMemoryZirconHandleFUCHSIA,
19631 pub get_memory_zircon_handle_properties_fuchsia: PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA,
19632}
19633unsafe impl Send for FuchsiaExternalMemoryFn {}
19634unsafe impl Sync for FuchsiaExternalMemoryFn {}
19635impl FuchsiaExternalMemoryFn {
19636 pub fn load<F>(mut _f: F) -> Self
19637 where
19638 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19639 {
19640 Self {
19641 get_memory_zircon_handle_fuchsia: unsafe {
19642 unsafe extern "system" fn get_memory_zircon_handle_fuchsia(
19643 _device: Device,
19644 _p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA,
19645 _p_zircon_handle: *mut zx_handle_t,
19646 ) -> Result {
19647 panic!(concat!(
19648 "Unable to load ",
19649 stringify!(get_memory_zircon_handle_fuchsia)
19650 ))
19651 }
19652 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19653 b"vkGetMemoryZirconHandleFUCHSIA\0",
19654 );
19655 let val = _f(cname);
19656 if val.is_null() {
19657 get_memory_zircon_handle_fuchsia
19658 } else {
19659 ::std::mem::transmute(val)
19660 }
19661 },
19662 get_memory_zircon_handle_properties_fuchsia: unsafe {
19663 unsafe extern "system" fn get_memory_zircon_handle_properties_fuchsia(
19664 _device: Device,
19665 _handle_type: ExternalMemoryHandleTypeFlags,
19666 _zircon_handle: zx_handle_t,
19667 _p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA,
19668 ) -> Result {
19669 panic!(concat!(
19670 "Unable to load ",
19671 stringify!(get_memory_zircon_handle_properties_fuchsia)
19672 ))
19673 }
19674 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19675 b"vkGetMemoryZirconHandlePropertiesFUCHSIA\0",
19676 );
19677 let val = _f(cname);
19678 if val.is_null() {
19679 get_memory_zircon_handle_properties_fuchsia
19680 } else {
19681 ::std::mem::transmute(val)
19682 }
19683 },
19684 }
19685 }
19686}
19687#[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
19688impl ExternalMemoryHandleTypeFlags {
19689 pub const ZIRCON_VMO_FUCHSIA: Self = Self(0b1000_0000_0000);
19690}
19691#[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
19692impl StructureType {
19693 pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_000);
19694 pub const MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: Self = Self(1_000_364_001);
19695 pub const MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_002);
19696}
19697impl FuchsiaExternalSemaphoreFn {
19698 #[inline]
19699 pub const fn name() -> &'static ::std::ffi::CStr {
19700 unsafe {
19701 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_semaphore\0")
19702 }
19703 }
19704 pub const SPEC_VERSION: u32 = 1u32;
19705}
19706#[allow(non_camel_case_types)]
19707pub type PFN_vkImportSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn(
19708 device: Device,
19709 p_import_semaphore_zircon_handle_info: *const ImportSemaphoreZirconHandleInfoFUCHSIA,
19710) -> Result;
19711#[allow(non_camel_case_types)]
19712pub type PFN_vkGetSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn(
19713 device: Device,
19714 p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA,
19715 p_zircon_handle: *mut zx_handle_t,
19716) -> Result;
19717#[derive(Clone)]
19718pub struct FuchsiaExternalSemaphoreFn {
19719 pub import_semaphore_zircon_handle_fuchsia: PFN_vkImportSemaphoreZirconHandleFUCHSIA,
19720 pub get_semaphore_zircon_handle_fuchsia: PFN_vkGetSemaphoreZirconHandleFUCHSIA,
19721}
19722unsafe impl Send for FuchsiaExternalSemaphoreFn {}
19723unsafe impl Sync for FuchsiaExternalSemaphoreFn {}
19724impl FuchsiaExternalSemaphoreFn {
19725 pub fn load<F>(mut _f: F) -> Self
19726 where
19727 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19728 {
19729 Self {
19730 import_semaphore_zircon_handle_fuchsia: unsafe {
19731 unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia(
19732 _device: Device,
19733 _p_import_semaphore_zircon_handle_info : * const ImportSemaphoreZirconHandleInfoFUCHSIA,
19734 ) -> Result {
19735 panic!(concat!(
19736 "Unable to load ",
19737 stringify!(import_semaphore_zircon_handle_fuchsia)
19738 ))
19739 }
19740 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19741 b"vkImportSemaphoreZirconHandleFUCHSIA\0",
19742 );
19743 let val = _f(cname);
19744 if val.is_null() {
19745 import_semaphore_zircon_handle_fuchsia
19746 } else {
19747 ::std::mem::transmute(val)
19748 }
19749 },
19750 get_semaphore_zircon_handle_fuchsia: unsafe {
19751 unsafe extern "system" fn get_semaphore_zircon_handle_fuchsia(
19752 _device: Device,
19753 _p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA,
19754 _p_zircon_handle: *mut zx_handle_t,
19755 ) -> Result {
19756 panic!(concat!(
19757 "Unable to load ",
19758 stringify!(get_semaphore_zircon_handle_fuchsia)
19759 ))
19760 }
19761 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19762 b"vkGetSemaphoreZirconHandleFUCHSIA\0",
19763 );
19764 let val = _f(cname);
19765 if val.is_null() {
19766 get_semaphore_zircon_handle_fuchsia
19767 } else {
19768 ::std::mem::transmute(val)
19769 }
19770 },
19771 }
19772 }
19773}
19774#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"]
19775impl ExternalSemaphoreHandleTypeFlags {
19776 pub const ZIRCON_EVENT_FUCHSIA: Self = Self(0b1000_0000);
19777}
19778#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"]
19779impl StructureType {
19780 pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_000);
19781 pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_001);
19782}
19783impl FuchsiaBufferCollectionFn {
19784 #[inline]
19785 pub const fn name() -> &'static ::std::ffi::CStr {
19786 unsafe {
19787 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_buffer_collection\0")
19788 }
19789 }
19790 pub const SPEC_VERSION: u32 = 2u32;
19791}
19792#[allow(non_camel_case_types)]
19793pub type PFN_vkCreateBufferCollectionFUCHSIA = unsafe extern "system" fn(
19794 device: Device,
19795 p_create_info: *const BufferCollectionCreateInfoFUCHSIA,
19796 p_allocator: *const AllocationCallbacks,
19797 p_collection: *mut BufferCollectionFUCHSIA,
19798) -> Result;
19799#[allow(non_camel_case_types)]
19800pub type PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = unsafe extern "system" fn(
19801 device: Device,
19802 collection: BufferCollectionFUCHSIA,
19803 p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA,
19804) -> Result;
19805#[allow(non_camel_case_types)]
19806pub type PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = unsafe extern "system" fn(
19807 device: Device,
19808 collection: BufferCollectionFUCHSIA,
19809 p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA,
19810) -> Result;
19811#[allow(non_camel_case_types)]
19812pub type PFN_vkDestroyBufferCollectionFUCHSIA = unsafe extern "system" fn(
19813 device: Device,
19814 collection: BufferCollectionFUCHSIA,
19815 p_allocator: *const AllocationCallbacks,
19816);
19817#[allow(non_camel_case_types)]
19818pub type PFN_vkGetBufferCollectionPropertiesFUCHSIA = unsafe extern "system" fn(
19819 device: Device,
19820 collection: BufferCollectionFUCHSIA,
19821 p_properties: *mut BufferCollectionPropertiesFUCHSIA,
19822) -> Result;
19823#[derive(Clone)]
19824pub struct FuchsiaBufferCollectionFn {
19825 pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA,
19826 pub set_buffer_collection_image_constraints_fuchsia:
19827 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA,
19828 pub set_buffer_collection_buffer_constraints_fuchsia:
19829 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA,
19830 pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA,
19831 pub get_buffer_collection_properties_fuchsia: PFN_vkGetBufferCollectionPropertiesFUCHSIA,
19832}
19833unsafe impl Send for FuchsiaBufferCollectionFn {}
19834unsafe impl Sync for FuchsiaBufferCollectionFn {}
19835impl FuchsiaBufferCollectionFn {
19836 pub fn load<F>(mut _f: F) -> Self
19837 where
19838 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19839 {
19840 Self {
19841 create_buffer_collection_fuchsia: unsafe {
19842 unsafe extern "system" fn create_buffer_collection_fuchsia(
19843 _device: Device,
19844 _p_create_info: *const BufferCollectionCreateInfoFUCHSIA,
19845 _p_allocator: *const AllocationCallbacks,
19846 _p_collection: *mut BufferCollectionFUCHSIA,
19847 ) -> Result {
19848 panic!(concat!(
19849 "Unable to load ",
19850 stringify!(create_buffer_collection_fuchsia)
19851 ))
19852 }
19853 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19854 b"vkCreateBufferCollectionFUCHSIA\0",
19855 );
19856 let val = _f(cname);
19857 if val.is_null() {
19858 create_buffer_collection_fuchsia
19859 } else {
19860 ::std::mem::transmute(val)
19861 }
19862 },
19863 set_buffer_collection_image_constraints_fuchsia: unsafe {
19864 unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia(
19865 _device: Device,
19866 _collection: BufferCollectionFUCHSIA,
19867 _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA,
19868 ) -> Result {
19869 panic!(concat!(
19870 "Unable to load ",
19871 stringify!(set_buffer_collection_image_constraints_fuchsia)
19872 ))
19873 }
19874 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19875 b"vkSetBufferCollectionImageConstraintsFUCHSIA\0",
19876 );
19877 let val = _f(cname);
19878 if val.is_null() {
19879 set_buffer_collection_image_constraints_fuchsia
19880 } else {
19881 ::std::mem::transmute(val)
19882 }
19883 },
19884 set_buffer_collection_buffer_constraints_fuchsia: unsafe {
19885 unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia(
19886 _device: Device,
19887 _collection: BufferCollectionFUCHSIA,
19888 _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA,
19889 ) -> Result {
19890 panic!(concat!(
19891 "Unable to load ",
19892 stringify!(set_buffer_collection_buffer_constraints_fuchsia)
19893 ))
19894 }
19895 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19896 b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0",
19897 );
19898 let val = _f(cname);
19899 if val.is_null() {
19900 set_buffer_collection_buffer_constraints_fuchsia
19901 } else {
19902 ::std::mem::transmute(val)
19903 }
19904 },
19905 destroy_buffer_collection_fuchsia: unsafe {
19906 unsafe extern "system" fn destroy_buffer_collection_fuchsia(
19907 _device: Device,
19908 _collection: BufferCollectionFUCHSIA,
19909 _p_allocator: *const AllocationCallbacks,
19910 ) {
19911 panic!(concat!(
19912 "Unable to load ",
19913 stringify!(destroy_buffer_collection_fuchsia)
19914 ))
19915 }
19916 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19917 b"vkDestroyBufferCollectionFUCHSIA\0",
19918 );
19919 let val = _f(cname);
19920 if val.is_null() {
19921 destroy_buffer_collection_fuchsia
19922 } else {
19923 ::std::mem::transmute(val)
19924 }
19925 },
19926 get_buffer_collection_properties_fuchsia: unsafe {
19927 unsafe extern "system" fn get_buffer_collection_properties_fuchsia(
19928 _device: Device,
19929 _collection: BufferCollectionFUCHSIA,
19930 _p_properties: *mut BufferCollectionPropertiesFUCHSIA,
19931 ) -> Result {
19932 panic!(concat!(
19933 "Unable to load ",
19934 stringify!(get_buffer_collection_properties_fuchsia)
19935 ))
19936 }
19937 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19938 b"vkGetBufferCollectionPropertiesFUCHSIA\0",
19939 );
19940 let val = _f(cname);
19941 if val.is_null() {
19942 get_buffer_collection_properties_fuchsia
19943 } else {
19944 ::std::mem::transmute(val)
19945 }
19946 },
19947 }
19948 }
19949}
19950#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
19951impl DebugReportObjectTypeEXT {
19952 pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000);
19953}
19954#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
19955impl ObjectType {
19956 #[doc = "VkBufferCollectionFUCHSIA"]
19957 pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000);
19958}
19959#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
19960impl StructureType {
19961 pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_000);
19962 pub const IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_001);
19963 pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_002);
19964 pub const BUFFER_COLLECTION_PROPERTIES_FUCHSIA: Self = Self(1_000_366_003);
19965 pub const BUFFER_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_004);
19966 pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_005);
19967 pub const IMAGE_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_006);
19968 pub const IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_007);
19969 pub const SYSMEM_COLOR_SPACE_FUCHSIA: Self = Self(1_000_366_008);
19970 pub const BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_009);
19971}
19972impl FuchsiaExtension368Fn {
19973 #[inline]
19974 pub const fn name() -> &'static ::std::ffi::CStr {
19975 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_368\0") }
19976 }
19977 pub const SPEC_VERSION: u32 = 0u32;
19978}
19979#[derive(Clone)]
19980pub struct FuchsiaExtension368Fn {}
19981unsafe impl Send for FuchsiaExtension368Fn {}
19982unsafe impl Sync for FuchsiaExtension368Fn {}
19983impl FuchsiaExtension368Fn {
19984 pub fn load<F>(mut _f: F) -> Self
19985 where
19986 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19987 {
19988 Self {}
19989 }
19990}
19991impl QcomExtension369Fn {
19992 #[inline]
19993 pub const fn name() -> &'static ::std::ffi::CStr {
19994 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_369\0") }
19995 }
19996 pub const SPEC_VERSION: u32 = 0u32;
19997}
19998#[derive(Clone)]
19999pub struct QcomExtension369Fn {}
20000unsafe impl Send for QcomExtension369Fn {}
20001unsafe impl Sync for QcomExtension369Fn {}
20002impl QcomExtension369Fn {
20003 pub fn load<F>(mut _f: F) -> Self
20004 where
20005 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20006 {
20007 Self {}
20008 }
20009}
20010#[doc = "Generated from 'VK_QCOM_extension_369'"]
20011impl DescriptorBindingFlags {
20012 pub const RESERVED_4_QCOM: Self = Self(0b1_0000);
20013}
20014impl HuaweiSubpassShadingFn {
20015 #[inline]
20016 pub const fn name() -> &'static ::std::ffi::CStr {
20017 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_subpass_shading\0") }
20018 }
20019 pub const SPEC_VERSION: u32 = 2u32;
20020}
20021#[allow(non_camel_case_types)]
20022pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn(
20023 device: Device,
20024 renderpass: RenderPass,
20025 p_max_workgroup_size: *mut Extent2D,
20026) -> Result;
20027#[allow(non_camel_case_types)]
20028pub type PFN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(command_buffer: CommandBuffer);
20029#[derive(Clone)]
20030pub struct HuaweiSubpassShadingFn {
20031 pub get_device_subpass_shading_max_workgroup_size_huawei:
20032 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
20033 pub cmd_subpass_shading_huawei: PFN_vkCmdSubpassShadingHUAWEI,
20034}
20035unsafe impl Send for HuaweiSubpassShadingFn {}
20036unsafe impl Sync for HuaweiSubpassShadingFn {}
20037impl HuaweiSubpassShadingFn {
20038 pub fn load<F>(mut _f: F) -> Self
20039 where
20040 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20041 {
20042 Self {
20043 get_device_subpass_shading_max_workgroup_size_huawei: unsafe {
20044 unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei(
20045 _device: Device,
20046 _renderpass: RenderPass,
20047 _p_max_workgroup_size: *mut Extent2D,
20048 ) -> Result {
20049 panic!(concat!(
20050 "Unable to load ",
20051 stringify!(get_device_subpass_shading_max_workgroup_size_huawei)
20052 ))
20053 }
20054 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20055 b"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\0",
20056 );
20057 let val = _f(cname);
20058 if val.is_null() {
20059 get_device_subpass_shading_max_workgroup_size_huawei
20060 } else {
20061 ::std::mem::transmute(val)
20062 }
20063 },
20064 cmd_subpass_shading_huawei: unsafe {
20065 unsafe extern "system" fn cmd_subpass_shading_huawei(
20066 _command_buffer: CommandBuffer,
20067 ) {
20068 panic!(concat!(
20069 "Unable to load ",
20070 stringify!(cmd_subpass_shading_huawei)
20071 ))
20072 }
20073 let cname =
20074 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSubpassShadingHUAWEI\0");
20075 let val = _f(cname);
20076 if val.is_null() {
20077 cmd_subpass_shading_huawei
20078 } else {
20079 ::std::mem::transmute(val)
20080 }
20081 },
20082 }
20083 }
20084}
20085#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
20086impl PipelineBindPoint {
20087 pub const SUBPASS_SHADING_HUAWEI: Self = Self(1_000_369_003);
20088}
20089#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
20090impl PipelineStageFlags2 {
20091 pub const SUBPASS_SHADING_HUAWEI: Self =
20092 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
20093}
20094#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
20095impl ShaderStageFlags {
20096 pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000);
20097}
20098#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
20099impl StructureType {
20100 pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: Self = Self(1_000_369_000);
20101 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: Self = Self(1_000_369_001);
20102 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: Self = Self(1_000_369_002);
20103}
20104impl HuaweiInvocationMaskFn {
20105 #[inline]
20106 pub const fn name() -> &'static ::std::ffi::CStr {
20107 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_invocation_mask\0") }
20108 }
20109 pub const SPEC_VERSION: u32 = 1u32;
20110}
20111#[allow(non_camel_case_types)]
20112pub type PFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(
20113 command_buffer: CommandBuffer,
20114 image_view: ImageView,
20115 image_layout: ImageLayout,
20116);
20117#[derive(Clone)]
20118pub struct HuaweiInvocationMaskFn {
20119 pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI,
20120}
20121unsafe impl Send for HuaweiInvocationMaskFn {}
20122unsafe impl Sync for HuaweiInvocationMaskFn {}
20123impl HuaweiInvocationMaskFn {
20124 pub fn load<F>(mut _f: F) -> Self
20125 where
20126 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20127 {
20128 Self {
20129 cmd_bind_invocation_mask_huawei: unsafe {
20130 unsafe extern "system" fn cmd_bind_invocation_mask_huawei(
20131 _command_buffer: CommandBuffer,
20132 _image_view: ImageView,
20133 _image_layout: ImageLayout,
20134 ) {
20135 panic!(concat!(
20136 "Unable to load ",
20137 stringify!(cmd_bind_invocation_mask_huawei)
20138 ))
20139 }
20140 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20141 b"vkCmdBindInvocationMaskHUAWEI\0",
20142 );
20143 let val = _f(cname);
20144 if val.is_null() {
20145 cmd_bind_invocation_mask_huawei
20146 } else {
20147 ::std::mem::transmute(val)
20148 }
20149 },
20150 }
20151 }
20152}
20153#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
20154impl AccessFlags2 {
20155 pub const INVOCATION_MASK_READ_HUAWEI: Self =
20156 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
20157}
20158#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
20159impl ImageUsageFlags {
20160 pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000);
20161}
20162#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
20163impl PipelineStageFlags2 {
20164 pub const INVOCATION_MASK_HUAWEI: Self =
20165 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
20166}
20167#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
20168impl StructureType {
20169 pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000);
20170}
20171impl NvExternalMemoryRdmaFn {
20172 #[inline]
20173 pub const fn name() -> &'static ::std::ffi::CStr {
20174 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_rdma\0") }
20175 }
20176 pub const SPEC_VERSION: u32 = 1u32;
20177}
20178#[allow(non_camel_case_types)]
20179pub type PFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(
20180 device: Device,
20181 p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
20182 p_address: *mut RemoteAddressNV,
20183) -> Result;
20184#[derive(Clone)]
20185pub struct NvExternalMemoryRdmaFn {
20186 pub get_memory_remote_address_nv: PFN_vkGetMemoryRemoteAddressNV,
20187}
20188unsafe impl Send for NvExternalMemoryRdmaFn {}
20189unsafe impl Sync for NvExternalMemoryRdmaFn {}
20190impl NvExternalMemoryRdmaFn {
20191 pub fn load<F>(mut _f: F) -> Self
20192 where
20193 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20194 {
20195 Self {
20196 get_memory_remote_address_nv: unsafe {
20197 unsafe extern "system" fn get_memory_remote_address_nv(
20198 _device: Device,
20199 _p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
20200 _p_address: *mut RemoteAddressNV,
20201 ) -> Result {
20202 panic!(concat!(
20203 "Unable to load ",
20204 stringify!(get_memory_remote_address_nv)
20205 ))
20206 }
20207 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20208 b"vkGetMemoryRemoteAddressNV\0",
20209 );
20210 let val = _f(cname);
20211 if val.is_null() {
20212 get_memory_remote_address_nv
20213 } else {
20214 ::std::mem::transmute(val)
20215 }
20216 },
20217 }
20218 }
20219}
20220#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
20221impl ExternalMemoryHandleTypeFlags {
20222 pub const RDMA_ADDRESS_NV: Self = Self(0b1_0000_0000_0000);
20223}
20224#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
20225impl MemoryPropertyFlags {
20226 pub const RDMA_CAPABLE_NV: Self = Self(0b1_0000_0000);
20227}
20228#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
20229impl StructureType {
20230 pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1_000_371_000);
20231 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1_000_371_001);
20232}
20233impl ExtPipelinePropertiesFn {
20234 #[inline]
20235 pub const fn name() -> &'static ::std::ffi::CStr {
20236 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_properties\0") }
20237 }
20238 pub const SPEC_VERSION: u32 = 1u32;
20239}
20240#[allow(non_camel_case_types)]
20241#[doc = "Implemented for all types that can be passed as argument to `pipeline_properties` in [`PFN_vkGetPipelinePropertiesEXT`]"]
20242pub unsafe trait GetPipelinePropertiesEXTParamPipelineProperties {}
20243unsafe impl GetPipelinePropertiesEXTParamPipelineProperties for PipelinePropertiesIdentifierEXT {}
20244#[allow(non_camel_case_types)]
20245pub type PFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn(
20246 device: Device,
20247 p_pipeline_info: *const PipelineInfoEXT,
20248 p_pipeline_properties: *mut BaseOutStructure,
20249) -> Result;
20250#[derive(Clone)]
20251pub struct ExtPipelinePropertiesFn {
20252 pub get_pipeline_properties_ext: PFN_vkGetPipelinePropertiesEXT,
20253}
20254unsafe impl Send for ExtPipelinePropertiesFn {}
20255unsafe impl Sync for ExtPipelinePropertiesFn {}
20256impl ExtPipelinePropertiesFn {
20257 pub fn load<F>(mut _f: F) -> Self
20258 where
20259 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20260 {
20261 Self {
20262 get_pipeline_properties_ext: unsafe {
20263 unsafe extern "system" fn get_pipeline_properties_ext(
20264 _device: Device,
20265 _p_pipeline_info: *const PipelineInfoEXT,
20266 _p_pipeline_properties: *mut BaseOutStructure,
20267 ) -> Result {
20268 panic!(concat!(
20269 "Unable to load ",
20270 stringify!(get_pipeline_properties_ext)
20271 ))
20272 }
20273 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20274 b"vkGetPipelinePropertiesEXT\0",
20275 );
20276 let val = _f(cname);
20277 if val.is_null() {
20278 get_pipeline_properties_ext
20279 } else {
20280 ::std::mem::transmute(val)
20281 }
20282 },
20283 }
20284 }
20285}
20286#[doc = "Generated from 'VK_EXT_pipeline_properties'"]
20287impl StructureType {
20288 pub const PIPELINE_PROPERTIES_IDENTIFIER_EXT: Self = Self(1_000_372_000);
20289 pub const PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: Self = Self(1_000_372_001);
20290 pub const PIPELINE_INFO_EXT: Self = Self::PIPELINE_INFO_KHR;
20291}
20292impl ExtExtension376Fn {
20293 #[inline]
20294 pub const fn name() -> &'static ::std::ffi::CStr {
20295 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_376\0") }
20296 }
20297 pub const SPEC_VERSION: u32 = 0u32;
20298}
20299#[derive(Clone)]
20300pub struct ExtExtension376Fn {}
20301unsafe impl Send for ExtExtension376Fn {}
20302unsafe impl Sync for ExtExtension376Fn {}
20303impl ExtExtension376Fn {
20304 pub fn load<F>(mut _f: F) -> Self
20305 where
20306 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20307 {
20308 Self {}
20309 }
20310}
20311impl ExtMultisampledRenderToSingleSampledFn {
20312 #[inline]
20313 pub const fn name() -> &'static ::std::ffi::CStr {
20314 unsafe {
20315 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20316 b"VK_EXT_multisampled_render_to_single_sampled\0",
20317 )
20318 }
20319 }
20320 pub const SPEC_VERSION: u32 = 1u32;
20321}
20322#[derive(Clone)]
20323pub struct ExtMultisampledRenderToSingleSampledFn {}
20324unsafe impl Send for ExtMultisampledRenderToSingleSampledFn {}
20325unsafe impl Sync for ExtMultisampledRenderToSingleSampledFn {}
20326impl ExtMultisampledRenderToSingleSampledFn {
20327 pub fn load<F>(mut _f: F) -> Self
20328 where
20329 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20330 {
20331 Self {}
20332 }
20333}
20334#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"]
20335impl ImageCreateFlags {
20336 pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXT: Self = Self(0b100_0000_0000_0000_0000);
20337}
20338#[doc = "Generated from 'VK_EXT_multisampled_render_to_single_sampled'"]
20339impl StructureType {
20340 pub const PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: Self =
20341 Self(1_000_376_000);
20342 pub const SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: Self = Self(1_000_376_001);
20343 pub const MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: Self = Self(1_000_376_002);
20344}
20345impl ExtExtendedDynamicState2Fn {
20346 #[inline]
20347 pub const fn name() -> &'static ::std::ffi::CStr {
20348 unsafe {
20349 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state2\0")
20350 }
20351 }
20352 pub const SPEC_VERSION: u32 = 1u32;
20353}
20354#[allow(non_camel_case_types)]
20355pub type PFN_vkCmdSetPatchControlPointsEXT =
20356 unsafe extern "system" fn(command_buffer: CommandBuffer, patch_control_points: u32);
20357#[allow(non_camel_case_types)]
20358pub type PFN_vkCmdSetRasterizerDiscardEnable =
20359 unsafe extern "system" fn(command_buffer: CommandBuffer, rasterizer_discard_enable: Bool32);
20360#[allow(non_camel_case_types)]
20361pub type PFN_vkCmdSetDepthBiasEnable =
20362 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bias_enable: Bool32);
20363#[allow(non_camel_case_types)]
20364pub type PFN_vkCmdSetLogicOpEXT =
20365 unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op: LogicOp);
20366#[allow(non_camel_case_types)]
20367pub type PFN_vkCmdSetPrimitiveRestartEnable =
20368 unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_restart_enable: Bool32);
20369#[derive(Clone)]
20370pub struct ExtExtendedDynamicState2Fn {
20371 pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT,
20372 pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable,
20373 pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable,
20374 pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT,
20375 pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable,
20376}
20377unsafe impl Send for ExtExtendedDynamicState2Fn {}
20378unsafe impl Sync for ExtExtendedDynamicState2Fn {}
20379impl ExtExtendedDynamicState2Fn {
20380 pub fn load<F>(mut _f: F) -> Self
20381 where
20382 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20383 {
20384 Self {
20385 cmd_set_patch_control_points_ext: unsafe {
20386 unsafe extern "system" fn cmd_set_patch_control_points_ext(
20387 _command_buffer: CommandBuffer,
20388 _patch_control_points: u32,
20389 ) {
20390 panic!(concat!(
20391 "Unable to load ",
20392 stringify!(cmd_set_patch_control_points_ext)
20393 ))
20394 }
20395 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20396 b"vkCmdSetPatchControlPointsEXT\0",
20397 );
20398 let val = _f(cname);
20399 if val.is_null() {
20400 cmd_set_patch_control_points_ext
20401 } else {
20402 ::std::mem::transmute(val)
20403 }
20404 },
20405 cmd_set_rasterizer_discard_enable_ext: unsafe {
20406 unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext(
20407 _command_buffer: CommandBuffer,
20408 _rasterizer_discard_enable: Bool32,
20409 ) {
20410 panic!(concat!(
20411 "Unable to load ",
20412 stringify!(cmd_set_rasterizer_discard_enable_ext)
20413 ))
20414 }
20415 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20416 b"vkCmdSetRasterizerDiscardEnableEXT\0",
20417 );
20418 let val = _f(cname);
20419 if val.is_null() {
20420 cmd_set_rasterizer_discard_enable_ext
20421 } else {
20422 ::std::mem::transmute(val)
20423 }
20424 },
20425 cmd_set_depth_bias_enable_ext: unsafe {
20426 unsafe extern "system" fn cmd_set_depth_bias_enable_ext(
20427 _command_buffer: CommandBuffer,
20428 _depth_bias_enable: Bool32,
20429 ) {
20430 panic!(concat!(
20431 "Unable to load ",
20432 stringify!(cmd_set_depth_bias_enable_ext)
20433 ))
20434 }
20435 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20436 b"vkCmdSetDepthBiasEnableEXT\0",
20437 );
20438 let val = _f(cname);
20439 if val.is_null() {
20440 cmd_set_depth_bias_enable_ext
20441 } else {
20442 ::std::mem::transmute(val)
20443 }
20444 },
20445 cmd_set_logic_op_ext: unsafe {
20446 unsafe extern "system" fn cmd_set_logic_op_ext(
20447 _command_buffer: CommandBuffer,
20448 _logic_op: LogicOp,
20449 ) {
20450 panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext)))
20451 }
20452 let cname =
20453 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
20454 let val = _f(cname);
20455 if val.is_null() {
20456 cmd_set_logic_op_ext
20457 } else {
20458 ::std::mem::transmute(val)
20459 }
20460 },
20461 cmd_set_primitive_restart_enable_ext: unsafe {
20462 unsafe extern "system" fn cmd_set_primitive_restart_enable_ext(
20463 _command_buffer: CommandBuffer,
20464 _primitive_restart_enable: Bool32,
20465 ) {
20466 panic!(concat!(
20467 "Unable to load ",
20468 stringify!(cmd_set_primitive_restart_enable_ext)
20469 ))
20470 }
20471 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20472 b"vkCmdSetPrimitiveRestartEnableEXT\0",
20473 );
20474 let val = _f(cname);
20475 if val.is_null() {
20476 cmd_set_primitive_restart_enable_ext
20477 } else {
20478 ::std::mem::transmute(val)
20479 }
20480 },
20481 }
20482 }
20483}
20484#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
20485impl DynamicState {
20486 #[doc = "Not promoted to 1.3"]
20487 pub const PATCH_CONTROL_POINTS_EXT: Self = Self(1_000_377_000);
20488 pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self::RASTERIZER_DISCARD_ENABLE;
20489 pub const DEPTH_BIAS_ENABLE_EXT: Self = Self::DEPTH_BIAS_ENABLE;
20490 #[doc = "Not promoted to 1.3"]
20491 pub const LOGIC_OP_EXT: Self = Self(1_000_377_003);
20492 pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self::PRIMITIVE_RESTART_ENABLE;
20493}
20494#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
20495impl StructureType {
20496 #[doc = "Not promoted to 1.3"]
20497 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1_000_377_000);
20498}
20499impl QnxScreenSurfaceFn {
20500 #[inline]
20501 pub const fn name() -> &'static ::std::ffi::CStr {
20502 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_screen_surface\0") }
20503 }
20504 pub const SPEC_VERSION: u32 = 1u32;
20505}
20506#[allow(non_camel_case_types)]
20507pub type PFN_vkCreateScreenSurfaceQNX = unsafe extern "system" fn(
20508 instance: Instance,
20509 p_create_info: *const ScreenSurfaceCreateInfoQNX,
20510 p_allocator: *const AllocationCallbacks,
20511 p_surface: *mut SurfaceKHR,
20512) -> Result;
20513#[allow(non_camel_case_types)]
20514pub type PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = unsafe extern "system" fn(
20515 physical_device: PhysicalDevice,
20516 queue_family_index: u32,
20517 window: *mut _screen_window,
20518) -> Bool32;
20519#[derive(Clone)]
20520pub struct QnxScreenSurfaceFn {
20521 pub create_screen_surface_qnx: PFN_vkCreateScreenSurfaceQNX,
20522 pub get_physical_device_screen_presentation_support_qnx:
20523 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX,
20524}
20525unsafe impl Send for QnxScreenSurfaceFn {}
20526unsafe impl Sync for QnxScreenSurfaceFn {}
20527impl QnxScreenSurfaceFn {
20528 pub fn load<F>(mut _f: F) -> Self
20529 where
20530 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20531 {
20532 Self {
20533 create_screen_surface_qnx: unsafe {
20534 unsafe extern "system" fn create_screen_surface_qnx(
20535 _instance: Instance,
20536 _p_create_info: *const ScreenSurfaceCreateInfoQNX,
20537 _p_allocator: *const AllocationCallbacks,
20538 _p_surface: *mut SurfaceKHR,
20539 ) -> Result {
20540 panic!(concat!(
20541 "Unable to load ",
20542 stringify!(create_screen_surface_qnx)
20543 ))
20544 }
20545 let cname =
20546 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateScreenSurfaceQNX\0");
20547 let val = _f(cname);
20548 if val.is_null() {
20549 create_screen_surface_qnx
20550 } else {
20551 ::std::mem::transmute(val)
20552 }
20553 },
20554 get_physical_device_screen_presentation_support_qnx: unsafe {
20555 unsafe extern "system" fn get_physical_device_screen_presentation_support_qnx(
20556 _physical_device: PhysicalDevice,
20557 _queue_family_index: u32,
20558 _window: *mut _screen_window,
20559 ) -> Bool32 {
20560 panic!(concat!(
20561 "Unable to load ",
20562 stringify!(get_physical_device_screen_presentation_support_qnx)
20563 ))
20564 }
20565 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20566 b"vkGetPhysicalDeviceScreenPresentationSupportQNX\0",
20567 );
20568 let val = _f(cname);
20569 if val.is_null() {
20570 get_physical_device_screen_presentation_support_qnx
20571 } else {
20572 ::std::mem::transmute(val)
20573 }
20574 },
20575 }
20576 }
20577}
20578#[doc = "Generated from 'VK_QNX_screen_surface'"]
20579impl StructureType {
20580 pub const SCREEN_SURFACE_CREATE_INFO_QNX: Self = Self(1_000_378_000);
20581}
20582impl KhrExtension380Fn {
20583 #[inline]
20584 pub const fn name() -> &'static ::std::ffi::CStr {
20585 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_380\0") }
20586 }
20587 pub const SPEC_VERSION: u32 = 0u32;
20588}
20589#[derive(Clone)]
20590pub struct KhrExtension380Fn {}
20591unsafe impl Send for KhrExtension380Fn {}
20592unsafe impl Sync for KhrExtension380Fn {}
20593impl KhrExtension380Fn {
20594 pub fn load<F>(mut _f: F) -> Self
20595 where
20596 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20597 {
20598 Self {}
20599 }
20600}
20601impl KhrExtension381Fn {
20602 #[inline]
20603 pub const fn name() -> &'static ::std::ffi::CStr {
20604 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_381\0") }
20605 }
20606 pub const SPEC_VERSION: u32 = 0u32;
20607}
20608#[derive(Clone)]
20609pub struct KhrExtension381Fn {}
20610unsafe impl Send for KhrExtension381Fn {}
20611unsafe impl Sync for KhrExtension381Fn {}
20612impl KhrExtension381Fn {
20613 pub fn load<F>(mut _f: F) -> Self
20614 where
20615 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20616 {
20617 Self {}
20618 }
20619}
20620impl ExtColorWriteEnableFn {
20621 #[inline]
20622 pub const fn name() -> &'static ::std::ffi::CStr {
20623 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_color_write_enable\0") }
20624 }
20625 pub const SPEC_VERSION: u32 = 1u32;
20626}
20627#[allow(non_camel_case_types)]
20628pub type PFN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn(
20629 command_buffer: CommandBuffer,
20630 attachment_count: u32,
20631 p_color_write_enables: *const Bool32,
20632);
20633#[derive(Clone)]
20634pub struct ExtColorWriteEnableFn {
20635 pub cmd_set_color_write_enable_ext: PFN_vkCmdSetColorWriteEnableEXT,
20636}
20637unsafe impl Send for ExtColorWriteEnableFn {}
20638unsafe impl Sync for ExtColorWriteEnableFn {}
20639impl ExtColorWriteEnableFn {
20640 pub fn load<F>(mut _f: F) -> Self
20641 where
20642 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20643 {
20644 Self {
20645 cmd_set_color_write_enable_ext: unsafe {
20646 unsafe extern "system" fn cmd_set_color_write_enable_ext(
20647 _command_buffer: CommandBuffer,
20648 _attachment_count: u32,
20649 _p_color_write_enables: *const Bool32,
20650 ) {
20651 panic!(concat!(
20652 "Unable to load ",
20653 stringify!(cmd_set_color_write_enable_ext)
20654 ))
20655 }
20656 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20657 b"vkCmdSetColorWriteEnableEXT\0",
20658 );
20659 let val = _f(cname);
20660 if val.is_null() {
20661 cmd_set_color_write_enable_ext
20662 } else {
20663 ::std::mem::transmute(val)
20664 }
20665 },
20666 }
20667 }
20668}
20669#[doc = "Generated from 'VK_EXT_color_write_enable'"]
20670impl DynamicState {
20671 pub const COLOR_WRITE_ENABLE_EXT: Self = Self(1_000_381_000);
20672}
20673#[doc = "Generated from 'VK_EXT_color_write_enable'"]
20674impl StructureType {
20675 pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self(1_000_381_000);
20676 pub const PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: Self = Self(1_000_381_001);
20677}
20678impl ExtPrimitivesGeneratedQueryFn {
20679 #[inline]
20680 pub const fn name() -> &'static ::std::ffi::CStr {
20681 unsafe {
20682 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_primitives_generated_query\0")
20683 }
20684 }
20685 pub const SPEC_VERSION: u32 = 1u32;
20686}
20687#[derive(Clone)]
20688pub struct ExtPrimitivesGeneratedQueryFn {}
20689unsafe impl Send for ExtPrimitivesGeneratedQueryFn {}
20690unsafe impl Sync for ExtPrimitivesGeneratedQueryFn {}
20691impl ExtPrimitivesGeneratedQueryFn {
20692 pub fn load<F>(mut _f: F) -> Self
20693 where
20694 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20695 {
20696 Self {}
20697 }
20698}
20699#[doc = "Generated from 'VK_EXT_primitives_generated_query'"]
20700impl QueryType {
20701 pub const PRIMITIVES_GENERATED_EXT: Self = Self(1_000_382_000);
20702}
20703#[doc = "Generated from 'VK_EXT_primitives_generated_query'"]
20704impl StructureType {
20705 pub const PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: Self = Self(1_000_382_000);
20706}
20707impl ExtExtension384Fn {
20708 #[inline]
20709 pub const fn name() -> &'static ::std::ffi::CStr {
20710 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_384\0") }
20711 }
20712 pub const SPEC_VERSION: u32 = 0u32;
20713}
20714#[derive(Clone)]
20715pub struct ExtExtension384Fn {}
20716unsafe impl Send for ExtExtension384Fn {}
20717unsafe impl Sync for ExtExtension384Fn {}
20718impl ExtExtension384Fn {
20719 pub fn load<F>(mut _f: F) -> Self
20720 where
20721 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20722 {
20723 Self {}
20724 }
20725}
20726impl MesaExtension385Fn {
20727 #[inline]
20728 pub const fn name() -> &'static ::std::ffi::CStr {
20729 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_385\0") }
20730 }
20731 pub const SPEC_VERSION: u32 = 0u32;
20732}
20733#[derive(Clone)]
20734pub struct MesaExtension385Fn {}
20735unsafe impl Send for MesaExtension385Fn {}
20736unsafe impl Sync for MesaExtension385Fn {}
20737impl MesaExtension385Fn {
20738 pub fn load<F>(mut _f: F) -> Self
20739 where
20740 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20741 {
20742 Self {}
20743 }
20744}
20745impl GoogleExtension386Fn {
20746 #[inline]
20747 pub const fn name() -> &'static ::std::ffi::CStr {
20748 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_386\0") }
20749 }
20750 pub const SPEC_VERSION: u32 = 0u32;
20751}
20752#[derive(Clone)]
20753pub struct GoogleExtension386Fn {}
20754unsafe impl Send for GoogleExtension386Fn {}
20755unsafe impl Sync for GoogleExtension386Fn {}
20756impl GoogleExtension386Fn {
20757 pub fn load<F>(mut _f: F) -> Self
20758 where
20759 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20760 {
20761 Self {}
20762 }
20763}
20764impl KhrRayTracingMaintenance1Fn {
20765 #[inline]
20766 pub const fn name() -> &'static ::std::ffi::CStr {
20767 unsafe {
20768 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_maintenance1\0")
20769 }
20770 }
20771 pub const SPEC_VERSION: u32 = 1u32;
20772}
20773#[allow(non_camel_case_types)]
20774pub type PFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn(
20775 command_buffer: CommandBuffer,
20776 indirect_device_address: DeviceAddress,
20777);
20778#[derive(Clone)]
20779pub struct KhrRayTracingMaintenance1Fn {
20780 pub cmd_trace_rays_indirect2_khr: PFN_vkCmdTraceRaysIndirect2KHR,
20781}
20782unsafe impl Send for KhrRayTracingMaintenance1Fn {}
20783unsafe impl Sync for KhrRayTracingMaintenance1Fn {}
20784impl KhrRayTracingMaintenance1Fn {
20785 pub fn load<F>(mut _f: F) -> Self
20786 where
20787 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20788 {
20789 Self {
20790 cmd_trace_rays_indirect2_khr: unsafe {
20791 unsafe extern "system" fn cmd_trace_rays_indirect2_khr(
20792 _command_buffer: CommandBuffer,
20793 _indirect_device_address: DeviceAddress,
20794 ) {
20795 panic!(concat!(
20796 "Unable to load ",
20797 stringify!(cmd_trace_rays_indirect2_khr)
20798 ))
20799 }
20800 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20801 b"vkCmdTraceRaysIndirect2KHR\0",
20802 );
20803 let val = _f(cname);
20804 if val.is_null() {
20805 cmd_trace_rays_indirect2_khr
20806 } else {
20807 ::std::mem::transmute(val)
20808 }
20809 },
20810 }
20811 }
20812}
20813#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
20814impl AccessFlags2 {
20815 pub const SHADER_BINDING_TABLE_READ_KHR: Self =
20816 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
20817}
20818#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
20819impl PipelineStageFlags2 {
20820 pub const ACCELERATION_STRUCTURE_COPY_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
20821}
20822#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
20823impl QueryType {
20824 pub const ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: Self =
20825 Self(1_000_386_000);
20826 pub const ACCELERATION_STRUCTURE_SIZE_KHR: Self = Self(1_000_386_001);
20827}
20828#[doc = "Generated from 'VK_KHR_ray_tracing_maintenance1'"]
20829impl StructureType {
20830 pub const PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: Self = Self(1_000_386_000);
20831}
20832impl ExtExtension388Fn {
20833 #[inline]
20834 pub const fn name() -> &'static ::std::ffi::CStr {
20835 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_388\0") }
20836 }
20837 pub const SPEC_VERSION: u32 = 0u32;
20838}
20839#[derive(Clone)]
20840pub struct ExtExtension388Fn {}
20841unsafe impl Send for ExtExtension388Fn {}
20842unsafe impl Sync for ExtExtension388Fn {}
20843impl ExtExtension388Fn {
20844 pub fn load<F>(mut _f: F) -> Self
20845 where
20846 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20847 {
20848 Self {}
20849 }
20850}
20851impl ExtGlobalPriorityQueryFn {
20852 #[inline]
20853 pub const fn name() -> &'static ::std::ffi::CStr {
20854 unsafe {
20855 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority_query\0")
20856 }
20857 }
20858 pub const SPEC_VERSION: u32 = 1u32;
20859}
20860#[derive(Clone)]
20861pub struct ExtGlobalPriorityQueryFn {}
20862unsafe impl Send for ExtGlobalPriorityQueryFn {}
20863unsafe impl Sync for ExtGlobalPriorityQueryFn {}
20864impl ExtGlobalPriorityQueryFn {
20865 pub fn load<F>(mut _f: F) -> Self
20866 where
20867 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20868 {
20869 Self {}
20870 }
20871}
20872#[doc = "Generated from 'VK_EXT_global_priority_query'"]
20873impl StructureType {
20874 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self =
20875 Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
20876 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self =
20877 Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
20878}
20879impl ExtExtension390Fn {
20880 #[inline]
20881 pub const fn name() -> &'static ::std::ffi::CStr {
20882 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_390\0") }
20883 }
20884 pub const SPEC_VERSION: u32 = 0u32;
20885}
20886#[derive(Clone)]
20887pub struct ExtExtension390Fn {}
20888unsafe impl Send for ExtExtension390Fn {}
20889unsafe impl Sync for ExtExtension390Fn {}
20890impl ExtExtension390Fn {
20891 pub fn load<F>(mut _f: F) -> Self
20892 where
20893 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20894 {
20895 Self {}
20896 }
20897}
20898impl ExtExtension391Fn {
20899 #[inline]
20900 pub const fn name() -> &'static ::std::ffi::CStr {
20901 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_391\0") }
20902 }
20903 pub const SPEC_VERSION: u32 = 0u32;
20904}
20905#[derive(Clone)]
20906pub struct ExtExtension391Fn {}
20907unsafe impl Send for ExtExtension391Fn {}
20908unsafe impl Sync for ExtExtension391Fn {}
20909impl ExtExtension391Fn {
20910 pub fn load<F>(mut _f: F) -> Self
20911 where
20912 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20913 {
20914 Self {}
20915 }
20916}
20917impl ExtImageViewMinLodFn {
20918 #[inline]
20919 pub const fn name() -> &'static ::std::ffi::CStr {
20920 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_view_min_lod\0") }
20921 }
20922 pub const SPEC_VERSION: u32 = 1u32;
20923}
20924#[derive(Clone)]
20925pub struct ExtImageViewMinLodFn {}
20926unsafe impl Send for ExtImageViewMinLodFn {}
20927unsafe impl Sync for ExtImageViewMinLodFn {}
20928impl ExtImageViewMinLodFn {
20929 pub fn load<F>(mut _f: F) -> Self
20930 where
20931 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20932 {
20933 Self {}
20934 }
20935}
20936#[doc = "Generated from 'VK_EXT_image_view_min_lod'"]
20937impl StructureType {
20938 pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1_000_391_000);
20939 pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: Self = Self(1_000_391_001);
20940}
20941impl ExtMultiDrawFn {
20942 #[inline]
20943 pub const fn name() -> &'static ::std::ffi::CStr {
20944 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_multi_draw\0") }
20945 }
20946 pub const SPEC_VERSION: u32 = 1u32;
20947}
20948#[allow(non_camel_case_types)]
20949pub type PFN_vkCmdDrawMultiEXT = unsafe extern "system" fn(
20950 command_buffer: CommandBuffer,
20951 draw_count: u32,
20952 p_vertex_info: *const MultiDrawInfoEXT,
20953 instance_count: u32,
20954 first_instance: u32,
20955 stride: u32,
20956);
20957#[allow(non_camel_case_types)]
20958pub type PFN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn(
20959 command_buffer: CommandBuffer,
20960 draw_count: u32,
20961 p_index_info: *const MultiDrawIndexedInfoEXT,
20962 instance_count: u32,
20963 first_instance: u32,
20964 stride: u32,
20965 p_vertex_offset: *const i32,
20966);
20967#[derive(Clone)]
20968pub struct ExtMultiDrawFn {
20969 pub cmd_draw_multi_ext: PFN_vkCmdDrawMultiEXT,
20970 pub cmd_draw_multi_indexed_ext: PFN_vkCmdDrawMultiIndexedEXT,
20971}
20972unsafe impl Send for ExtMultiDrawFn {}
20973unsafe impl Sync for ExtMultiDrawFn {}
20974impl ExtMultiDrawFn {
20975 pub fn load<F>(mut _f: F) -> Self
20976 where
20977 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20978 {
20979 Self {
20980 cmd_draw_multi_ext: unsafe {
20981 unsafe extern "system" fn cmd_draw_multi_ext(
20982 _command_buffer: CommandBuffer,
20983 _draw_count: u32,
20984 _p_vertex_info: *const MultiDrawInfoEXT,
20985 _instance_count: u32,
20986 _first_instance: u32,
20987 _stride: u32,
20988 ) {
20989 panic!(concat!("Unable to load ", stringify!(cmd_draw_multi_ext)))
20990 }
20991 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiEXT\0");
20992 let val = _f(cname);
20993 if val.is_null() {
20994 cmd_draw_multi_ext
20995 } else {
20996 ::std::mem::transmute(val)
20997 }
20998 },
20999 cmd_draw_multi_indexed_ext: unsafe {
21000 unsafe extern "system" fn cmd_draw_multi_indexed_ext(
21001 _command_buffer: CommandBuffer,
21002 _draw_count: u32,
21003 _p_index_info: *const MultiDrawIndexedInfoEXT,
21004 _instance_count: u32,
21005 _first_instance: u32,
21006 _stride: u32,
21007 _p_vertex_offset: *const i32,
21008 ) {
21009 panic!(concat!(
21010 "Unable to load ",
21011 stringify!(cmd_draw_multi_indexed_ext)
21012 ))
21013 }
21014 let cname =
21015 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiIndexedEXT\0");
21016 let val = _f(cname);
21017 if val.is_null() {
21018 cmd_draw_multi_indexed_ext
21019 } else {
21020 ::std::mem::transmute(val)
21021 }
21022 },
21023 }
21024 }
21025}
21026#[doc = "Generated from 'VK_EXT_multi_draw'"]
21027impl StructureType {
21028 pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: Self = Self(1_000_392_000);
21029 pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: Self = Self(1_000_392_001);
21030}
21031impl ExtImage2dViewOf3dFn {
21032 #[inline]
21033 pub const fn name() -> &'static ::std::ffi::CStr {
21034 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_2d_view_of_3d\0") }
21035 }
21036 pub const SPEC_VERSION: u32 = 1u32;
21037}
21038#[derive(Clone)]
21039pub struct ExtImage2dViewOf3dFn {}
21040unsafe impl Send for ExtImage2dViewOf3dFn {}
21041unsafe impl Sync for ExtImage2dViewOf3dFn {}
21042impl ExtImage2dViewOf3dFn {
21043 pub fn load<F>(mut _f: F) -> Self
21044 where
21045 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21046 {
21047 Self {}
21048 }
21049}
21050#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"]
21051impl ImageCreateFlags {
21052 #[doc = "Image is created with a layout where individual slices are capable of being used as 2D images"]
21053 pub const TYPE_2D_VIEW_COMPATIBLE_EXT: Self = Self(0b10_0000_0000_0000_0000);
21054}
21055#[doc = "Generated from 'VK_EXT_image_2d_view_of_3d'"]
21056impl StructureType {
21057 pub const PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: Self = Self(1_000_393_000);
21058}
21059impl KhrPortabilityEnumerationFn {
21060 #[inline]
21061 pub const fn name() -> &'static ::std::ffi::CStr {
21062 unsafe {
21063 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_enumeration\0")
21064 }
21065 }
21066 pub const SPEC_VERSION: u32 = 1u32;
21067}
21068#[derive(Clone)]
21069pub struct KhrPortabilityEnumerationFn {}
21070unsafe impl Send for KhrPortabilityEnumerationFn {}
21071unsafe impl Sync for KhrPortabilityEnumerationFn {}
21072impl KhrPortabilityEnumerationFn {
21073 pub fn load<F>(mut _f: F) -> Self
21074 where
21075 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21076 {
21077 Self {}
21078 }
21079}
21080#[doc = "Generated from 'VK_KHR_portability_enumeration'"]
21081impl InstanceCreateFlags {
21082 pub const ENUMERATE_PORTABILITY_KHR: Self = Self(0b1);
21083}
21084impl ExtShaderTileImageFn {
21085 #[inline]
21086 pub const fn name() -> &'static ::std::ffi::CStr {
21087 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_tile_image\0") }
21088 }
21089 pub const SPEC_VERSION: u32 = 1u32;
21090}
21091#[derive(Clone)]
21092pub struct ExtShaderTileImageFn {}
21093unsafe impl Send for ExtShaderTileImageFn {}
21094unsafe impl Sync for ExtShaderTileImageFn {}
21095impl ExtShaderTileImageFn {
21096 pub fn load<F>(mut _f: F) -> Self
21097 where
21098 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21099 {
21100 Self {}
21101 }
21102}
21103#[doc = "Generated from 'VK_EXT_shader_tile_image'"]
21104impl StructureType {
21105 pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: Self = Self(1_000_395_000);
21106 pub const PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: Self = Self(1_000_395_001);
21107}
21108impl ExtOpacityMicromapFn {
21109 #[inline]
21110 pub const fn name() -> &'static ::std::ffi::CStr {
21111 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_opacity_micromap\0") }
21112 }
21113 pub const SPEC_VERSION: u32 = 2u32;
21114}
21115#[allow(non_camel_case_types)]
21116pub type PFN_vkCreateMicromapEXT = unsafe extern "system" fn(
21117 device: Device,
21118 p_create_info: *const MicromapCreateInfoEXT,
21119 p_allocator: *const AllocationCallbacks,
21120 p_micromap: *mut MicromapEXT,
21121) -> Result;
21122#[allow(non_camel_case_types)]
21123pub type PFN_vkDestroyMicromapEXT = unsafe extern "system" fn(
21124 device: Device,
21125 micromap: MicromapEXT,
21126 p_allocator: *const AllocationCallbacks,
21127);
21128#[allow(non_camel_case_types)]
21129pub type PFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn(
21130 command_buffer: CommandBuffer,
21131 info_count: u32,
21132 p_infos: *const MicromapBuildInfoEXT,
21133);
21134#[allow(non_camel_case_types)]
21135pub type PFN_vkBuildMicromapsEXT = unsafe extern "system" fn(
21136 device: Device,
21137 deferred_operation: DeferredOperationKHR,
21138 info_count: u32,
21139 p_infos: *const MicromapBuildInfoEXT,
21140) -> Result;
21141#[allow(non_camel_case_types)]
21142pub type PFN_vkCopyMicromapEXT = unsafe extern "system" fn(
21143 device: Device,
21144 deferred_operation: DeferredOperationKHR,
21145 p_info: *const CopyMicromapInfoEXT,
21146) -> Result;
21147#[allow(non_camel_case_types)]
21148pub type PFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn(
21149 device: Device,
21150 deferred_operation: DeferredOperationKHR,
21151 p_info: *const CopyMicromapToMemoryInfoEXT,
21152) -> Result;
21153#[allow(non_camel_case_types)]
21154pub type PFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn(
21155 device: Device,
21156 deferred_operation: DeferredOperationKHR,
21157 p_info: *const CopyMemoryToMicromapInfoEXT,
21158) -> Result;
21159#[allow(non_camel_case_types)]
21160pub type PFN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn(
21161 device: Device,
21162 micromap_count: u32,
21163 p_micromaps: *const MicromapEXT,
21164 query_type: QueryType,
21165 data_size: usize,
21166 p_data: *mut c_void,
21167 stride: usize,
21168) -> Result;
21169#[allow(non_camel_case_types)]
21170pub type PFN_vkCmdCopyMicromapEXT =
21171 unsafe extern "system" fn(command_buffer: CommandBuffer, p_info: *const CopyMicromapInfoEXT);
21172#[allow(non_camel_case_types)]
21173pub type PFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn(
21174 command_buffer: CommandBuffer,
21175 p_info: *const CopyMicromapToMemoryInfoEXT,
21176);
21177#[allow(non_camel_case_types)]
21178pub type PFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn(
21179 command_buffer: CommandBuffer,
21180 p_info: *const CopyMemoryToMicromapInfoEXT,
21181);
21182#[allow(non_camel_case_types)]
21183pub type PFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn(
21184 command_buffer: CommandBuffer,
21185 micromap_count: u32,
21186 p_micromaps: *const MicromapEXT,
21187 query_type: QueryType,
21188 query_pool: QueryPool,
21189 first_query: u32,
21190);
21191#[allow(non_camel_case_types)]
21192pub type PFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn(
21193 device: Device,
21194 p_version_info: *const MicromapVersionInfoEXT,
21195 p_compatibility: *mut AccelerationStructureCompatibilityKHR,
21196);
21197#[allow(non_camel_case_types)]
21198pub type PFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn(
21199 device: Device,
21200 build_type: AccelerationStructureBuildTypeKHR,
21201 p_build_info: *const MicromapBuildInfoEXT,
21202 p_size_info: *mut MicromapBuildSizesInfoEXT,
21203);
21204#[derive(Clone)]
21205pub struct ExtOpacityMicromapFn {
21206 pub create_micromap_ext: PFN_vkCreateMicromapEXT,
21207 pub destroy_micromap_ext: PFN_vkDestroyMicromapEXT,
21208 pub cmd_build_micromaps_ext: PFN_vkCmdBuildMicromapsEXT,
21209 pub build_micromaps_ext: PFN_vkBuildMicromapsEXT,
21210 pub copy_micromap_ext: PFN_vkCopyMicromapEXT,
21211 pub copy_micromap_to_memory_ext: PFN_vkCopyMicromapToMemoryEXT,
21212 pub copy_memory_to_micromap_ext: PFN_vkCopyMemoryToMicromapEXT,
21213 pub write_micromaps_properties_ext: PFN_vkWriteMicromapsPropertiesEXT,
21214 pub cmd_copy_micromap_ext: PFN_vkCmdCopyMicromapEXT,
21215 pub cmd_copy_micromap_to_memory_ext: PFN_vkCmdCopyMicromapToMemoryEXT,
21216 pub cmd_copy_memory_to_micromap_ext: PFN_vkCmdCopyMemoryToMicromapEXT,
21217 pub cmd_write_micromaps_properties_ext: PFN_vkCmdWriteMicromapsPropertiesEXT,
21218 pub get_device_micromap_compatibility_ext: PFN_vkGetDeviceMicromapCompatibilityEXT,
21219 pub get_micromap_build_sizes_ext: PFN_vkGetMicromapBuildSizesEXT,
21220}
21221unsafe impl Send for ExtOpacityMicromapFn {}
21222unsafe impl Sync for ExtOpacityMicromapFn {}
21223impl ExtOpacityMicromapFn {
21224 pub fn load<F>(mut _f: F) -> Self
21225 where
21226 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21227 {
21228 Self {
21229 create_micromap_ext: unsafe {
21230 unsafe extern "system" fn create_micromap_ext(
21231 _device: Device,
21232 _p_create_info: *const MicromapCreateInfoEXT,
21233 _p_allocator: *const AllocationCallbacks,
21234 _p_micromap: *mut MicromapEXT,
21235 ) -> Result {
21236 panic!(concat!("Unable to load ", stringify!(create_micromap_ext)))
21237 }
21238 let cname =
21239 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMicromapEXT\0");
21240 let val = _f(cname);
21241 if val.is_null() {
21242 create_micromap_ext
21243 } else {
21244 ::std::mem::transmute(val)
21245 }
21246 },
21247 destroy_micromap_ext: unsafe {
21248 unsafe extern "system" fn destroy_micromap_ext(
21249 _device: Device,
21250 _micromap: MicromapEXT,
21251 _p_allocator: *const AllocationCallbacks,
21252 ) {
21253 panic!(concat!("Unable to load ", stringify!(destroy_micromap_ext)))
21254 }
21255 let cname =
21256 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyMicromapEXT\0");
21257 let val = _f(cname);
21258 if val.is_null() {
21259 destroy_micromap_ext
21260 } else {
21261 ::std::mem::transmute(val)
21262 }
21263 },
21264 cmd_build_micromaps_ext: unsafe {
21265 unsafe extern "system" fn cmd_build_micromaps_ext(
21266 _command_buffer: CommandBuffer,
21267 _info_count: u32,
21268 _p_infos: *const MicromapBuildInfoEXT,
21269 ) {
21270 panic!(concat!(
21271 "Unable to load ",
21272 stringify!(cmd_build_micromaps_ext)
21273 ))
21274 }
21275 let cname =
21276 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBuildMicromapsEXT\0");
21277 let val = _f(cname);
21278 if val.is_null() {
21279 cmd_build_micromaps_ext
21280 } else {
21281 ::std::mem::transmute(val)
21282 }
21283 },
21284 build_micromaps_ext: unsafe {
21285 unsafe extern "system" fn build_micromaps_ext(
21286 _device: Device,
21287 _deferred_operation: DeferredOperationKHR,
21288 _info_count: u32,
21289 _p_infos: *const MicromapBuildInfoEXT,
21290 ) -> Result {
21291 panic!(concat!("Unable to load ", stringify!(build_micromaps_ext)))
21292 }
21293 let cname =
21294 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBuildMicromapsEXT\0");
21295 let val = _f(cname);
21296 if val.is_null() {
21297 build_micromaps_ext
21298 } else {
21299 ::std::mem::transmute(val)
21300 }
21301 },
21302 copy_micromap_ext: unsafe {
21303 unsafe extern "system" fn copy_micromap_ext(
21304 _device: Device,
21305 _deferred_operation: DeferredOperationKHR,
21306 _p_info: *const CopyMicromapInfoEXT,
21307 ) -> Result {
21308 panic!(concat!("Unable to load ", stringify!(copy_micromap_ext)))
21309 }
21310 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapEXT\0");
21311 let val = _f(cname);
21312 if val.is_null() {
21313 copy_micromap_ext
21314 } else {
21315 ::std::mem::transmute(val)
21316 }
21317 },
21318 copy_micromap_to_memory_ext: unsafe {
21319 unsafe extern "system" fn copy_micromap_to_memory_ext(
21320 _device: Device,
21321 _deferred_operation: DeferredOperationKHR,
21322 _p_info: *const CopyMicromapToMemoryInfoEXT,
21323 ) -> Result {
21324 panic!(concat!(
21325 "Unable to load ",
21326 stringify!(copy_micromap_to_memory_ext)
21327 ))
21328 }
21329 let cname =
21330 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMicromapToMemoryEXT\0");
21331 let val = _f(cname);
21332 if val.is_null() {
21333 copy_micromap_to_memory_ext
21334 } else {
21335 ::std::mem::transmute(val)
21336 }
21337 },
21338 copy_memory_to_micromap_ext: unsafe {
21339 unsafe extern "system" fn copy_memory_to_micromap_ext(
21340 _device: Device,
21341 _deferred_operation: DeferredOperationKHR,
21342 _p_info: *const CopyMemoryToMicromapInfoEXT,
21343 ) -> Result {
21344 panic!(concat!(
21345 "Unable to load ",
21346 stringify!(copy_memory_to_micromap_ext)
21347 ))
21348 }
21349 let cname =
21350 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCopyMemoryToMicromapEXT\0");
21351 let val = _f(cname);
21352 if val.is_null() {
21353 copy_memory_to_micromap_ext
21354 } else {
21355 ::std::mem::transmute(val)
21356 }
21357 },
21358 write_micromaps_properties_ext: unsafe {
21359 unsafe extern "system" fn write_micromaps_properties_ext(
21360 _device: Device,
21361 _micromap_count: u32,
21362 _p_micromaps: *const MicromapEXT,
21363 _query_type: QueryType,
21364 _data_size: usize,
21365 _p_data: *mut c_void,
21366 _stride: usize,
21367 ) -> Result {
21368 panic!(concat!(
21369 "Unable to load ",
21370 stringify!(write_micromaps_properties_ext)
21371 ))
21372 }
21373 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21374 b"vkWriteMicromapsPropertiesEXT\0",
21375 );
21376 let val = _f(cname);
21377 if val.is_null() {
21378 write_micromaps_properties_ext
21379 } else {
21380 ::std::mem::transmute(val)
21381 }
21382 },
21383 cmd_copy_micromap_ext: unsafe {
21384 unsafe extern "system" fn cmd_copy_micromap_ext(
21385 _command_buffer: CommandBuffer,
21386 _p_info: *const CopyMicromapInfoEXT,
21387 ) {
21388 panic!(concat!(
21389 "Unable to load ",
21390 stringify!(cmd_copy_micromap_ext)
21391 ))
21392 }
21393 let cname =
21394 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMicromapEXT\0");
21395 let val = _f(cname);
21396 if val.is_null() {
21397 cmd_copy_micromap_ext
21398 } else {
21399 ::std::mem::transmute(val)
21400 }
21401 },
21402 cmd_copy_micromap_to_memory_ext: unsafe {
21403 unsafe extern "system" fn cmd_copy_micromap_to_memory_ext(
21404 _command_buffer: CommandBuffer,
21405 _p_info: *const CopyMicromapToMemoryInfoEXT,
21406 ) {
21407 panic!(concat!(
21408 "Unable to load ",
21409 stringify!(cmd_copy_micromap_to_memory_ext)
21410 ))
21411 }
21412 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21413 b"vkCmdCopyMicromapToMemoryEXT\0",
21414 );
21415 let val = _f(cname);
21416 if val.is_null() {
21417 cmd_copy_micromap_to_memory_ext
21418 } else {
21419 ::std::mem::transmute(val)
21420 }
21421 },
21422 cmd_copy_memory_to_micromap_ext: unsafe {
21423 unsafe extern "system" fn cmd_copy_memory_to_micromap_ext(
21424 _command_buffer: CommandBuffer,
21425 _p_info: *const CopyMemoryToMicromapInfoEXT,
21426 ) {
21427 panic!(concat!(
21428 "Unable to load ",
21429 stringify!(cmd_copy_memory_to_micromap_ext)
21430 ))
21431 }
21432 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21433 b"vkCmdCopyMemoryToMicromapEXT\0",
21434 );
21435 let val = _f(cname);
21436 if val.is_null() {
21437 cmd_copy_memory_to_micromap_ext
21438 } else {
21439 ::std::mem::transmute(val)
21440 }
21441 },
21442 cmd_write_micromaps_properties_ext: unsafe {
21443 unsafe extern "system" fn cmd_write_micromaps_properties_ext(
21444 _command_buffer: CommandBuffer,
21445 _micromap_count: u32,
21446 _p_micromaps: *const MicromapEXT,
21447 _query_type: QueryType,
21448 _query_pool: QueryPool,
21449 _first_query: u32,
21450 ) {
21451 panic!(concat!(
21452 "Unable to load ",
21453 stringify!(cmd_write_micromaps_properties_ext)
21454 ))
21455 }
21456 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21457 b"vkCmdWriteMicromapsPropertiesEXT\0",
21458 );
21459 let val = _f(cname);
21460 if val.is_null() {
21461 cmd_write_micromaps_properties_ext
21462 } else {
21463 ::std::mem::transmute(val)
21464 }
21465 },
21466 get_device_micromap_compatibility_ext: unsafe {
21467 unsafe extern "system" fn get_device_micromap_compatibility_ext(
21468 _device: Device,
21469 _p_version_info: *const MicromapVersionInfoEXT,
21470 _p_compatibility: *mut AccelerationStructureCompatibilityKHR,
21471 ) {
21472 panic!(concat!(
21473 "Unable to load ",
21474 stringify!(get_device_micromap_compatibility_ext)
21475 ))
21476 }
21477 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21478 b"vkGetDeviceMicromapCompatibilityEXT\0",
21479 );
21480 let val = _f(cname);
21481 if val.is_null() {
21482 get_device_micromap_compatibility_ext
21483 } else {
21484 ::std::mem::transmute(val)
21485 }
21486 },
21487 get_micromap_build_sizes_ext: unsafe {
21488 unsafe extern "system" fn get_micromap_build_sizes_ext(
21489 _device: Device,
21490 _build_type: AccelerationStructureBuildTypeKHR,
21491 _p_build_info: *const MicromapBuildInfoEXT,
21492 _p_size_info: *mut MicromapBuildSizesInfoEXT,
21493 ) {
21494 panic!(concat!(
21495 "Unable to load ",
21496 stringify!(get_micromap_build_sizes_ext)
21497 ))
21498 }
21499 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21500 b"vkGetMicromapBuildSizesEXT\0",
21501 );
21502 let val = _f(cname);
21503 if val.is_null() {
21504 get_micromap_build_sizes_ext
21505 } else {
21506 ::std::mem::transmute(val)
21507 }
21508 },
21509 }
21510 }
21511}
21512#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21513impl AccessFlags2 {
21514 pub const MICROMAP_READ_EXT: Self =
21515 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
21516 pub const MICROMAP_WRITE_EXT: Self =
21517 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
21518}
21519#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21520impl BufferUsageFlags {
21521 pub const MICROMAP_BUILD_INPUT_READ_ONLY_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
21522 pub const MICROMAP_STORAGE_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
21523}
21524#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21525impl BuildAccelerationStructureFlagsKHR {
21526 pub const ALLOW_OPACITY_MICROMAP_UPDATE_EXT: Self = Self(0b100_0000);
21527 pub const ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b1000_0000);
21528 pub const ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: Self = Self(0b1_0000_0000);
21529}
21530#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21531impl GeometryInstanceFlagsKHR {
21532 pub const FORCE_OPACITY_MICROMAP_2_STATE_EXT: Self = Self(0b1_0000);
21533 pub const DISABLE_OPACITY_MICROMAPS_EXT: Self = Self(0b10_0000);
21534}
21535#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21536impl ObjectType {
21537 pub const MICROMAP_EXT: Self = Self(1_000_396_000);
21538}
21539#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21540impl PipelineCreateFlags {
21541 pub const RAY_TRACING_OPACITY_MICROMAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
21542}
21543#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21544impl PipelineStageFlags2 {
21545 pub const MICROMAP_BUILD_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000);
21546}
21547#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21548impl QueryType {
21549 pub const MICROMAP_SERIALIZATION_SIZE_EXT: Self = Self(1_000_396_000);
21550 pub const MICROMAP_COMPACTED_SIZE_EXT: Self = Self(1_000_396_001);
21551}
21552#[doc = "Generated from 'VK_EXT_opacity_micromap'"]
21553impl StructureType {
21554 pub const MICROMAP_BUILD_INFO_EXT: Self = Self(1_000_396_000);
21555 pub const MICROMAP_VERSION_INFO_EXT: Self = Self(1_000_396_001);
21556 pub const COPY_MICROMAP_INFO_EXT: Self = Self(1_000_396_002);
21557 pub const COPY_MICROMAP_TO_MEMORY_INFO_EXT: Self = Self(1_000_396_003);
21558 pub const COPY_MEMORY_TO_MICROMAP_INFO_EXT: Self = Self(1_000_396_004);
21559 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: Self = Self(1_000_396_005);
21560 pub const PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: Self = Self(1_000_396_006);
21561 pub const MICROMAP_CREATE_INFO_EXT: Self = Self(1_000_396_007);
21562 pub const MICROMAP_BUILD_SIZES_INFO_EXT: Self = Self(1_000_396_008);
21563 pub const ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: Self = Self(1_000_396_009);
21564}
21565impl NvDisplacementMicromapFn {
21566 #[inline]
21567 pub const fn name() -> &'static ::std::ffi::CStr {
21568 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_displacement_micromap\0") }
21569 }
21570 pub const SPEC_VERSION: u32 = 1u32;
21571}
21572#[derive(Clone)]
21573pub struct NvDisplacementMicromapFn {}
21574unsafe impl Send for NvDisplacementMicromapFn {}
21575unsafe impl Sync for NvDisplacementMicromapFn {}
21576impl NvDisplacementMicromapFn {
21577 pub fn load<F>(mut _f: F) -> Self
21578 where
21579 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21580 {
21581 Self {}
21582 }
21583}
21584#[doc = "Generated from 'VK_NV_displacement_micromap'"]
21585impl BuildAccelerationStructureFlagsKHR {
21586 pub const ALLOW_DISPLACEMENT_MICROMAP_UPDATE_NV: Self = Self(0b10_0000_0000);
21587}
21588#[doc = "Generated from 'VK_NV_displacement_micromap'"]
21589impl MicromapTypeEXT {
21590 pub const DISPLACEMENT_MICROMAP_NV: Self = Self(1_000_397_000);
21591}
21592#[doc = "Generated from 'VK_NV_displacement_micromap'"]
21593impl PipelineCreateFlags {
21594 pub const RAY_TRACING_DISPLACEMENT_MICROMAP_NV: Self =
21595 Self(0b1_0000_0000_0000_0000_0000_0000_0000);
21596}
21597#[doc = "Generated from 'VK_NV_displacement_micromap'"]
21598impl StructureType {
21599 pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_FEATURES_NV: Self = Self(1_000_397_000);
21600 pub const PHYSICAL_DEVICE_DISPLACEMENT_MICROMAP_PROPERTIES_NV: Self = Self(1_000_397_001);
21601 pub const ACCELERATION_STRUCTURE_TRIANGLES_DISPLACEMENT_MICROMAP_NV: Self = Self(1_000_397_002);
21602}
21603impl JuiceExtension399Fn {
21604 #[inline]
21605 pub const fn name() -> &'static ::std::ffi::CStr {
21606 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_399\0") }
21607 }
21608 pub const SPEC_VERSION: u32 = 0u32;
21609}
21610#[derive(Clone)]
21611pub struct JuiceExtension399Fn {}
21612unsafe impl Send for JuiceExtension399Fn {}
21613unsafe impl Sync for JuiceExtension399Fn {}
21614impl JuiceExtension399Fn {
21615 pub fn load<F>(mut _f: F) -> Self
21616 where
21617 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21618 {
21619 Self {}
21620 }
21621}
21622impl JuiceExtension400Fn {
21623 #[inline]
21624 pub const fn name() -> &'static ::std::ffi::CStr {
21625 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_400\0") }
21626 }
21627 pub const SPEC_VERSION: u32 = 0u32;
21628}
21629#[derive(Clone)]
21630pub struct JuiceExtension400Fn {}
21631unsafe impl Send for JuiceExtension400Fn {}
21632unsafe impl Sync for JuiceExtension400Fn {}
21633impl JuiceExtension400Fn {
21634 pub fn load<F>(mut _f: F) -> Self
21635 where
21636 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21637 {
21638 Self {}
21639 }
21640}
21641impl ExtLoadStoreOpNoneFn {
21642 #[inline]
21643 pub const fn name() -> &'static ::std::ffi::CStr {
21644 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_load_store_op_none\0") }
21645 }
21646 pub const SPEC_VERSION: u32 = 1u32;
21647}
21648#[derive(Clone)]
21649pub struct ExtLoadStoreOpNoneFn {}
21650unsafe impl Send for ExtLoadStoreOpNoneFn {}
21651unsafe impl Sync for ExtLoadStoreOpNoneFn {}
21652impl ExtLoadStoreOpNoneFn {
21653 pub fn load<F>(mut _f: F) -> Self
21654 where
21655 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21656 {
21657 Self {}
21658 }
21659}
21660#[doc = "Generated from 'VK_EXT_load_store_op_none'"]
21661impl AttachmentLoadOp {
21662 pub const NONE_EXT: Self = Self(1_000_400_000);
21663}
21664#[doc = "Generated from 'VK_EXT_load_store_op_none'"]
21665impl AttachmentStoreOp {
21666 pub const NONE_EXT: Self = Self::NONE;
21667}
21668impl FbExtension402Fn {
21669 #[inline]
21670 pub const fn name() -> &'static ::std::ffi::CStr {
21671 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_402\0") }
21672 }
21673 pub const SPEC_VERSION: u32 = 0u32;
21674}
21675#[derive(Clone)]
21676pub struct FbExtension402Fn {}
21677unsafe impl Send for FbExtension402Fn {}
21678unsafe impl Sync for FbExtension402Fn {}
21679impl FbExtension402Fn {
21680 pub fn load<F>(mut _f: F) -> Self
21681 where
21682 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21683 {
21684 Self {}
21685 }
21686}
21687impl FbExtension403Fn {
21688 #[inline]
21689 pub const fn name() -> &'static ::std::ffi::CStr {
21690 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_403\0") }
21691 }
21692 pub const SPEC_VERSION: u32 = 0u32;
21693}
21694#[derive(Clone)]
21695pub struct FbExtension403Fn {}
21696unsafe impl Send for FbExtension403Fn {}
21697unsafe impl Sync for FbExtension403Fn {}
21698impl FbExtension403Fn {
21699 pub fn load<F>(mut _f: F) -> Self
21700 where
21701 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21702 {
21703 Self {}
21704 }
21705}
21706impl FbExtension404Fn {
21707 #[inline]
21708 pub const fn name() -> &'static ::std::ffi::CStr {
21709 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_404\0") }
21710 }
21711 pub const SPEC_VERSION: u32 = 0u32;
21712}
21713#[derive(Clone)]
21714pub struct FbExtension404Fn {}
21715unsafe impl Send for FbExtension404Fn {}
21716unsafe impl Sync for FbExtension404Fn {}
21717impl FbExtension404Fn {
21718 pub fn load<F>(mut _f: F) -> Self
21719 where
21720 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21721 {
21722 Self {}
21723 }
21724}
21725impl HuaweiClusterCullingShaderFn {
21726 #[inline]
21727 pub const fn name() -> &'static ::std::ffi::CStr {
21728 unsafe {
21729 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_cluster_culling_shader\0")
21730 }
21731 }
21732 pub const SPEC_VERSION: u32 = 2u32;
21733}
21734#[allow(non_camel_case_types)]
21735pub type PFN_vkCmdDrawClusterHUAWEI = unsafe extern "system" fn(
21736 command_buffer: CommandBuffer,
21737 group_count_x: u32,
21738 group_count_y: u32,
21739 group_count_z: u32,
21740);
21741#[allow(non_camel_case_types)]
21742pub type PFN_vkCmdDrawClusterIndirectHUAWEI =
21743 unsafe extern "system" fn(command_buffer: CommandBuffer, buffer: Buffer, offset: DeviceSize);
21744#[derive(Clone)]
21745pub struct HuaweiClusterCullingShaderFn {
21746 pub cmd_draw_cluster_huawei: PFN_vkCmdDrawClusterHUAWEI,
21747 pub cmd_draw_cluster_indirect_huawei: PFN_vkCmdDrawClusterIndirectHUAWEI,
21748}
21749unsafe impl Send for HuaweiClusterCullingShaderFn {}
21750unsafe impl Sync for HuaweiClusterCullingShaderFn {}
21751impl HuaweiClusterCullingShaderFn {
21752 pub fn load<F>(mut _f: F) -> Self
21753 where
21754 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21755 {
21756 Self {
21757 cmd_draw_cluster_huawei: unsafe {
21758 unsafe extern "system" fn cmd_draw_cluster_huawei(
21759 _command_buffer: CommandBuffer,
21760 _group_count_x: u32,
21761 _group_count_y: u32,
21762 _group_count_z: u32,
21763 ) {
21764 panic!(concat!(
21765 "Unable to load ",
21766 stringify!(cmd_draw_cluster_huawei)
21767 ))
21768 }
21769 let cname =
21770 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawClusterHUAWEI\0");
21771 let val = _f(cname);
21772 if val.is_null() {
21773 cmd_draw_cluster_huawei
21774 } else {
21775 ::std::mem::transmute(val)
21776 }
21777 },
21778 cmd_draw_cluster_indirect_huawei: unsafe {
21779 unsafe extern "system" fn cmd_draw_cluster_indirect_huawei(
21780 _command_buffer: CommandBuffer,
21781 _buffer: Buffer,
21782 _offset: DeviceSize,
21783 ) {
21784 panic!(concat!(
21785 "Unable to load ",
21786 stringify!(cmd_draw_cluster_indirect_huawei)
21787 ))
21788 }
21789 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21790 b"vkCmdDrawClusterIndirectHUAWEI\0",
21791 );
21792 let val = _f(cname);
21793 if val.is_null() {
21794 cmd_draw_cluster_indirect_huawei
21795 } else {
21796 ::std::mem::transmute(val)
21797 }
21798 },
21799 }
21800 }
21801}
21802#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
21803impl PipelineStageFlags2 {
21804 pub const CLUSTER_CULLING_SHADER_HUAWEI: Self =
21805 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
21806}
21807#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
21808impl QueryPipelineStatisticFlags {
21809 pub const CLUSTER_CULLING_SHADER_INVOCATIONS_HUAWEI: Self = Self(0b10_0000_0000_0000);
21810}
21811#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
21812impl ShaderStageFlags {
21813 pub const CLUSTER_CULLING_HUAWEI: Self = Self(0b1000_0000_0000_0000_0000);
21814}
21815#[doc = "Generated from 'VK_HUAWEI_cluster_culling_shader'"]
21816impl StructureType {
21817 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: Self = Self(1_000_404_000);
21818 pub const PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: Self = Self(1_000_404_001);
21819}
21820impl HuaweiExtension406Fn {
21821 #[inline]
21822 pub const fn name() -> &'static ::std::ffi::CStr {
21823 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_406\0") }
21824 }
21825 pub const SPEC_VERSION: u32 = 0u32;
21826}
21827#[derive(Clone)]
21828pub struct HuaweiExtension406Fn {}
21829unsafe impl Send for HuaweiExtension406Fn {}
21830unsafe impl Sync for HuaweiExtension406Fn {}
21831impl HuaweiExtension406Fn {
21832 pub fn load<F>(mut _f: F) -> Self
21833 where
21834 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21835 {
21836 Self {}
21837 }
21838}
21839impl GgpExtension407Fn {
21840 #[inline]
21841 pub const fn name() -> &'static ::std::ffi::CStr {
21842 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_407\0") }
21843 }
21844 pub const SPEC_VERSION: u32 = 0u32;
21845}
21846#[derive(Clone)]
21847pub struct GgpExtension407Fn {}
21848unsafe impl Send for GgpExtension407Fn {}
21849unsafe impl Sync for GgpExtension407Fn {}
21850impl GgpExtension407Fn {
21851 pub fn load<F>(mut _f: F) -> Self
21852 where
21853 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21854 {
21855 Self {}
21856 }
21857}
21858impl GgpExtension408Fn {
21859 #[inline]
21860 pub const fn name() -> &'static ::std::ffi::CStr {
21861 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_408\0") }
21862 }
21863 pub const SPEC_VERSION: u32 = 0u32;
21864}
21865#[derive(Clone)]
21866pub struct GgpExtension408Fn {}
21867unsafe impl Send for GgpExtension408Fn {}
21868unsafe impl Sync for GgpExtension408Fn {}
21869impl GgpExtension408Fn {
21870 pub fn load<F>(mut _f: F) -> Self
21871 where
21872 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21873 {
21874 Self {}
21875 }
21876}
21877impl GgpExtension409Fn {
21878 #[inline]
21879 pub const fn name() -> &'static ::std::ffi::CStr {
21880 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_409\0") }
21881 }
21882 pub const SPEC_VERSION: u32 = 0u32;
21883}
21884#[derive(Clone)]
21885pub struct GgpExtension409Fn {}
21886unsafe impl Send for GgpExtension409Fn {}
21887unsafe impl Sync for GgpExtension409Fn {}
21888impl GgpExtension409Fn {
21889 pub fn load<F>(mut _f: F) -> Self
21890 where
21891 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21892 {
21893 Self {}
21894 }
21895}
21896impl GgpExtension410Fn {
21897 #[inline]
21898 pub const fn name() -> &'static ::std::ffi::CStr {
21899 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_410\0") }
21900 }
21901 pub const SPEC_VERSION: u32 = 0u32;
21902}
21903#[derive(Clone)]
21904pub struct GgpExtension410Fn {}
21905unsafe impl Send for GgpExtension410Fn {}
21906unsafe impl Sync for GgpExtension410Fn {}
21907impl GgpExtension410Fn {
21908 pub fn load<F>(mut _f: F) -> Self
21909 where
21910 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21911 {
21912 Self {}
21913 }
21914}
21915impl GgpExtension411Fn {
21916 #[inline]
21917 pub const fn name() -> &'static ::std::ffi::CStr {
21918 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_411\0") }
21919 }
21920 pub const SPEC_VERSION: u32 = 0u32;
21921}
21922#[derive(Clone)]
21923pub struct GgpExtension411Fn {}
21924unsafe impl Send for GgpExtension411Fn {}
21925unsafe impl Sync for GgpExtension411Fn {}
21926impl GgpExtension411Fn {
21927 pub fn load<F>(mut _f: F) -> Self
21928 where
21929 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21930 {
21931 Self {}
21932 }
21933}
21934impl ExtBorderColorSwizzleFn {
21935 #[inline]
21936 pub const fn name() -> &'static ::std::ffi::CStr {
21937 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_border_color_swizzle\0") }
21938 }
21939 pub const SPEC_VERSION: u32 = 1u32;
21940}
21941#[derive(Clone)]
21942pub struct ExtBorderColorSwizzleFn {}
21943unsafe impl Send for ExtBorderColorSwizzleFn {}
21944unsafe impl Sync for ExtBorderColorSwizzleFn {}
21945impl ExtBorderColorSwizzleFn {
21946 pub fn load<F>(mut _f: F) -> Self
21947 where
21948 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21949 {
21950 Self {}
21951 }
21952}
21953#[doc = "Generated from 'VK_EXT_border_color_swizzle'"]
21954impl StructureType {
21955 pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1_000_411_000);
21956 pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: Self = Self(1_000_411_001);
21957}
21958impl ExtPageableDeviceLocalMemoryFn {
21959 #[inline]
21960 pub const fn name() -> &'static ::std::ffi::CStr {
21961 unsafe {
21962 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21963 b"VK_EXT_pageable_device_local_memory\0",
21964 )
21965 }
21966 }
21967 pub const SPEC_VERSION: u32 = 1u32;
21968}
21969#[allow(non_camel_case_types)]
21970pub type PFN_vkSetDeviceMemoryPriorityEXT =
21971 unsafe extern "system" fn(device: Device, memory: DeviceMemory, priority: f32);
21972#[derive(Clone)]
21973pub struct ExtPageableDeviceLocalMemoryFn {
21974 pub set_device_memory_priority_ext: PFN_vkSetDeviceMemoryPriorityEXT,
21975}
21976unsafe impl Send for ExtPageableDeviceLocalMemoryFn {}
21977unsafe impl Sync for ExtPageableDeviceLocalMemoryFn {}
21978impl ExtPageableDeviceLocalMemoryFn {
21979 pub fn load<F>(mut _f: F) -> Self
21980 where
21981 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21982 {
21983 Self {
21984 set_device_memory_priority_ext: unsafe {
21985 unsafe extern "system" fn set_device_memory_priority_ext(
21986 _device: Device,
21987 _memory: DeviceMemory,
21988 _priority: f32,
21989 ) {
21990 panic!(concat!(
21991 "Unable to load ",
21992 stringify!(set_device_memory_priority_ext)
21993 ))
21994 }
21995 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
21996 b"vkSetDeviceMemoryPriorityEXT\0",
21997 );
21998 let val = _f(cname);
21999 if val.is_null() {
22000 set_device_memory_priority_ext
22001 } else {
22002 ::std::mem::transmute(val)
22003 }
22004 },
22005 }
22006 }
22007}
22008#[doc = "Generated from 'VK_EXT_pageable_device_local_memory'"]
22009impl StructureType {
22010 pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self(1_000_412_000);
22011}
22012impl KhrMaintenance4Fn {
22013 #[inline]
22014 pub const fn name() -> &'static ::std::ffi::CStr {
22015 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance4\0") }
22016 }
22017 pub const SPEC_VERSION: u32 = 2u32;
22018}
22019#[allow(non_camel_case_types)]
22020pub type PFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn(
22021 device: Device,
22022 p_info: *const DeviceBufferMemoryRequirements,
22023 p_memory_requirements: *mut MemoryRequirements2,
22024);
22025#[allow(non_camel_case_types)]
22026pub type PFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn(
22027 device: Device,
22028 p_info: *const DeviceImageMemoryRequirements,
22029 p_memory_requirements: *mut MemoryRequirements2,
22030);
22031#[allow(non_camel_case_types)]
22032pub type PFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn(
22033 device: Device,
22034 p_info: *const DeviceImageMemoryRequirements,
22035 p_sparse_memory_requirement_count: *mut u32,
22036 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
22037);
22038#[derive(Clone)]
22039pub struct KhrMaintenance4Fn {
22040 pub get_device_buffer_memory_requirements_khr: PFN_vkGetDeviceBufferMemoryRequirements,
22041 pub get_device_image_memory_requirements_khr: PFN_vkGetDeviceImageMemoryRequirements,
22042 pub get_device_image_sparse_memory_requirements_khr:
22043 PFN_vkGetDeviceImageSparseMemoryRequirements,
22044}
22045unsafe impl Send for KhrMaintenance4Fn {}
22046unsafe impl Sync for KhrMaintenance4Fn {}
22047impl KhrMaintenance4Fn {
22048 pub fn load<F>(mut _f: F) -> Self
22049 where
22050 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22051 {
22052 Self {
22053 get_device_buffer_memory_requirements_khr: unsafe {
22054 unsafe extern "system" fn get_device_buffer_memory_requirements_khr(
22055 _device: Device,
22056 _p_info: *const DeviceBufferMemoryRequirements,
22057 _p_memory_requirements: *mut MemoryRequirements2,
22058 ) {
22059 panic!(concat!(
22060 "Unable to load ",
22061 stringify!(get_device_buffer_memory_requirements_khr)
22062 ))
22063 }
22064 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22065 b"vkGetDeviceBufferMemoryRequirementsKHR\0",
22066 );
22067 let val = _f(cname);
22068 if val.is_null() {
22069 get_device_buffer_memory_requirements_khr
22070 } else {
22071 ::std::mem::transmute(val)
22072 }
22073 },
22074 get_device_image_memory_requirements_khr: unsafe {
22075 unsafe extern "system" fn get_device_image_memory_requirements_khr(
22076 _device: Device,
22077 _p_info: *const DeviceImageMemoryRequirements,
22078 _p_memory_requirements: *mut MemoryRequirements2,
22079 ) {
22080 panic!(concat!(
22081 "Unable to load ",
22082 stringify!(get_device_image_memory_requirements_khr)
22083 ))
22084 }
22085 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22086 b"vkGetDeviceImageMemoryRequirementsKHR\0",
22087 );
22088 let val = _f(cname);
22089 if val.is_null() {
22090 get_device_image_memory_requirements_khr
22091 } else {
22092 ::std::mem::transmute(val)
22093 }
22094 },
22095 get_device_image_sparse_memory_requirements_khr: unsafe {
22096 unsafe extern "system" fn get_device_image_sparse_memory_requirements_khr(
22097 _device: Device,
22098 _p_info: *const DeviceImageMemoryRequirements,
22099 _p_sparse_memory_requirement_count: *mut u32,
22100 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
22101 ) {
22102 panic!(concat!(
22103 "Unable to load ",
22104 stringify!(get_device_image_sparse_memory_requirements_khr)
22105 ))
22106 }
22107 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22108 b"vkGetDeviceImageSparseMemoryRequirementsKHR\0",
22109 );
22110 let val = _f(cname);
22111 if val.is_null() {
22112 get_device_image_sparse_memory_requirements_khr
22113 } else {
22114 ::std::mem::transmute(val)
22115 }
22116 },
22117 }
22118 }
22119}
22120#[doc = "Generated from 'VK_KHR_maintenance4'"]
22121impl ImageAspectFlags {
22122 pub const NONE_KHR: Self = Self::NONE;
22123}
22124#[doc = "Generated from 'VK_KHR_maintenance4'"]
22125impl StructureType {
22126 pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: Self =
22127 Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
22128 pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: Self =
22129 Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
22130 pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS;
22131 pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS;
22132}
22133impl HuaweiExtension415Fn {
22134 #[inline]
22135 pub const fn name() -> &'static ::std::ffi::CStr {
22136 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_415\0") }
22137 }
22138 pub const SPEC_VERSION: u32 = 0u32;
22139}
22140#[derive(Clone)]
22141pub struct HuaweiExtension415Fn {}
22142unsafe impl Send for HuaweiExtension415Fn {}
22143unsafe impl Sync for HuaweiExtension415Fn {}
22144impl HuaweiExtension415Fn {
22145 pub fn load<F>(mut _f: F) -> Self
22146 where
22147 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22148 {
22149 Self {}
22150 }
22151}
22152impl ArmShaderCorePropertiesFn {
22153 #[inline]
22154 pub const fn name() -> &'static ::std::ffi::CStr {
22155 unsafe {
22156 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_shader_core_properties\0")
22157 }
22158 }
22159 pub const SPEC_VERSION: u32 = 1u32;
22160}
22161#[derive(Clone)]
22162pub struct ArmShaderCorePropertiesFn {}
22163unsafe impl Send for ArmShaderCorePropertiesFn {}
22164unsafe impl Sync for ArmShaderCorePropertiesFn {}
22165impl ArmShaderCorePropertiesFn {
22166 pub fn load<F>(mut _f: F) -> Self
22167 where
22168 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22169 {
22170 Self {}
22171 }
22172}
22173#[doc = "Generated from 'VK_ARM_shader_core_properties'"]
22174impl StructureType {
22175 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: Self = Self(1_000_415_000);
22176}
22177impl KhrExtension417Fn {
22178 #[inline]
22179 pub const fn name() -> &'static ::std::ffi::CStr {
22180 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_417\0") }
22181 }
22182 pub const SPEC_VERSION: u32 = 0u32;
22183}
22184#[derive(Clone)]
22185pub struct KhrExtension417Fn {}
22186unsafe impl Send for KhrExtension417Fn {}
22187unsafe impl Sync for KhrExtension417Fn {}
22188impl KhrExtension417Fn {
22189 pub fn load<F>(mut _f: F) -> Self
22190 where
22191 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22192 {
22193 Self {}
22194 }
22195}
22196impl ArmExtension418Fn {
22197 #[inline]
22198 pub const fn name() -> &'static ::std::ffi::CStr {
22199 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_418\0") }
22200 }
22201 pub const SPEC_VERSION: u32 = 0u32;
22202}
22203#[derive(Clone)]
22204pub struct ArmExtension418Fn {}
22205unsafe impl Send for ArmExtension418Fn {}
22206unsafe impl Sync for ArmExtension418Fn {}
22207impl ArmExtension418Fn {
22208 pub fn load<F>(mut _f: F) -> Self
22209 where
22210 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22211 {
22212 Self {}
22213 }
22214}
22215impl ExtImageSlicedViewOf3dFn {
22216 #[inline]
22217 pub const fn name() -> &'static ::std::ffi::CStr {
22218 unsafe {
22219 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_sliced_view_of_3d\0")
22220 }
22221 }
22222 pub const SPEC_VERSION: u32 = 1u32;
22223}
22224#[derive(Clone)]
22225pub struct ExtImageSlicedViewOf3dFn {}
22226unsafe impl Send for ExtImageSlicedViewOf3dFn {}
22227unsafe impl Sync for ExtImageSlicedViewOf3dFn {}
22228impl ExtImageSlicedViewOf3dFn {
22229 pub fn load<F>(mut _f: F) -> Self
22230 where
22231 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22232 {
22233 Self {}
22234 }
22235}
22236#[doc = "Generated from 'VK_EXT_image_sliced_view_of_3d'"]
22237impl StructureType {
22238 pub const PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: Self = Self(1_000_418_000);
22239 pub const IMAGE_VIEW_SLICED_CREATE_INFO_EXT: Self = Self(1_000_418_001);
22240}
22241impl ExtExtension420Fn {
22242 #[inline]
22243 pub const fn name() -> &'static ::std::ffi::CStr {
22244 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_420\0") }
22245 }
22246 pub const SPEC_VERSION: u32 = 0u32;
22247}
22248#[derive(Clone)]
22249pub struct ExtExtension420Fn {}
22250unsafe impl Send for ExtExtension420Fn {}
22251unsafe impl Sync for ExtExtension420Fn {}
22252impl ExtExtension420Fn {
22253 pub fn load<F>(mut _f: F) -> Self
22254 where
22255 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22256 {
22257 Self {}
22258 }
22259}
22260#[doc = "Generated from 'VK_EXT_extension_420'"]
22261impl SwapchainCreateFlagsKHR {
22262 pub const RESERVED_4_EXT: Self = Self(0b1_0000);
22263}
22264impl ValveDescriptorSetHostMappingFn {
22265 #[inline]
22266 pub const fn name() -> &'static ::std::ffi::CStr {
22267 unsafe {
22268 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22269 b"VK_VALVE_descriptor_set_host_mapping\0",
22270 )
22271 }
22272 }
22273 pub const SPEC_VERSION: u32 = 1u32;
22274}
22275#[allow(non_camel_case_types)]
22276pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn(
22277 device: Device,
22278 p_binding_reference: *const DescriptorSetBindingReferenceVALVE,
22279 p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE,
22280);
22281#[allow(non_camel_case_types)]
22282pub type PFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn(
22283 device: Device,
22284 descriptor_set: DescriptorSet,
22285 pp_data: *mut *mut c_void,
22286);
22287#[derive(Clone)]
22288pub struct ValveDescriptorSetHostMappingFn {
22289 pub get_descriptor_set_layout_host_mapping_info_valve:
22290 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
22291 pub get_descriptor_set_host_mapping_valve: PFN_vkGetDescriptorSetHostMappingVALVE,
22292}
22293unsafe impl Send for ValveDescriptorSetHostMappingFn {}
22294unsafe impl Sync for ValveDescriptorSetHostMappingFn {}
22295impl ValveDescriptorSetHostMappingFn {
22296 pub fn load<F>(mut _f: F) -> Self
22297 where
22298 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22299 {
22300 Self {
22301 get_descriptor_set_layout_host_mapping_info_valve: unsafe {
22302 unsafe extern "system" fn get_descriptor_set_layout_host_mapping_info_valve(
22303 _device: Device,
22304 _p_binding_reference: *const DescriptorSetBindingReferenceVALVE,
22305 _p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE,
22306 ) {
22307 panic!(concat!(
22308 "Unable to load ",
22309 stringify!(get_descriptor_set_layout_host_mapping_info_valve)
22310 ))
22311 }
22312 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22313 b"vkGetDescriptorSetLayoutHostMappingInfoVALVE\0",
22314 );
22315 let val = _f(cname);
22316 if val.is_null() {
22317 get_descriptor_set_layout_host_mapping_info_valve
22318 } else {
22319 ::std::mem::transmute(val)
22320 }
22321 },
22322 get_descriptor_set_host_mapping_valve: unsafe {
22323 unsafe extern "system" fn get_descriptor_set_host_mapping_valve(
22324 _device: Device,
22325 _descriptor_set: DescriptorSet,
22326 _pp_data: *mut *mut c_void,
22327 ) {
22328 panic!(concat!(
22329 "Unable to load ",
22330 stringify!(get_descriptor_set_host_mapping_valve)
22331 ))
22332 }
22333 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22334 b"vkGetDescriptorSetHostMappingVALVE\0",
22335 );
22336 let val = _f(cname);
22337 if val.is_null() {
22338 get_descriptor_set_host_mapping_valve
22339 } else {
22340 ::std::mem::transmute(val)
22341 }
22342 },
22343 }
22344 }
22345}
22346#[doc = "Generated from 'VK_VALVE_descriptor_set_host_mapping'"]
22347impl StructureType {
22348 pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self =
22349 Self(1_000_420_000);
22350 pub const DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: Self = Self(1_000_420_001);
22351 pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: Self = Self(1_000_420_002);
22352}
22353impl ExtDepthClampZeroOneFn {
22354 #[inline]
22355 pub const fn name() -> &'static ::std::ffi::CStr {
22356 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clamp_zero_one\0") }
22357 }
22358 pub const SPEC_VERSION: u32 = 1u32;
22359}
22360#[derive(Clone)]
22361pub struct ExtDepthClampZeroOneFn {}
22362unsafe impl Send for ExtDepthClampZeroOneFn {}
22363unsafe impl Sync for ExtDepthClampZeroOneFn {}
22364impl ExtDepthClampZeroOneFn {
22365 pub fn load<F>(mut _f: F) -> Self
22366 where
22367 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22368 {
22369 Self {}
22370 }
22371}
22372#[doc = "Generated from 'VK_EXT_depth_clamp_zero_one'"]
22373impl StructureType {
22374 pub const PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: Self = Self(1_000_421_000);
22375}
22376impl ExtNonSeamlessCubeMapFn {
22377 #[inline]
22378 pub const fn name() -> &'static ::std::ffi::CStr {
22379 unsafe {
22380 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_non_seamless_cube_map\0")
22381 }
22382 }
22383 pub const SPEC_VERSION: u32 = 1u32;
22384}
22385#[derive(Clone)]
22386pub struct ExtNonSeamlessCubeMapFn {}
22387unsafe impl Send for ExtNonSeamlessCubeMapFn {}
22388unsafe impl Sync for ExtNonSeamlessCubeMapFn {}
22389impl ExtNonSeamlessCubeMapFn {
22390 pub fn load<F>(mut _f: F) -> Self
22391 where
22392 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22393 {
22394 Self {}
22395 }
22396}
22397#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"]
22398impl SamplerCreateFlags {
22399 pub const NON_SEAMLESS_CUBE_MAP_EXT: Self = Self(0b100);
22400}
22401#[doc = "Generated from 'VK_EXT_non_seamless_cube_map'"]
22402impl StructureType {
22403 pub const PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: Self = Self(1_000_422_000);
22404}
22405impl ArmExtension424Fn {
22406 #[inline]
22407 pub const fn name() -> &'static ::std::ffi::CStr {
22408 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_424\0") }
22409 }
22410 pub const SPEC_VERSION: u32 = 0u32;
22411}
22412#[derive(Clone)]
22413pub struct ArmExtension424Fn {}
22414unsafe impl Send for ArmExtension424Fn {}
22415unsafe impl Sync for ArmExtension424Fn {}
22416impl ArmExtension424Fn {
22417 pub fn load<F>(mut _f: F) -> Self
22418 where
22419 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22420 {
22421 Self {}
22422 }
22423}
22424impl ArmExtension425Fn {
22425 #[inline]
22426 pub const fn name() -> &'static ::std::ffi::CStr {
22427 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_425\0") }
22428 }
22429 pub const SPEC_VERSION: u32 = 0u32;
22430}
22431#[derive(Clone)]
22432pub struct ArmExtension425Fn {}
22433unsafe impl Send for ArmExtension425Fn {}
22434unsafe impl Sync for ArmExtension425Fn {}
22435impl ArmExtension425Fn {
22436 pub fn load<F>(mut _f: F) -> Self
22437 where
22438 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22439 {
22440 Self {}
22441 }
22442}
22443impl QcomFragmentDensityMapOffsetFn {
22444 #[inline]
22445 pub const fn name() -> &'static ::std::ffi::CStr {
22446 unsafe {
22447 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22448 b"VK_QCOM_fragment_density_map_offset\0",
22449 )
22450 }
22451 }
22452 pub const SPEC_VERSION: u32 = 1u32;
22453}
22454#[derive(Clone)]
22455pub struct QcomFragmentDensityMapOffsetFn {}
22456unsafe impl Send for QcomFragmentDensityMapOffsetFn {}
22457unsafe impl Sync for QcomFragmentDensityMapOffsetFn {}
22458impl QcomFragmentDensityMapOffsetFn {
22459 pub fn load<F>(mut _f: F) -> Self
22460 where
22461 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22462 {
22463 Self {}
22464 }
22465}
22466#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"]
22467impl ImageCreateFlags {
22468 pub const FRAGMENT_DENSITY_MAP_OFFSET_QCOM: Self = Self(0b1000_0000_0000_0000);
22469}
22470#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"]
22471impl StructureType {
22472 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: Self = Self(1_000_425_000);
22473 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: Self =
22474 Self(1_000_425_001);
22475 pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1_000_425_002);
22476}
22477impl NvCopyMemoryIndirectFn {
22478 #[inline]
22479 pub const fn name() -> &'static ::std::ffi::CStr {
22480 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_copy_memory_indirect\0") }
22481 }
22482 pub const SPEC_VERSION: u32 = 1u32;
22483}
22484#[allow(non_camel_case_types)]
22485pub type PFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn(
22486 command_buffer: CommandBuffer,
22487 copy_buffer_address: DeviceAddress,
22488 copy_count: u32,
22489 stride: u32,
22490);
22491#[allow(non_camel_case_types)]
22492pub type PFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn(
22493 command_buffer: CommandBuffer,
22494 copy_buffer_address: DeviceAddress,
22495 copy_count: u32,
22496 stride: u32,
22497 dst_image: Image,
22498 dst_image_layout: ImageLayout,
22499 p_image_subresources: *const ImageSubresourceLayers,
22500);
22501#[derive(Clone)]
22502pub struct NvCopyMemoryIndirectFn {
22503 pub cmd_copy_memory_indirect_nv: PFN_vkCmdCopyMemoryIndirectNV,
22504 pub cmd_copy_memory_to_image_indirect_nv: PFN_vkCmdCopyMemoryToImageIndirectNV,
22505}
22506unsafe impl Send for NvCopyMemoryIndirectFn {}
22507unsafe impl Sync for NvCopyMemoryIndirectFn {}
22508impl NvCopyMemoryIndirectFn {
22509 pub fn load<F>(mut _f: F) -> Self
22510 where
22511 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22512 {
22513 Self {
22514 cmd_copy_memory_indirect_nv: unsafe {
22515 unsafe extern "system" fn cmd_copy_memory_indirect_nv(
22516 _command_buffer: CommandBuffer,
22517 _copy_buffer_address: DeviceAddress,
22518 _copy_count: u32,
22519 _stride: u32,
22520 ) {
22521 panic!(concat!(
22522 "Unable to load ",
22523 stringify!(cmd_copy_memory_indirect_nv)
22524 ))
22525 }
22526 let cname =
22527 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyMemoryIndirectNV\0");
22528 let val = _f(cname);
22529 if val.is_null() {
22530 cmd_copy_memory_indirect_nv
22531 } else {
22532 ::std::mem::transmute(val)
22533 }
22534 },
22535 cmd_copy_memory_to_image_indirect_nv: unsafe {
22536 unsafe extern "system" fn cmd_copy_memory_to_image_indirect_nv(
22537 _command_buffer: CommandBuffer,
22538 _copy_buffer_address: DeviceAddress,
22539 _copy_count: u32,
22540 _stride: u32,
22541 _dst_image: Image,
22542 _dst_image_layout: ImageLayout,
22543 _p_image_subresources: *const ImageSubresourceLayers,
22544 ) {
22545 panic!(concat!(
22546 "Unable to load ",
22547 stringify!(cmd_copy_memory_to_image_indirect_nv)
22548 ))
22549 }
22550 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22551 b"vkCmdCopyMemoryToImageIndirectNV\0",
22552 );
22553 let val = _f(cname);
22554 if val.is_null() {
22555 cmd_copy_memory_to_image_indirect_nv
22556 } else {
22557 ::std::mem::transmute(val)
22558 }
22559 },
22560 }
22561 }
22562}
22563#[doc = "Generated from 'VK_NV_copy_memory_indirect'"]
22564impl StructureType {
22565 pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: Self = Self(1_000_426_000);
22566 pub const PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: Self = Self(1_000_426_001);
22567}
22568impl NvMemoryDecompressionFn {
22569 #[inline]
22570 pub const fn name() -> &'static ::std::ffi::CStr {
22571 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_memory_decompression\0") }
22572 }
22573 pub const SPEC_VERSION: u32 = 1u32;
22574}
22575#[allow(non_camel_case_types)]
22576pub type PFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn(
22577 command_buffer: CommandBuffer,
22578 decompress_region_count: u32,
22579 p_decompress_memory_regions: *const DecompressMemoryRegionNV,
22580);
22581#[allow(non_camel_case_types)]
22582pub type PFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn(
22583 command_buffer: CommandBuffer,
22584 indirect_commands_address: DeviceAddress,
22585 indirect_commands_count_address: DeviceAddress,
22586 stride: u32,
22587);
22588#[derive(Clone)]
22589pub struct NvMemoryDecompressionFn {
22590 pub cmd_decompress_memory_nv: PFN_vkCmdDecompressMemoryNV,
22591 pub cmd_decompress_memory_indirect_count_nv: PFN_vkCmdDecompressMemoryIndirectCountNV,
22592}
22593unsafe impl Send for NvMemoryDecompressionFn {}
22594unsafe impl Sync for NvMemoryDecompressionFn {}
22595impl NvMemoryDecompressionFn {
22596 pub fn load<F>(mut _f: F) -> Self
22597 where
22598 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22599 {
22600 Self {
22601 cmd_decompress_memory_nv: unsafe {
22602 unsafe extern "system" fn cmd_decompress_memory_nv(
22603 _command_buffer: CommandBuffer,
22604 _decompress_region_count: u32,
22605 _p_decompress_memory_regions: *const DecompressMemoryRegionNV,
22606 ) {
22607 panic!(concat!(
22608 "Unable to load ",
22609 stringify!(cmd_decompress_memory_nv)
22610 ))
22611 }
22612 let cname =
22613 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecompressMemoryNV\0");
22614 let val = _f(cname);
22615 if val.is_null() {
22616 cmd_decompress_memory_nv
22617 } else {
22618 ::std::mem::transmute(val)
22619 }
22620 },
22621 cmd_decompress_memory_indirect_count_nv: unsafe {
22622 unsafe extern "system" fn cmd_decompress_memory_indirect_count_nv(
22623 _command_buffer: CommandBuffer,
22624 _indirect_commands_address: DeviceAddress,
22625 _indirect_commands_count_address: DeviceAddress,
22626 _stride: u32,
22627 ) {
22628 panic!(concat!(
22629 "Unable to load ",
22630 stringify!(cmd_decompress_memory_indirect_count_nv)
22631 ))
22632 }
22633 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22634 b"vkCmdDecompressMemoryIndirectCountNV\0",
22635 );
22636 let val = _f(cname);
22637 if val.is_null() {
22638 cmd_decompress_memory_indirect_count_nv
22639 } else {
22640 ::std::mem::transmute(val)
22641 }
22642 },
22643 }
22644 }
22645}
22646#[doc = "Generated from 'VK_NV_memory_decompression'"]
22647impl StructureType {
22648 pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: Self = Self(1_000_427_000);
22649 pub const PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: Self = Self(1_000_427_001);
22650}
22651impl NvExtension429Fn {
22652 #[inline]
22653 pub const fn name() -> &'static ::std::ffi::CStr {
22654 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_429\0") }
22655 }
22656 pub const SPEC_VERSION: u32 = 0u32;
22657}
22658#[derive(Clone)]
22659pub struct NvExtension429Fn {}
22660unsafe impl Send for NvExtension429Fn {}
22661unsafe impl Sync for NvExtension429Fn {}
22662impl NvExtension429Fn {
22663 pub fn load<F>(mut _f: F) -> Self
22664 where
22665 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22666 {
22667 Self {}
22668 }
22669}
22670impl NvExtension430Fn {
22671 #[inline]
22672 pub const fn name() -> &'static ::std::ffi::CStr {
22673 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_430\0") }
22674 }
22675 pub const SPEC_VERSION: u32 = 0u32;
22676}
22677#[derive(Clone)]
22678pub struct NvExtension430Fn {}
22679unsafe impl Send for NvExtension430Fn {}
22680unsafe impl Sync for NvExtension430Fn {}
22681impl NvExtension430Fn {
22682 pub fn load<F>(mut _f: F) -> Self
22683 where
22684 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22685 {
22686 Self {}
22687 }
22688}
22689impl NvLinearColorAttachmentFn {
22690 #[inline]
22691 pub const fn name() -> &'static ::std::ffi::CStr {
22692 unsafe {
22693 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_linear_color_attachment\0")
22694 }
22695 }
22696 pub const SPEC_VERSION: u32 = 1u32;
22697}
22698#[derive(Clone)]
22699pub struct NvLinearColorAttachmentFn {}
22700unsafe impl Send for NvLinearColorAttachmentFn {}
22701unsafe impl Sync for NvLinearColorAttachmentFn {}
22702impl NvLinearColorAttachmentFn {
22703 pub fn load<F>(mut _f: F) -> Self
22704 where
22705 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22706 {
22707 Self {}
22708 }
22709}
22710#[doc = "Generated from 'VK_NV_linear_color_attachment'"]
22711impl FormatFeatureFlags2 {
22712 #[doc = "Format support linear image as render target, it cannot be mixed with non linear attachment"]
22713 pub const LINEAR_COLOR_ATTACHMENT_NV: Self =
22714 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
22715}
22716#[doc = "Generated from 'VK_NV_linear_color_attachment'"]
22717impl StructureType {
22718 pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self(1_000_430_000);
22719}
22720impl NvExtension432Fn {
22721 #[inline]
22722 pub const fn name() -> &'static ::std::ffi::CStr {
22723 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_432\0") }
22724 }
22725 pub const SPEC_VERSION: u32 = 0u32;
22726}
22727#[derive(Clone)]
22728pub struct NvExtension432Fn {}
22729unsafe impl Send for NvExtension432Fn {}
22730unsafe impl Sync for NvExtension432Fn {}
22731impl NvExtension432Fn {
22732 pub fn load<F>(mut _f: F) -> Self
22733 where
22734 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22735 {
22736 Self {}
22737 }
22738}
22739impl NvExtension433Fn {
22740 #[inline]
22741 pub const fn name() -> &'static ::std::ffi::CStr {
22742 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_433\0") }
22743 }
22744 pub const SPEC_VERSION: u32 = 0u32;
22745}
22746#[derive(Clone)]
22747pub struct NvExtension433Fn {}
22748unsafe impl Send for NvExtension433Fn {}
22749unsafe impl Sync for NvExtension433Fn {}
22750impl NvExtension433Fn {
22751 pub fn load<F>(mut _f: F) -> Self
22752 where
22753 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22754 {
22755 Self {}
22756 }
22757}
22758impl GoogleSurfacelessQueryFn {
22759 #[inline]
22760 pub const fn name() -> &'static ::std::ffi::CStr {
22761 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_surfaceless_query\0") }
22762 }
22763 pub const SPEC_VERSION: u32 = 2u32;
22764}
22765#[derive(Clone)]
22766pub struct GoogleSurfacelessQueryFn {}
22767unsafe impl Send for GoogleSurfacelessQueryFn {}
22768unsafe impl Sync for GoogleSurfacelessQueryFn {}
22769impl GoogleSurfacelessQueryFn {
22770 pub fn load<F>(mut _f: F) -> Self
22771 where
22772 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22773 {
22774 Self {}
22775 }
22776}
22777impl KhrExtension435Fn {
22778 #[inline]
22779 pub const fn name() -> &'static ::std::ffi::CStr {
22780 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_435\0") }
22781 }
22782 pub const SPEC_VERSION: u32 = 0u32;
22783}
22784#[derive(Clone)]
22785pub struct KhrExtension435Fn {}
22786unsafe impl Send for KhrExtension435Fn {}
22787unsafe impl Sync for KhrExtension435Fn {}
22788impl KhrExtension435Fn {
22789 pub fn load<F>(mut _f: F) -> Self
22790 where
22791 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22792 {
22793 Self {}
22794 }
22795}
22796impl ExtExtension437Fn {
22797 #[inline]
22798 pub const fn name() -> &'static ::std::ffi::CStr {
22799 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_437\0") }
22800 }
22801 pub const SPEC_VERSION: u32 = 0u32;
22802}
22803#[derive(Clone)]
22804pub struct ExtExtension437Fn {}
22805unsafe impl Send for ExtExtension437Fn {}
22806unsafe impl Sync for ExtExtension437Fn {}
22807impl ExtExtension437Fn {
22808 pub fn load<F>(mut _f: F) -> Self
22809 where
22810 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22811 {
22812 Self {}
22813 }
22814}
22815impl ExtImageCompressionControlSwapchainFn {
22816 #[inline]
22817 pub const fn name() -> &'static ::std::ffi::CStr {
22818 unsafe {
22819 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
22820 b"VK_EXT_image_compression_control_swapchain\0",
22821 )
22822 }
22823 }
22824 pub const SPEC_VERSION: u32 = 1u32;
22825}
22826#[derive(Clone)]
22827pub struct ExtImageCompressionControlSwapchainFn {}
22828unsafe impl Send for ExtImageCompressionControlSwapchainFn {}
22829unsafe impl Sync for ExtImageCompressionControlSwapchainFn {}
22830impl ExtImageCompressionControlSwapchainFn {
22831 pub fn load<F>(mut _f: F) -> Self
22832 where
22833 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22834 {
22835 Self {}
22836 }
22837}
22838#[doc = "Generated from 'VK_EXT_image_compression_control_swapchain'"]
22839impl StructureType {
22840 pub const PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: Self =
22841 Self(1_000_437_000);
22842}
22843impl SecExtension439Fn {
22844 #[inline]
22845 pub const fn name() -> &'static ::std::ffi::CStr {
22846 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_439\0") }
22847 }
22848 pub const SPEC_VERSION: u32 = 0u32;
22849}
22850#[derive(Clone)]
22851pub struct SecExtension439Fn {}
22852unsafe impl Send for SecExtension439Fn {}
22853unsafe impl Sync for SecExtension439Fn {}
22854impl SecExtension439Fn {
22855 pub fn load<F>(mut _f: F) -> Self
22856 where
22857 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22858 {
22859 Self {}
22860 }
22861}
22862impl QcomExtension440Fn {
22863 #[inline]
22864 pub const fn name() -> &'static ::std::ffi::CStr {
22865 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_440\0") }
22866 }
22867 pub const SPEC_VERSION: u32 = 0u32;
22868}
22869#[derive(Clone)]
22870pub struct QcomExtension440Fn {}
22871unsafe impl Send for QcomExtension440Fn {}
22872unsafe impl Sync for QcomExtension440Fn {}
22873impl QcomExtension440Fn {
22874 pub fn load<F>(mut _f: F) -> Self
22875 where
22876 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22877 {
22878 Self {}
22879 }
22880}
22881#[doc = "Generated from 'VK_QCOM_extension_440'"]
22882impl DeviceQueueCreateFlags {
22883 pub const RESERVED_1_QCOM: Self = Self(0b10);
22884}
22885#[doc = "Generated from 'VK_QCOM_extension_440'"]
22886impl QueueFlags {
22887 pub const RESERVED_7_QCOM: Self = Self(0b1000_0000);
22888}
22889impl QcomImageProcessingFn {
22890 #[inline]
22891 pub const fn name() -> &'static ::std::ffi::CStr {
22892 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_image_processing\0") }
22893 }
22894 pub const SPEC_VERSION: u32 = 1u32;
22895}
22896#[derive(Clone)]
22897pub struct QcomImageProcessingFn {}
22898unsafe impl Send for QcomImageProcessingFn {}
22899unsafe impl Sync for QcomImageProcessingFn {}
22900impl QcomImageProcessingFn {
22901 pub fn load<F>(mut _f: F) -> Self
22902 where
22903 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22904 {
22905 Self {}
22906 }
22907}
22908#[doc = "Generated from 'VK_QCOM_image_processing'"]
22909impl DescriptorType {
22910 pub const SAMPLE_WEIGHT_IMAGE_QCOM: Self = Self(1_000_440_000);
22911 pub const BLOCK_MATCH_IMAGE_QCOM: Self = Self(1_000_440_001);
22912}
22913#[doc = "Generated from 'VK_QCOM_image_processing'"]
22914impl FormatFeatureFlags2 {
22915 pub const WEIGHT_IMAGE_QCOM: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000);
22916 pub const WEIGHT_SAMPLED_IMAGE_QCOM: Self =
22917 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
22918 pub const BLOCK_MATCHING_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
22919 pub const BOX_FILTER_SAMPLED_QCOM: Self =
22920 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
22921}
22922#[doc = "Generated from 'VK_QCOM_image_processing'"]
22923impl ImageUsageFlags {
22924 pub const SAMPLE_WEIGHT_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000);
22925 pub const SAMPLE_BLOCK_MATCH_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000);
22926}
22927#[doc = "Generated from 'VK_QCOM_image_processing'"]
22928impl SamplerCreateFlags {
22929 pub const IMAGE_PROCESSING_QCOM: Self = Self(0b1_0000);
22930}
22931#[doc = "Generated from 'VK_QCOM_image_processing'"]
22932impl StructureType {
22933 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: Self = Self(1_000_440_000);
22934 pub const PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: Self = Self(1_000_440_001);
22935 pub const IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: Self = Self(1_000_440_002);
22936}
22937impl CoreaviExtension442Fn {
22938 #[inline]
22939 pub const fn name() -> &'static ::std::ffi::CStr {
22940 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_442\0") }
22941 }
22942 pub const SPEC_VERSION: u32 = 0u32;
22943}
22944#[derive(Clone)]
22945pub struct CoreaviExtension442Fn {}
22946unsafe impl Send for CoreaviExtension442Fn {}
22947unsafe impl Sync for CoreaviExtension442Fn {}
22948impl CoreaviExtension442Fn {
22949 pub fn load<F>(mut _f: F) -> Self
22950 where
22951 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22952 {
22953 Self {}
22954 }
22955}
22956impl CoreaviExtension443Fn {
22957 #[inline]
22958 pub const fn name() -> &'static ::std::ffi::CStr {
22959 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_443\0") }
22960 }
22961 pub const SPEC_VERSION: u32 = 0u32;
22962}
22963#[derive(Clone)]
22964pub struct CoreaviExtension443Fn {}
22965unsafe impl Send for CoreaviExtension443Fn {}
22966unsafe impl Sync for CoreaviExtension443Fn {}
22967impl CoreaviExtension443Fn {
22968 pub fn load<F>(mut _f: F) -> Self
22969 where
22970 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22971 {
22972 Self {}
22973 }
22974}
22975impl CoreaviExtension444Fn {
22976 #[inline]
22977 pub const fn name() -> &'static ::std::ffi::CStr {
22978 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_444\0") }
22979 }
22980 pub const SPEC_VERSION: u32 = 0u32;
22981}
22982#[derive(Clone)]
22983pub struct CoreaviExtension444Fn {}
22984unsafe impl Send for CoreaviExtension444Fn {}
22985unsafe impl Sync for CoreaviExtension444Fn {}
22986impl CoreaviExtension444Fn {
22987 pub fn load<F>(mut _f: F) -> Self
22988 where
22989 F: FnMut(&::std::ffi::CStr) -> *const c_void,
22990 {
22991 Self {}
22992 }
22993}
22994#[doc = "Generated from 'VK_COREAVI_extension_444'"]
22995impl CommandPoolResetFlags {
22996 pub const RESERVED_1_COREAVI: Self = Self(0b10);
22997}
22998impl CoreaviExtension445Fn {
22999 #[inline]
23000 pub const fn name() -> &'static ::std::ffi::CStr {
23001 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_445\0") }
23002 }
23003 pub const SPEC_VERSION: u32 = 0u32;
23004}
23005#[derive(Clone)]
23006pub struct CoreaviExtension445Fn {}
23007unsafe impl Send for CoreaviExtension445Fn {}
23008unsafe impl Sync for CoreaviExtension445Fn {}
23009impl CoreaviExtension445Fn {
23010 pub fn load<F>(mut _f: F) -> Self
23011 where
23012 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23013 {
23014 Self {}
23015 }
23016}
23017impl CoreaviExtension446Fn {
23018 #[inline]
23019 pub const fn name() -> &'static ::std::ffi::CStr {
23020 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_446\0") }
23021 }
23022 pub const SPEC_VERSION: u32 = 0u32;
23023}
23024#[derive(Clone)]
23025pub struct CoreaviExtension446Fn {}
23026unsafe impl Send for CoreaviExtension446Fn {}
23027unsafe impl Sync for CoreaviExtension446Fn {}
23028impl CoreaviExtension446Fn {
23029 pub fn load<F>(mut _f: F) -> Self
23030 where
23031 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23032 {
23033 Self {}
23034 }
23035}
23036impl CoreaviExtension447Fn {
23037 #[inline]
23038 pub const fn name() -> &'static ::std::ffi::CStr {
23039 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_447\0") }
23040 }
23041 pub const SPEC_VERSION: u32 = 0u32;
23042}
23043#[derive(Clone)]
23044pub struct CoreaviExtension447Fn {}
23045unsafe impl Send for CoreaviExtension447Fn {}
23046unsafe impl Sync for CoreaviExtension447Fn {}
23047impl CoreaviExtension447Fn {
23048 pub fn load<F>(mut _f: F) -> Self
23049 where
23050 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23051 {
23052 Self {}
23053 }
23054}
23055impl SecExtension448Fn {
23056 #[inline]
23057 pub const fn name() -> &'static ::std::ffi::CStr {
23058 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_448\0") }
23059 }
23060 pub const SPEC_VERSION: u32 = 0u32;
23061}
23062#[derive(Clone)]
23063pub struct SecExtension448Fn {}
23064unsafe impl Send for SecExtension448Fn {}
23065unsafe impl Sync for SecExtension448Fn {}
23066impl SecExtension448Fn {
23067 pub fn load<F>(mut _f: F) -> Self
23068 where
23069 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23070 {
23071 Self {}
23072 }
23073}
23074impl SecExtension449Fn {
23075 #[inline]
23076 pub const fn name() -> &'static ::std::ffi::CStr {
23077 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_449\0") }
23078 }
23079 pub const SPEC_VERSION: u32 = 0u32;
23080}
23081#[derive(Clone)]
23082pub struct SecExtension449Fn {}
23083unsafe impl Send for SecExtension449Fn {}
23084unsafe impl Sync for SecExtension449Fn {}
23085impl SecExtension449Fn {
23086 pub fn load<F>(mut _f: F) -> Self
23087 where
23088 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23089 {
23090 Self {}
23091 }
23092}
23093impl SecExtension450Fn {
23094 #[inline]
23095 pub const fn name() -> &'static ::std::ffi::CStr {
23096 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_450\0") }
23097 }
23098 pub const SPEC_VERSION: u32 = 0u32;
23099}
23100#[derive(Clone)]
23101pub struct SecExtension450Fn {}
23102unsafe impl Send for SecExtension450Fn {}
23103unsafe impl Sync for SecExtension450Fn {}
23104impl SecExtension450Fn {
23105 pub fn load<F>(mut _f: F) -> Self
23106 where
23107 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23108 {
23109 Self {}
23110 }
23111}
23112impl SecExtension451Fn {
23113 #[inline]
23114 pub const fn name() -> &'static ::std::ffi::CStr {
23115 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_451\0") }
23116 }
23117 pub const SPEC_VERSION: u32 = 0u32;
23118}
23119#[derive(Clone)]
23120pub struct SecExtension451Fn {}
23121unsafe impl Send for SecExtension451Fn {}
23122unsafe impl Sync for SecExtension451Fn {}
23123impl SecExtension451Fn {
23124 pub fn load<F>(mut _f: F) -> Self
23125 where
23126 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23127 {
23128 Self {}
23129 }
23130}
23131impl NvExtension452Fn {
23132 #[inline]
23133 pub const fn name() -> &'static ::std::ffi::CStr {
23134 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_452\0") }
23135 }
23136 pub const SPEC_VERSION: u32 = 0u32;
23137}
23138#[derive(Clone)]
23139pub struct NvExtension452Fn {}
23140unsafe impl Send for NvExtension452Fn {}
23141unsafe impl Sync for NvExtension452Fn {}
23142impl NvExtension452Fn {
23143 pub fn load<F>(mut _f: F) -> Self
23144 where
23145 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23146 {
23147 Self {}
23148 }
23149}
23150impl ArmExtension453Fn {
23151 #[inline]
23152 pub const fn name() -> &'static ::std::ffi::CStr {
23153 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_453\0") }
23154 }
23155 pub const SPEC_VERSION: u32 = 0u32;
23156}
23157#[derive(Clone)]
23158pub struct ArmExtension453Fn {}
23159unsafe impl Send for ArmExtension453Fn {}
23160unsafe impl Sync for ArmExtension453Fn {}
23161impl ArmExtension453Fn {
23162 pub fn load<F>(mut _f: F) -> Self
23163 where
23164 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23165 {
23166 Self {}
23167 }
23168}
23169#[doc = "Generated from 'VK_ARM_extension_453'"]
23170impl AccessFlags2 {
23171 pub const RESERVED_49_ARM: Self =
23172 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
23173 pub const RESERVED_50_ARM: Self =
23174 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
23175}
23176#[doc = "Generated from 'VK_ARM_extension_453'"]
23177impl PipelineStageFlags2 {
23178 pub const RESERVED_43_ARM: Self =
23179 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
23180}
23181#[doc = "Generated from 'VK_ARM_extension_453'"]
23182impl QueueFlags {
23183 pub const RESERVED_11_ARM: Self = Self(0b1000_0000_0000);
23184}
23185impl GoogleExtension454Fn {
23186 #[inline]
23187 pub const fn name() -> &'static ::std::ffi::CStr {
23188 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_454\0") }
23189 }
23190 pub const SPEC_VERSION: u32 = 0u32;
23191}
23192#[derive(Clone)]
23193pub struct GoogleExtension454Fn {}
23194unsafe impl Send for GoogleExtension454Fn {}
23195unsafe impl Sync for GoogleExtension454Fn {}
23196impl GoogleExtension454Fn {
23197 pub fn load<F>(mut _f: F) -> Self
23198 where
23199 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23200 {
23201 Self {}
23202 }
23203}
23204impl GoogleExtension455Fn {
23205 #[inline]
23206 pub const fn name() -> &'static ::std::ffi::CStr {
23207 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_455\0") }
23208 }
23209 pub const SPEC_VERSION: u32 = 0u32;
23210}
23211#[derive(Clone)]
23212pub struct GoogleExtension455Fn {}
23213unsafe impl Send for GoogleExtension455Fn {}
23214unsafe impl Sync for GoogleExtension455Fn {}
23215impl GoogleExtension455Fn {
23216 pub fn load<F>(mut _f: F) -> Self
23217 where
23218 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23219 {
23220 Self {}
23221 }
23222}
23223impl ExtExtendedDynamicState3Fn {
23224 #[inline]
23225 pub const fn name() -> &'static ::std::ffi::CStr {
23226 unsafe {
23227 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state3\0")
23228 }
23229 }
23230 pub const SPEC_VERSION: u32 = 2u32;
23231}
23232#[allow(non_camel_case_types)]
23233pub type PFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn(
23234 command_buffer: CommandBuffer,
23235 domain_origin: TessellationDomainOrigin,
23236);
23237#[allow(non_camel_case_types)]
23238pub type PFN_vkCmdSetDepthClampEnableEXT =
23239 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clamp_enable: Bool32);
23240#[allow(non_camel_case_types)]
23241pub type PFN_vkCmdSetPolygonModeEXT =
23242 unsafe extern "system" fn(command_buffer: CommandBuffer, polygon_mode: PolygonMode);
23243#[allow(non_camel_case_types)]
23244pub type PFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn(
23245 command_buffer: CommandBuffer,
23246 rasterization_samples: SampleCountFlags,
23247);
23248#[allow(non_camel_case_types)]
23249pub type PFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn(
23250 command_buffer: CommandBuffer,
23251 samples: SampleCountFlags,
23252 p_sample_mask: *const SampleMask,
23253);
23254#[allow(non_camel_case_types)]
23255pub type PFN_vkCmdSetAlphaToCoverageEnableEXT =
23256 unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_coverage_enable: Bool32);
23257#[allow(non_camel_case_types)]
23258pub type PFN_vkCmdSetAlphaToOneEnableEXT =
23259 unsafe extern "system" fn(command_buffer: CommandBuffer, alpha_to_one_enable: Bool32);
23260#[allow(non_camel_case_types)]
23261pub type PFN_vkCmdSetLogicOpEnableEXT =
23262 unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op_enable: Bool32);
23263#[allow(non_camel_case_types)]
23264pub type PFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn(
23265 command_buffer: CommandBuffer,
23266 first_attachment: u32,
23267 attachment_count: u32,
23268 p_color_blend_enables: *const Bool32,
23269);
23270#[allow(non_camel_case_types)]
23271pub type PFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn(
23272 command_buffer: CommandBuffer,
23273 first_attachment: u32,
23274 attachment_count: u32,
23275 p_color_blend_equations: *const ColorBlendEquationEXT,
23276);
23277#[allow(non_camel_case_types)]
23278pub type PFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn(
23279 command_buffer: CommandBuffer,
23280 first_attachment: u32,
23281 attachment_count: u32,
23282 p_color_write_masks: *const ColorComponentFlags,
23283);
23284#[allow(non_camel_case_types)]
23285pub type PFN_vkCmdSetRasterizationStreamEXT =
23286 unsafe extern "system" fn(command_buffer: CommandBuffer, rasterization_stream: u32);
23287#[allow(non_camel_case_types)]
23288pub type PFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn(
23289 command_buffer: CommandBuffer,
23290 conservative_rasterization_mode: ConservativeRasterizationModeEXT,
23291);
23292#[allow(non_camel_case_types)]
23293pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn(
23294 command_buffer: CommandBuffer,
23295 extra_primitive_overestimation_size: f32,
23296);
23297#[allow(non_camel_case_types)]
23298pub type PFN_vkCmdSetDepthClipEnableEXT =
23299 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_clip_enable: Bool32);
23300#[allow(non_camel_case_types)]
23301pub type PFN_vkCmdSetSampleLocationsEnableEXT =
23302 unsafe extern "system" fn(command_buffer: CommandBuffer, sample_locations_enable: Bool32);
23303#[allow(non_camel_case_types)]
23304pub type PFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn(
23305 command_buffer: CommandBuffer,
23306 first_attachment: u32,
23307 attachment_count: u32,
23308 p_color_blend_advanced: *const ColorBlendAdvancedEXT,
23309);
23310#[allow(non_camel_case_types)]
23311pub type PFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn(
23312 command_buffer: CommandBuffer,
23313 provoking_vertex_mode: ProvokingVertexModeEXT,
23314);
23315#[allow(non_camel_case_types)]
23316pub type PFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn(
23317 command_buffer: CommandBuffer,
23318 line_rasterization_mode: LineRasterizationModeEXT,
23319);
23320#[allow(non_camel_case_types)]
23321pub type PFN_vkCmdSetLineStippleEnableEXT =
23322 unsafe extern "system" fn(command_buffer: CommandBuffer, stippled_line_enable: Bool32);
23323#[allow(non_camel_case_types)]
23324pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT =
23325 unsafe extern "system" fn(command_buffer: CommandBuffer, negative_one_to_one: Bool32);
23326#[allow(non_camel_case_types)]
23327pub type PFN_vkCmdSetViewportWScalingEnableNV =
23328 unsafe extern "system" fn(command_buffer: CommandBuffer, viewport_w_scaling_enable: Bool32);
23329#[allow(non_camel_case_types)]
23330pub type PFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn(
23331 command_buffer: CommandBuffer,
23332 first_viewport: u32,
23333 viewport_count: u32,
23334 p_viewport_swizzles: *const ViewportSwizzleNV,
23335);
23336#[allow(non_camel_case_types)]
23337pub type PFN_vkCmdSetCoverageToColorEnableNV =
23338 unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_enable: Bool32);
23339#[allow(non_camel_case_types)]
23340pub type PFN_vkCmdSetCoverageToColorLocationNV =
23341 unsafe extern "system" fn(command_buffer: CommandBuffer, coverage_to_color_location: u32);
23342#[allow(non_camel_case_types)]
23343pub type PFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn(
23344 command_buffer: CommandBuffer,
23345 coverage_modulation_mode: CoverageModulationModeNV,
23346);
23347#[allow(non_camel_case_types)]
23348pub type PFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn(
23349 command_buffer: CommandBuffer,
23350 coverage_modulation_table_enable: Bool32,
23351);
23352#[allow(non_camel_case_types)]
23353pub type PFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn(
23354 command_buffer: CommandBuffer,
23355 coverage_modulation_table_count: u32,
23356 p_coverage_modulation_table: *const f32,
23357);
23358#[allow(non_camel_case_types)]
23359pub type PFN_vkCmdSetShadingRateImageEnableNV =
23360 unsafe extern "system" fn(command_buffer: CommandBuffer, shading_rate_image_enable: Bool32);
23361#[allow(non_camel_case_types)]
23362pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn(
23363 command_buffer: CommandBuffer,
23364 representative_fragment_test_enable: Bool32,
23365);
23366#[allow(non_camel_case_types)]
23367pub type PFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn(
23368 command_buffer: CommandBuffer,
23369 coverage_reduction_mode: CoverageReductionModeNV,
23370);
23371#[derive(Clone)]
23372pub struct ExtExtendedDynamicState3Fn {
23373 pub cmd_set_tessellation_domain_origin_ext: PFN_vkCmdSetTessellationDomainOriginEXT,
23374 pub cmd_set_depth_clamp_enable_ext: PFN_vkCmdSetDepthClampEnableEXT,
23375 pub cmd_set_polygon_mode_ext: PFN_vkCmdSetPolygonModeEXT,
23376 pub cmd_set_rasterization_samples_ext: PFN_vkCmdSetRasterizationSamplesEXT,
23377 pub cmd_set_sample_mask_ext: PFN_vkCmdSetSampleMaskEXT,
23378 pub cmd_set_alpha_to_coverage_enable_ext: PFN_vkCmdSetAlphaToCoverageEnableEXT,
23379 pub cmd_set_alpha_to_one_enable_ext: PFN_vkCmdSetAlphaToOneEnableEXT,
23380 pub cmd_set_logic_op_enable_ext: PFN_vkCmdSetLogicOpEnableEXT,
23381 pub cmd_set_color_blend_enable_ext: PFN_vkCmdSetColorBlendEnableEXT,
23382 pub cmd_set_color_blend_equation_ext: PFN_vkCmdSetColorBlendEquationEXT,
23383 pub cmd_set_color_write_mask_ext: PFN_vkCmdSetColorWriteMaskEXT,
23384 pub cmd_set_rasterization_stream_ext: PFN_vkCmdSetRasterizationStreamEXT,
23385 pub cmd_set_conservative_rasterization_mode_ext: PFN_vkCmdSetConservativeRasterizationModeEXT,
23386 pub cmd_set_extra_primitive_overestimation_size_ext:
23387 PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
23388 pub cmd_set_depth_clip_enable_ext: PFN_vkCmdSetDepthClipEnableEXT,
23389 pub cmd_set_sample_locations_enable_ext: PFN_vkCmdSetSampleLocationsEnableEXT,
23390 pub cmd_set_color_blend_advanced_ext: PFN_vkCmdSetColorBlendAdvancedEXT,
23391 pub cmd_set_provoking_vertex_mode_ext: PFN_vkCmdSetProvokingVertexModeEXT,
23392 pub cmd_set_line_rasterization_mode_ext: PFN_vkCmdSetLineRasterizationModeEXT,
23393 pub cmd_set_line_stipple_enable_ext: PFN_vkCmdSetLineStippleEnableEXT,
23394 pub cmd_set_depth_clip_negative_one_to_one_ext: PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
23395 pub cmd_set_viewport_w_scaling_enable_nv: PFN_vkCmdSetViewportWScalingEnableNV,
23396 pub cmd_set_viewport_swizzle_nv: PFN_vkCmdSetViewportSwizzleNV,
23397 pub cmd_set_coverage_to_color_enable_nv: PFN_vkCmdSetCoverageToColorEnableNV,
23398 pub cmd_set_coverage_to_color_location_nv: PFN_vkCmdSetCoverageToColorLocationNV,
23399 pub cmd_set_coverage_modulation_mode_nv: PFN_vkCmdSetCoverageModulationModeNV,
23400 pub cmd_set_coverage_modulation_table_enable_nv: PFN_vkCmdSetCoverageModulationTableEnableNV,
23401 pub cmd_set_coverage_modulation_table_nv: PFN_vkCmdSetCoverageModulationTableNV,
23402 pub cmd_set_shading_rate_image_enable_nv: PFN_vkCmdSetShadingRateImageEnableNV,
23403 pub cmd_set_representative_fragment_test_enable_nv:
23404 PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
23405 pub cmd_set_coverage_reduction_mode_nv: PFN_vkCmdSetCoverageReductionModeNV,
23406}
23407unsafe impl Send for ExtExtendedDynamicState3Fn {}
23408unsafe impl Sync for ExtExtendedDynamicState3Fn {}
23409impl ExtExtendedDynamicState3Fn {
23410 pub fn load<F>(mut _f: F) -> Self
23411 where
23412 F: FnMut(&::std::ffi::CStr) -> *const c_void,
23413 {
23414 Self {
23415 cmd_set_tessellation_domain_origin_ext: unsafe {
23416 unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext(
23417 _command_buffer: CommandBuffer,
23418 _domain_origin: TessellationDomainOrigin,
23419 ) {
23420 panic!(concat!(
23421 "Unable to load ",
23422 stringify!(cmd_set_tessellation_domain_origin_ext)
23423 ))
23424 }
23425 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23426 b"vkCmdSetTessellationDomainOriginEXT\0",
23427 );
23428 let val = _f(cname);
23429 if val.is_null() {
23430 cmd_set_tessellation_domain_origin_ext
23431 } else {
23432 ::std::mem::transmute(val)
23433 }
23434 },
23435 cmd_set_depth_clamp_enable_ext: unsafe {
23436 unsafe extern "system" fn cmd_set_depth_clamp_enable_ext(
23437 _command_buffer: CommandBuffer,
23438 _depth_clamp_enable: Bool32,
23439 ) {
23440 panic!(concat!(
23441 "Unable to load ",
23442 stringify!(cmd_set_depth_clamp_enable_ext)
23443 ))
23444 }
23445 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23446 b"vkCmdSetDepthClampEnableEXT\0",
23447 );
23448 let val = _f(cname);
23449 if val.is_null() {
23450 cmd_set_depth_clamp_enable_ext
23451 } else {
23452 ::std::mem::transmute(val)
23453 }
23454 },
23455 cmd_set_polygon_mode_ext: unsafe {
23456 unsafe extern "system" fn cmd_set_polygon_mode_ext(
23457 _command_buffer: CommandBuffer,
23458 _polygon_mode: PolygonMode,
23459 ) {
23460 panic!(concat!(
23461 "Unable to load ",
23462 stringify!(cmd_set_polygon_mode_ext)
23463 ))
23464 }
23465 let cname =
23466 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
23467 let val = _f(cname);
23468 if val.is_null() {
23469 cmd_set_polygon_mode_ext
23470 } else {
23471 ::std::mem::transmute(val)
23472 }
23473 },
23474 cmd_set_rasterization_samples_ext: unsafe {
23475 unsafe extern "system" fn cmd_set_rasterization_samples_ext(
23476 _command_buffer: CommandBuffer,
23477 _rasterization_samples: SampleCountFlags,
23478 ) {
23479 panic!(concat!(
23480 "Unable to load ",
23481 stringify!(cmd_set_rasterization_samples_ext)
23482 ))
23483 }
23484 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23485 b"vkCmdSetRasterizationSamplesEXT\0",
23486 );
23487 let val = _f(cname);
23488 if val.is_null() {
23489 cmd_set_rasterization_samples_ext
23490 } else {
23491 ::std::mem::transmute(val)
23492 }
23493 },
23494 cmd_set_sample_mask_ext: unsafe {
23495 unsafe extern "system" fn cmd_set_sample_mask_ext(
23496 _command_buffer: CommandBuffer,
23497 _samples: SampleCountFlags,
23498 _p_sample_mask: *const SampleMask,
23499 ) {
23500 panic!(concat!(
23501 "Unable to load ",
23502 stringify!(cmd_set_sample_mask_ext)
23503 ))
23504 }
23505 let cname =
23506 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
23507 let val = _f(cname);
23508 if val.is_null() {
23509 cmd_set_sample_mask_ext
23510 } else {
23511 ::std::mem::transmute(val)
23512 }
23513 },
23514 cmd_set_alpha_to_coverage_enable_ext: unsafe {
23515 unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext(
23516 _command_buffer: CommandBuffer,
23517 _alpha_to_coverage_enable: Bool32,
23518 ) {
23519 panic!(concat!(
23520 "Unable to load ",
23521 stringify!(cmd_set_alpha_to_coverage_enable_ext)
23522 ))
23523 }
23524 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23525 b"vkCmdSetAlphaToCoverageEnableEXT\0",
23526 );
23527 let val = _f(cname);
23528 if val.is_null() {
23529 cmd_set_alpha_to_coverage_enable_ext
23530 } else {
23531 ::std::mem::transmute(val)
23532 }
23533 },
23534 cmd_set_alpha_to_one_enable_ext: unsafe {
23535 unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext(
23536 _command_buffer: CommandBuffer,
23537 _alpha_to_one_enable: Bool32,
23538 ) {
23539 panic!(concat!(
23540 "Unable to load ",
23541 stringify!(cmd_set_alpha_to_one_enable_ext)
23542 ))
23543 }
23544 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23545 b"vkCmdSetAlphaToOneEnableEXT\0",
23546 );
23547 let val = _f(cname);
23548 if val.is_null() {
23549 cmd_set_alpha_to_one_enable_ext
23550 } else {
23551 ::std::mem::transmute(val)
23552 }
23553 },
23554 cmd_set_logic_op_enable_ext: unsafe {
23555 unsafe extern "system" fn cmd_set_logic_op_enable_ext(
23556 _command_buffer: CommandBuffer,
23557 _logic_op_enable: Bool32,
23558 ) {
23559 panic!(concat!(
23560 "Unable to load ",
23561 stringify!(cmd_set_logic_op_enable_ext)
23562 ))
23563 }
23564 let cname =
23565 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
23566 let val = _f(cname);
23567 if val.is_null() {
23568 cmd_set_logic_op_enable_ext
23569 } else {
23570 ::std::mem::transmute(val)
23571 }
23572 },
23573 cmd_set_color_blend_enable_ext: unsafe {
23574 unsafe extern "system" fn cmd_set_color_blend_enable_ext(
23575 _command_buffer: CommandBuffer,
23576 _first_attachment: u32,
23577 _attachment_count: u32,
23578 _p_color_blend_enables: *const Bool32,
23579 ) {
23580 panic!(concat!(
23581 "Unable to load ",
23582 stringify!(cmd_set_color_blend_enable_ext)
23583 ))
23584 }
23585 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23586 b"vkCmdSetColorBlendEnableEXT\0",
23587 );
23588 let val = _f(cname);
23589 if val.is_null() {
23590 cmd_set_color_blend_enable_ext
23591 } else {
23592 ::std::mem::transmute(val)
23593 }
23594 },
23595 cmd_set_color_blend_equation_ext: unsafe {
23596 unsafe extern "system" fn cmd_set_color_blend_equation_ext(
23597 _command_buffer: CommandBuffer,
23598 _first_attachment: u32,
23599 _attachment_count: u32,
23600 _p_color_blend_equations: *const ColorBlendEquationEXT,
23601 ) {
23602 panic!(concat!(
23603 "Unable to load ",
23604 stringify!(cmd_set_color_blend_equation_ext)
23605 ))
23606 }
23607 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23608 b"vkCmdSetColorBlendEquationEXT\0",
23609 );
23610 let val = _f(cname);
23611 if val.is_null() {
23612 cmd_set_color_blend_equation_ext
23613 } else {
23614 ::std::mem::transmute(val)
23615 }
23616 },
23617 cmd_set_color_write_mask_ext: unsafe {
23618 unsafe extern "system" fn cmd_set_color_write_mask_ext(
23619 _command_buffer: CommandBuffer,
23620 _first_attachment: u32,
23621 _attachment_count: u32,
23622 _p_color_write_masks: *const ColorComponentFlags,
23623 ) {
23624 panic!(concat!(
23625 "Unable to load ",
23626 stringify!(cmd_set_color_write_mask_ext)
23627 ))
23628 }
23629 let cname =
23630 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
23631 let val = _f(cname);
23632 if val.is_null() {
23633 cmd_set_color_write_mask_ext
23634 } else {
23635 ::std::mem::transmute(val)
23636 }
23637 },
23638 cmd_set_rasterization_stream_ext: unsafe {
23639 unsafe extern "system" fn cmd_set_rasterization_stream_ext(
23640 _command_buffer: CommandBuffer,
23641 _rasterization_stream: u32,
23642 ) {
23643 panic!(concat!(
23644 "Unable to load ",
23645 stringify!(cmd_set_rasterization_stream_ext)
23646 ))
23647 }
23648 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23649 b"vkCmdSetRasterizationStreamEXT\0",
23650 );
23651 let val = _f(cname);
23652 if val.is_null() {
23653 cmd_set_rasterization_stream_ext
23654 } else {
23655 ::std::mem::transmute(val)
23656 }
23657 },
23658 cmd_set_conservative_rasterization_mode_ext: unsafe {
23659 unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext(
23660 _command_buffer: CommandBuffer,
23661 _conservative_rasterization_mode: ConservativeRasterizationModeEXT,
23662 ) {
23663 panic!(concat!(
23664 "Unable to load ",
23665 stringify!(cmd_set_conservative_rasterization_mode_ext)
23666 ))
23667 }
23668 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23669 b"vkCmdSetConservativeRasterizationModeEXT\0",
23670 );
23671 let val = _f(cname);
23672 if val.is_null() {
23673 cmd_set_conservative_rasterization_mode_ext
23674 } else {
23675 ::std::mem::transmute(val)
23676 }
23677 },
23678 cmd_set_extra_primitive_overestimation_size_ext: unsafe {
23679 unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext(
23680 _command_buffer: CommandBuffer,
23681 _extra_primitive_overestimation_size: f32,
23682 ) {
23683 panic!(concat!(
23684 "Unable to load ",
23685 stringify!(cmd_set_extra_primitive_overestimation_size_ext)
23686 ))
23687 }
23688 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23689 b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0",
23690 );
23691 let val = _f(cname);
23692 if val.is_null() {
23693 cmd_set_extra_primitive_overestimation_size_ext
23694 } else {
23695 ::std::mem::transmute(val)
23696 }
23697 },
23698 cmd_set_depth_clip_enable_ext: unsafe {
23699 unsafe extern "system" fn cmd_set_depth_clip_enable_ext(
23700 _command_buffer: CommandBuffer,
23701 _depth_clip_enable: Bool32,
23702 ) {
23703 panic!(concat!(
23704 "Unable to load ",
23705 stringify!(cmd_set_depth_clip_enable_ext)
23706 ))
23707 }
23708 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23709 b"vkCmdSetDepthClipEnableEXT\0",
23710 );
23711 let val = _f(cname);
23712 if val.is_null() {
23713 cmd_set_depth_clip_enable_ext
23714 } else {
23715 ::std::mem::transmute(val)
23716 }
23717 },
23718 cmd_set_sample_locations_enable_ext: unsafe {
23719 unsafe extern "system" fn cmd_set_sample_locations_enable_ext(
23720 _command_buffer: CommandBuffer,
23721 _sample_locations_enable: Bool32,
23722 ) {
23723 panic!(concat!(
23724 "Unable to load ",
23725 stringify!(cmd_set_sample_locations_enable_ext)
23726 ))
23727 }
23728 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23729 b"vkCmdSetSampleLocationsEnableEXT\0",
23730 );
23731 let val = _f(cname);
23732 if val.is_null() {
23733 cmd_set_sample_locations_enable_ext
23734 } else {
23735 ::std::mem::transmute(val)
23736 }
23737 },
23738 cmd_set_color_blend_advanced_ext: unsafe {
23739 unsafe extern "system" fn cmd_set_color_blend_advanced_ext(
23740 _command_buffer: CommandBuffer,
23741 _first_attachment: u32,
23742 _attachment_count: u32,
23743 _p_color_blend_advanced: *const ColorBlendAdvancedEXT,
23744 ) {
23745 panic!(concat!(
23746 "Unable to load ",
23747 stringify!(cmd_set_color_blend_advanced_ext)
23748 ))
23749 }
23750 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23751 b"vkCmdSetColorBlendAdvancedEXT\0",
23752 );
23753 let val = _f(cname);
23754 if val.is_null() {
23755 cmd_set_color_blend_advanced_ext
23756 } else {
23757 ::std::mem::transmute(val)
23758 }
23759 },
23760 cmd_set_provoking_vertex_mode_ext: unsafe {
23761 unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext(
23762 _command_buffer: CommandBuffer,
23763 _provoking_vertex_mode: ProvokingVertexModeEXT,
23764 ) {
23765 panic!(concat!(
23766 "Unable to load ",
23767 stringify!(cmd_set_provoking_vertex_mode_ext)
23768 ))
23769 }
23770 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23771 b"vkCmdSetProvokingVertexModeEXT\0",
23772 );
23773 let val = _f(cname);
23774 if val.is_null() {
23775 cmd_set_provoking_vertex_mode_ext
23776 } else {
23777 ::std::mem::transmute(val)
23778 }
23779 },
23780 cmd_set_line_rasterization_mode_ext: unsafe {
23781 unsafe extern "system" fn cmd_set_line_rasterization_mode_ext(
23782 _command_buffer: CommandBuffer,
23783 _line_rasterization_mode: LineRasterizationModeEXT,
23784 ) {
23785 panic!(concat!(
23786 "Unable to load ",
23787 stringify!(cmd_set_line_rasterization_mode_ext)
23788 ))
23789 }
23790 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23791 b"vkCmdSetLineRasterizationModeEXT\0",
23792 );
23793 let val = _f(cname);
23794 if val.is_null() {
23795 cmd_set_line_rasterization_mode_ext
23796 } else {
23797 ::std::mem::transmute(val)
23798 }
23799 },
23800 cmd_set_line_stipple_enable_ext: unsafe {
23801 unsafe extern "system" fn cmd_set_line_stipple_enable_ext(
23802 _command_buffer: CommandBuffer,
23803 _stippled_line_enable: Bool32,
23804 ) {
23805 panic!(concat!(
23806 "Unable to load ",
23807 stringify!(cmd_set_line_stipple_enable_ext)
23808 ))
23809 }
23810 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23811 b"vkCmdSetLineStippleEnableEXT\0",
23812 );
23813 let val = _f(cname);
23814 if val.is_null() {
23815 cmd_set_line_stipple_enable_ext
23816 } else {
23817 ::std::mem::transmute(val)
23818 }
23819 },
23820 cmd_set_depth_clip_negative_one_to_one_ext: unsafe {
23821 unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext(
23822 _command_buffer: CommandBuffer,
23823 _negative_one_to_one: Bool32,
23824 ) {
23825 panic!(concat!(
23826 "Unable to load ",
23827 stringify!(cmd_set_depth_clip_negative_one_to_one_ext)
23828 ))
23829 }
23830 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23831 b"vkCmdSetDepthClipNegativeOneToOneEXT\0",
23832 );
23833 let val = _f(cname);
23834 if val.is_null() {
23835 cmd_set_depth_clip_negative_one_to_one_ext
23836 } else {
23837 ::std::mem::transmute(val)
23838 }
23839 },
23840 cmd_set_viewport_w_scaling_enable_nv: unsafe {
23841 unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv(
23842 _command_buffer: CommandBuffer,
23843 _viewport_w_scaling_enable: Bool32,
23844 ) {
23845 panic!(concat!(
23846 "Unable to load ",
23847 stringify!(cmd_set_viewport_w_scaling_enable_nv)
23848 ))
23849 }
23850 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23851 b"vkCmdSetViewportWScalingEnableNV\0",
23852 );
23853 let val = _f(cname);
23854 if val.is_null() {
23855 cmd_set_viewport_w_scaling_enable_nv
23856 } else {
23857 ::std::mem::transmute(val)
23858 }
23859 },
23860 cmd_set_viewport_swizzle_nv: unsafe {
23861 unsafe extern "system" fn cmd_set_viewport_swizzle_nv(
23862 _command_buffer: CommandBuffer,
23863 _first_viewport: u32,
23864 _viewport_count: u32,
23865 _p_viewport_swizzles: *const ViewportSwizzleNV,
23866 ) {
23867 panic!(concat!(
23868 "Unable to load ",
23869 stringify!(cmd_set_viewport_swizzle_nv)
23870 ))
23871 }
23872 let cname =
23873 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
23874 let val = _f(cname);
23875 if val.is_null() {
23876 cmd_set_viewport_swizzle_nv
23877 } else {
23878 ::std::mem::transmute(val)
23879 }
23880 },
23881 cmd_set_coverage_to_color_enable_nv: unsafe {
23882 unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv(
23883 _command_buffer: CommandBuffer,
23884 _coverage_to_color_enable: Bool32,
23885 ) {
23886 panic!(concat!(
23887 "Unable to load ",
23888 stringify!(cmd_set_coverage_to_color_enable_nv)
23889 ))
23890 }
23891 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23892 b"vkCmdSetCoverageToColorEnableNV\0",
23893 );
23894 let val = _f(cname);
23895 if val.is_null() {
23896 cmd_set_coverage_to_color_enable_nv
23897 } else {
23898 ::std::mem::transmute(val)
23899 }
23900 },
23901 cmd_set_coverage_to_color_location_nv: unsafe {
23902 unsafe extern "system" fn cmd_set_coverage_to_color_location_nv(
23903 _command_buffer: CommandBuffer,
23904 _coverage_to_color_location: u32,
23905 ) {
23906 panic!(concat!(
23907 "Unable to load ",
23908 stringify!(cmd_set_coverage_to_color_location_nv)
23909 ))
23910 }
23911 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23912 b"vkCmdSetCoverageToColorLocationNV\0",
23913 );
23914 let val = _f(cname);
23915 if val.is_null() {
23916 cmd_set_coverage_to_color_location_nv
23917 } else {
23918 ::std::mem::transmute(val)
23919 }
23920 },
23921 cmd_set_coverage_modulation_mode_nv: unsafe {
23922 unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv(
23923 _command_buffer: CommandBuffer,
23924 _coverage_modulation_mode: CoverageModulationModeNV,
23925 ) {
23926 panic!(concat!(
23927 "Unable to load ",
23928 stringify!(cmd_set_coverage_modulation_mode_nv)
23929 ))
23930 }
23931 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23932 b"vkCmdSetCoverageModulationModeNV\0",
23933 );
23934 let val = _f(cname);
23935 if val.is_null() {
23936 cmd_set_coverage_modulation_mode_nv
23937 } else {
23938 ::std::mem::transmute(val)
23939 }
23940 },
23941 cmd_set_coverage_modulation_table_enable_nv: unsafe {
23942 unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv(
23943 _command_buffer: CommandBuffer,
23944 _coverage_modulation_table_enable: Bool32,
23945 ) {
23946 panic!(concat!(
23947 "Unable to load ",
23948 stringify!(cmd_set_coverage_modulation_table_enable_nv)
23949 ))
23950 }
23951 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23952 b"vkCmdSetCoverageModulationTableEnableNV\0",
23953 );
23954 let val = _f(cname);
23955 if val.is_null() {
23956 cmd_set_coverage_modulation_table_enable_nv
23957 } else {
23958 ::std::mem::transmute(val)
23959 }
23960 },
23961 cmd_set_coverage_modulation_table_nv: unsafe {
23962 unsafe extern "system" fn cmd_set_coverage_modulation_table_nv(
23963 _command_buffer: CommandBuffer,
23964 _coverage_modulation_table_count: u32,
23965 _p_coverage_modulation_table: *const f32,
23966 ) {
23967 panic!(concat!(
23968 "Unable to load ",
23969 stringify!(cmd_set_coverage_modulation_table_nv)
23970 ))
23971 }
23972 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23973 b"vkCmdSetCoverageModulationTableNV\0",
23974 );
23975 let val = _f(cname);
23976 if val.is_null() {
23977 cmd_set_coverage_modulation_table_nv
23978 } else {
23979 ::std::mem::transmute(val)
23980 }
23981 },
23982 cmd_set_shading_rate_image_enable_nv: unsafe {
23983 unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv(
23984 _command_buffer: CommandBuffer,
23985 _shading_rate_image_enable: Bool32,
23986 ) {
23987 panic!(concat!(
23988 "Unable to load ",
23989 stringify!(cmd_set_shading_rate_image_enable_nv)
23990 ))
23991 }
23992 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
23993 b"vkCmdSetShadingRateImageEnableNV\0",
23994 );
23995 let val = _f(cname);
23996 if val.is_null() {
23997 cmd_set_shading_rate_image_enable_nv
23998 } else {
23999 ::std::mem::transmute(val)
24000 }
24001 },
24002 cmd_set_representative_fragment_test_enable_nv: unsafe {
24003 unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv(
24004 _command_buffer: CommandBuffer,
24005 _representative_fragment_test_enable: Bool32,
24006 ) {
24007 panic!(concat!(
24008 "Unable to load ",
24009 stringify!(cmd_set_representative_fragment_test_enable_nv)
24010 ))
24011 }
24012 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24013 b"vkCmdSetRepresentativeFragmentTestEnableNV\0",
24014 );
24015 let val = _f(cname);
24016 if val.is_null() {
24017 cmd_set_representative_fragment_test_enable_nv
24018 } else {
24019 ::std::mem::transmute(val)
24020 }
24021 },
24022 cmd_set_coverage_reduction_mode_nv: unsafe {
24023 unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv(
24024 _command_buffer: CommandBuffer,
24025 _coverage_reduction_mode: CoverageReductionModeNV,
24026 ) {
24027 panic!(concat!(
24028 "Unable to load ",
24029 stringify!(cmd_set_coverage_reduction_mode_nv)
24030 ))
24031 }
24032 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24033 b"vkCmdSetCoverageReductionModeNV\0",
24034 );
24035 let val = _f(cname);
24036 if val.is_null() {
24037 cmd_set_coverage_reduction_mode_nv
24038 } else {
24039 ::std::mem::transmute(val)
24040 }
24041 },
24042 }
24043 }
24044}
24045#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"]
24046impl DynamicState {
24047 pub const TESSELLATION_DOMAIN_ORIGIN_EXT: Self = Self(1_000_455_002);
24048 pub const DEPTH_CLAMP_ENABLE_EXT: Self = Self(1_000_455_003);
24049 pub const POLYGON_MODE_EXT: Self = Self(1_000_455_004);
24050 pub const RASTERIZATION_SAMPLES_EXT: Self = Self(1_000_455_005);
24051 pub const SAMPLE_MASK_EXT: Self = Self(1_000_455_006);
24052 pub const ALPHA_TO_COVERAGE_ENABLE_EXT: Self = Self(1_000_455_007);
24053 pub const ALPHA_TO_ONE_ENABLE_EXT: Self = Self(1_000_455_008);
24054 pub const LOGIC_OP_ENABLE_EXT: Self = Self(1_000_455_009);
24055 pub const COLOR_BLEND_ENABLE_EXT: Self = Self(1_000_455_010);
24056 pub const COLOR_BLEND_EQUATION_EXT: Self = Self(1_000_455_011);
24057 pub const COLOR_WRITE_MASK_EXT: Self = Self(1_000_455_012);
24058 pub const RASTERIZATION_STREAM_EXT: Self = Self(1_000_455_013);
24059 pub const CONSERVATIVE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_014);
24060 pub const EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: Self = Self(1_000_455_015);
24061 pub const DEPTH_CLIP_ENABLE_EXT: Self = Self(1_000_455_016);
24062 pub const SAMPLE_LOCATIONS_ENABLE_EXT: Self = Self(1_000_455_017);
24063 pub const COLOR_BLEND_ADVANCED_EXT: Self = Self(1_000_455_018);
24064 pub const PROVOKING_VERTEX_MODE_EXT: Self = Self(1_000_455_019);
24065 pub const LINE_RASTERIZATION_MODE_EXT: Self = Self(1_000_455_020);
24066 pub const LINE_STIPPLE_ENABLE_EXT: Self = Self(1_000_455_021);
24067 pub const DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: Self = Self(1_000_455_022);
24068 pub const VIEWPORT_W_SCALING_ENABLE_NV: Self = Self(1_000_455_023);
24069 pub const VIEWPORT_SWIZZLE_NV: Self = Self(1_000_455_024);
24070 pub const COVERAGE_TO_COLOR_ENABLE_NV: Self = Self(1_000_455_025);
24071 pub const COVERAGE_TO_COLOR_LOCATION_NV: Self = Self(1_000_455_026);
24072 pub const COVERAGE_MODULATION_MODE_NV: Self = Self(1_000_455_027);
24073 pub const COVERAGE_MODULATION_TABLE_ENABLE_NV: Self = Self(1_000_455_028);
24074 pub const COVERAGE_MODULATION_TABLE_NV: Self = Self(1_000_455_029);
24075 pub const SHADING_RATE_IMAGE_ENABLE_NV: Self = Self(1_000_455_030);
24076 pub const REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: Self = Self(1_000_455_031);
24077 pub const COVERAGE_REDUCTION_MODE_NV: Self = Self(1_000_455_032);
24078}
24079#[doc = "Generated from 'VK_EXT_extended_dynamic_state3'"]
24080impl StructureType {
24081 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: Self = Self(1_000_455_000);
24082 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: Self = Self(1_000_455_001);
24083}
24084impl ExtExtension457Fn {
24085 #[inline]
24086 pub const fn name() -> &'static ::std::ffi::CStr {
24087 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_457\0") }
24088 }
24089 pub const SPEC_VERSION: u32 = 0u32;
24090}
24091#[derive(Clone)]
24092pub struct ExtExtension457Fn {}
24093unsafe impl Send for ExtExtension457Fn {}
24094unsafe impl Sync for ExtExtension457Fn {}
24095impl ExtExtension457Fn {
24096 pub fn load<F>(mut _f: F) -> Self
24097 where
24098 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24099 {
24100 Self {}
24101 }
24102}
24103impl ExtExtension458Fn {
24104 #[inline]
24105 pub const fn name() -> &'static ::std::ffi::CStr {
24106 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_458\0") }
24107 }
24108 pub const SPEC_VERSION: u32 = 0u32;
24109}
24110#[derive(Clone)]
24111pub struct ExtExtension458Fn {}
24112unsafe impl Send for ExtExtension458Fn {}
24113unsafe impl Sync for ExtExtension458Fn {}
24114impl ExtExtension458Fn {
24115 pub fn load<F>(mut _f: F) -> Self
24116 where
24117 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24118 {
24119 Self {}
24120 }
24121}
24122impl ExtSubpassMergeFeedbackFn {
24123 #[inline]
24124 pub const fn name() -> &'static ::std::ffi::CStr {
24125 unsafe {
24126 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subpass_merge_feedback\0")
24127 }
24128 }
24129 pub const SPEC_VERSION: u32 = 2u32;
24130}
24131#[derive(Clone)]
24132pub struct ExtSubpassMergeFeedbackFn {}
24133unsafe impl Send for ExtSubpassMergeFeedbackFn {}
24134unsafe impl Sync for ExtSubpassMergeFeedbackFn {}
24135impl ExtSubpassMergeFeedbackFn {
24136 pub fn load<F>(mut _f: F) -> Self
24137 where
24138 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24139 {
24140 Self {}
24141 }
24142}
24143#[doc = "Generated from 'VK_EXT_subpass_merge_feedback'"]
24144impl StructureType {
24145 pub const PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: Self = Self(1_000_458_000);
24146 pub const RENDER_PASS_CREATION_CONTROL_EXT: Self = Self(1_000_458_001);
24147 pub const RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_002);
24148 pub const RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: Self = Self(1_000_458_003);
24149}
24150impl LunargDirectDriverLoadingFn {
24151 #[inline]
24152 pub const fn name() -> &'static ::std::ffi::CStr {
24153 unsafe {
24154 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_LUNARG_direct_driver_loading\0")
24155 }
24156 }
24157 pub const SPEC_VERSION: u32 = 1u32;
24158}
24159#[derive(Clone)]
24160pub struct LunargDirectDriverLoadingFn {}
24161unsafe impl Send for LunargDirectDriverLoadingFn {}
24162unsafe impl Sync for LunargDirectDriverLoadingFn {}
24163impl LunargDirectDriverLoadingFn {
24164 pub fn load<F>(mut _f: F) -> Self
24165 where
24166 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24167 {
24168 Self {}
24169 }
24170}
24171#[doc = "Generated from 'VK_LUNARG_direct_driver_loading'"]
24172impl StructureType {
24173 pub const DIRECT_DRIVER_LOADING_INFO_LUNARG: Self = Self(1_000_459_000);
24174 pub const DIRECT_DRIVER_LOADING_LIST_LUNARG: Self = Self(1_000_459_001);
24175}
24176impl ExtExtension461Fn {
24177 #[inline]
24178 pub const fn name() -> &'static ::std::ffi::CStr {
24179 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_461\0") }
24180 }
24181 pub const SPEC_VERSION: u32 = 0u32;
24182}
24183#[derive(Clone)]
24184pub struct ExtExtension461Fn {}
24185unsafe impl Send for ExtExtension461Fn {}
24186unsafe impl Sync for ExtExtension461Fn {}
24187impl ExtExtension461Fn {
24188 pub fn load<F>(mut _f: F) -> Self
24189 where
24190 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24191 {
24192 Self {}
24193 }
24194}
24195#[doc = "Generated from 'VK_EXT_extension_461'"]
24196impl FormatFeatureFlags2 {
24197 pub const RESERVED_39_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
24198}
24199#[doc = "Generated from 'VK_EXT_extension_461'"]
24200impl ImageUsageFlags {
24201 pub const RESERVED_23_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
24202}
24203impl ExtExtension462Fn {
24204 #[inline]
24205 pub const fn name() -> &'static ::std::ffi::CStr {
24206 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_462\0") }
24207 }
24208 pub const SPEC_VERSION: u32 = 0u32;
24209}
24210#[derive(Clone)]
24211pub struct ExtExtension462Fn {}
24212unsafe impl Send for ExtExtension462Fn {}
24213unsafe impl Sync for ExtExtension462Fn {}
24214impl ExtExtension462Fn {
24215 pub fn load<F>(mut _f: F) -> Self
24216 where
24217 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24218 {
24219 Self {}
24220 }
24221}
24222impl ExtShaderModuleIdentifierFn {
24223 #[inline]
24224 pub const fn name() -> &'static ::std::ffi::CStr {
24225 unsafe {
24226 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_module_identifier\0")
24227 }
24228 }
24229 pub const SPEC_VERSION: u32 = 1u32;
24230}
24231#[allow(non_camel_case_types)]
24232pub type PFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn(
24233 device: Device,
24234 shader_module: ShaderModule,
24235 p_identifier: *mut ShaderModuleIdentifierEXT,
24236);
24237#[allow(non_camel_case_types)]
24238pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn(
24239 device: Device,
24240 p_create_info: *const ShaderModuleCreateInfo,
24241 p_identifier: *mut ShaderModuleIdentifierEXT,
24242);
24243#[derive(Clone)]
24244pub struct ExtShaderModuleIdentifierFn {
24245 pub get_shader_module_identifier_ext: PFN_vkGetShaderModuleIdentifierEXT,
24246 pub get_shader_module_create_info_identifier_ext: PFN_vkGetShaderModuleCreateInfoIdentifierEXT,
24247}
24248unsafe impl Send for ExtShaderModuleIdentifierFn {}
24249unsafe impl Sync for ExtShaderModuleIdentifierFn {}
24250impl ExtShaderModuleIdentifierFn {
24251 pub fn load<F>(mut _f: F) -> Self
24252 where
24253 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24254 {
24255 Self {
24256 get_shader_module_identifier_ext: unsafe {
24257 unsafe extern "system" fn get_shader_module_identifier_ext(
24258 _device: Device,
24259 _shader_module: ShaderModule,
24260 _p_identifier: *mut ShaderModuleIdentifierEXT,
24261 ) {
24262 panic!(concat!(
24263 "Unable to load ",
24264 stringify!(get_shader_module_identifier_ext)
24265 ))
24266 }
24267 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24268 b"vkGetShaderModuleIdentifierEXT\0",
24269 );
24270 let val = _f(cname);
24271 if val.is_null() {
24272 get_shader_module_identifier_ext
24273 } else {
24274 ::std::mem::transmute(val)
24275 }
24276 },
24277 get_shader_module_create_info_identifier_ext: unsafe {
24278 unsafe extern "system" fn get_shader_module_create_info_identifier_ext(
24279 _device: Device,
24280 _p_create_info: *const ShaderModuleCreateInfo,
24281 _p_identifier: *mut ShaderModuleIdentifierEXT,
24282 ) {
24283 panic!(concat!(
24284 "Unable to load ",
24285 stringify!(get_shader_module_create_info_identifier_ext)
24286 ))
24287 }
24288 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24289 b"vkGetShaderModuleCreateInfoIdentifierEXT\0",
24290 );
24291 let val = _f(cname);
24292 if val.is_null() {
24293 get_shader_module_create_info_identifier_ext
24294 } else {
24295 ::std::mem::transmute(val)
24296 }
24297 },
24298 }
24299 }
24300}
24301#[doc = "Generated from 'VK_EXT_shader_module_identifier'"]
24302impl StructureType {
24303 pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: Self = Self(1_000_462_000);
24304 pub const PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: Self = Self(1_000_462_001);
24305 pub const PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: Self = Self(1_000_462_002);
24306 pub const SHADER_MODULE_IDENTIFIER_EXT: Self = Self(1_000_462_003);
24307}
24308impl ExtRasterizationOrderAttachmentAccessFn {
24309 #[inline]
24310 pub const fn name() -> &'static ::std::ffi::CStr {
24311 unsafe {
24312 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24313 b"VK_EXT_rasterization_order_attachment_access\0",
24314 )
24315 }
24316 }
24317 pub const SPEC_VERSION: u32 = 1u32;
24318}
24319#[derive(Clone)]
24320pub struct ExtRasterizationOrderAttachmentAccessFn {}
24321unsafe impl Send for ExtRasterizationOrderAttachmentAccessFn {}
24322unsafe impl Sync for ExtRasterizationOrderAttachmentAccessFn {}
24323impl ExtRasterizationOrderAttachmentAccessFn {
24324 pub fn load<F>(mut _f: F) -> Self
24325 where
24326 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24327 {
24328 Self {}
24329 }
24330}
24331#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
24332impl PipelineColorBlendStateCreateFlags {
24333 pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXT: Self = Self(0b1);
24334}
24335#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
24336impl PipelineDepthStencilStateCreateFlags {
24337 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b1);
24338 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b10);
24339}
24340#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
24341impl StructureType {
24342 pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: Self =
24343 Self(1_000_342_000);
24344}
24345#[doc = "Generated from 'VK_EXT_rasterization_order_attachment_access'"]
24346impl SubpassDescriptionFlags {
24347 pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_EXT: Self = Self(0b1_0000);
24348 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_EXT: Self = Self(0b10_0000);
24349 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_EXT: Self = Self(0b100_0000);
24350}
24351impl NvOpticalFlowFn {
24352 #[inline]
24353 pub const fn name() -> &'static ::std::ffi::CStr {
24354 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_optical_flow\0") }
24355 }
24356 pub const SPEC_VERSION: u32 = 1u32;
24357}
24358#[allow(non_camel_case_types)]
24359pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn(
24360 physical_device: PhysicalDevice,
24361 p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV,
24362 p_format_count: *mut u32,
24363 p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV,
24364) -> Result;
24365#[allow(non_camel_case_types)]
24366pub type PFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn(
24367 device: Device,
24368 p_create_info: *const OpticalFlowSessionCreateInfoNV,
24369 p_allocator: *const AllocationCallbacks,
24370 p_session: *mut OpticalFlowSessionNV,
24371) -> Result;
24372#[allow(non_camel_case_types)]
24373pub type PFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn(
24374 device: Device,
24375 session: OpticalFlowSessionNV,
24376 p_allocator: *const AllocationCallbacks,
24377);
24378#[allow(non_camel_case_types)]
24379pub type PFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn(
24380 device: Device,
24381 session: OpticalFlowSessionNV,
24382 binding_point: OpticalFlowSessionBindingPointNV,
24383 view: ImageView,
24384 layout: ImageLayout,
24385) -> Result;
24386#[allow(non_camel_case_types)]
24387pub type PFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn(
24388 command_buffer: CommandBuffer,
24389 session: OpticalFlowSessionNV,
24390 p_execute_info: *const OpticalFlowExecuteInfoNV,
24391);
24392#[derive(Clone)]
24393pub struct NvOpticalFlowFn {
24394 pub get_physical_device_optical_flow_image_formats_nv:
24395 PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV,
24396 pub create_optical_flow_session_nv: PFN_vkCreateOpticalFlowSessionNV,
24397 pub destroy_optical_flow_session_nv: PFN_vkDestroyOpticalFlowSessionNV,
24398 pub bind_optical_flow_session_image_nv: PFN_vkBindOpticalFlowSessionImageNV,
24399 pub cmd_optical_flow_execute_nv: PFN_vkCmdOpticalFlowExecuteNV,
24400}
24401unsafe impl Send for NvOpticalFlowFn {}
24402unsafe impl Sync for NvOpticalFlowFn {}
24403impl NvOpticalFlowFn {
24404 pub fn load<F>(mut _f: F) -> Self
24405 where
24406 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24407 {
24408 Self {
24409 get_physical_device_optical_flow_image_formats_nv: unsafe {
24410 unsafe extern "system" fn get_physical_device_optical_flow_image_formats_nv(
24411 _physical_device: PhysicalDevice,
24412 _p_optical_flow_image_format_info: *const OpticalFlowImageFormatInfoNV,
24413 _p_format_count: *mut u32,
24414 _p_image_format_properties: *mut OpticalFlowImageFormatPropertiesNV,
24415 ) -> Result {
24416 panic!(concat!(
24417 "Unable to load ",
24418 stringify!(get_physical_device_optical_flow_image_formats_nv)
24419 ))
24420 }
24421 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24422 b"vkGetPhysicalDeviceOpticalFlowImageFormatsNV\0",
24423 );
24424 let val = _f(cname);
24425 if val.is_null() {
24426 get_physical_device_optical_flow_image_formats_nv
24427 } else {
24428 ::std::mem::transmute(val)
24429 }
24430 },
24431 create_optical_flow_session_nv: unsafe {
24432 unsafe extern "system" fn create_optical_flow_session_nv(
24433 _device: Device,
24434 _p_create_info: *const OpticalFlowSessionCreateInfoNV,
24435 _p_allocator: *const AllocationCallbacks,
24436 _p_session: *mut OpticalFlowSessionNV,
24437 ) -> Result {
24438 panic!(concat!(
24439 "Unable to load ",
24440 stringify!(create_optical_flow_session_nv)
24441 ))
24442 }
24443 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24444 b"vkCreateOpticalFlowSessionNV\0",
24445 );
24446 let val = _f(cname);
24447 if val.is_null() {
24448 create_optical_flow_session_nv
24449 } else {
24450 ::std::mem::transmute(val)
24451 }
24452 },
24453 destroy_optical_flow_session_nv: unsafe {
24454 unsafe extern "system" fn destroy_optical_flow_session_nv(
24455 _device: Device,
24456 _session: OpticalFlowSessionNV,
24457 _p_allocator: *const AllocationCallbacks,
24458 ) {
24459 panic!(concat!(
24460 "Unable to load ",
24461 stringify!(destroy_optical_flow_session_nv)
24462 ))
24463 }
24464 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24465 b"vkDestroyOpticalFlowSessionNV\0",
24466 );
24467 let val = _f(cname);
24468 if val.is_null() {
24469 destroy_optical_flow_session_nv
24470 } else {
24471 ::std::mem::transmute(val)
24472 }
24473 },
24474 bind_optical_flow_session_image_nv: unsafe {
24475 unsafe extern "system" fn bind_optical_flow_session_image_nv(
24476 _device: Device,
24477 _session: OpticalFlowSessionNV,
24478 _binding_point: OpticalFlowSessionBindingPointNV,
24479 _view: ImageView,
24480 _layout: ImageLayout,
24481 ) -> Result {
24482 panic!(concat!(
24483 "Unable to load ",
24484 stringify!(bind_optical_flow_session_image_nv)
24485 ))
24486 }
24487 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
24488 b"vkBindOpticalFlowSessionImageNV\0",
24489 );
24490 let val = _f(cname);
24491 if val.is_null() {
24492 bind_optical_flow_session_image_nv
24493 } else {
24494 ::std::mem::transmute(val)
24495 }
24496 },
24497 cmd_optical_flow_execute_nv: unsafe {
24498 unsafe extern "system" fn cmd_optical_flow_execute_nv(
24499 _command_buffer: CommandBuffer,
24500 _session: OpticalFlowSessionNV,
24501 _p_execute_info: *const OpticalFlowExecuteInfoNV,
24502 ) {
24503 panic!(concat!(
24504 "Unable to load ",
24505 stringify!(cmd_optical_flow_execute_nv)
24506 ))
24507 }
24508 let cname =
24509 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdOpticalFlowExecuteNV\0");
24510 let val = _f(cname);
24511 if val.is_null() {
24512 cmd_optical_flow_execute_nv
24513 } else {
24514 ::std::mem::transmute(val)
24515 }
24516 },
24517 }
24518 }
24519}
24520#[doc = "Generated from 'VK_NV_optical_flow'"]
24521impl AccessFlags2 {
24522 pub const OPTICAL_FLOW_READ_NV: Self =
24523 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
24524 pub const OPTICAL_FLOW_WRITE_NV: Self =
24525 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
24526}
24527#[doc = "Generated from 'VK_NV_optical_flow'"]
24528impl Format {
24529 pub const R16G16_S10_5_NV: Self = Self(1_000_464_000);
24530}
24531#[doc = "Generated from 'VK_NV_optical_flow'"]
24532impl FormatFeatureFlags2 {
24533 pub const OPTICAL_FLOW_IMAGE_NV: Self =
24534 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
24535 pub const OPTICAL_FLOW_VECTOR_NV: Self =
24536 Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
24537 pub const OPTICAL_FLOW_COST_NV: Self =
24538 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
24539}
24540#[doc = "Generated from 'VK_NV_optical_flow'"]
24541impl ObjectType {
24542 pub const OPTICAL_FLOW_SESSION_NV: Self = Self(1_000_464_000);
24543}
24544#[doc = "Generated from 'VK_NV_optical_flow'"]
24545impl PipelineStageFlags2 {
24546 pub const OPTICAL_FLOW_NV: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000);
24547}
24548#[doc = "Generated from 'VK_NV_optical_flow'"]
24549impl QueueFlags {
24550 pub const OPTICAL_FLOW_NV: Self = Self(0b1_0000_0000);
24551}
24552#[doc = "Generated from 'VK_NV_optical_flow'"]
24553impl StructureType {
24554 pub const PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: Self = Self(1_000_464_000);
24555 pub const PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: Self = Self(1_000_464_001);
24556 pub const OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: Self = Self(1_000_464_002);
24557 pub const OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: Self = Self(1_000_464_003);
24558 pub const OPTICAL_FLOW_SESSION_CREATE_INFO_NV: Self = Self(1_000_464_004);
24559 pub const OPTICAL_FLOW_EXECUTE_INFO_NV: Self = Self(1_000_464_005);
24560 pub const OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: Self = Self(1_000_464_010);
24561}
24562impl ExtLegacyDitheringFn {
24563 #[inline]
24564 pub const fn name() -> &'static ::std::ffi::CStr {
24565 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_legacy_dithering\0") }
24566 }
24567 pub const SPEC_VERSION: u32 = 1u32;
24568}
24569#[derive(Clone)]
24570pub struct ExtLegacyDitheringFn {}
24571unsafe impl Send for ExtLegacyDitheringFn {}
24572unsafe impl Sync for ExtLegacyDitheringFn {}
24573impl ExtLegacyDitheringFn {
24574 pub fn load<F>(mut _f: F) -> Self
24575 where
24576 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24577 {
24578 Self {}
24579 }
24580}
24581#[doc = "Generated from 'VK_EXT_legacy_dithering'"]
24582impl RenderingFlags {
24583 pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000);
24584}
24585#[doc = "Generated from 'VK_EXT_legacy_dithering'"]
24586impl StructureType {
24587 pub const PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: Self = Self(1_000_465_000);
24588}
24589#[doc = "Generated from 'VK_EXT_legacy_dithering'"]
24590impl SubpassDescriptionFlags {
24591 pub const ENABLE_LEGACY_DITHERING_EXT: Self = Self(0b1000_0000);
24592}
24593impl ExtPipelineProtectedAccessFn {
24594 #[inline]
24595 pub const fn name() -> &'static ::std::ffi::CStr {
24596 unsafe {
24597 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_protected_access\0")
24598 }
24599 }
24600 pub const SPEC_VERSION: u32 = 1u32;
24601}
24602#[derive(Clone)]
24603pub struct ExtPipelineProtectedAccessFn {}
24604unsafe impl Send for ExtPipelineProtectedAccessFn {}
24605unsafe impl Sync for ExtPipelineProtectedAccessFn {}
24606impl ExtPipelineProtectedAccessFn {
24607 pub fn load<F>(mut _f: F) -> Self
24608 where
24609 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24610 {
24611 Self {}
24612 }
24613}
24614#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"]
24615impl PipelineCreateFlags {
24616 pub const NO_PROTECTED_ACCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
24617 pub const PROTECTED_ACCESS_ONLY_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000);
24618}
24619#[doc = "Generated from 'VK_EXT_pipeline_protected_access'"]
24620impl StructureType {
24621 pub const PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: Self = Self(1_000_466_000);
24622}
24623impl ExtExtension468Fn {
24624 #[inline]
24625 pub const fn name() -> &'static ::std::ffi::CStr {
24626 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_468\0") }
24627 }
24628 pub const SPEC_VERSION: u32 = 0u32;
24629}
24630#[derive(Clone)]
24631pub struct ExtExtension468Fn {}
24632unsafe impl Send for ExtExtension468Fn {}
24633unsafe impl Sync for ExtExtension468Fn {}
24634impl ExtExtension468Fn {
24635 pub fn load<F>(mut _f: F) -> Self
24636 where
24637 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24638 {
24639 Self {}
24640 }
24641}
24642impl AndroidExtension469Fn {
24643 #[inline]
24644 pub const fn name() -> &'static ::std::ffi::CStr {
24645 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_extension_469\0") }
24646 }
24647 pub const SPEC_VERSION: u32 = 0u32;
24648}
24649#[derive(Clone)]
24650pub struct AndroidExtension469Fn {}
24651unsafe impl Send for AndroidExtension469Fn {}
24652unsafe impl Sync for AndroidExtension469Fn {}
24653impl AndroidExtension469Fn {
24654 pub fn load<F>(mut _f: F) -> Self
24655 where
24656 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24657 {
24658 Self {}
24659 }
24660}
24661#[doc = "Generated from 'VK_ANDROID_extension_469'"]
24662impl ResolveModeFlags {
24663 pub const EXTENSION_469_FLAG_0: Self = Self(0b1_0000);
24664}
24665impl AmdExtension470Fn {
24666 #[inline]
24667 pub const fn name() -> &'static ::std::ffi::CStr {
24668 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_470\0") }
24669 }
24670 pub const SPEC_VERSION: u32 = 0u32;
24671}
24672#[derive(Clone)]
24673pub struct AmdExtension470Fn {}
24674unsafe impl Send for AmdExtension470Fn {}
24675unsafe impl Sync for AmdExtension470Fn {}
24676impl AmdExtension470Fn {
24677 pub fn load<F>(mut _f: F) -> Self
24678 where
24679 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24680 {
24681 Self {}
24682 }
24683}
24684impl AmdExtension471Fn {
24685 #[inline]
24686 pub const fn name() -> &'static ::std::ffi::CStr {
24687 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_471\0") }
24688 }
24689 pub const SPEC_VERSION: u32 = 0u32;
24690}
24691#[derive(Clone)]
24692pub struct AmdExtension471Fn {}
24693unsafe impl Send for AmdExtension471Fn {}
24694unsafe impl Sync for AmdExtension471Fn {}
24695impl AmdExtension471Fn {
24696 pub fn load<F>(mut _f: F) -> Self
24697 where
24698 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24699 {
24700 Self {}
24701 }
24702}
24703impl AmdExtension472Fn {
24704 #[inline]
24705 pub const fn name() -> &'static ::std::ffi::CStr {
24706 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_472\0") }
24707 }
24708 pub const SPEC_VERSION: u32 = 0u32;
24709}
24710#[derive(Clone)]
24711pub struct AmdExtension472Fn {}
24712unsafe impl Send for AmdExtension472Fn {}
24713unsafe impl Sync for AmdExtension472Fn {}
24714impl AmdExtension472Fn {
24715 pub fn load<F>(mut _f: F) -> Self
24716 where
24717 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24718 {
24719 Self {}
24720 }
24721}
24722impl AmdExtension473Fn {
24723 #[inline]
24724 pub const fn name() -> &'static ::std::ffi::CStr {
24725 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_473\0") }
24726 }
24727 pub const SPEC_VERSION: u32 = 0u32;
24728}
24729#[derive(Clone)]
24730pub struct AmdExtension473Fn {}
24731unsafe impl Send for AmdExtension473Fn {}
24732unsafe impl Sync for AmdExtension473Fn {}
24733impl AmdExtension473Fn {
24734 pub fn load<F>(mut _f: F) -> Self
24735 where
24736 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24737 {
24738 Self {}
24739 }
24740}
24741impl AmdExtension474Fn {
24742 #[inline]
24743 pub const fn name() -> &'static ::std::ffi::CStr {
24744 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_474\0") }
24745 }
24746 pub const SPEC_VERSION: u32 = 0u32;
24747}
24748#[derive(Clone)]
24749pub struct AmdExtension474Fn {}
24750unsafe impl Send for AmdExtension474Fn {}
24751unsafe impl Sync for AmdExtension474Fn {}
24752impl AmdExtension474Fn {
24753 pub fn load<F>(mut _f: F) -> Self
24754 where
24755 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24756 {
24757 Self {}
24758 }
24759}
24760impl AmdExtension475Fn {
24761 #[inline]
24762 pub const fn name() -> &'static ::std::ffi::CStr {
24763 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_475\0") }
24764 }
24765 pub const SPEC_VERSION: u32 = 0u32;
24766}
24767#[derive(Clone)]
24768pub struct AmdExtension475Fn {}
24769unsafe impl Send for AmdExtension475Fn {}
24770unsafe impl Sync for AmdExtension475Fn {}
24771impl AmdExtension475Fn {
24772 pub fn load<F>(mut _f: F) -> Self
24773 where
24774 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24775 {
24776 Self {}
24777 }
24778}
24779impl AmdExtension476Fn {
24780 #[inline]
24781 pub const fn name() -> &'static ::std::ffi::CStr {
24782 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_476\0") }
24783 }
24784 pub const SPEC_VERSION: u32 = 0u32;
24785}
24786#[derive(Clone)]
24787pub struct AmdExtension476Fn {}
24788unsafe impl Send for AmdExtension476Fn {}
24789unsafe impl Sync for AmdExtension476Fn {}
24790impl AmdExtension476Fn {
24791 pub fn load<F>(mut _f: F) -> Self
24792 where
24793 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24794 {
24795 Self {}
24796 }
24797}
24798impl AmdExtension477Fn {
24799 #[inline]
24800 pub const fn name() -> &'static ::std::ffi::CStr {
24801 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_477\0") }
24802 }
24803 pub const SPEC_VERSION: u32 = 0u32;
24804}
24805#[derive(Clone)]
24806pub struct AmdExtension477Fn {}
24807unsafe impl Send for AmdExtension477Fn {}
24808unsafe impl Sync for AmdExtension477Fn {}
24809impl AmdExtension477Fn {
24810 pub fn load<F>(mut _f: F) -> Self
24811 where
24812 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24813 {
24814 Self {}
24815 }
24816}
24817impl AmdExtension478Fn {
24818 #[inline]
24819 pub const fn name() -> &'static ::std::ffi::CStr {
24820 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_478\0") }
24821 }
24822 pub const SPEC_VERSION: u32 = 0u32;
24823}
24824#[derive(Clone)]
24825pub struct AmdExtension478Fn {}
24826unsafe impl Send for AmdExtension478Fn {}
24827unsafe impl Sync for AmdExtension478Fn {}
24828impl AmdExtension478Fn {
24829 pub fn load<F>(mut _f: F) -> Self
24830 where
24831 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24832 {
24833 Self {}
24834 }
24835}
24836impl AmdExtension479Fn {
24837 #[inline]
24838 pub const fn name() -> &'static ::std::ffi::CStr {
24839 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_479\0") }
24840 }
24841 pub const SPEC_VERSION: u32 = 0u32;
24842}
24843#[derive(Clone)]
24844pub struct AmdExtension479Fn {}
24845unsafe impl Send for AmdExtension479Fn {}
24846unsafe impl Sync for AmdExtension479Fn {}
24847impl AmdExtension479Fn {
24848 pub fn load<F>(mut _f: F) -> Self
24849 where
24850 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24851 {
24852 Self {}
24853 }
24854}
24855impl ExtExtension480Fn {
24856 #[inline]
24857 pub const fn name() -> &'static ::std::ffi::CStr {
24858 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_480\0") }
24859 }
24860 pub const SPEC_VERSION: u32 = 0u32;
24861}
24862#[derive(Clone)]
24863pub struct ExtExtension480Fn {}
24864unsafe impl Send for ExtExtension480Fn {}
24865unsafe impl Sync for ExtExtension480Fn {}
24866impl ExtExtension480Fn {
24867 pub fn load<F>(mut _f: F) -> Self
24868 where
24869 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24870 {
24871 Self {}
24872 }
24873}
24874impl ExtExtension481Fn {
24875 #[inline]
24876 pub const fn name() -> &'static ::std::ffi::CStr {
24877 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_481\0") }
24878 }
24879 pub const SPEC_VERSION: u32 = 0u32;
24880}
24881#[derive(Clone)]
24882pub struct ExtExtension481Fn {}
24883unsafe impl Send for ExtExtension481Fn {}
24884unsafe impl Sync for ExtExtension481Fn {}
24885impl ExtExtension481Fn {
24886 pub fn load<F>(mut _f: F) -> Self
24887 where
24888 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24889 {
24890 Self {}
24891 }
24892}
24893impl KhrRayTracingPositionFetchFn {
24894 #[inline]
24895 pub const fn name() -> &'static ::std::ffi::CStr {
24896 unsafe {
24897 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_position_fetch\0")
24898 }
24899 }
24900 pub const SPEC_VERSION: u32 = 1u32;
24901}
24902#[derive(Clone)]
24903pub struct KhrRayTracingPositionFetchFn {}
24904unsafe impl Send for KhrRayTracingPositionFetchFn {}
24905unsafe impl Sync for KhrRayTracingPositionFetchFn {}
24906impl KhrRayTracingPositionFetchFn {
24907 pub fn load<F>(mut _f: F) -> Self
24908 where
24909 F: FnMut(&::std::ffi::CStr) -> *const c_void,
24910 {
24911 Self {}
24912 }
24913}
24914#[doc = "Generated from 'VK_KHR_ray_tracing_position_fetch'"]
24915impl BuildAccelerationStructureFlagsKHR {
24916 pub const ALLOW_DATA_ACCESS: Self = Self(0b1000_0000_0000);
24917}
24918#[doc = "Generated from 'VK_KHR_ray_tracing_position_fetch'"]
24919impl StructureType {
24920 pub const PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: Self = Self(1_000_481_000);
24921}
24922impl ExtShaderObjectFn {
24923 #[inline]
24924 pub const fn name() -> &'static ::std::ffi::CStr {
24925 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_object\0") }
24926 }
24927 pub const SPEC_VERSION: u32 = 1u32;
24928}
24929#[allow(non_camel_case_types)]
24930pub type PFN_vkCreateShadersEXT = unsafe extern "system" fn(
24931 device: Device,
24932 create_info_count: u32,
24933 p_create_infos: *const ShaderCreateInfoEXT,
24934 p_allocator: *const AllocationCallbacks,
24935 p_shaders: *mut ShaderEXT,
24936) -> Result;
24937#[allow(non_camel_case_types)]
24938pub type PFN_vkDestroyShaderEXT = unsafe extern "system" fn(
24939 device: Device,
24940 shader: ShaderEXT,
24941 p_allocator: *const AllocationCallbacks,
24942);
24943#[allow(non_camel_case_types)]
24944pub type PFN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn(
24945 device: Device,
24946 shader: ShaderEXT,
24947 p_data_size: *mut usize,
24948 p_data: *mut c_void,
24949) -> Result;
24950#[allow(non_camel_case_types)]
24951pub type PFN_vkCmdBindShadersEXT = unsafe extern "system" fn(
24952 command_buffer: CommandBuffer,
24953 stage_count: u32,
24954 p_stages: *const ShaderStageFlags,
24955 p_shaders: *const ShaderEXT,
24956);
24957#[derive(Clone)]
24958pub struct ExtShaderObjectFn {
24959 pub create_shaders_ext: PFN_vkCreateShadersEXT,
24960 pub destroy_shader_ext: PFN_vkDestroyShaderEXT,
24961 pub get_shader_binary_data_ext: PFN_vkGetShaderBinaryDataEXT,
24962 pub cmd_bind_shaders_ext: PFN_vkCmdBindShadersEXT,
24963 pub cmd_set_cull_mode_ext: crate::vk::PFN_vkCmdSetCullMode,
24964 pub cmd_set_front_face_ext: crate::vk::PFN_vkCmdSetFrontFace,
24965 pub cmd_set_primitive_topology_ext: crate::vk::PFN_vkCmdSetPrimitiveTopology,
24966 pub cmd_set_viewport_with_count_ext: crate::vk::PFN_vkCmdSetViewportWithCount,
24967 pub cmd_set_scissor_with_count_ext: crate::vk::PFN_vkCmdSetScissorWithCount,
24968 pub cmd_bind_vertex_buffers2_ext: crate::vk::PFN_vkCmdBindVertexBuffers2,
24969 pub cmd_set_depth_test_enable_ext: crate::vk::PFN_vkCmdSetDepthTestEnable,
24970 pub cmd_set_depth_write_enable_ext: crate::vk::PFN_vkCmdSetDepthWriteEnable,
24971 pub cmd_set_depth_compare_op_ext: crate::vk::PFN_vkCmdSetDepthCompareOp,
24972 pub cmd_set_depth_bounds_test_enable_ext: crate::vk::PFN_vkCmdSetDepthBoundsTestEnable,
24973 pub cmd_set_stencil_test_enable_ext: crate::vk::PFN_vkCmdSetStencilTestEnable,
24974 pub cmd_set_stencil_op_ext: crate::vk::PFN_vkCmdSetStencilOp,
24975 pub cmd_set_vertex_input_ext: crate::vk::PFN_vkCmdSetVertexInputEXT,
24976 pub cmd_set_patch_control_points_ext: crate::vk::PFN_vkCmdSetPatchControlPointsEXT,
24977 pub cmd_set_rasterizer_discard_enable_ext: crate::vk::PFN_vkCmdSetRasterizerDiscardEnable,
24978 pub cmd_set_depth_bias_enable_ext: crate::vk::PFN_vkCmdSetDepthBiasEnable,
24979 pub cmd_set_logic_op_ext: crate::vk::PFN_vkCmdSetLogicOpEXT,
24980 pub cmd_set_primitive_restart_enable_ext: crate::vk::PFN_vkCmdSetPrimitiveRestartEnable,
24981 pub cmd_set_tessellation_domain_origin_ext: crate::vk::PFN_vkCmdSetTessellationDomainOriginEXT,
24982 pub cmd_set_depth_clamp_enable_ext: crate::vk::PFN_vkCmdSetDepthClampEnableEXT,
24983 pub cmd_set_polygon_mode_ext: crate::vk::PFN_vkCmdSetPolygonModeEXT,
24984 pub cmd_set_rasterization_samples_ext: crate::vk::PFN_vkCmdSetRasterizationSamplesEXT,
24985 pub cmd_set_sample_mask_ext: crate::vk::PFN_vkCmdSetSampleMaskEXT,
24986 pub cmd_set_alpha_to_coverage_enable_ext: crate::vk::PFN_vkCmdSetAlphaToCoverageEnableEXT,
24987 pub cmd_set_alpha_to_one_enable_ext: crate::vk::PFN_vkCmdSetAlphaToOneEnableEXT,
24988 pub cmd_set_logic_op_enable_ext: crate::vk::PFN_vkCmdSetLogicOpEnableEXT,
24989 pub cmd_set_color_blend_enable_ext: crate::vk::PFN_vkCmdSetColorBlendEnableEXT,
24990 pub cmd_set_color_blend_equation_ext: crate::vk::PFN_vkCmdSetColorBlendEquationEXT,
24991 pub cmd_set_color_write_mask_ext: crate::vk::PFN_vkCmdSetColorWriteMaskEXT,
24992 pub cmd_set_rasterization_stream_ext: crate::vk::PFN_vkCmdSetRasterizationStreamEXT,
24993 pub cmd_set_conservative_rasterization_mode_ext:
24994 crate::vk::PFN_vkCmdSetConservativeRasterizationModeEXT,
24995 pub cmd_set_extra_primitive_overestimation_size_ext:
24996 crate::vk::PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT,
24997 pub cmd_set_depth_clip_enable_ext: crate::vk::PFN_vkCmdSetDepthClipEnableEXT,
24998 pub cmd_set_sample_locations_enable_ext: crate::vk::PFN_vkCmdSetSampleLocationsEnableEXT,
24999 pub cmd_set_color_blend_advanced_ext: crate::vk::PFN_vkCmdSetColorBlendAdvancedEXT,
25000 pub cmd_set_provoking_vertex_mode_ext: crate::vk::PFN_vkCmdSetProvokingVertexModeEXT,
25001 pub cmd_set_line_rasterization_mode_ext: crate::vk::PFN_vkCmdSetLineRasterizationModeEXT,
25002 pub cmd_set_line_stipple_enable_ext: crate::vk::PFN_vkCmdSetLineStippleEnableEXT,
25003 pub cmd_set_depth_clip_negative_one_to_one_ext:
25004 crate::vk::PFN_vkCmdSetDepthClipNegativeOneToOneEXT,
25005 pub cmd_set_viewport_w_scaling_enable_nv: crate::vk::PFN_vkCmdSetViewportWScalingEnableNV,
25006 pub cmd_set_viewport_swizzle_nv: crate::vk::PFN_vkCmdSetViewportSwizzleNV,
25007 pub cmd_set_coverage_to_color_enable_nv: crate::vk::PFN_vkCmdSetCoverageToColorEnableNV,
25008 pub cmd_set_coverage_to_color_location_nv: crate::vk::PFN_vkCmdSetCoverageToColorLocationNV,
25009 pub cmd_set_coverage_modulation_mode_nv: crate::vk::PFN_vkCmdSetCoverageModulationModeNV,
25010 pub cmd_set_coverage_modulation_table_enable_nv:
25011 crate::vk::PFN_vkCmdSetCoverageModulationTableEnableNV,
25012 pub cmd_set_coverage_modulation_table_nv: crate::vk::PFN_vkCmdSetCoverageModulationTableNV,
25013 pub cmd_set_shading_rate_image_enable_nv: crate::vk::PFN_vkCmdSetShadingRateImageEnableNV,
25014 pub cmd_set_representative_fragment_test_enable_nv:
25015 crate::vk::PFN_vkCmdSetRepresentativeFragmentTestEnableNV,
25016 pub cmd_set_coverage_reduction_mode_nv: crate::vk::PFN_vkCmdSetCoverageReductionModeNV,
25017}
25018unsafe impl Send for ExtShaderObjectFn {}
25019unsafe impl Sync for ExtShaderObjectFn {}
25020impl ExtShaderObjectFn {
25021 pub fn load<F>(mut _f: F) -> Self
25022 where
25023 F: FnMut(&::std::ffi::CStr) -> *const c_void,
25024 {
25025 Self {
25026 create_shaders_ext: unsafe {
25027 unsafe extern "system" fn create_shaders_ext(
25028 _device: Device,
25029 _create_info_count: u32,
25030 _p_create_infos: *const ShaderCreateInfoEXT,
25031 _p_allocator: *const AllocationCallbacks,
25032 _p_shaders: *mut ShaderEXT,
25033 ) -> Result {
25034 panic!(concat!("Unable to load ", stringify!(create_shaders_ext)))
25035 }
25036 let cname =
25037 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateShadersEXT\0");
25038 let val = _f(cname);
25039 if val.is_null() {
25040 create_shaders_ext
25041 } else {
25042 ::std::mem::transmute(val)
25043 }
25044 },
25045 destroy_shader_ext: unsafe {
25046 unsafe extern "system" fn destroy_shader_ext(
25047 _device: Device,
25048 _shader: ShaderEXT,
25049 _p_allocator: *const AllocationCallbacks,
25050 ) {
25051 panic!(concat!("Unable to load ", stringify!(destroy_shader_ext)))
25052 }
25053 let cname =
25054 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyShaderEXT\0");
25055 let val = _f(cname);
25056 if val.is_null() {
25057 destroy_shader_ext
25058 } else {
25059 ::std::mem::transmute(val)
25060 }
25061 },
25062 get_shader_binary_data_ext: unsafe {
25063 unsafe extern "system" fn get_shader_binary_data_ext(
25064 _device: Device,
25065 _shader: ShaderEXT,
25066 _p_data_size: *mut usize,
25067 _p_data: *mut c_void,
25068 ) -> Result {
25069 panic!(concat!(
25070 "Unable to load ",
25071 stringify!(get_shader_binary_data_ext)
25072 ))
25073 }
25074 let cname =
25075 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetShaderBinaryDataEXT\0");
25076 let val = _f(cname);
25077 if val.is_null() {
25078 get_shader_binary_data_ext
25079 } else {
25080 ::std::mem::transmute(val)
25081 }
25082 },
25083 cmd_bind_shaders_ext: unsafe {
25084 unsafe extern "system" fn cmd_bind_shaders_ext(
25085 _command_buffer: CommandBuffer,
25086 _stage_count: u32,
25087 _p_stages: *const ShaderStageFlags,
25088 _p_shaders: *const ShaderEXT,
25089 ) {
25090 panic!(concat!("Unable to load ", stringify!(cmd_bind_shaders_ext)))
25091 }
25092 let cname =
25093 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBindShadersEXT\0");
25094 let val = _f(cname);
25095 if val.is_null() {
25096 cmd_bind_shaders_ext
25097 } else {
25098 ::std::mem::transmute(val)
25099 }
25100 },
25101 cmd_set_cull_mode_ext: unsafe {
25102 unsafe extern "system" fn cmd_set_cull_mode_ext(
25103 _command_buffer: CommandBuffer,
25104 _cull_mode: CullModeFlags,
25105 ) {
25106 panic!(concat!(
25107 "Unable to load ",
25108 stringify!(cmd_set_cull_mode_ext)
25109 ))
25110 }
25111 let cname =
25112 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
25113 let val = _f(cname);
25114 if val.is_null() {
25115 cmd_set_cull_mode_ext
25116 } else {
25117 ::std::mem::transmute(val)
25118 }
25119 },
25120 cmd_set_front_face_ext: unsafe {
25121 unsafe extern "system" fn cmd_set_front_face_ext(
25122 _command_buffer: CommandBuffer,
25123 _front_face: FrontFace,
25124 ) {
25125 panic!(concat!(
25126 "Unable to load ",
25127 stringify!(cmd_set_front_face_ext)
25128 ))
25129 }
25130 let cname =
25131 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
25132 let val = _f(cname);
25133 if val.is_null() {
25134 cmd_set_front_face_ext
25135 } else {
25136 ::std::mem::transmute(val)
25137 }
25138 },
25139 cmd_set_primitive_topology_ext: unsafe {
25140 unsafe extern "system" fn cmd_set_primitive_topology_ext(
25141 _command_buffer: CommandBuffer,
25142 _primitive_topology: PrimitiveTopology,
25143 ) {
25144 panic!(concat!(
25145 "Unable to load ",
25146 stringify!(cmd_set_primitive_topology_ext)
25147 ))
25148 }
25149 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25150 b"vkCmdSetPrimitiveTopologyEXT\0",
25151 );
25152 let val = _f(cname);
25153 if val.is_null() {
25154 cmd_set_primitive_topology_ext
25155 } else {
25156 ::std::mem::transmute(val)
25157 }
25158 },
25159 cmd_set_viewport_with_count_ext: unsafe {
25160 unsafe extern "system" fn cmd_set_viewport_with_count_ext(
25161 _command_buffer: CommandBuffer,
25162 _viewport_count: u32,
25163 _p_viewports: *const Viewport,
25164 ) {
25165 panic!(concat!(
25166 "Unable to load ",
25167 stringify!(cmd_set_viewport_with_count_ext)
25168 ))
25169 }
25170 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25171 b"vkCmdSetViewportWithCountEXT\0",
25172 );
25173 let val = _f(cname);
25174 if val.is_null() {
25175 cmd_set_viewport_with_count_ext
25176 } else {
25177 ::std::mem::transmute(val)
25178 }
25179 },
25180 cmd_set_scissor_with_count_ext: unsafe {
25181 unsafe extern "system" fn cmd_set_scissor_with_count_ext(
25182 _command_buffer: CommandBuffer,
25183 _scissor_count: u32,
25184 _p_scissors: *const Rect2D,
25185 ) {
25186 panic!(concat!(
25187 "Unable to load ",
25188 stringify!(cmd_set_scissor_with_count_ext)
25189 ))
25190 }
25191 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25192 b"vkCmdSetScissorWithCountEXT\0",
25193 );
25194 let val = _f(cname);
25195 if val.is_null() {
25196 cmd_set_scissor_with_count_ext
25197 } else {
25198 ::std::mem::transmute(val)
25199 }
25200 },
25201 cmd_bind_vertex_buffers2_ext: unsafe {
25202 unsafe extern "system" fn cmd_bind_vertex_buffers2_ext(
25203 _command_buffer: CommandBuffer,
25204 _first_binding: u32,
25205 _binding_count: u32,
25206 _p_buffers: *const Buffer,
25207 _p_offsets: *const DeviceSize,
25208 _p_sizes: *const DeviceSize,
25209 _p_strides: *const DeviceSize,
25210 ) {
25211 panic!(concat!(
25212 "Unable to load ",
25213 stringify!(cmd_bind_vertex_buffers2_ext)
25214 ))
25215 }
25216 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25217 b"vkCmdBindVertexBuffers2EXT\0",
25218 );
25219 let val = _f(cname);
25220 if val.is_null() {
25221 cmd_bind_vertex_buffers2_ext
25222 } else {
25223 ::std::mem::transmute(val)
25224 }
25225 },
25226 cmd_set_depth_test_enable_ext: unsafe {
25227 unsafe extern "system" fn cmd_set_depth_test_enable_ext(
25228 _command_buffer: CommandBuffer,
25229 _depth_test_enable: Bool32,
25230 ) {
25231 panic!(concat!(
25232 "Unable to load ",
25233 stringify!(cmd_set_depth_test_enable_ext)
25234 ))
25235 }
25236 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25237 b"vkCmdSetDepthTestEnableEXT\0",
25238 );
25239 let val = _f(cname);
25240 if val.is_null() {
25241 cmd_set_depth_test_enable_ext
25242 } else {
25243 ::std::mem::transmute(val)
25244 }
25245 },
25246 cmd_set_depth_write_enable_ext: unsafe {
25247 unsafe extern "system" fn cmd_set_depth_write_enable_ext(
25248 _command_buffer: CommandBuffer,
25249 _depth_write_enable: Bool32,
25250 ) {
25251 panic!(concat!(
25252 "Unable to load ",
25253 stringify!(cmd_set_depth_write_enable_ext)
25254 ))
25255 }
25256 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25257 b"vkCmdSetDepthWriteEnableEXT\0",
25258 );
25259 let val = _f(cname);
25260 if val.is_null() {
25261 cmd_set_depth_write_enable_ext
25262 } else {
25263 ::std::mem::transmute(val)
25264 }
25265 },
25266 cmd_set_depth_compare_op_ext: unsafe {
25267 unsafe extern "system" fn cmd_set_depth_compare_op_ext(
25268 _command_buffer: CommandBuffer,
25269 _depth_compare_op: CompareOp,
25270 ) {
25271 panic!(concat!(
25272 "Unable to load ",
25273 stringify!(cmd_set_depth_compare_op_ext)
25274 ))
25275 }
25276 let cname =
25277 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
25278 let val = _f(cname);
25279 if val.is_null() {
25280 cmd_set_depth_compare_op_ext
25281 } else {
25282 ::std::mem::transmute(val)
25283 }
25284 },
25285 cmd_set_depth_bounds_test_enable_ext: unsafe {
25286 unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext(
25287 _command_buffer: CommandBuffer,
25288 _depth_bounds_test_enable: Bool32,
25289 ) {
25290 panic!(concat!(
25291 "Unable to load ",
25292 stringify!(cmd_set_depth_bounds_test_enable_ext)
25293 ))
25294 }
25295 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25296 b"vkCmdSetDepthBoundsTestEnableEXT\0",
25297 );
25298 let val = _f(cname);
25299 if val.is_null() {
25300 cmd_set_depth_bounds_test_enable_ext
25301 } else {
25302 ::std::mem::transmute(val)
25303 }
25304 },
25305 cmd_set_stencil_test_enable_ext: unsafe {
25306 unsafe extern "system" fn cmd_set_stencil_test_enable_ext(
25307 _command_buffer: CommandBuffer,
25308 _stencil_test_enable: Bool32,
25309 ) {
25310 panic!(concat!(
25311 "Unable to load ",
25312 stringify!(cmd_set_stencil_test_enable_ext)
25313 ))
25314 }
25315 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25316 b"vkCmdSetStencilTestEnableEXT\0",
25317 );
25318 let val = _f(cname);
25319 if val.is_null() {
25320 cmd_set_stencil_test_enable_ext
25321 } else {
25322 ::std::mem::transmute(val)
25323 }
25324 },
25325 cmd_set_stencil_op_ext: unsafe {
25326 unsafe extern "system" fn cmd_set_stencil_op_ext(
25327 _command_buffer: CommandBuffer,
25328 _face_mask: StencilFaceFlags,
25329 _fail_op: StencilOp,
25330 _pass_op: StencilOp,
25331 _depth_fail_op: StencilOp,
25332 _compare_op: CompareOp,
25333 ) {
25334 panic!(concat!(
25335 "Unable to load ",
25336 stringify!(cmd_set_stencil_op_ext)
25337 ))
25338 }
25339 let cname =
25340 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
25341 let val = _f(cname);
25342 if val.is_null() {
25343 cmd_set_stencil_op_ext
25344 } else {
25345 ::std::mem::transmute(val)
25346 }
25347 },
25348 cmd_set_vertex_input_ext: unsafe {
25349 unsafe extern "system" fn cmd_set_vertex_input_ext(
25350 _command_buffer: CommandBuffer,
25351 _vertex_binding_description_count: u32,
25352 _p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT,
25353 _vertex_attribute_description_count: u32,
25354 _p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT,
25355 ) {
25356 panic!(concat!(
25357 "Unable to load ",
25358 stringify!(cmd_set_vertex_input_ext)
25359 ))
25360 }
25361 let cname =
25362 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
25363 let val = _f(cname);
25364 if val.is_null() {
25365 cmd_set_vertex_input_ext
25366 } else {
25367 ::std::mem::transmute(val)
25368 }
25369 },
25370 cmd_set_patch_control_points_ext: unsafe {
25371 unsafe extern "system" fn cmd_set_patch_control_points_ext(
25372 _command_buffer: CommandBuffer,
25373 _patch_control_points: u32,
25374 ) {
25375 panic!(concat!(
25376 "Unable to load ",
25377 stringify!(cmd_set_patch_control_points_ext)
25378 ))
25379 }
25380 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25381 b"vkCmdSetPatchControlPointsEXT\0",
25382 );
25383 let val = _f(cname);
25384 if val.is_null() {
25385 cmd_set_patch_control_points_ext
25386 } else {
25387 ::std::mem::transmute(val)
25388 }
25389 },
25390 cmd_set_rasterizer_discard_enable_ext: unsafe {
25391 unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext(
25392 _command_buffer: CommandBuffer,
25393 _rasterizer_discard_enable: Bool32,
25394 ) {
25395 panic!(concat!(
25396 "Unable to load ",
25397 stringify!(cmd_set_rasterizer_discard_enable_ext)
25398 ))
25399 }
25400 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25401 b"vkCmdSetRasterizerDiscardEnableEXT\0",
25402 );
25403 let val = _f(cname);
25404 if val.is_null() {
25405 cmd_set_rasterizer_discard_enable_ext
25406 } else {
25407 ::std::mem::transmute(val)
25408 }
25409 },
25410 cmd_set_depth_bias_enable_ext: unsafe {
25411 unsafe extern "system" fn cmd_set_depth_bias_enable_ext(
25412 _command_buffer: CommandBuffer,
25413 _depth_bias_enable: Bool32,
25414 ) {
25415 panic!(concat!(
25416 "Unable to load ",
25417 stringify!(cmd_set_depth_bias_enable_ext)
25418 ))
25419 }
25420 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25421 b"vkCmdSetDepthBiasEnableEXT\0",
25422 );
25423 let val = _f(cname);
25424 if val.is_null() {
25425 cmd_set_depth_bias_enable_ext
25426 } else {
25427 ::std::mem::transmute(val)
25428 }
25429 },
25430 cmd_set_logic_op_ext: unsafe {
25431 unsafe extern "system" fn cmd_set_logic_op_ext(
25432 _command_buffer: CommandBuffer,
25433 _logic_op: LogicOp,
25434 ) {
25435 panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext)))
25436 }
25437 let cname =
25438 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
25439 let val = _f(cname);
25440 if val.is_null() {
25441 cmd_set_logic_op_ext
25442 } else {
25443 ::std::mem::transmute(val)
25444 }
25445 },
25446 cmd_set_primitive_restart_enable_ext: unsafe {
25447 unsafe extern "system" fn cmd_set_primitive_restart_enable_ext(
25448 _command_buffer: CommandBuffer,
25449 _primitive_restart_enable: Bool32,
25450 ) {
25451 panic!(concat!(
25452 "Unable to load ",
25453 stringify!(cmd_set_primitive_restart_enable_ext)
25454 ))
25455 }
25456 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25457 b"vkCmdSetPrimitiveRestartEnableEXT\0",
25458 );
25459 let val = _f(cname);
25460 if val.is_null() {
25461 cmd_set_primitive_restart_enable_ext
25462 } else {
25463 ::std::mem::transmute(val)
25464 }
25465 },
25466 cmd_set_tessellation_domain_origin_ext: unsafe {
25467 unsafe extern "system" fn cmd_set_tessellation_domain_origin_ext(
25468 _command_buffer: CommandBuffer,
25469 _domain_origin: TessellationDomainOrigin,
25470 ) {
25471 panic!(concat!(
25472 "Unable to load ",
25473 stringify!(cmd_set_tessellation_domain_origin_ext)
25474 ))
25475 }
25476 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25477 b"vkCmdSetTessellationDomainOriginEXT\0",
25478 );
25479 let val = _f(cname);
25480 if val.is_null() {
25481 cmd_set_tessellation_domain_origin_ext
25482 } else {
25483 ::std::mem::transmute(val)
25484 }
25485 },
25486 cmd_set_depth_clamp_enable_ext: unsafe {
25487 unsafe extern "system" fn cmd_set_depth_clamp_enable_ext(
25488 _command_buffer: CommandBuffer,
25489 _depth_clamp_enable: Bool32,
25490 ) {
25491 panic!(concat!(
25492 "Unable to load ",
25493 stringify!(cmd_set_depth_clamp_enable_ext)
25494 ))
25495 }
25496 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25497 b"vkCmdSetDepthClampEnableEXT\0",
25498 );
25499 let val = _f(cname);
25500 if val.is_null() {
25501 cmd_set_depth_clamp_enable_ext
25502 } else {
25503 ::std::mem::transmute(val)
25504 }
25505 },
25506 cmd_set_polygon_mode_ext: unsafe {
25507 unsafe extern "system" fn cmd_set_polygon_mode_ext(
25508 _command_buffer: CommandBuffer,
25509 _polygon_mode: PolygonMode,
25510 ) {
25511 panic!(concat!(
25512 "Unable to load ",
25513 stringify!(cmd_set_polygon_mode_ext)
25514 ))
25515 }
25516 let cname =
25517 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetPolygonModeEXT\0");
25518 let val = _f(cname);
25519 if val.is_null() {
25520 cmd_set_polygon_mode_ext
25521 } else {
25522 ::std::mem::transmute(val)
25523 }
25524 },
25525 cmd_set_rasterization_samples_ext: unsafe {
25526 unsafe extern "system" fn cmd_set_rasterization_samples_ext(
25527 _command_buffer: CommandBuffer,
25528 _rasterization_samples: SampleCountFlags,
25529 ) {
25530 panic!(concat!(
25531 "Unable to load ",
25532 stringify!(cmd_set_rasterization_samples_ext)
25533 ))
25534 }
25535 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25536 b"vkCmdSetRasterizationSamplesEXT\0",
25537 );
25538 let val = _f(cname);
25539 if val.is_null() {
25540 cmd_set_rasterization_samples_ext
25541 } else {
25542 ::std::mem::transmute(val)
25543 }
25544 },
25545 cmd_set_sample_mask_ext: unsafe {
25546 unsafe extern "system" fn cmd_set_sample_mask_ext(
25547 _command_buffer: CommandBuffer,
25548 _samples: SampleCountFlags,
25549 _p_sample_mask: *const SampleMask,
25550 ) {
25551 panic!(concat!(
25552 "Unable to load ",
25553 stringify!(cmd_set_sample_mask_ext)
25554 ))
25555 }
25556 let cname =
25557 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetSampleMaskEXT\0");
25558 let val = _f(cname);
25559 if val.is_null() {
25560 cmd_set_sample_mask_ext
25561 } else {
25562 ::std::mem::transmute(val)
25563 }
25564 },
25565 cmd_set_alpha_to_coverage_enable_ext: unsafe {
25566 unsafe extern "system" fn cmd_set_alpha_to_coverage_enable_ext(
25567 _command_buffer: CommandBuffer,
25568 _alpha_to_coverage_enable: Bool32,
25569 ) {
25570 panic!(concat!(
25571 "Unable to load ",
25572 stringify!(cmd_set_alpha_to_coverage_enable_ext)
25573 ))
25574 }
25575 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25576 b"vkCmdSetAlphaToCoverageEnableEXT\0",
25577 );
25578 let val = _f(cname);
25579 if val.is_null() {
25580 cmd_set_alpha_to_coverage_enable_ext
25581 } else {
25582 ::std::mem::transmute(val)
25583 }
25584 },
25585 cmd_set_alpha_to_one_enable_ext: unsafe {
25586 unsafe extern "system" fn cmd_set_alpha_to_one_enable_ext(
25587 _command_buffer: CommandBuffer,
25588 _alpha_to_one_enable: Bool32,
25589 ) {
25590 panic!(concat!(
25591 "Unable to load ",
25592 stringify!(cmd_set_alpha_to_one_enable_ext)
25593 ))
25594 }
25595 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25596 b"vkCmdSetAlphaToOneEnableEXT\0",
25597 );
25598 let val = _f(cname);
25599 if val.is_null() {
25600 cmd_set_alpha_to_one_enable_ext
25601 } else {
25602 ::std::mem::transmute(val)
25603 }
25604 },
25605 cmd_set_logic_op_enable_ext: unsafe {
25606 unsafe extern "system" fn cmd_set_logic_op_enable_ext(
25607 _command_buffer: CommandBuffer,
25608 _logic_op_enable: Bool32,
25609 ) {
25610 panic!(concat!(
25611 "Unable to load ",
25612 stringify!(cmd_set_logic_op_enable_ext)
25613 ))
25614 }
25615 let cname =
25616 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEnableEXT\0");
25617 let val = _f(cname);
25618 if val.is_null() {
25619 cmd_set_logic_op_enable_ext
25620 } else {
25621 ::std::mem::transmute(val)
25622 }
25623 },
25624 cmd_set_color_blend_enable_ext: unsafe {
25625 unsafe extern "system" fn cmd_set_color_blend_enable_ext(
25626 _command_buffer: CommandBuffer,
25627 _first_attachment: u32,
25628 _attachment_count: u32,
25629 _p_color_blend_enables: *const Bool32,
25630 ) {
25631 panic!(concat!(
25632 "Unable to load ",
25633 stringify!(cmd_set_color_blend_enable_ext)
25634 ))
25635 }
25636 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25637 b"vkCmdSetColorBlendEnableEXT\0",
25638 );
25639 let val = _f(cname);
25640 if val.is_null() {
25641 cmd_set_color_blend_enable_ext
25642 } else {
25643 ::std::mem::transmute(val)
25644 }
25645 },
25646 cmd_set_color_blend_equation_ext: unsafe {
25647 unsafe extern "system" fn cmd_set_color_blend_equation_ext(
25648 _command_buffer: CommandBuffer,
25649 _first_attachment: u32,
25650 _attachment_count: u32,
25651 _p_color_blend_equations: *const ColorBlendEquationEXT,
25652 ) {
25653 panic!(concat!(
25654 "Unable to load ",
25655 stringify!(cmd_set_color_blend_equation_ext)
25656 ))
25657 }
25658 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25659 b"vkCmdSetColorBlendEquationEXT\0",
25660 );
25661 let val = _f(cname);
25662 if val.is_null() {
25663 cmd_set_color_blend_equation_ext
25664 } else {
25665 ::std::mem::transmute(val)
25666 }
25667 },
25668 cmd_set_color_write_mask_ext: unsafe {
25669 unsafe extern "system" fn cmd_set_color_write_mask_ext(
25670 _command_buffer: CommandBuffer,
25671 _first_attachment: u32,
25672 _attachment_count: u32,
25673 _p_color_write_masks: *const ColorComponentFlags,
25674 ) {
25675 panic!(concat!(
25676 "Unable to load ",
25677 stringify!(cmd_set_color_write_mask_ext)
25678 ))
25679 }
25680 let cname =
25681 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetColorWriteMaskEXT\0");
25682 let val = _f(cname);
25683 if val.is_null() {
25684 cmd_set_color_write_mask_ext
25685 } else {
25686 ::std::mem::transmute(val)
25687 }
25688 },
25689 cmd_set_rasterization_stream_ext: unsafe {
25690 unsafe extern "system" fn cmd_set_rasterization_stream_ext(
25691 _command_buffer: CommandBuffer,
25692 _rasterization_stream: u32,
25693 ) {
25694 panic!(concat!(
25695 "Unable to load ",
25696 stringify!(cmd_set_rasterization_stream_ext)
25697 ))
25698 }
25699 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25700 b"vkCmdSetRasterizationStreamEXT\0",
25701 );
25702 let val = _f(cname);
25703 if val.is_null() {
25704 cmd_set_rasterization_stream_ext
25705 } else {
25706 ::std::mem::transmute(val)
25707 }
25708 },
25709 cmd_set_conservative_rasterization_mode_ext: unsafe {
25710 unsafe extern "system" fn cmd_set_conservative_rasterization_mode_ext(
25711 _command_buffer: CommandBuffer,
25712 _conservative_rasterization_mode: ConservativeRasterizationModeEXT,
25713 ) {
25714 panic!(concat!(
25715 "Unable to load ",
25716 stringify!(cmd_set_conservative_rasterization_mode_ext)
25717 ))
25718 }
25719 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25720 b"vkCmdSetConservativeRasterizationModeEXT\0",
25721 );
25722 let val = _f(cname);
25723 if val.is_null() {
25724 cmd_set_conservative_rasterization_mode_ext
25725 } else {
25726 ::std::mem::transmute(val)
25727 }
25728 },
25729 cmd_set_extra_primitive_overestimation_size_ext: unsafe {
25730 unsafe extern "system" fn cmd_set_extra_primitive_overestimation_size_ext(
25731 _command_buffer: CommandBuffer,
25732 _extra_primitive_overestimation_size: f32,
25733 ) {
25734 panic!(concat!(
25735 "Unable to load ",
25736 stringify!(cmd_set_extra_primitive_overestimation_size_ext)
25737 ))
25738 }
25739 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25740 b"vkCmdSetExtraPrimitiveOverestimationSizeEXT\0",
25741 );
25742 let val = _f(cname);
25743 if val.is_null() {
25744 cmd_set_extra_primitive_overestimation_size_ext
25745 } else {
25746 ::std::mem::transmute(val)
25747 }
25748 },
25749 cmd_set_depth_clip_enable_ext: unsafe {
25750 unsafe extern "system" fn cmd_set_depth_clip_enable_ext(
25751 _command_buffer: CommandBuffer,
25752 _depth_clip_enable: Bool32,
25753 ) {
25754 panic!(concat!(
25755 "Unable to load ",
25756 stringify!(cmd_set_depth_clip_enable_ext)
25757 ))
25758 }
25759 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25760 b"vkCmdSetDepthClipEnableEXT\0",
25761 );
25762 let val = _f(cname);
25763 if val.is_null() {
25764 cmd_set_depth_clip_enable_ext
25765 } else {
25766 ::std::mem::transmute(val)
25767 }
25768 },
25769 cmd_set_sample_locations_enable_ext: unsafe {
25770 unsafe extern "system" fn cmd_set_sample_locations_enable_ext(
25771 _command_buffer: CommandBuffer,
25772 _sample_locations_enable: Bool32,
25773 ) {
25774 panic!(concat!(
25775 "Unable to load ",
25776 stringify!(cmd_set_sample_locations_enable_ext)
25777 ))
25778 }
25779 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25780 b"vkCmdSetSampleLocationsEnableEXT\0",
25781 );
25782 let val = _f(cname);
25783 if val.is_null() {
25784 cmd_set_sample_locations_enable_ext
25785 } else {
25786 ::std::mem::transmute(val)
25787 }
25788 },
25789 cmd_set_color_blend_advanced_ext: unsafe {
25790 unsafe extern "system" fn cmd_set_color_blend_advanced_ext(
25791 _command_buffer: CommandBuffer,
25792 _first_attachment: u32,
25793 _attachment_count: u32,
25794 _p_color_blend_advanced: *const ColorBlendAdvancedEXT,
25795 ) {
25796 panic!(concat!(
25797 "Unable to load ",
25798 stringify!(cmd_set_color_blend_advanced_ext)
25799 ))
25800 }
25801 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25802 b"vkCmdSetColorBlendAdvancedEXT\0",
25803 );
25804 let val = _f(cname);
25805 if val.is_null() {
25806 cmd_set_color_blend_advanced_ext
25807 } else {
25808 ::std::mem::transmute(val)
25809 }
25810 },
25811 cmd_set_provoking_vertex_mode_ext: unsafe {
25812 unsafe extern "system" fn cmd_set_provoking_vertex_mode_ext(
25813 _command_buffer: CommandBuffer,
25814 _provoking_vertex_mode: ProvokingVertexModeEXT,
25815 ) {
25816 panic!(concat!(
25817 "Unable to load ",
25818 stringify!(cmd_set_provoking_vertex_mode_ext)
25819 ))
25820 }
25821 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25822 b"vkCmdSetProvokingVertexModeEXT\0",
25823 );
25824 let val = _f(cname);
25825 if val.is_null() {
25826 cmd_set_provoking_vertex_mode_ext
25827 } else {
25828 ::std::mem::transmute(val)
25829 }
25830 },
25831 cmd_set_line_rasterization_mode_ext: unsafe {
25832 unsafe extern "system" fn cmd_set_line_rasterization_mode_ext(
25833 _command_buffer: CommandBuffer,
25834 _line_rasterization_mode: LineRasterizationModeEXT,
25835 ) {
25836 panic!(concat!(
25837 "Unable to load ",
25838 stringify!(cmd_set_line_rasterization_mode_ext)
25839 ))
25840 }
25841 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25842 b"vkCmdSetLineRasterizationModeEXT\0",
25843 );
25844 let val = _f(cname);
25845 if val.is_null() {
25846 cmd_set_line_rasterization_mode_ext
25847 } else {
25848 ::std::mem::transmute(val)
25849 }
25850 },
25851 cmd_set_line_stipple_enable_ext: unsafe {
25852 unsafe extern "system" fn cmd_set_line_stipple_enable_ext(
25853 _command_buffer: CommandBuffer,
25854 _stippled_line_enable: Bool32,
25855 ) {
25856 panic!(concat!(
25857 "Unable to load ",
25858 stringify!(cmd_set_line_stipple_enable_ext)
25859 ))
25860 }
25861 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25862 b"vkCmdSetLineStippleEnableEXT\0",
25863 );
25864 let val = _f(cname);
25865 if val.is_null() {
25866 cmd_set_line_stipple_enable_ext
25867 } else {
25868 ::std::mem::transmute(val)
25869 }
25870 },
25871 cmd_set_depth_clip_negative_one_to_one_ext: unsafe {
25872 unsafe extern "system" fn cmd_set_depth_clip_negative_one_to_one_ext(
25873 _command_buffer: CommandBuffer,
25874 _negative_one_to_one: Bool32,
25875 ) {
25876 panic!(concat!(
25877 "Unable to load ",
25878 stringify!(cmd_set_depth_clip_negative_one_to_one_ext)
25879 ))
25880 }
25881 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25882 b"vkCmdSetDepthClipNegativeOneToOneEXT\0",
25883 );
25884 let val = _f(cname);
25885 if val.is_null() {
25886 cmd_set_depth_clip_negative_one_to_one_ext
25887 } else {
25888 ::std::mem::transmute(val)
25889 }
25890 },
25891 cmd_set_viewport_w_scaling_enable_nv: unsafe {
25892 unsafe extern "system" fn cmd_set_viewport_w_scaling_enable_nv(
25893 _command_buffer: CommandBuffer,
25894 _viewport_w_scaling_enable: Bool32,
25895 ) {
25896 panic!(concat!(
25897 "Unable to load ",
25898 stringify!(cmd_set_viewport_w_scaling_enable_nv)
25899 ))
25900 }
25901 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25902 b"vkCmdSetViewportWScalingEnableNV\0",
25903 );
25904 let val = _f(cname);
25905 if val.is_null() {
25906 cmd_set_viewport_w_scaling_enable_nv
25907 } else {
25908 ::std::mem::transmute(val)
25909 }
25910 },
25911 cmd_set_viewport_swizzle_nv: unsafe {
25912 unsafe extern "system" fn cmd_set_viewport_swizzle_nv(
25913 _command_buffer: CommandBuffer,
25914 _first_viewport: u32,
25915 _viewport_count: u32,
25916 _p_viewport_swizzles: *const ViewportSwizzleNV,
25917 ) {
25918 panic!(concat!(
25919 "Unable to load ",
25920 stringify!(cmd_set_viewport_swizzle_nv)
25921 ))
25922 }
25923 let cname =
25924 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetViewportSwizzleNV\0");
25925 let val = _f(cname);
25926 if val.is_null() {
25927 cmd_set_viewport_swizzle_nv
25928 } else {
25929 ::std::mem::transmute(val)
25930 }
25931 },
25932 cmd_set_coverage_to_color_enable_nv: unsafe {
25933 unsafe extern "system" fn cmd_set_coverage_to_color_enable_nv(
25934 _command_buffer: CommandBuffer,
25935 _coverage_to_color_enable: Bool32,
25936 ) {
25937 panic!(concat!(
25938 "Unable to load ",
25939 stringify!(cmd_set_coverage_to_color_enable_nv)
25940 ))
25941 }
25942 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25943 b"vkCmdSetCoverageToColorEnableNV\0",
25944 );
25945 let val = _f(cname);
25946 if val.is_null() {
25947 cmd_set_coverage_to_color_enable_nv
25948 } else {
25949 ::std::mem::transmute(val)
25950 }
25951 },
25952 cmd_set_coverage_to_color_location_nv: unsafe {
25953 unsafe extern "system" fn cmd_set_coverage_to_color_location_nv(
25954 _command_buffer: CommandBuffer,
25955 _coverage_to_color_location: u32,
25956 ) {
25957 panic!(concat!(
25958 "Unable to load ",
25959 stringify!(cmd_set_coverage_to_color_location_nv)
25960 ))
25961 }
25962 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25963 b"vkCmdSetCoverageToColorLocationNV\0",
25964 );
25965 let val = _f(cname);
25966 if val.is_null() {
25967 cmd_set_coverage_to_color_location_nv
25968 } else {
25969 ::std::mem::transmute(val)
25970 }
25971 },
25972 cmd_set_coverage_modulation_mode_nv: unsafe {
25973 unsafe extern "system" fn cmd_set_coverage_modulation_mode_nv(
25974 _command_buffer: CommandBuffer,
25975 _coverage_modulation_mode: CoverageModulationModeNV,
25976 ) {
25977 panic!(concat!(
25978 "Unable to load ",
25979 stringify!(cmd_set_coverage_modulation_mode_nv)
25980 ))
25981 }
25982 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
25983 b"vkCmdSetCoverageModulationModeNV\0",
25984 );
25985 let val = _f(cname);
25986 if val.is_null() {
25987 cmd_set_coverage_modulation_mode_nv
25988 } else {
25989 ::std::mem::transmute(val)
25990 }
25991 },
25992 cmd_set_coverage_modulation_table_enable_nv: unsafe {
25993 unsafe extern "system" fn cmd_set_coverage_modulation_table_enable_nv(
25994 _command_buffer: CommandBuffer,
25995 _coverage_modulation_table_enable: Bool32,
25996 ) {
25997 panic!(concat!(
25998 "Unable to load ",
25999 stringify!(cmd_set_coverage_modulation_table_enable_nv)
26000 ))
26001 }
26002 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26003 b"vkCmdSetCoverageModulationTableEnableNV\0",
26004 );
26005 let val = _f(cname);
26006 if val.is_null() {
26007 cmd_set_coverage_modulation_table_enable_nv
26008 } else {
26009 ::std::mem::transmute(val)
26010 }
26011 },
26012 cmd_set_coverage_modulation_table_nv: unsafe {
26013 unsafe extern "system" fn cmd_set_coverage_modulation_table_nv(
26014 _command_buffer: CommandBuffer,
26015 _coverage_modulation_table_count: u32,
26016 _p_coverage_modulation_table: *const f32,
26017 ) {
26018 panic!(concat!(
26019 "Unable to load ",
26020 stringify!(cmd_set_coverage_modulation_table_nv)
26021 ))
26022 }
26023 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26024 b"vkCmdSetCoverageModulationTableNV\0",
26025 );
26026 let val = _f(cname);
26027 if val.is_null() {
26028 cmd_set_coverage_modulation_table_nv
26029 } else {
26030 ::std::mem::transmute(val)
26031 }
26032 },
26033 cmd_set_shading_rate_image_enable_nv: unsafe {
26034 unsafe extern "system" fn cmd_set_shading_rate_image_enable_nv(
26035 _command_buffer: CommandBuffer,
26036 _shading_rate_image_enable: Bool32,
26037 ) {
26038 panic!(concat!(
26039 "Unable to load ",
26040 stringify!(cmd_set_shading_rate_image_enable_nv)
26041 ))
26042 }
26043 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26044 b"vkCmdSetShadingRateImageEnableNV\0",
26045 );
26046 let val = _f(cname);
26047 if val.is_null() {
26048 cmd_set_shading_rate_image_enable_nv
26049 } else {
26050 ::std::mem::transmute(val)
26051 }
26052 },
26053 cmd_set_representative_fragment_test_enable_nv: unsafe {
26054 unsafe extern "system" fn cmd_set_representative_fragment_test_enable_nv(
26055 _command_buffer: CommandBuffer,
26056 _representative_fragment_test_enable: Bool32,
26057 ) {
26058 panic!(concat!(
26059 "Unable to load ",
26060 stringify!(cmd_set_representative_fragment_test_enable_nv)
26061 ))
26062 }
26063 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26064 b"vkCmdSetRepresentativeFragmentTestEnableNV\0",
26065 );
26066 let val = _f(cname);
26067 if val.is_null() {
26068 cmd_set_representative_fragment_test_enable_nv
26069 } else {
26070 ::std::mem::transmute(val)
26071 }
26072 },
26073 cmd_set_coverage_reduction_mode_nv: unsafe {
26074 unsafe extern "system" fn cmd_set_coverage_reduction_mode_nv(
26075 _command_buffer: CommandBuffer,
26076 _coverage_reduction_mode: CoverageReductionModeNV,
26077 ) {
26078 panic!(concat!(
26079 "Unable to load ",
26080 stringify!(cmd_set_coverage_reduction_mode_nv)
26081 ))
26082 }
26083 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26084 b"vkCmdSetCoverageReductionModeNV\0",
26085 );
26086 let val = _f(cname);
26087 if val.is_null() {
26088 cmd_set_coverage_reduction_mode_nv
26089 } else {
26090 ::std::mem::transmute(val)
26091 }
26092 },
26093 }
26094 }
26095}
26096#[doc = "Generated from 'VK_EXT_shader_object'"]
26097impl ObjectType {
26098 pub const SHADER_EXT: Self = Self(1_000_482_000);
26099}
26100#[doc = "Generated from 'VK_EXT_shader_object'"]
26101impl Result {
26102 pub const ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: Self = Self(1_000_482_000);
26103}
26104#[doc = "Generated from 'VK_EXT_shader_object'"]
26105impl ShaderCreateFlagsEXT {
26106 pub const ALLOW_VARYING_SUBGROUP_SIZE: Self = Self(0b10);
26107 pub const REQUIRE_FULL_SUBGROUPS: Self = Self(0b100);
26108 pub const NO_TASK_SHADER: Self = Self(0b1000);
26109 pub const DISPATCH_BASE: Self = Self(0b1_0000);
26110 pub const FRAGMENT_SHADING_RATE_ATTACHMENT: Self = Self(0b10_0000);
26111 pub const FRAGMENT_DENSITY_MAP_ATTACHMENT: Self = Self(0b100_0000);
26112}
26113#[doc = "Generated from 'VK_EXT_shader_object'"]
26114impl StructureType {
26115 pub const PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: Self = Self(1_000_482_000);
26116 pub const PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: Self = Self(1_000_482_001);
26117 pub const SHADER_CREATE_INFO_EXT: Self = Self(1_000_482_002);
26118 pub const SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self =
26119 Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
26120}
26121impl ExtExtension484Fn {
26122 #[inline]
26123 pub const fn name() -> &'static ::std::ffi::CStr {
26124 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_484\0") }
26125 }
26126 pub const SPEC_VERSION: u32 = 0u32;
26127}
26128#[derive(Clone)]
26129pub struct ExtExtension484Fn {}
26130unsafe impl Send for ExtExtension484Fn {}
26131unsafe impl Sync for ExtExtension484Fn {}
26132impl ExtExtension484Fn {
26133 pub fn load<F>(mut _f: F) -> Self
26134 where
26135 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26136 {
26137 Self {}
26138 }
26139}
26140impl QcomTilePropertiesFn {
26141 #[inline]
26142 pub const fn name() -> &'static ::std::ffi::CStr {
26143 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_tile_properties\0") }
26144 }
26145 pub const SPEC_VERSION: u32 = 1u32;
26146}
26147#[allow(non_camel_case_types)]
26148pub type PFN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn(
26149 device: Device,
26150 framebuffer: Framebuffer,
26151 p_properties_count: *mut u32,
26152 p_properties: *mut TilePropertiesQCOM,
26153) -> Result;
26154#[allow(non_camel_case_types)]
26155pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn(
26156 device: Device,
26157 p_rendering_info: *const RenderingInfo,
26158 p_properties: *mut TilePropertiesQCOM,
26159) -> Result;
26160#[derive(Clone)]
26161pub struct QcomTilePropertiesFn {
26162 pub get_framebuffer_tile_properties_qcom: PFN_vkGetFramebufferTilePropertiesQCOM,
26163 pub get_dynamic_rendering_tile_properties_qcom: PFN_vkGetDynamicRenderingTilePropertiesQCOM,
26164}
26165unsafe impl Send for QcomTilePropertiesFn {}
26166unsafe impl Sync for QcomTilePropertiesFn {}
26167impl QcomTilePropertiesFn {
26168 pub fn load<F>(mut _f: F) -> Self
26169 where
26170 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26171 {
26172 Self {
26173 get_framebuffer_tile_properties_qcom: unsafe {
26174 unsafe extern "system" fn get_framebuffer_tile_properties_qcom(
26175 _device: Device,
26176 _framebuffer: Framebuffer,
26177 _p_properties_count: *mut u32,
26178 _p_properties: *mut TilePropertiesQCOM,
26179 ) -> Result {
26180 panic!(concat!(
26181 "Unable to load ",
26182 stringify!(get_framebuffer_tile_properties_qcom)
26183 ))
26184 }
26185 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26186 b"vkGetFramebufferTilePropertiesQCOM\0",
26187 );
26188 let val = _f(cname);
26189 if val.is_null() {
26190 get_framebuffer_tile_properties_qcom
26191 } else {
26192 ::std::mem::transmute(val)
26193 }
26194 },
26195 get_dynamic_rendering_tile_properties_qcom: unsafe {
26196 unsafe extern "system" fn get_dynamic_rendering_tile_properties_qcom(
26197 _device: Device,
26198 _p_rendering_info: *const RenderingInfo,
26199 _p_properties: *mut TilePropertiesQCOM,
26200 ) -> Result {
26201 panic!(concat!(
26202 "Unable to load ",
26203 stringify!(get_dynamic_rendering_tile_properties_qcom)
26204 ))
26205 }
26206 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26207 b"vkGetDynamicRenderingTilePropertiesQCOM\0",
26208 );
26209 let val = _f(cname);
26210 if val.is_null() {
26211 get_dynamic_rendering_tile_properties_qcom
26212 } else {
26213 ::std::mem::transmute(val)
26214 }
26215 },
26216 }
26217 }
26218}
26219#[doc = "Generated from 'VK_QCOM_tile_properties'"]
26220impl StructureType {
26221 pub const PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: Self = Self(1_000_484_000);
26222 pub const TILE_PROPERTIES_QCOM: Self = Self(1_000_484_001);
26223}
26224impl SecAmigoProfilingFn {
26225 #[inline]
26226 pub const fn name() -> &'static ::std::ffi::CStr {
26227 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_amigo_profiling\0") }
26228 }
26229 pub const SPEC_VERSION: u32 = 1u32;
26230}
26231#[derive(Clone)]
26232pub struct SecAmigoProfilingFn {}
26233unsafe impl Send for SecAmigoProfilingFn {}
26234unsafe impl Sync for SecAmigoProfilingFn {}
26235impl SecAmigoProfilingFn {
26236 pub fn load<F>(mut _f: F) -> Self
26237 where
26238 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26239 {
26240 Self {}
26241 }
26242}
26243#[doc = "Generated from 'VK_SEC_amigo_profiling'"]
26244impl StructureType {
26245 pub const PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: Self = Self(1_000_485_000);
26246 pub const AMIGO_PROFILING_SUBMIT_INFO_SEC: Self = Self(1_000_485_001);
26247}
26248impl ExtExtension487Fn {
26249 #[inline]
26250 pub const fn name() -> &'static ::std::ffi::CStr {
26251 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_487\0") }
26252 }
26253 pub const SPEC_VERSION: u32 = 0u32;
26254}
26255#[derive(Clone)]
26256pub struct ExtExtension487Fn {}
26257unsafe impl Send for ExtExtension487Fn {}
26258unsafe impl Sync for ExtExtension487Fn {}
26259impl ExtExtension487Fn {
26260 pub fn load<F>(mut _f: F) -> Self
26261 where
26262 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26263 {
26264 Self {}
26265 }
26266}
26267impl ExtExtension488Fn {
26268 #[inline]
26269 pub const fn name() -> &'static ::std::ffi::CStr {
26270 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_488\0") }
26271 }
26272 pub const SPEC_VERSION: u32 = 0u32;
26273}
26274#[derive(Clone)]
26275pub struct ExtExtension488Fn {}
26276unsafe impl Send for ExtExtension488Fn {}
26277unsafe impl Sync for ExtExtension488Fn {}
26278impl ExtExtension488Fn {
26279 pub fn load<F>(mut _f: F) -> Self
26280 where
26281 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26282 {
26283 Self {}
26284 }
26285}
26286impl QcomMultiviewPerViewViewportsFn {
26287 #[inline]
26288 pub const fn name() -> &'static ::std::ffi::CStr {
26289 unsafe {
26290 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26291 b"VK_QCOM_multiview_per_view_viewports\0",
26292 )
26293 }
26294 }
26295 pub const SPEC_VERSION: u32 = 1u32;
26296}
26297#[derive(Clone)]
26298pub struct QcomMultiviewPerViewViewportsFn {}
26299unsafe impl Send for QcomMultiviewPerViewViewportsFn {}
26300unsafe impl Sync for QcomMultiviewPerViewViewportsFn {}
26301impl QcomMultiviewPerViewViewportsFn {
26302 pub fn load<F>(mut _f: F) -> Self
26303 where
26304 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26305 {
26306 Self {}
26307 }
26308}
26309#[doc = "Generated from 'VK_QCOM_multiview_per_view_viewports'"]
26310impl StructureType {
26311 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: Self =
26312 Self(1_000_488_000);
26313}
26314impl NvRayTracingInvocationReorderFn {
26315 #[inline]
26316 pub const fn name() -> &'static ::std::ffi::CStr {
26317 unsafe {
26318 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26319 b"VK_NV_ray_tracing_invocation_reorder\0",
26320 )
26321 }
26322 }
26323 pub const SPEC_VERSION: u32 = 1u32;
26324}
26325#[derive(Clone)]
26326pub struct NvRayTracingInvocationReorderFn {}
26327unsafe impl Send for NvRayTracingInvocationReorderFn {}
26328unsafe impl Sync for NvRayTracingInvocationReorderFn {}
26329impl NvRayTracingInvocationReorderFn {
26330 pub fn load<F>(mut _f: F) -> Self
26331 where
26332 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26333 {
26334 Self {}
26335 }
26336}
26337#[doc = "Generated from 'VK_NV_ray_tracing_invocation_reorder'"]
26338impl StructureType {
26339 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: Self =
26340 Self(1_000_490_000);
26341 pub const PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: Self =
26342 Self(1_000_490_001);
26343}
26344impl NvExtension492Fn {
26345 #[inline]
26346 pub const fn name() -> &'static ::std::ffi::CStr {
26347 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_492\0") }
26348 }
26349 pub const SPEC_VERSION: u32 = 0u32;
26350}
26351#[derive(Clone)]
26352pub struct NvExtension492Fn {}
26353unsafe impl Send for NvExtension492Fn {}
26354unsafe impl Sync for NvExtension492Fn {}
26355impl NvExtension492Fn {
26356 pub fn load<F>(mut _f: F) -> Self
26357 where
26358 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26359 {
26360 Self {}
26361 }
26362}
26363impl NvExtension493Fn {
26364 #[inline]
26365 pub const fn name() -> &'static ::std::ffi::CStr {
26366 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_493\0") }
26367 }
26368 pub const SPEC_VERSION: u32 = 0u32;
26369}
26370#[derive(Clone)]
26371pub struct NvExtension493Fn {}
26372unsafe impl Send for NvExtension493Fn {}
26373unsafe impl Sync for NvExtension493Fn {}
26374impl NvExtension493Fn {
26375 pub fn load<F>(mut _f: F) -> Self
26376 where
26377 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26378 {
26379 Self {}
26380 }
26381}
26382impl NvExtension494Fn {
26383 #[inline]
26384 pub const fn name() -> &'static ::std::ffi::CStr {
26385 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_494\0") }
26386 }
26387 pub const SPEC_VERSION: u32 = 0u32;
26388}
26389#[derive(Clone)]
26390pub struct NvExtension494Fn {}
26391unsafe impl Send for NvExtension494Fn {}
26392unsafe impl Sync for NvExtension494Fn {}
26393impl NvExtension494Fn {
26394 pub fn load<F>(mut _f: F) -> Self
26395 where
26396 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26397 {
26398 Self {}
26399 }
26400}
26401impl ExtMutableDescriptorTypeFn {
26402 #[inline]
26403 pub const fn name() -> &'static ::std::ffi::CStr {
26404 unsafe {
26405 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_mutable_descriptor_type\0")
26406 }
26407 }
26408 pub const SPEC_VERSION: u32 = 1u32;
26409}
26410#[derive(Clone)]
26411pub struct ExtMutableDescriptorTypeFn {}
26412unsafe impl Send for ExtMutableDescriptorTypeFn {}
26413unsafe impl Sync for ExtMutableDescriptorTypeFn {}
26414impl ExtMutableDescriptorTypeFn {
26415 pub fn load<F>(mut _f: F) -> Self
26416 where
26417 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26418 {
26419 Self {}
26420 }
26421}
26422#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
26423impl DescriptorPoolCreateFlags {
26424 pub const HOST_ONLY_EXT: Self = Self(0b100);
26425}
26426#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
26427impl DescriptorSetLayoutCreateFlags {
26428 pub const HOST_ONLY_POOL_EXT: Self = Self(0b100);
26429}
26430#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
26431impl DescriptorType {
26432 pub const MUTABLE_EXT: Self = Self(1_000_351_000);
26433}
26434#[doc = "Generated from 'VK_EXT_mutable_descriptor_type'"]
26435impl StructureType {
26436 pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: Self = Self(1_000_351_000);
26437 pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: Self = Self(1_000_351_002);
26438}
26439impl ExtExtension496Fn {
26440 #[inline]
26441 pub const fn name() -> &'static ::std::ffi::CStr {
26442 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_496\0") }
26443 }
26444 pub const SPEC_VERSION: u32 = 0u32;
26445}
26446#[derive(Clone)]
26447pub struct ExtExtension496Fn {}
26448unsafe impl Send for ExtExtension496Fn {}
26449unsafe impl Sync for ExtExtension496Fn {}
26450impl ExtExtension496Fn {
26451 pub fn load<F>(mut _f: F) -> Self
26452 where
26453 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26454 {
26455 Self {}
26456 }
26457}
26458impl ExtExtension497Fn {
26459 #[inline]
26460 pub const fn name() -> &'static ::std::ffi::CStr {
26461 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_497\0") }
26462 }
26463 pub const SPEC_VERSION: u32 = 0u32;
26464}
26465#[derive(Clone)]
26466pub struct ExtExtension497Fn {}
26467unsafe impl Send for ExtExtension497Fn {}
26468unsafe impl Sync for ExtExtension497Fn {}
26469impl ExtExtension497Fn {
26470 pub fn load<F>(mut _f: F) -> Self
26471 where
26472 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26473 {
26474 Self {}
26475 }
26476}
26477impl ArmShaderCoreBuiltinsFn {
26478 #[inline]
26479 pub const fn name() -> &'static ::std::ffi::CStr {
26480 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_shader_core_builtins\0") }
26481 }
26482 pub const SPEC_VERSION: u32 = 2u32;
26483}
26484#[derive(Clone)]
26485pub struct ArmShaderCoreBuiltinsFn {}
26486unsafe impl Send for ArmShaderCoreBuiltinsFn {}
26487unsafe impl Sync for ArmShaderCoreBuiltinsFn {}
26488impl ArmShaderCoreBuiltinsFn {
26489 pub fn load<F>(mut _f: F) -> Self
26490 where
26491 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26492 {
26493 Self {}
26494 }
26495}
26496#[doc = "Generated from 'VK_ARM_shader_core_builtins'"]
26497impl StructureType {
26498 pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: Self = Self(1_000_497_000);
26499 pub const PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: Self = Self(1_000_497_001);
26500}
26501impl ExtPipelineLibraryGroupHandlesFn {
26502 #[inline]
26503 pub const fn name() -> &'static ::std::ffi::CStr {
26504 unsafe {
26505 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26506 b"VK_EXT_pipeline_library_group_handles\0",
26507 )
26508 }
26509 }
26510 pub const SPEC_VERSION: u32 = 1u32;
26511}
26512#[derive(Clone)]
26513pub struct ExtPipelineLibraryGroupHandlesFn {}
26514unsafe impl Send for ExtPipelineLibraryGroupHandlesFn {}
26515unsafe impl Sync for ExtPipelineLibraryGroupHandlesFn {}
26516impl ExtPipelineLibraryGroupHandlesFn {
26517 pub fn load<F>(mut _f: F) -> Self
26518 where
26519 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26520 {
26521 Self {}
26522 }
26523}
26524#[doc = "Generated from 'VK_EXT_pipeline_library_group_handles'"]
26525impl StructureType {
26526 pub const PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: Self =
26527 Self(1_000_498_000);
26528}
26529impl ExtDynamicRenderingUnusedAttachmentsFn {
26530 #[inline]
26531 pub const fn name() -> &'static ::std::ffi::CStr {
26532 unsafe {
26533 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26534 b"VK_EXT_dynamic_rendering_unused_attachments\0",
26535 )
26536 }
26537 }
26538 pub const SPEC_VERSION: u32 = 1u32;
26539}
26540#[derive(Clone)]
26541pub struct ExtDynamicRenderingUnusedAttachmentsFn {}
26542unsafe impl Send for ExtDynamicRenderingUnusedAttachmentsFn {}
26543unsafe impl Sync for ExtDynamicRenderingUnusedAttachmentsFn {}
26544impl ExtDynamicRenderingUnusedAttachmentsFn {
26545 pub fn load<F>(mut _f: F) -> Self
26546 where
26547 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26548 {
26549 Self {}
26550 }
26551}
26552#[doc = "Generated from 'VK_EXT_dynamic_rendering_unused_attachments'"]
26553impl StructureType {
26554 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: Self =
26555 Self(1_000_499_000);
26556}
26557impl ExtExtension501Fn {
26558 #[inline]
26559 pub const fn name() -> &'static ::std::ffi::CStr {
26560 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_501\0") }
26561 }
26562 pub const SPEC_VERSION: u32 = 0u32;
26563}
26564#[derive(Clone)]
26565pub struct ExtExtension501Fn {}
26566unsafe impl Send for ExtExtension501Fn {}
26567unsafe impl Sync for ExtExtension501Fn {}
26568impl ExtExtension501Fn {
26569 pub fn load<F>(mut _f: F) -> Self
26570 where
26571 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26572 {
26573 Self {}
26574 }
26575}
26576impl ExtExtension502Fn {
26577 #[inline]
26578 pub const fn name() -> &'static ::std::ffi::CStr {
26579 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_502\0") }
26580 }
26581 pub const SPEC_VERSION: u32 = 0u32;
26582}
26583#[derive(Clone)]
26584pub struct ExtExtension502Fn {}
26585unsafe impl Send for ExtExtension502Fn {}
26586unsafe impl Sync for ExtExtension502Fn {}
26587impl ExtExtension502Fn {
26588 pub fn load<F>(mut _f: F) -> Self
26589 where
26590 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26591 {
26592 Self {}
26593 }
26594}
26595impl ExtExtension503Fn {
26596 #[inline]
26597 pub const fn name() -> &'static ::std::ffi::CStr {
26598 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_503\0") }
26599 }
26600 pub const SPEC_VERSION: u32 = 0u32;
26601}
26602#[derive(Clone)]
26603pub struct ExtExtension503Fn {}
26604unsafe impl Send for ExtExtension503Fn {}
26605unsafe impl Sync for ExtExtension503Fn {}
26606impl ExtExtension503Fn {
26607 pub fn load<F>(mut _f: F) -> Self
26608 where
26609 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26610 {
26611 Self {}
26612 }
26613}
26614impl NvExtension504Fn {
26615 #[inline]
26616 pub const fn name() -> &'static ::std::ffi::CStr {
26617 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_504\0") }
26618 }
26619 pub const SPEC_VERSION: u32 = 0u32;
26620}
26621#[derive(Clone)]
26622pub struct NvExtension504Fn {}
26623unsafe impl Send for NvExtension504Fn {}
26624unsafe impl Sync for NvExtension504Fn {}
26625impl NvExtension504Fn {
26626 pub fn load<F>(mut _f: F) -> Self
26627 where
26628 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26629 {
26630 Self {}
26631 }
26632}
26633impl ExtExtension505Fn {
26634 #[inline]
26635 pub const fn name() -> &'static ::std::ffi::CStr {
26636 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_505\0") }
26637 }
26638 pub const SPEC_VERSION: u32 = 0u32;
26639}
26640#[derive(Clone)]
26641pub struct ExtExtension505Fn {}
26642unsafe impl Send for ExtExtension505Fn {}
26643unsafe impl Sync for ExtExtension505Fn {}
26644impl ExtExtension505Fn {
26645 pub fn load<F>(mut _f: F) -> Self
26646 where
26647 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26648 {
26649 Self {}
26650 }
26651}
26652impl NvExtension506Fn {
26653 #[inline]
26654 pub const fn name() -> &'static ::std::ffi::CStr {
26655 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_506\0") }
26656 }
26657 pub const SPEC_VERSION: u32 = 0u32;
26658}
26659#[derive(Clone)]
26660pub struct NvExtension506Fn {}
26661unsafe impl Send for NvExtension506Fn {}
26662unsafe impl Sync for NvExtension506Fn {}
26663impl NvExtension506Fn {
26664 pub fn load<F>(mut _f: F) -> Self
26665 where
26666 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26667 {
26668 Self {}
26669 }
26670}
26671impl KhrExtension507Fn {
26672 #[inline]
26673 pub const fn name() -> &'static ::std::ffi::CStr {
26674 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_507\0") }
26675 }
26676 pub const SPEC_VERSION: u32 = 0u32;
26677}
26678#[derive(Clone)]
26679pub struct KhrExtension507Fn {}
26680unsafe impl Send for KhrExtension507Fn {}
26681unsafe impl Sync for KhrExtension507Fn {}
26682impl KhrExtension507Fn {
26683 pub fn load<F>(mut _f: F) -> Self
26684 where
26685 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26686 {
26687 Self {}
26688 }
26689}
26690impl ExtExtension508Fn {
26691 #[inline]
26692 pub const fn name() -> &'static ::std::ffi::CStr {
26693 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_508\0") }
26694 }
26695 pub const SPEC_VERSION: u32 = 0u32;
26696}
26697#[derive(Clone)]
26698pub struct ExtExtension508Fn {}
26699unsafe impl Send for ExtExtension508Fn {}
26700unsafe impl Sync for ExtExtension508Fn {}
26701impl ExtExtension508Fn {
26702 pub fn load<F>(mut _f: F) -> Self
26703 where
26704 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26705 {
26706 Self {}
26707 }
26708}
26709#[doc = "Generated from 'VK_EXT_extension_508'"]
26710impl AccessFlags2 {
26711 pub const RESERVED_47_EXT: Self =
26712 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
26713 pub const RESERVED_48_EXT: Self =
26714 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
26715}
26716#[doc = "Generated from 'VK_EXT_extension_508'"]
26717impl PipelineStageFlags2 {
26718 pub const RESERVED_42_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
26719}
26720#[doc = "Generated from 'VK_EXT_extension_508'"]
26721impl QueueFlags {
26722 pub const RESERVED_10_EXT: Self = Self(0b100_0000_0000);
26723}
26724impl ExtExtension509Fn {
26725 #[inline]
26726 pub const fn name() -> &'static ::std::ffi::CStr {
26727 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_509\0") }
26728 }
26729 pub const SPEC_VERSION: u32 = 0u32;
26730}
26731#[derive(Clone)]
26732pub struct ExtExtension509Fn {}
26733unsafe impl Send for ExtExtension509Fn {}
26734unsafe impl Sync for ExtExtension509Fn {}
26735impl ExtExtension509Fn {
26736 pub fn load<F>(mut _f: F) -> Self
26737 where
26738 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26739 {
26740 Self {}
26741 }
26742}
26743impl MesaExtension510Fn {
26744 #[inline]
26745 pub const fn name() -> &'static ::std::ffi::CStr {
26746 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_510\0") }
26747 }
26748 pub const SPEC_VERSION: u32 = 0u32;
26749}
26750#[derive(Clone)]
26751pub struct MesaExtension510Fn {}
26752unsafe impl Send for MesaExtension510Fn {}
26753unsafe impl Sync for MesaExtension510Fn {}
26754impl MesaExtension510Fn {
26755 pub fn load<F>(mut _f: F) -> Self
26756 where
26757 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26758 {
26759 Self {}
26760 }
26761}
26762impl QcomMultiviewPerViewRenderAreasFn {
26763 #[inline]
26764 pub const fn name() -> &'static ::std::ffi::CStr {
26765 unsafe {
26766 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
26767 b"VK_QCOM_multiview_per_view_render_areas\0",
26768 )
26769 }
26770 }
26771 pub const SPEC_VERSION: u32 = 1u32;
26772}
26773#[derive(Clone)]
26774pub struct QcomMultiviewPerViewRenderAreasFn {}
26775unsafe impl Send for QcomMultiviewPerViewRenderAreasFn {}
26776unsafe impl Sync for QcomMultiviewPerViewRenderAreasFn {}
26777impl QcomMultiviewPerViewRenderAreasFn {
26778 pub fn load<F>(mut _f: F) -> Self
26779 where
26780 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26781 {
26782 Self {}
26783 }
26784}
26785#[doc = "Generated from 'VK_QCOM_multiview_per_view_render_areas'"]
26786impl StructureType {
26787 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: Self =
26788 Self(1_000_510_000);
26789 pub const MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: Self =
26790 Self(1_000_510_001);
26791}
26792impl ExtExtension512Fn {
26793 #[inline]
26794 pub const fn name() -> &'static ::std::ffi::CStr {
26795 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_512\0") }
26796 }
26797 pub const SPEC_VERSION: u32 = 0u32;
26798}
26799#[derive(Clone)]
26800pub struct ExtExtension512Fn {}
26801unsafe impl Send for ExtExtension512Fn {}
26802unsafe impl Sync for ExtExtension512Fn {}
26803impl ExtExtension512Fn {
26804 pub fn load<F>(mut _f: F) -> Self
26805 where
26806 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26807 {
26808 Self {}
26809 }
26810}
26811impl KhrExtension513Fn {
26812 #[inline]
26813 pub const fn name() -> &'static ::std::ffi::CStr {
26814 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_513\0") }
26815 }
26816 pub const SPEC_VERSION: u32 = 0u32;
26817}
26818#[derive(Clone)]
26819pub struct KhrExtension513Fn {}
26820unsafe impl Send for KhrExtension513Fn {}
26821unsafe impl Sync for KhrExtension513Fn {}
26822impl KhrExtension513Fn {
26823 pub fn load<F>(mut _f: F) -> Self
26824 where
26825 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26826 {
26827 Self {}
26828 }
26829}
26830impl KhrExtension514Fn {
26831 #[inline]
26832 pub const fn name() -> &'static ::std::ffi::CStr {
26833 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_514\0") }
26834 }
26835 pub const SPEC_VERSION: u32 = 0u32;
26836}
26837#[derive(Clone)]
26838pub struct KhrExtension514Fn {}
26839unsafe impl Send for KhrExtension514Fn {}
26840unsafe impl Sync for KhrExtension514Fn {}
26841impl KhrExtension514Fn {
26842 pub fn load<F>(mut _f: F) -> Self
26843 where
26844 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26845 {
26846 Self {}
26847 }
26848}
26849impl KhrExtension515Fn {
26850 #[inline]
26851 pub const fn name() -> &'static ::std::ffi::CStr {
26852 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_515\0") }
26853 }
26854 pub const SPEC_VERSION: u32 = 0u32;
26855}
26856#[derive(Clone)]
26857pub struct KhrExtension515Fn {}
26858unsafe impl Send for KhrExtension515Fn {}
26859unsafe impl Sync for KhrExtension515Fn {}
26860impl KhrExtension515Fn {
26861 pub fn load<F>(mut _f: F) -> Self
26862 where
26863 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26864 {
26865 Self {}
26866 }
26867}
26868impl KhrExtension516Fn {
26869 #[inline]
26870 pub const fn name() -> &'static ::std::ffi::CStr {
26871 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_516\0") }
26872 }
26873 pub const SPEC_VERSION: u32 = 0u32;
26874}
26875#[derive(Clone)]
26876pub struct KhrExtension516Fn {}
26877unsafe impl Send for KhrExtension516Fn {}
26878unsafe impl Sync for KhrExtension516Fn {}
26879impl KhrExtension516Fn {
26880 pub fn load<F>(mut _f: F) -> Self
26881 where
26882 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26883 {
26884 Self {}
26885 }
26886}
26887#[doc = "Generated from 'VK_KHR_extension_516'"]
26888impl BufferCreateFlags {
26889 pub const RESERVED_6_KHR: Self = Self(0b100_0000);
26890}
26891#[doc = "Generated from 'VK_KHR_extension_516'"]
26892impl ImageCreateFlags {
26893 pub const RESERVED_20_KHR: Self = Self(0b1_0000_0000_0000_0000_0000);
26894}
26895impl ExtExtension517Fn {
26896 #[inline]
26897 pub const fn name() -> &'static ::std::ffi::CStr {
26898 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_517\0") }
26899 }
26900 pub const SPEC_VERSION: u32 = 0u32;
26901}
26902#[derive(Clone)]
26903pub struct ExtExtension517Fn {}
26904unsafe impl Send for ExtExtension517Fn {}
26905unsafe impl Sync for ExtExtension517Fn {}
26906impl ExtExtension517Fn {
26907 pub fn load<F>(mut _f: F) -> Self
26908 where
26909 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26910 {
26911 Self {}
26912 }
26913}
26914#[doc = "Generated from 'VK_EXT_extension_517'"]
26915impl DescriptorSetLayoutCreateFlags {
26916 pub const RESERVED_6_EXT: Self = Self(0b100_0000);
26917}
26918impl MesaExtension518Fn {
26919 #[inline]
26920 pub const fn name() -> &'static ::std::ffi::CStr {
26921 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_518\0") }
26922 }
26923 pub const SPEC_VERSION: u32 = 0u32;
26924}
26925#[derive(Clone)]
26926pub struct MesaExtension518Fn {}
26927unsafe impl Send for MesaExtension518Fn {}
26928unsafe impl Sync for MesaExtension518Fn {}
26929impl MesaExtension518Fn {
26930 pub fn load<F>(mut _f: F) -> Self
26931 where
26932 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26933 {
26934 Self {}
26935 }
26936}
26937impl QcomExtension519Fn {
26938 #[inline]
26939 pub const fn name() -> &'static ::std::ffi::CStr {
26940 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_519\0") }
26941 }
26942 pub const SPEC_VERSION: u32 = 0u32;
26943}
26944#[derive(Clone)]
26945pub struct QcomExtension519Fn {}
26946unsafe impl Send for QcomExtension519Fn {}
26947unsafe impl Sync for QcomExtension519Fn {}
26948impl QcomExtension519Fn {
26949 pub fn load<F>(mut _f: F) -> Self
26950 where
26951 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26952 {
26953 Self {}
26954 }
26955}
26956impl QcomExtension520Fn {
26957 #[inline]
26958 pub const fn name() -> &'static ::std::ffi::CStr {
26959 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_520\0") }
26960 }
26961 pub const SPEC_VERSION: u32 = 0u32;
26962}
26963#[derive(Clone)]
26964pub struct QcomExtension520Fn {}
26965unsafe impl Send for QcomExtension520Fn {}
26966unsafe impl Sync for QcomExtension520Fn {}
26967impl QcomExtension520Fn {
26968 pub fn load<F>(mut _f: F) -> Self
26969 where
26970 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26971 {
26972 Self {}
26973 }
26974}
26975impl QcomExtension521Fn {
26976 #[inline]
26977 pub const fn name() -> &'static ::std::ffi::CStr {
26978 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_521\0") }
26979 }
26980 pub const SPEC_VERSION: u32 = 0u32;
26981}
26982#[derive(Clone)]
26983pub struct QcomExtension521Fn {}
26984unsafe impl Send for QcomExtension521Fn {}
26985unsafe impl Sync for QcomExtension521Fn {}
26986impl QcomExtension521Fn {
26987 pub fn load<F>(mut _f: F) -> Self
26988 where
26989 F: FnMut(&::std::ffi::CStr) -> *const c_void,
26990 {
26991 Self {}
26992 }
26993}
26994impl QcomExtension522Fn {
26995 #[inline]
26996 pub const fn name() -> &'static ::std::ffi::CStr {
26997 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_522\0") }
26998 }
26999 pub const SPEC_VERSION: u32 = 0u32;
27000}
27001#[derive(Clone)]
27002pub struct QcomExtension522Fn {}
27003unsafe impl Send for QcomExtension522Fn {}
27004unsafe impl Sync for QcomExtension522Fn {}
27005impl QcomExtension522Fn {
27006 pub fn load<F>(mut _f: F) -> Self
27007 where
27008 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27009 {
27010 Self {}
27011 }
27012}
27013impl ExtExtension523Fn {
27014 #[inline]
27015 pub const fn name() -> &'static ::std::ffi::CStr {
27016 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_523\0") }
27017 }
27018 pub const SPEC_VERSION: u32 = 0u32;
27019}
27020#[derive(Clone)]
27021pub struct ExtExtension523Fn {}
27022unsafe impl Send for ExtExtension523Fn {}
27023unsafe impl Sync for ExtExtension523Fn {}
27024impl ExtExtension523Fn {
27025 pub fn load<F>(mut _f: F) -> Self
27026 where
27027 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27028 {
27029 Self {}
27030 }
27031}
27032impl ExtExtension524Fn {
27033 #[inline]
27034 pub const fn name() -> &'static ::std::ffi::CStr {
27035 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_524\0") }
27036 }
27037 pub const SPEC_VERSION: u32 = 0u32;
27038}
27039#[derive(Clone)]
27040pub struct ExtExtension524Fn {}
27041unsafe impl Send for ExtExtension524Fn {}
27042unsafe impl Sync for ExtExtension524Fn {}
27043impl ExtExtension524Fn {
27044 pub fn load<F>(mut _f: F) -> Self
27045 where
27046 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27047 {
27048 Self {}
27049 }
27050}
27051impl ExtAttachmentFeedbackLoopDynamicStateFn {
27052 #[inline]
27053 pub const fn name() -> &'static ::std::ffi::CStr {
27054 unsafe {
27055 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
27056 b"VK_EXT_attachment_feedback_loop_dynamic_state\0",
27057 )
27058 }
27059 }
27060 pub const SPEC_VERSION: u32 = 1u32;
27061}
27062#[allow(non_camel_case_types)]
27063pub type PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT =
27064 unsafe extern "system" fn(command_buffer: CommandBuffer, aspect_mask: ImageAspectFlags);
27065#[derive(Clone)]
27066pub struct ExtAttachmentFeedbackLoopDynamicStateFn {
27067 pub cmd_set_attachment_feedback_loop_enable_ext: PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT,
27068}
27069unsafe impl Send for ExtAttachmentFeedbackLoopDynamicStateFn {}
27070unsafe impl Sync for ExtAttachmentFeedbackLoopDynamicStateFn {}
27071impl ExtAttachmentFeedbackLoopDynamicStateFn {
27072 pub fn load<F>(mut _f: F) -> Self
27073 where
27074 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27075 {
27076 Self {
27077 cmd_set_attachment_feedback_loop_enable_ext: unsafe {
27078 unsafe extern "system" fn cmd_set_attachment_feedback_loop_enable_ext(
27079 _command_buffer: CommandBuffer,
27080 _aspect_mask: ImageAspectFlags,
27081 ) {
27082 panic!(concat!(
27083 "Unable to load ",
27084 stringify!(cmd_set_attachment_feedback_loop_enable_ext)
27085 ))
27086 }
27087 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
27088 b"vkCmdSetAttachmentFeedbackLoopEnableEXT\0",
27089 );
27090 let val = _f(cname);
27091 if val.is_null() {
27092 cmd_set_attachment_feedback_loop_enable_ext
27093 } else {
27094 ::std::mem::transmute(val)
27095 }
27096 },
27097 }
27098 }
27099}
27100#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_dynamic_state'"]
27101impl DynamicState {
27102 pub const ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: Self = Self(1_000_524_000);
27103}
27104#[doc = "Generated from 'VK_EXT_attachment_feedback_loop_dynamic_state'"]
27105impl StructureType {
27106 pub const PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: Self =
27107 Self(1_000_524_000);
27108}
27109impl ExtExtension526Fn {
27110 #[inline]
27111 pub const fn name() -> &'static ::std::ffi::CStr {
27112 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_526\0") }
27113 }
27114 pub const SPEC_VERSION: u32 = 0u32;
27115}
27116#[derive(Clone)]
27117pub struct ExtExtension526Fn {}
27118unsafe impl Send for ExtExtension526Fn {}
27119unsafe impl Sync for ExtExtension526Fn {}
27120impl ExtExtension526Fn {
27121 pub fn load<F>(mut _f: F) -> Self
27122 where
27123 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27124 {
27125 Self {}
27126 }
27127}
27128impl ExtExtension527Fn {
27129 #[inline]
27130 pub const fn name() -> &'static ::std::ffi::CStr {
27131 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_527\0") }
27132 }
27133 pub const SPEC_VERSION: u32 = 0u32;
27134}
27135#[derive(Clone)]
27136pub struct ExtExtension527Fn {}
27137unsafe impl Send for ExtExtension527Fn {}
27138unsafe impl Sync for ExtExtension527Fn {}
27139impl ExtExtension527Fn {
27140 pub fn load<F>(mut _f: F) -> Self
27141 where
27142 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27143 {
27144 Self {}
27145 }
27146}
27147impl ExtExtension528Fn {
27148 #[inline]
27149 pub const fn name() -> &'static ::std::ffi::CStr {
27150 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_528\0") }
27151 }
27152 pub const SPEC_VERSION: u32 = 0u32;
27153}
27154#[derive(Clone)]
27155pub struct ExtExtension528Fn {}
27156unsafe impl Send for ExtExtension528Fn {}
27157unsafe impl Sync for ExtExtension528Fn {}
27158impl ExtExtension528Fn {
27159 pub fn load<F>(mut _f: F) -> Self
27160 where
27161 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27162 {
27163 Self {}
27164 }
27165}
27166impl KhrExtension529Fn {
27167 #[inline]
27168 pub const fn name() -> &'static ::std::ffi::CStr {
27169 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_529\0") }
27170 }
27171 pub const SPEC_VERSION: u32 = 0u32;
27172}
27173#[derive(Clone)]
27174pub struct KhrExtension529Fn {}
27175unsafe impl Send for KhrExtension529Fn {}
27176unsafe impl Sync for KhrExtension529Fn {}
27177impl KhrExtension529Fn {
27178 pub fn load<F>(mut _f: F) -> Self
27179 where
27180 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27181 {
27182 Self {}
27183 }
27184}
27185impl QnxExtension530Fn {
27186 #[inline]
27187 pub const fn name() -> &'static ::std::ffi::CStr {
27188 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_extension_530\0") }
27189 }
27190 pub const SPEC_VERSION: u32 = 0u32;
27191}
27192#[derive(Clone)]
27193pub struct QnxExtension530Fn {}
27194unsafe impl Send for QnxExtension530Fn {}
27195unsafe impl Sync for QnxExtension530Fn {}
27196impl QnxExtension530Fn {
27197 pub fn load<F>(mut _f: F) -> Self
27198 where
27199 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27200 {
27201 Self {}
27202 }
27203}
27204#[doc = "Generated from 'VK_QNX_extension_530'"]
27205impl ExternalMemoryHandleTypeFlags {
27206 pub const TYPE_530_QNX: Self = Self(0b100_0000_0000_0000);
27207}
27208impl MsftExtension531Fn {
27209 #[inline]
27210 pub const fn name() -> &'static ::std::ffi::CStr {
27211 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MSFT_extension_531\0") }
27212 }
27213 pub const SPEC_VERSION: u32 = 0u32;
27214}
27215#[derive(Clone)]
27216pub struct MsftExtension531Fn {}
27217unsafe impl Send for MsftExtension531Fn {}
27218unsafe impl Sync for MsftExtension531Fn {}
27219impl MsftExtension531Fn {
27220 pub fn load<F>(mut _f: F) -> Self
27221 where
27222 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27223 {
27224 Self {}
27225 }
27226}
27227impl KhrExtension532Fn {
27228 #[inline]
27229 pub const fn name() -> &'static ::std::ffi::CStr {
27230 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_532\0") }
27231 }
27232 pub const SPEC_VERSION: u32 = 0u32;
27233}
27234#[derive(Clone)]
27235pub struct KhrExtension532Fn {}
27236unsafe impl Send for KhrExtension532Fn {}
27237unsafe impl Sync for KhrExtension532Fn {}
27238impl KhrExtension532Fn {
27239 pub fn load<F>(mut _f: F) -> Self
27240 where
27241 F: FnMut(&::std::ffi::CStr) -> *const c_void,
27242 {
27243 Self {}
27244 }
27245}