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 pub const fn name() -> &'static ::std::ffi::CStr {
9 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_surface\0") }
10 }
11 pub const SPEC_VERSION: u32 = 25u32;
12}
13#[allow(non_camel_case_types)]
14pub type PFN_vkDestroySurfaceKHR = unsafe extern "system" fn(
15 instance: Instance,
16 surface: SurfaceKHR,
17 p_allocator: *const AllocationCallbacks,
18);
19#[allow(non_camel_case_types)]
20pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn(
21 physical_device: PhysicalDevice,
22 queue_family_index: u32,
23 surface: SurfaceKHR,
24 p_supported: *mut Bool32,
25) -> Result;
26#[allow(non_camel_case_types)]
27pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn(
28 physical_device: PhysicalDevice,
29 surface: SurfaceKHR,
30 p_surface_capabilities: *mut SurfaceCapabilitiesKHR,
31) -> Result;
32#[allow(non_camel_case_types)]
33pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn(
34 physical_device: PhysicalDevice,
35 surface: SurfaceKHR,
36 p_surface_format_count: *mut u32,
37 p_surface_formats: *mut SurfaceFormatKHR,
38) -> Result;
39#[allow(non_camel_case_types)]
40pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn(
41 physical_device: PhysicalDevice,
42 surface: SurfaceKHR,
43 p_present_mode_count: *mut u32,
44 p_present_modes: *mut PresentModeKHR,
45) -> Result;
46#[derive(Clone)]
47pub struct KhrSurfaceFn {
48 pub destroy_surface_khr: PFN_vkDestroySurfaceKHR,
49 pub get_physical_device_surface_support_khr: PFN_vkGetPhysicalDeviceSurfaceSupportKHR,
50 pub get_physical_device_surface_capabilities_khr: PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR,
51 pub get_physical_device_surface_formats_khr: PFN_vkGetPhysicalDeviceSurfaceFormatsKHR,
52 pub get_physical_device_surface_present_modes_khr:
53 PFN_vkGetPhysicalDeviceSurfacePresentModesKHR,
54}
55unsafe impl Send for KhrSurfaceFn {}
56unsafe impl Sync for KhrSurfaceFn {}
57impl KhrSurfaceFn {
58 pub fn load<F>(mut _f: F) -> Self
59 where
60 F: FnMut(&::std::ffi::CStr) -> *const c_void,
61 {
62 Self {
63 destroy_surface_khr: unsafe {
64 unsafe extern "system" fn destroy_surface_khr(
65 _instance: Instance,
66 _surface: SurfaceKHR,
67 _p_allocator: *const AllocationCallbacks,
68 ) {
69 panic!(concat!("Unable to load ", stringify!(destroy_surface_khr)))
70 }
71 let cname =
72 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySurfaceKHR\0");
73 let val = _f(cname);
74 if val.is_null() {
75 destroy_surface_khr
76 } else {
77 ::std::mem::transmute(val)
78 }
79 },
80 get_physical_device_surface_support_khr: unsafe {
81 unsafe extern "system" fn get_physical_device_surface_support_khr(
82 _physical_device: PhysicalDevice,
83 _queue_family_index: u32,
84 _surface: SurfaceKHR,
85 _p_supported: *mut Bool32,
86 ) -> Result {
87 panic!(concat!(
88 "Unable to load ",
89 stringify!(get_physical_device_surface_support_khr)
90 ))
91 }
92 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
93 b"vkGetPhysicalDeviceSurfaceSupportKHR\0",
94 );
95 let val = _f(cname);
96 if val.is_null() {
97 get_physical_device_surface_support_khr
98 } else {
99 ::std::mem::transmute(val)
100 }
101 },
102 get_physical_device_surface_capabilities_khr: unsafe {
103 unsafe extern "system" fn get_physical_device_surface_capabilities_khr(
104 _physical_device: PhysicalDevice,
105 _surface: SurfaceKHR,
106 _p_surface_capabilities: *mut SurfaceCapabilitiesKHR,
107 ) -> Result {
108 panic!(concat!(
109 "Unable to load ",
110 stringify!(get_physical_device_surface_capabilities_khr)
111 ))
112 }
113 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
114 b"vkGetPhysicalDeviceSurfaceCapabilitiesKHR\0",
115 );
116 let val = _f(cname);
117 if val.is_null() {
118 get_physical_device_surface_capabilities_khr
119 } else {
120 ::std::mem::transmute(val)
121 }
122 },
123 get_physical_device_surface_formats_khr: unsafe {
124 unsafe extern "system" fn get_physical_device_surface_formats_khr(
125 _physical_device: PhysicalDevice,
126 _surface: SurfaceKHR,
127 _p_surface_format_count: *mut u32,
128 _p_surface_formats: *mut SurfaceFormatKHR,
129 ) -> Result {
130 panic!(concat!(
131 "Unable to load ",
132 stringify!(get_physical_device_surface_formats_khr)
133 ))
134 }
135 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
136 b"vkGetPhysicalDeviceSurfaceFormatsKHR\0",
137 );
138 let val = _f(cname);
139 if val.is_null() {
140 get_physical_device_surface_formats_khr
141 } else {
142 ::std::mem::transmute(val)
143 }
144 },
145 get_physical_device_surface_present_modes_khr: unsafe {
146 unsafe extern "system" fn get_physical_device_surface_present_modes_khr(
147 _physical_device: PhysicalDevice,
148 _surface: SurfaceKHR,
149 _p_present_mode_count: *mut u32,
150 _p_present_modes: *mut PresentModeKHR,
151 ) -> Result {
152 panic!(concat!(
153 "Unable to load ",
154 stringify!(get_physical_device_surface_present_modes_khr)
155 ))
156 }
157 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
158 b"vkGetPhysicalDeviceSurfacePresentModesKHR\0",
159 );
160 let val = _f(cname);
161 if val.is_null() {
162 get_physical_device_surface_present_modes_khr
163 } else {
164 ::std::mem::transmute(val)
165 }
166 },
167 }
168 }
169}
170#[doc = "Generated from 'VK_KHR_surface'"]
171impl ObjectType {
172 pub const SURFACE_KHR: Self = Self(1_000_000_000);
173}
174#[doc = "Generated from 'VK_KHR_surface'"]
175impl Result {
176 pub const ERROR_SURFACE_LOST_KHR: Self = Self(-1_000_000_000);
177 pub const ERROR_NATIVE_WINDOW_IN_USE_KHR: Self = Self(-1_000_000_001);
178}
179impl KhrSwapchainFn {
180 pub const fn name() -> &'static ::std::ffi::CStr {
181 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain\0") }
182 }
183 pub const SPEC_VERSION: u32 = 70u32;
184}
185#[allow(non_camel_case_types)]
186pub type PFN_vkCreateSwapchainKHR = unsafe extern "system" fn(
187 device: Device,
188 p_create_info: *const SwapchainCreateInfoKHR,
189 p_allocator: *const AllocationCallbacks,
190 p_swapchain: *mut SwapchainKHR,
191) -> Result;
192#[allow(non_camel_case_types)]
193pub type PFN_vkDestroySwapchainKHR = unsafe extern "system" fn(
194 device: Device,
195 swapchain: SwapchainKHR,
196 p_allocator: *const AllocationCallbacks,
197);
198#[allow(non_camel_case_types)]
199pub type PFN_vkGetSwapchainImagesKHR = unsafe extern "system" fn(
200 device: Device,
201 swapchain: SwapchainKHR,
202 p_swapchain_image_count: *mut u32,
203 p_swapchain_images: *mut Image,
204) -> Result;
205#[allow(non_camel_case_types)]
206pub type PFN_vkAcquireNextImageKHR = unsafe extern "system" fn(
207 device: Device,
208 swapchain: SwapchainKHR,
209 timeout: u64,
210 semaphore: Semaphore,
211 fence: Fence,
212 p_image_index: *mut u32,
213) -> Result;
214#[allow(non_camel_case_types)]
215pub type PFN_vkQueuePresentKHR =
216 unsafe extern "system" fn(queue: Queue, p_present_info: *const PresentInfoKHR) -> Result;
217#[allow(non_camel_case_types)]
218pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn(
219 device: Device,
220 p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
221) -> Result;
222#[allow(non_camel_case_types)]
223pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn(
224 device: Device,
225 surface: SurfaceKHR,
226 p_modes: *mut DeviceGroupPresentModeFlagsKHR,
227) -> Result;
228#[allow(non_camel_case_types)]
229pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn(
230 physical_device: PhysicalDevice,
231 surface: SurfaceKHR,
232 p_rect_count: *mut u32,
233 p_rects: *mut Rect2D,
234) -> Result;
235#[allow(non_camel_case_types)]
236pub type PFN_vkAcquireNextImage2KHR = unsafe extern "system" fn(
237 device: Device,
238 p_acquire_info: *const AcquireNextImageInfoKHR,
239 p_image_index: *mut u32,
240) -> Result;
241#[derive(Clone)]
242pub struct KhrSwapchainFn {
243 pub create_swapchain_khr: PFN_vkCreateSwapchainKHR,
244 pub destroy_swapchain_khr: PFN_vkDestroySwapchainKHR,
245 pub get_swapchain_images_khr: PFN_vkGetSwapchainImagesKHR,
246 pub acquire_next_image_khr: PFN_vkAcquireNextImageKHR,
247 pub queue_present_khr: PFN_vkQueuePresentKHR,
248 pub get_device_group_present_capabilities_khr: PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
249 pub get_device_group_surface_present_modes_khr: PFN_vkGetDeviceGroupSurfacePresentModesKHR,
250 pub get_physical_device_present_rectangles_khr: PFN_vkGetPhysicalDevicePresentRectanglesKHR,
251 pub acquire_next_image2_khr: PFN_vkAcquireNextImage2KHR,
252}
253unsafe impl Send for KhrSwapchainFn {}
254unsafe impl Sync for KhrSwapchainFn {}
255impl KhrSwapchainFn {
256 pub fn load<F>(mut _f: F) -> Self
257 where
258 F: FnMut(&::std::ffi::CStr) -> *const c_void,
259 {
260 Self {
261 create_swapchain_khr: unsafe {
262 unsafe extern "system" fn create_swapchain_khr(
263 _device: Device,
264 _p_create_info: *const SwapchainCreateInfoKHR,
265 _p_allocator: *const AllocationCallbacks,
266 _p_swapchain: *mut SwapchainKHR,
267 ) -> Result {
268 panic!(concat!("Unable to load ", stringify!(create_swapchain_khr)))
269 }
270 let cname =
271 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateSwapchainKHR\0");
272 let val = _f(cname);
273 if val.is_null() {
274 create_swapchain_khr
275 } else {
276 ::std::mem::transmute(val)
277 }
278 },
279 destroy_swapchain_khr: unsafe {
280 unsafe extern "system" fn destroy_swapchain_khr(
281 _device: Device,
282 _swapchain: SwapchainKHR,
283 _p_allocator: *const AllocationCallbacks,
284 ) {
285 panic!(concat!(
286 "Unable to load ",
287 stringify!(destroy_swapchain_khr)
288 ))
289 }
290 let cname =
291 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroySwapchainKHR\0");
292 let val = _f(cname);
293 if val.is_null() {
294 destroy_swapchain_khr
295 } else {
296 ::std::mem::transmute(val)
297 }
298 },
299 get_swapchain_images_khr: unsafe {
300 unsafe extern "system" fn get_swapchain_images_khr(
301 _device: Device,
302 _swapchain: SwapchainKHR,
303 _p_swapchain_image_count: *mut u32,
304 _p_swapchain_images: *mut Image,
305 ) -> Result {
306 panic!(concat!(
307 "Unable to load ",
308 stringify!(get_swapchain_images_khr)
309 ))
310 }
311 let cname =
312 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainImagesKHR\0");
313 let val = _f(cname);
314 if val.is_null() {
315 get_swapchain_images_khr
316 } else {
317 ::std::mem::transmute(val)
318 }
319 },
320 acquire_next_image_khr: unsafe {
321 unsafe extern "system" fn acquire_next_image_khr(
322 _device: Device,
323 _swapchain: SwapchainKHR,
324 _timeout: u64,
325 _semaphore: Semaphore,
326 _fence: Fence,
327 _p_image_index: *mut u32,
328 ) -> Result {
329 panic!(concat!(
330 "Unable to load ",
331 stringify!(acquire_next_image_khr)
332 ))
333 }
334 let cname =
335 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImageKHR\0");
336 let val = _f(cname);
337 if val.is_null() {
338 acquire_next_image_khr
339 } else {
340 ::std::mem::transmute(val)
341 }
342 },
343 queue_present_khr: unsafe {
344 unsafe extern "system" fn queue_present_khr(
345 _queue: Queue,
346 _p_present_info: *const PresentInfoKHR,
347 ) -> Result {
348 panic!(concat!("Unable to load ", stringify!(queue_present_khr)))
349 }
350 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueuePresentKHR\0");
351 let val = _f(cname);
352 if val.is_null() {
353 queue_present_khr
354 } else {
355 ::std::mem::transmute(val)
356 }
357 },
358 get_device_group_present_capabilities_khr: unsafe {
359 unsafe extern "system" fn get_device_group_present_capabilities_khr(
360 _device: Device,
361 _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
362 ) -> Result {
363 panic!(concat!(
364 "Unable to load ",
365 stringify!(get_device_group_present_capabilities_khr)
366 ))
367 }
368 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
369 b"vkGetDeviceGroupPresentCapabilitiesKHR\0",
370 );
371 let val = _f(cname);
372 if val.is_null() {
373 get_device_group_present_capabilities_khr
374 } else {
375 ::std::mem::transmute(val)
376 }
377 },
378 get_device_group_surface_present_modes_khr: unsafe {
379 unsafe extern "system" fn get_device_group_surface_present_modes_khr(
380 _device: Device,
381 _surface: SurfaceKHR,
382 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
383 ) -> Result {
384 panic!(concat!(
385 "Unable to load ",
386 stringify!(get_device_group_surface_present_modes_khr)
387 ))
388 }
389 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
390 b"vkGetDeviceGroupSurfacePresentModesKHR\0",
391 );
392 let val = _f(cname);
393 if val.is_null() {
394 get_device_group_surface_present_modes_khr
395 } else {
396 ::std::mem::transmute(val)
397 }
398 },
399 get_physical_device_present_rectangles_khr: unsafe {
400 unsafe extern "system" fn get_physical_device_present_rectangles_khr(
401 _physical_device: PhysicalDevice,
402 _surface: SurfaceKHR,
403 _p_rect_count: *mut u32,
404 _p_rects: *mut Rect2D,
405 ) -> Result {
406 panic!(concat!(
407 "Unable to load ",
408 stringify!(get_physical_device_present_rectangles_khr)
409 ))
410 }
411 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
412 b"vkGetPhysicalDevicePresentRectanglesKHR\0",
413 );
414 let val = _f(cname);
415 if val.is_null() {
416 get_physical_device_present_rectangles_khr
417 } else {
418 ::std::mem::transmute(val)
419 }
420 },
421 acquire_next_image2_khr: unsafe {
422 unsafe extern "system" fn acquire_next_image2_khr(
423 _device: Device,
424 _p_acquire_info: *const AcquireNextImageInfoKHR,
425 _p_image_index: *mut u32,
426 ) -> Result {
427 panic!(concat!(
428 "Unable to load ",
429 stringify!(acquire_next_image2_khr)
430 ))
431 }
432 let cname =
433 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0");
434 let val = _f(cname);
435 if val.is_null() {
436 acquire_next_image2_khr
437 } else {
438 ::std::mem::transmute(val)
439 }
440 },
441 }
442 }
443}
444#[doc = "Generated from 'VK_KHR_swapchain'"]
445impl ImageLayout {
446 pub const PRESENT_SRC_KHR: Self = Self(1_000_001_002);
447}
448#[doc = "Generated from 'VK_KHR_swapchain'"]
449impl ObjectType {
450 pub const SWAPCHAIN_KHR: Self = Self(1_000_001_000);
451}
452#[doc = "Generated from 'VK_KHR_swapchain'"]
453impl Result {
454 pub const SUBOPTIMAL_KHR: Self = Self(1_000_001_003);
455 pub const ERROR_OUT_OF_DATE_KHR: Self = Self(-1_000_001_004);
456}
457#[doc = "Generated from 'VK_KHR_swapchain'"]
458impl StructureType {
459 pub const SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_001_000);
460 pub const PRESENT_INFO_KHR: Self = Self(1_000_001_001);
461 pub const DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: Self = Self(1_000_060_007);
462 pub const IMAGE_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_008);
463 pub const BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: Self = Self(1_000_060_009);
464 pub const ACQUIRE_NEXT_IMAGE_INFO_KHR: Self = Self(1_000_060_010);
465 pub const DEVICE_GROUP_PRESENT_INFO_KHR: Self = Self(1_000_060_011);
466 pub const DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: Self = Self(1_000_060_012);
467}
468#[doc = "Generated from 'VK_KHR_swapchain'"]
469impl SwapchainCreateFlagsKHR {
470 #[doc = "Allow images with VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT"]
471 pub const SPLIT_INSTANCE_BIND_REGIONS: Self = Self(0b1);
472 #[doc = "Swapchain is protected"]
473 pub const PROTECTED: Self = Self(0b10);
474}
475impl KhrDisplayFn {
476 pub const fn name() -> &'static ::std::ffi::CStr {
477 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display\0") }
478 }
479 pub const SPEC_VERSION: u32 = 23u32;
480}
481#[allow(non_camel_case_types)]
482pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn(
483 physical_device: PhysicalDevice,
484 p_property_count: *mut u32,
485 p_properties: *mut DisplayPropertiesKHR,
486) -> Result;
487#[allow(non_camel_case_types)]
488pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn(
489 physical_device: PhysicalDevice,
490 p_property_count: *mut u32,
491 p_properties: *mut DisplayPlanePropertiesKHR,
492) -> Result;
493#[allow(non_camel_case_types)]
494pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn(
495 physical_device: PhysicalDevice,
496 plane_index: u32,
497 p_display_count: *mut u32,
498 p_displays: *mut DisplayKHR,
499) -> Result;
500#[allow(non_camel_case_types)]
501pub type PFN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn(
502 physical_device: PhysicalDevice,
503 display: DisplayKHR,
504 p_property_count: *mut u32,
505 p_properties: *mut DisplayModePropertiesKHR,
506) -> Result;
507#[allow(non_camel_case_types)]
508pub type PFN_vkCreateDisplayModeKHR = unsafe extern "system" fn(
509 physical_device: PhysicalDevice,
510 display: DisplayKHR,
511 p_create_info: *const DisplayModeCreateInfoKHR,
512 p_allocator: *const AllocationCallbacks,
513 p_mode: *mut DisplayModeKHR,
514) -> Result;
515#[allow(non_camel_case_types)]
516pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn(
517 physical_device: PhysicalDevice,
518 mode: DisplayModeKHR,
519 plane_index: u32,
520 p_capabilities: *mut DisplayPlaneCapabilitiesKHR,
521) -> Result;
522#[allow(non_camel_case_types)]
523pub type PFN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn(
524 instance: Instance,
525 p_create_info: *const DisplaySurfaceCreateInfoKHR,
526 p_allocator: *const AllocationCallbacks,
527 p_surface: *mut SurfaceKHR,
528) -> Result;
529#[derive(Clone)]
530pub struct KhrDisplayFn {
531 pub get_physical_device_display_properties_khr: PFN_vkGetPhysicalDeviceDisplayPropertiesKHR,
532 pub get_physical_device_display_plane_properties_khr:
533 PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR,
534 pub get_display_plane_supported_displays_khr: PFN_vkGetDisplayPlaneSupportedDisplaysKHR,
535 pub get_display_mode_properties_khr: PFN_vkGetDisplayModePropertiesKHR,
536 pub create_display_mode_khr: PFN_vkCreateDisplayModeKHR,
537 pub get_display_plane_capabilities_khr: PFN_vkGetDisplayPlaneCapabilitiesKHR,
538 pub create_display_plane_surface_khr: PFN_vkCreateDisplayPlaneSurfaceKHR,
539}
540unsafe impl Send for KhrDisplayFn {}
541unsafe impl Sync for KhrDisplayFn {}
542impl KhrDisplayFn {
543 pub fn load<F>(mut _f: F) -> Self
544 where
545 F: FnMut(&::std::ffi::CStr) -> *const c_void,
546 {
547 Self {
548 get_physical_device_display_properties_khr: unsafe {
549 unsafe extern "system" fn get_physical_device_display_properties_khr(
550 _physical_device: PhysicalDevice,
551 _p_property_count: *mut u32,
552 _p_properties: *mut DisplayPropertiesKHR,
553 ) -> Result {
554 panic!(concat!(
555 "Unable to load ",
556 stringify!(get_physical_device_display_properties_khr)
557 ))
558 }
559 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
560 b"vkGetPhysicalDeviceDisplayPropertiesKHR\0",
561 );
562 let val = _f(cname);
563 if val.is_null() {
564 get_physical_device_display_properties_khr
565 } else {
566 ::std::mem::transmute(val)
567 }
568 },
569 get_physical_device_display_plane_properties_khr: unsafe {
570 unsafe extern "system" fn get_physical_device_display_plane_properties_khr(
571 _physical_device: PhysicalDevice,
572 _p_property_count: *mut u32,
573 _p_properties: *mut DisplayPlanePropertiesKHR,
574 ) -> Result {
575 panic!(concat!(
576 "Unable to load ",
577 stringify!(get_physical_device_display_plane_properties_khr)
578 ))
579 }
580 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
581 b"vkGetPhysicalDeviceDisplayPlanePropertiesKHR\0",
582 );
583 let val = _f(cname);
584 if val.is_null() {
585 get_physical_device_display_plane_properties_khr
586 } else {
587 ::std::mem::transmute(val)
588 }
589 },
590 get_display_plane_supported_displays_khr: unsafe {
591 unsafe extern "system" fn get_display_plane_supported_displays_khr(
592 _physical_device: PhysicalDevice,
593 _plane_index: u32,
594 _p_display_count: *mut u32,
595 _p_displays: *mut DisplayKHR,
596 ) -> Result {
597 panic!(concat!(
598 "Unable to load ",
599 stringify!(get_display_plane_supported_displays_khr)
600 ))
601 }
602 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
603 b"vkGetDisplayPlaneSupportedDisplaysKHR\0",
604 );
605 let val = _f(cname);
606 if val.is_null() {
607 get_display_plane_supported_displays_khr
608 } else {
609 ::std::mem::transmute(val)
610 }
611 },
612 get_display_mode_properties_khr: unsafe {
613 unsafe extern "system" fn get_display_mode_properties_khr(
614 _physical_device: PhysicalDevice,
615 _display: DisplayKHR,
616 _p_property_count: *mut u32,
617 _p_properties: *mut DisplayModePropertiesKHR,
618 ) -> Result {
619 panic!(concat!(
620 "Unable to load ",
621 stringify!(get_display_mode_properties_khr)
622 ))
623 }
624 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
625 b"vkGetDisplayModePropertiesKHR\0",
626 );
627 let val = _f(cname);
628 if val.is_null() {
629 get_display_mode_properties_khr
630 } else {
631 ::std::mem::transmute(val)
632 }
633 },
634 create_display_mode_khr: unsafe {
635 unsafe extern "system" fn create_display_mode_khr(
636 _physical_device: PhysicalDevice,
637 _display: DisplayKHR,
638 _p_create_info: *const DisplayModeCreateInfoKHR,
639 _p_allocator: *const AllocationCallbacks,
640 _p_mode: *mut DisplayModeKHR,
641 ) -> Result {
642 panic!(concat!(
643 "Unable to load ",
644 stringify!(create_display_mode_khr)
645 ))
646 }
647 let cname =
648 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateDisplayModeKHR\0");
649 let val = _f(cname);
650 if val.is_null() {
651 create_display_mode_khr
652 } else {
653 ::std::mem::transmute(val)
654 }
655 },
656 get_display_plane_capabilities_khr: unsafe {
657 unsafe extern "system" fn get_display_plane_capabilities_khr(
658 _physical_device: PhysicalDevice,
659 _mode: DisplayModeKHR,
660 _plane_index: u32,
661 _p_capabilities: *mut DisplayPlaneCapabilitiesKHR,
662 ) -> Result {
663 panic!(concat!(
664 "Unable to load ",
665 stringify!(get_display_plane_capabilities_khr)
666 ))
667 }
668 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
669 b"vkGetDisplayPlaneCapabilitiesKHR\0",
670 );
671 let val = _f(cname);
672 if val.is_null() {
673 get_display_plane_capabilities_khr
674 } else {
675 ::std::mem::transmute(val)
676 }
677 },
678 create_display_plane_surface_khr: unsafe {
679 unsafe extern "system" fn create_display_plane_surface_khr(
680 _instance: Instance,
681 _p_create_info: *const DisplaySurfaceCreateInfoKHR,
682 _p_allocator: *const AllocationCallbacks,
683 _p_surface: *mut SurfaceKHR,
684 ) -> Result {
685 panic!(concat!(
686 "Unable to load ",
687 stringify!(create_display_plane_surface_khr)
688 ))
689 }
690 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
691 b"vkCreateDisplayPlaneSurfaceKHR\0",
692 );
693 let val = _f(cname);
694 if val.is_null() {
695 create_display_plane_surface_khr
696 } else {
697 ::std::mem::transmute(val)
698 }
699 },
700 }
701 }
702}
703#[doc = "Generated from 'VK_KHR_display'"]
704impl ObjectType {
705 pub const DISPLAY_KHR: Self = Self(1_000_002_000);
706 pub const DISPLAY_MODE_KHR: Self = Self(1_000_002_001);
707}
708#[doc = "Generated from 'VK_KHR_display'"]
709impl StructureType {
710 pub const DISPLAY_MODE_CREATE_INFO_KHR: Self = Self(1_000_002_000);
711 pub const DISPLAY_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_002_001);
712}
713impl KhrDisplaySwapchainFn {
714 pub const fn name() -> &'static ::std::ffi::CStr {
715 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_display_swapchain\0") }
716 }
717 pub const SPEC_VERSION: u32 = 10u32;
718}
719#[allow(non_camel_case_types)]
720pub type PFN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn(
721 device: Device,
722 swapchain_count: u32,
723 p_create_infos: *const SwapchainCreateInfoKHR,
724 p_allocator: *const AllocationCallbacks,
725 p_swapchains: *mut SwapchainKHR,
726) -> Result;
727#[derive(Clone)]
728pub struct KhrDisplaySwapchainFn {
729 pub create_shared_swapchains_khr: PFN_vkCreateSharedSwapchainsKHR,
730}
731unsafe impl Send for KhrDisplaySwapchainFn {}
732unsafe impl Sync for KhrDisplaySwapchainFn {}
733impl KhrDisplaySwapchainFn {
734 pub fn load<F>(mut _f: F) -> Self
735 where
736 F: FnMut(&::std::ffi::CStr) -> *const c_void,
737 {
738 Self {
739 create_shared_swapchains_khr: unsafe {
740 unsafe extern "system" fn create_shared_swapchains_khr(
741 _device: Device,
742 _swapchain_count: u32,
743 _p_create_infos: *const SwapchainCreateInfoKHR,
744 _p_allocator: *const AllocationCallbacks,
745 _p_swapchains: *mut SwapchainKHR,
746 ) -> Result {
747 panic!(concat!(
748 "Unable to load ",
749 stringify!(create_shared_swapchains_khr)
750 ))
751 }
752 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
753 b"vkCreateSharedSwapchainsKHR\0",
754 );
755 let val = _f(cname);
756 if val.is_null() {
757 create_shared_swapchains_khr
758 } else {
759 ::std::mem::transmute(val)
760 }
761 },
762 }
763 }
764}
765#[doc = "Generated from 'VK_KHR_display_swapchain'"]
766impl Result {
767 pub const ERROR_INCOMPATIBLE_DISPLAY_KHR: Self = Self(-1_000_003_001);
768}
769#[doc = "Generated from 'VK_KHR_display_swapchain'"]
770impl StructureType {
771 pub const DISPLAY_PRESENT_INFO_KHR: Self = Self(1_000_003_000);
772}
773impl KhrXlibSurfaceFn {
774 pub const fn name() -> &'static ::std::ffi::CStr {
775 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xlib_surface\0") }
776 }
777 pub const SPEC_VERSION: u32 = 6u32;
778}
779#[allow(non_camel_case_types)]
780pub type PFN_vkCreateXlibSurfaceKHR = unsafe extern "system" fn(
781 instance: Instance,
782 p_create_info: *const XlibSurfaceCreateInfoKHR,
783 p_allocator: *const AllocationCallbacks,
784 p_surface: *mut SurfaceKHR,
785) -> Result;
786#[allow(non_camel_case_types)]
787pub type PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR = unsafe extern "system" fn(
788 physical_device: PhysicalDevice,
789 queue_family_index: u32,
790 dpy: *mut Display,
791 visual_id: VisualID,
792) -> Bool32;
793#[derive(Clone)]
794pub struct KhrXlibSurfaceFn {
795 pub create_xlib_surface_khr: PFN_vkCreateXlibSurfaceKHR,
796 pub get_physical_device_xlib_presentation_support_khr:
797 PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR,
798}
799unsafe impl Send for KhrXlibSurfaceFn {}
800unsafe impl Sync for KhrXlibSurfaceFn {}
801impl KhrXlibSurfaceFn {
802 pub fn load<F>(mut _f: F) -> Self
803 where
804 F: FnMut(&::std::ffi::CStr) -> *const c_void,
805 {
806 Self {
807 create_xlib_surface_khr: unsafe {
808 unsafe extern "system" fn create_xlib_surface_khr(
809 _instance: Instance,
810 _p_create_info: *const XlibSurfaceCreateInfoKHR,
811 _p_allocator: *const AllocationCallbacks,
812 _p_surface: *mut SurfaceKHR,
813 ) -> Result {
814 panic!(concat!(
815 "Unable to load ",
816 stringify!(create_xlib_surface_khr)
817 ))
818 }
819 let cname =
820 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXlibSurfaceKHR\0");
821 let val = _f(cname);
822 if val.is_null() {
823 create_xlib_surface_khr
824 } else {
825 ::std::mem::transmute(val)
826 }
827 },
828 get_physical_device_xlib_presentation_support_khr: unsafe {
829 unsafe extern "system" fn get_physical_device_xlib_presentation_support_khr(
830 _physical_device: PhysicalDevice,
831 _queue_family_index: u32,
832 _dpy: *mut Display,
833 _visual_id: VisualID,
834 ) -> Bool32 {
835 panic!(concat!(
836 "Unable to load ",
837 stringify!(get_physical_device_xlib_presentation_support_khr)
838 ))
839 }
840 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
841 b"vkGetPhysicalDeviceXlibPresentationSupportKHR\0",
842 );
843 let val = _f(cname);
844 if val.is_null() {
845 get_physical_device_xlib_presentation_support_khr
846 } else {
847 ::std::mem::transmute(val)
848 }
849 },
850 }
851 }
852}
853#[doc = "Generated from 'VK_KHR_xlib_surface'"]
854impl StructureType {
855 pub const XLIB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_004_000);
856}
857impl KhrXcbSurfaceFn {
858 pub const fn name() -> &'static ::std::ffi::CStr {
859 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_xcb_surface\0") }
860 }
861 pub const SPEC_VERSION: u32 = 6u32;
862}
863#[allow(non_camel_case_types)]
864pub type PFN_vkCreateXcbSurfaceKHR = unsafe extern "system" fn(
865 instance: Instance,
866 p_create_info: *const XcbSurfaceCreateInfoKHR,
867 p_allocator: *const AllocationCallbacks,
868 p_surface: *mut SurfaceKHR,
869) -> Result;
870#[allow(non_camel_case_types)]
871pub type PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR = unsafe extern "system" fn(
872 physical_device: PhysicalDevice,
873 queue_family_index: u32,
874 connection: *mut xcb_connection_t,
875 visual_id: xcb_visualid_t,
876) -> Bool32;
877#[derive(Clone)]
878pub struct KhrXcbSurfaceFn {
879 pub create_xcb_surface_khr: PFN_vkCreateXcbSurfaceKHR,
880 pub get_physical_device_xcb_presentation_support_khr:
881 PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR,
882}
883unsafe impl Send for KhrXcbSurfaceFn {}
884unsafe impl Sync for KhrXcbSurfaceFn {}
885impl KhrXcbSurfaceFn {
886 pub fn load<F>(mut _f: F) -> Self
887 where
888 F: FnMut(&::std::ffi::CStr) -> *const c_void,
889 {
890 Self {
891 create_xcb_surface_khr: unsafe {
892 unsafe extern "system" fn create_xcb_surface_khr(
893 _instance: Instance,
894 _p_create_info: *const XcbSurfaceCreateInfoKHR,
895 _p_allocator: *const AllocationCallbacks,
896 _p_surface: *mut SurfaceKHR,
897 ) -> Result {
898 panic!(concat!(
899 "Unable to load ",
900 stringify!(create_xcb_surface_khr)
901 ))
902 }
903 let cname =
904 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateXcbSurfaceKHR\0");
905 let val = _f(cname);
906 if val.is_null() {
907 create_xcb_surface_khr
908 } else {
909 ::std::mem::transmute(val)
910 }
911 },
912 get_physical_device_xcb_presentation_support_khr: unsafe {
913 unsafe extern "system" fn get_physical_device_xcb_presentation_support_khr(
914 _physical_device: PhysicalDevice,
915 _queue_family_index: u32,
916 _connection: *mut xcb_connection_t,
917 _visual_id: xcb_visualid_t,
918 ) -> Bool32 {
919 panic!(concat!(
920 "Unable to load ",
921 stringify!(get_physical_device_xcb_presentation_support_khr)
922 ))
923 }
924 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
925 b"vkGetPhysicalDeviceXcbPresentationSupportKHR\0",
926 );
927 let val = _f(cname);
928 if val.is_null() {
929 get_physical_device_xcb_presentation_support_khr
930 } else {
931 ::std::mem::transmute(val)
932 }
933 },
934 }
935 }
936}
937#[doc = "Generated from 'VK_KHR_xcb_surface'"]
938impl StructureType {
939 pub const XCB_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_005_000);
940}
941impl KhrWaylandSurfaceFn {
942 pub const fn name() -> &'static ::std::ffi::CStr {
943 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_wayland_surface\0") }
944 }
945 pub const SPEC_VERSION: u32 = 6u32;
946}
947#[allow(non_camel_case_types)]
948pub type PFN_vkCreateWaylandSurfaceKHR = unsafe extern "system" fn(
949 instance: Instance,
950 p_create_info: *const WaylandSurfaceCreateInfoKHR,
951 p_allocator: *const AllocationCallbacks,
952 p_surface: *mut SurfaceKHR,
953) -> Result;
954#[allow(non_camel_case_types)]
955pub type PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR = unsafe extern "system" fn(
956 physical_device: PhysicalDevice,
957 queue_family_index: u32,
958 display: *mut wl_display,
959)
960 -> Bool32;
961#[derive(Clone)]
962pub struct KhrWaylandSurfaceFn {
963 pub create_wayland_surface_khr: PFN_vkCreateWaylandSurfaceKHR,
964 pub get_physical_device_wayland_presentation_support_khr:
965 PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR,
966}
967unsafe impl Send for KhrWaylandSurfaceFn {}
968unsafe impl Sync for KhrWaylandSurfaceFn {}
969impl KhrWaylandSurfaceFn {
970 pub fn load<F>(mut _f: F) -> Self
971 where
972 F: FnMut(&::std::ffi::CStr) -> *const c_void,
973 {
974 Self {
975 create_wayland_surface_khr: unsafe {
976 unsafe extern "system" fn create_wayland_surface_khr(
977 _instance: Instance,
978 _p_create_info: *const WaylandSurfaceCreateInfoKHR,
979 _p_allocator: *const AllocationCallbacks,
980 _p_surface: *mut SurfaceKHR,
981 ) -> Result {
982 panic!(concat!(
983 "Unable to load ",
984 stringify!(create_wayland_surface_khr)
985 ))
986 }
987 let cname =
988 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWaylandSurfaceKHR\0");
989 let val = _f(cname);
990 if val.is_null() {
991 create_wayland_surface_khr
992 } else {
993 ::std::mem::transmute(val)
994 }
995 },
996 get_physical_device_wayland_presentation_support_khr: unsafe {
997 unsafe extern "system" fn get_physical_device_wayland_presentation_support_khr(
998 _physical_device: PhysicalDevice,
999 _queue_family_index: u32,
1000 _display: *mut wl_display,
1001 ) -> Bool32 {
1002 panic!(concat!(
1003 "Unable to load ",
1004 stringify!(get_physical_device_wayland_presentation_support_khr)
1005 ))
1006 }
1007 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1008 b"vkGetPhysicalDeviceWaylandPresentationSupportKHR\0",
1009 );
1010 let val = _f(cname);
1011 if val.is_null() {
1012 get_physical_device_wayland_presentation_support_khr
1013 } else {
1014 ::std::mem::transmute(val)
1015 }
1016 },
1017 }
1018 }
1019}
1020#[doc = "Generated from 'VK_KHR_wayland_surface'"]
1021impl StructureType {
1022 pub const WAYLAND_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_006_000);
1023}
1024impl KhrMirSurfaceFn {
1025 pub const fn name() -> &'static ::std::ffi::CStr {
1026 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_mir_surface\0") }
1027 }
1028 pub const SPEC_VERSION: u32 = 4u32;
1029}
1030#[derive(Clone)]
1031pub struct KhrMirSurfaceFn {}
1032unsafe impl Send for KhrMirSurfaceFn {}
1033unsafe impl Sync for KhrMirSurfaceFn {}
1034impl KhrMirSurfaceFn {
1035 pub fn load<F>(mut _f: F) -> Self
1036 where
1037 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1038 {
1039 Self {}
1040 }
1041}
1042impl KhrAndroidSurfaceFn {
1043 pub const fn name() -> &'static ::std::ffi::CStr {
1044 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_android_surface\0") }
1045 }
1046 pub const SPEC_VERSION: u32 = 6u32;
1047}
1048#[allow(non_camel_case_types)]
1049pub type PFN_vkCreateAndroidSurfaceKHR = unsafe extern "system" fn(
1050 instance: Instance,
1051 p_create_info: *const AndroidSurfaceCreateInfoKHR,
1052 p_allocator: *const AllocationCallbacks,
1053 p_surface: *mut SurfaceKHR,
1054) -> Result;
1055#[derive(Clone)]
1056pub struct KhrAndroidSurfaceFn {
1057 pub create_android_surface_khr: PFN_vkCreateAndroidSurfaceKHR,
1058}
1059unsafe impl Send for KhrAndroidSurfaceFn {}
1060unsafe impl Sync for KhrAndroidSurfaceFn {}
1061impl KhrAndroidSurfaceFn {
1062 pub fn load<F>(mut _f: F) -> Self
1063 where
1064 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1065 {
1066 Self {
1067 create_android_surface_khr: unsafe {
1068 unsafe extern "system" fn create_android_surface_khr(
1069 _instance: Instance,
1070 _p_create_info: *const AndroidSurfaceCreateInfoKHR,
1071 _p_allocator: *const AllocationCallbacks,
1072 _p_surface: *mut SurfaceKHR,
1073 ) -> Result {
1074 panic!(concat!(
1075 "Unable to load ",
1076 stringify!(create_android_surface_khr)
1077 ))
1078 }
1079 let cname =
1080 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateAndroidSurfaceKHR\0");
1081 let val = _f(cname);
1082 if val.is_null() {
1083 create_android_surface_khr
1084 } else {
1085 ::std::mem::transmute(val)
1086 }
1087 },
1088 }
1089 }
1090}
1091#[doc = "Generated from 'VK_KHR_android_surface'"]
1092impl StructureType {
1093 pub const ANDROID_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_008_000);
1094}
1095impl KhrWin32SurfaceFn {
1096 pub const fn name() -> &'static ::std::ffi::CStr {
1097 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_surface\0") }
1098 }
1099 pub const SPEC_VERSION: u32 = 6u32;
1100}
1101#[allow(non_camel_case_types)]
1102pub type PFN_vkCreateWin32SurfaceKHR = unsafe extern "system" fn(
1103 instance: Instance,
1104 p_create_info: *const Win32SurfaceCreateInfoKHR,
1105 p_allocator: *const AllocationCallbacks,
1106 p_surface: *mut SurfaceKHR,
1107) -> Result;
1108#[allow(non_camel_case_types)]
1109pub type PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR =
1110 unsafe extern "system" fn(physical_device: PhysicalDevice, queue_family_index: u32) -> Bool32;
1111#[derive(Clone)]
1112pub struct KhrWin32SurfaceFn {
1113 pub create_win32_surface_khr: PFN_vkCreateWin32SurfaceKHR,
1114 pub get_physical_device_win32_presentation_support_khr:
1115 PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR,
1116}
1117unsafe impl Send for KhrWin32SurfaceFn {}
1118unsafe impl Sync for KhrWin32SurfaceFn {}
1119impl KhrWin32SurfaceFn {
1120 pub fn load<F>(mut _f: F) -> Self
1121 where
1122 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1123 {
1124 Self {
1125 create_win32_surface_khr: unsafe {
1126 unsafe extern "system" fn create_win32_surface_khr(
1127 _instance: Instance,
1128 _p_create_info: *const Win32SurfaceCreateInfoKHR,
1129 _p_allocator: *const AllocationCallbacks,
1130 _p_surface: *mut SurfaceKHR,
1131 ) -> Result {
1132 panic!(concat!(
1133 "Unable to load ",
1134 stringify!(create_win32_surface_khr)
1135 ))
1136 }
1137 let cname =
1138 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateWin32SurfaceKHR\0");
1139 let val = _f(cname);
1140 if val.is_null() {
1141 create_win32_surface_khr
1142 } else {
1143 ::std::mem::transmute(val)
1144 }
1145 },
1146 get_physical_device_win32_presentation_support_khr: unsafe {
1147 unsafe extern "system" fn get_physical_device_win32_presentation_support_khr(
1148 _physical_device: PhysicalDevice,
1149 _queue_family_index: u32,
1150 ) -> Bool32 {
1151 panic!(concat!(
1152 "Unable to load ",
1153 stringify!(get_physical_device_win32_presentation_support_khr)
1154 ))
1155 }
1156 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1157 b"vkGetPhysicalDeviceWin32PresentationSupportKHR\0",
1158 );
1159 let val = _f(cname);
1160 if val.is_null() {
1161 get_physical_device_win32_presentation_support_khr
1162 } else {
1163 ::std::mem::transmute(val)
1164 }
1165 },
1166 }
1167 }
1168}
1169#[doc = "Generated from 'VK_KHR_win32_surface'"]
1170impl StructureType {
1171 pub const WIN32_SURFACE_CREATE_INFO_KHR: Self = Self(1_000_009_000);
1172}
1173impl AndroidNativeBufferFn {
1174 pub const fn name() -> &'static ::std::ffi::CStr {
1175 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ANDROID_native_buffer\0") }
1176 }
1177 pub const SPEC_VERSION: u32 = 8u32;
1178}
1179#[allow(non_camel_case_types)]
1180pub type PFN_vkGetSwapchainGrallocUsageANDROID = unsafe extern "system" fn(
1181 device: Device,
1182 format: Format,
1183 image_usage: ImageUsageFlags,
1184 gralloc_usage: *mut c_int,
1185) -> Result;
1186#[allow(non_camel_case_types)]
1187pub type PFN_vkAcquireImageANDROID = unsafe extern "system" fn(
1188 device: Device,
1189 image: Image,
1190 native_fence_fd: c_int,
1191 semaphore: Semaphore,
1192 fence: Fence,
1193) -> Result;
1194#[allow(non_camel_case_types)]
1195pub type PFN_vkQueueSignalReleaseImageANDROID = unsafe extern "system" fn(
1196 queue: Queue,
1197 wait_semaphore_count: u32,
1198 p_wait_semaphores: *const Semaphore,
1199 image: Image,
1200 p_native_fence_fd: *mut c_int,
1201) -> Result;
1202#[allow(non_camel_case_types)]
1203pub type PFN_vkGetSwapchainGrallocUsage2ANDROID = unsafe extern "system" fn(
1204 device: Device,
1205 format: Format,
1206 image_usage: ImageUsageFlags,
1207 swapchain_image_usage: SwapchainImageUsageFlagsANDROID,
1208 gralloc_consumer_usage: *mut u64,
1209 gralloc_producer_usage: *mut u64,
1210) -> Result;
1211#[derive(Clone)]
1212pub struct AndroidNativeBufferFn {
1213 pub get_swapchain_gralloc_usage_android: PFN_vkGetSwapchainGrallocUsageANDROID,
1214 pub acquire_image_android: PFN_vkAcquireImageANDROID,
1215 pub queue_signal_release_image_android: PFN_vkQueueSignalReleaseImageANDROID,
1216 pub get_swapchain_gralloc_usage2_android: PFN_vkGetSwapchainGrallocUsage2ANDROID,
1217}
1218unsafe impl Send for AndroidNativeBufferFn {}
1219unsafe impl Sync for AndroidNativeBufferFn {}
1220impl AndroidNativeBufferFn {
1221 pub fn load<F>(mut _f: F) -> Self
1222 where
1223 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1224 {
1225 Self {
1226 get_swapchain_gralloc_usage_android: unsafe {
1227 unsafe extern "system" fn get_swapchain_gralloc_usage_android(
1228 _device: Device,
1229 _format: Format,
1230 _image_usage: ImageUsageFlags,
1231 _gralloc_usage: *mut c_int,
1232 ) -> Result {
1233 panic!(concat!(
1234 "Unable to load ",
1235 stringify!(get_swapchain_gralloc_usage_android)
1236 ))
1237 }
1238 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1239 b"vkGetSwapchainGrallocUsageANDROID\0",
1240 );
1241 let val = _f(cname);
1242 if val.is_null() {
1243 get_swapchain_gralloc_usage_android
1244 } else {
1245 ::std::mem::transmute(val)
1246 }
1247 },
1248 acquire_image_android: unsafe {
1249 unsafe extern "system" fn acquire_image_android(
1250 _device: Device,
1251 _image: Image,
1252 _native_fence_fd: c_int,
1253 _semaphore: Semaphore,
1254 _fence: Fence,
1255 ) -> Result {
1256 panic!(concat!(
1257 "Unable to load ",
1258 stringify!(acquire_image_android)
1259 ))
1260 }
1261 let cname =
1262 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireImageANDROID\0");
1263 let val = _f(cname);
1264 if val.is_null() {
1265 acquire_image_android
1266 } else {
1267 ::std::mem::transmute(val)
1268 }
1269 },
1270 queue_signal_release_image_android: unsafe {
1271 unsafe extern "system" fn queue_signal_release_image_android(
1272 _queue: Queue,
1273 _wait_semaphore_count: u32,
1274 _p_wait_semaphores: *const Semaphore,
1275 _image: Image,
1276 _p_native_fence_fd: *mut c_int,
1277 ) -> Result {
1278 panic!(concat!(
1279 "Unable to load ",
1280 stringify!(queue_signal_release_image_android)
1281 ))
1282 }
1283 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1284 b"vkQueueSignalReleaseImageANDROID\0",
1285 );
1286 let val = _f(cname);
1287 if val.is_null() {
1288 queue_signal_release_image_android
1289 } else {
1290 ::std::mem::transmute(val)
1291 }
1292 },
1293 get_swapchain_gralloc_usage2_android: unsafe {
1294 unsafe extern "system" fn get_swapchain_gralloc_usage2_android(
1295 _device: Device,
1296 _format: Format,
1297 _image_usage: ImageUsageFlags,
1298 _swapchain_image_usage: SwapchainImageUsageFlagsANDROID,
1299 _gralloc_consumer_usage: *mut u64,
1300 _gralloc_producer_usage: *mut u64,
1301 ) -> Result {
1302 panic!(concat!(
1303 "Unable to load ",
1304 stringify!(get_swapchain_gralloc_usage2_android)
1305 ))
1306 }
1307 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1308 b"vkGetSwapchainGrallocUsage2ANDROID\0",
1309 );
1310 let val = _f(cname);
1311 if val.is_null() {
1312 get_swapchain_gralloc_usage2_android
1313 } else {
1314 ::std::mem::transmute(val)
1315 }
1316 },
1317 }
1318 }
1319}
1320#[doc = "Generated from 'VK_ANDROID_native_buffer'"]
1321impl StructureType {
1322 pub const NATIVE_BUFFER_ANDROID: Self = Self(1_000_010_000);
1323 pub const SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID: Self = Self(1_000_010_001);
1324 pub const PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: Self = Self(1_000_010_002);
1325}
1326impl ExtDebugReportFn {
1327 pub const fn name() -> &'static ::std::ffi::CStr {
1328 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_report\0") }
1329 }
1330 pub const SPEC_VERSION: u32 = 10u32;
1331}
1332#[allow(non_camel_case_types)]
1333pub type PFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn(
1334 instance: Instance,
1335 p_create_info: *const DebugReportCallbackCreateInfoEXT,
1336 p_allocator: *const AllocationCallbacks,
1337 p_callback: *mut DebugReportCallbackEXT,
1338) -> Result;
1339#[allow(non_camel_case_types)]
1340pub type PFN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn(
1341 instance: Instance,
1342 callback: DebugReportCallbackEXT,
1343 p_allocator: *const AllocationCallbacks,
1344);
1345#[allow(non_camel_case_types)]
1346pub type PFN_vkDebugReportMessageEXT = unsafe extern "system" fn(
1347 instance: Instance,
1348 flags: DebugReportFlagsEXT,
1349 object_type: DebugReportObjectTypeEXT,
1350 object: u64,
1351 location: usize,
1352 message_code: i32,
1353 p_layer_prefix: *const c_char,
1354 p_message: *const c_char,
1355);
1356#[derive(Clone)]
1357pub struct ExtDebugReportFn {
1358 pub create_debug_report_callback_ext: PFN_vkCreateDebugReportCallbackEXT,
1359 pub destroy_debug_report_callback_ext: PFN_vkDestroyDebugReportCallbackEXT,
1360 pub debug_report_message_ext: PFN_vkDebugReportMessageEXT,
1361}
1362unsafe impl Send for ExtDebugReportFn {}
1363unsafe impl Sync for ExtDebugReportFn {}
1364impl ExtDebugReportFn {
1365 pub fn load<F>(mut _f: F) -> Self
1366 where
1367 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1368 {
1369 Self {
1370 create_debug_report_callback_ext: unsafe {
1371 unsafe extern "system" fn create_debug_report_callback_ext(
1372 _instance: Instance,
1373 _p_create_info: *const DebugReportCallbackCreateInfoEXT,
1374 _p_allocator: *const AllocationCallbacks,
1375 _p_callback: *mut DebugReportCallbackEXT,
1376 ) -> Result {
1377 panic!(concat!(
1378 "Unable to load ",
1379 stringify!(create_debug_report_callback_ext)
1380 ))
1381 }
1382 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1383 b"vkCreateDebugReportCallbackEXT\0",
1384 );
1385 let val = _f(cname);
1386 if val.is_null() {
1387 create_debug_report_callback_ext
1388 } else {
1389 ::std::mem::transmute(val)
1390 }
1391 },
1392 destroy_debug_report_callback_ext: unsafe {
1393 unsafe extern "system" fn destroy_debug_report_callback_ext(
1394 _instance: Instance,
1395 _callback: DebugReportCallbackEXT,
1396 _p_allocator: *const AllocationCallbacks,
1397 ) {
1398 panic!(concat!(
1399 "Unable to load ",
1400 stringify!(destroy_debug_report_callback_ext)
1401 ))
1402 }
1403 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1404 b"vkDestroyDebugReportCallbackEXT\0",
1405 );
1406 let val = _f(cname);
1407 if val.is_null() {
1408 destroy_debug_report_callback_ext
1409 } else {
1410 ::std::mem::transmute(val)
1411 }
1412 },
1413 debug_report_message_ext: unsafe {
1414 unsafe extern "system" fn debug_report_message_ext(
1415 _instance: Instance,
1416 _flags: DebugReportFlagsEXT,
1417 _object_type: DebugReportObjectTypeEXT,
1418 _object: u64,
1419 _location: usize,
1420 _message_code: i32,
1421 _p_layer_prefix: *const c_char,
1422 _p_message: *const c_char,
1423 ) {
1424 panic!(concat!(
1425 "Unable to load ",
1426 stringify!(debug_report_message_ext)
1427 ))
1428 }
1429 let cname =
1430 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDebugReportMessageEXT\0");
1431 let val = _f(cname);
1432 if val.is_null() {
1433 debug_report_message_ext
1434 } else {
1435 ::std::mem::transmute(val)
1436 }
1437 },
1438 }
1439 }
1440}
1441#[doc = "Generated from 'VK_EXT_debug_report'"]
1442impl DebugReportObjectTypeEXT {
1443 pub const SAMPLER_YCBCR_CONVERSION: Self = Self(1_000_156_000);
1444 pub const DESCRIPTOR_UPDATE_TEMPLATE: Self = Self(1_000_085_000);
1445}
1446#[doc = "Generated from 'VK_EXT_debug_report'"]
1447impl ObjectType {
1448 pub const DEBUG_REPORT_CALLBACK_EXT: Self = Self(1_000_011_000);
1449}
1450#[doc = "Generated from 'VK_EXT_debug_report'"]
1451impl Result {
1452 pub const ERROR_VALIDATION_FAILED_EXT: Self = Self(-1_000_011_001);
1453}
1454#[doc = "Generated from 'VK_EXT_debug_report'"]
1455impl StructureType {
1456 pub const DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: Self = Self(1_000_011_000);
1457}
1458impl NvGlslShaderFn {
1459 pub const fn name() -> &'static ::std::ffi::CStr {
1460 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_glsl_shader\0") }
1461 }
1462 pub const SPEC_VERSION: u32 = 1u32;
1463}
1464#[derive(Clone)]
1465pub struct NvGlslShaderFn {}
1466unsafe impl Send for NvGlslShaderFn {}
1467unsafe impl Sync for NvGlslShaderFn {}
1468impl NvGlslShaderFn {
1469 pub fn load<F>(mut _f: F) -> Self
1470 where
1471 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1472 {
1473 Self {}
1474 }
1475}
1476#[doc = "Generated from 'VK_NV_glsl_shader'"]
1477impl Result {
1478 pub const ERROR_INVALID_SHADER_NV: Self = Self(-1_000_012_000);
1479}
1480impl ExtDepthRangeUnrestrictedFn {
1481 pub const fn name() -> &'static ::std::ffi::CStr {
1482 unsafe {
1483 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_range_unrestricted\0")
1484 }
1485 }
1486 pub const SPEC_VERSION: u32 = 1u32;
1487}
1488#[derive(Clone)]
1489pub struct ExtDepthRangeUnrestrictedFn {}
1490unsafe impl Send for ExtDepthRangeUnrestrictedFn {}
1491unsafe impl Sync for ExtDepthRangeUnrestrictedFn {}
1492impl ExtDepthRangeUnrestrictedFn {
1493 pub fn load<F>(mut _f: F) -> Self
1494 where
1495 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1496 {
1497 Self {}
1498 }
1499}
1500impl KhrSamplerMirrorClampToEdgeFn {
1501 pub const fn name() -> &'static ::std::ffi::CStr {
1502 unsafe {
1503 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1504 b"VK_KHR_sampler_mirror_clamp_to_edge\0",
1505 )
1506 }
1507 }
1508 pub const SPEC_VERSION: u32 = 3u32;
1509}
1510#[derive(Clone)]
1511pub struct KhrSamplerMirrorClampToEdgeFn {}
1512unsafe impl Send for KhrSamplerMirrorClampToEdgeFn {}
1513unsafe impl Sync for KhrSamplerMirrorClampToEdgeFn {}
1514impl KhrSamplerMirrorClampToEdgeFn {
1515 pub fn load<F>(mut _f: F) -> Self
1516 where
1517 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1518 {
1519 Self {}
1520 }
1521}
1522#[doc = "Generated from 'VK_KHR_sampler_mirror_clamp_to_edge'"]
1523impl SamplerAddressMode {
1524 #[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"]
1525 pub const MIRROR_CLAMP_TO_EDGE: Self = Self(4);
1526 #[deprecated = "Alias introduced for consistency with extension suffixing rules"]
1527 pub const MIRROR_CLAMP_TO_EDGE_KHR: Self = Self::MIRROR_CLAMP_TO_EDGE;
1528}
1529impl ImgFilterCubicFn {
1530 pub const fn name() -> &'static ::std::ffi::CStr {
1531 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_filter_cubic\0") }
1532 }
1533 pub const SPEC_VERSION: u32 = 1u32;
1534}
1535#[derive(Clone)]
1536pub struct ImgFilterCubicFn {}
1537unsafe impl Send for ImgFilterCubicFn {}
1538unsafe impl Sync for ImgFilterCubicFn {}
1539impl ImgFilterCubicFn {
1540 pub fn load<F>(mut _f: F) -> Self
1541 where
1542 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1543 {
1544 Self {}
1545 }
1546}
1547#[doc = "Generated from 'VK_IMG_filter_cubic'"]
1548impl Filter {
1549 pub const CUBIC_IMG: Self = Self(1_000_015_000);
1550}
1551#[doc = "Generated from 'VK_IMG_filter_cubic'"]
1552impl FormatFeatureFlags {
1553 #[doc = "Format can be filtered with VK_FILTER_CUBIC_IMG when being sampled"]
1554 pub const SAMPLED_IMAGE_FILTER_CUBIC_IMG: Self = Self(0b10_0000_0000_0000);
1555}
1556impl AmdExtension17Fn {
1557 pub const fn name() -> &'static ::std::ffi::CStr {
1558 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_17\0") }
1559 }
1560 pub const SPEC_VERSION: u32 = 0u32;
1561}
1562#[derive(Clone)]
1563pub struct AmdExtension17Fn {}
1564unsafe impl Send for AmdExtension17Fn {}
1565unsafe impl Sync for AmdExtension17Fn {}
1566impl AmdExtension17Fn {
1567 pub fn load<F>(mut _f: F) -> Self
1568 where
1569 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1570 {
1571 Self {}
1572 }
1573}
1574impl AmdExtension18Fn {
1575 pub const fn name() -> &'static ::std::ffi::CStr {
1576 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_18\0") }
1577 }
1578 pub const SPEC_VERSION: u32 = 0u32;
1579}
1580#[derive(Clone)]
1581pub struct AmdExtension18Fn {}
1582unsafe impl Send for AmdExtension18Fn {}
1583unsafe impl Sync for AmdExtension18Fn {}
1584impl AmdExtension18Fn {
1585 pub fn load<F>(mut _f: F) -> Self
1586 where
1587 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1588 {
1589 Self {}
1590 }
1591}
1592impl AmdRasterizationOrderFn {
1593 pub const fn name() -> &'static ::std::ffi::CStr {
1594 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_rasterization_order\0") }
1595 }
1596 pub const SPEC_VERSION: u32 = 1u32;
1597}
1598#[derive(Clone)]
1599pub struct AmdRasterizationOrderFn {}
1600unsafe impl Send for AmdRasterizationOrderFn {}
1601unsafe impl Sync for AmdRasterizationOrderFn {}
1602impl AmdRasterizationOrderFn {
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}
1610#[doc = "Generated from 'VK_AMD_rasterization_order'"]
1611impl StructureType {
1612 pub const PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: Self = Self(1_000_018_000);
1613}
1614impl AmdExtension20Fn {
1615 pub const fn name() -> &'static ::std::ffi::CStr {
1616 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_20\0") }
1617 }
1618 pub const SPEC_VERSION: u32 = 0u32;
1619}
1620#[derive(Clone)]
1621pub struct AmdExtension20Fn {}
1622unsafe impl Send for AmdExtension20Fn {}
1623unsafe impl Sync for AmdExtension20Fn {}
1624impl AmdExtension20Fn {
1625 pub fn load<F>(mut _f: F) -> Self
1626 where
1627 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1628 {
1629 Self {}
1630 }
1631}
1632impl AmdShaderTrinaryMinmaxFn {
1633 pub const fn name() -> &'static ::std::ffi::CStr {
1634 unsafe {
1635 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_trinary_minmax\0")
1636 }
1637 }
1638 pub const SPEC_VERSION: u32 = 1u32;
1639}
1640#[derive(Clone)]
1641pub struct AmdShaderTrinaryMinmaxFn {}
1642unsafe impl Send for AmdShaderTrinaryMinmaxFn {}
1643unsafe impl Sync for AmdShaderTrinaryMinmaxFn {}
1644impl AmdShaderTrinaryMinmaxFn {
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 AmdShaderExplicitVertexParameterFn {
1653 pub const fn name() -> &'static ::std::ffi::CStr {
1654 unsafe {
1655 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1656 b"VK_AMD_shader_explicit_vertex_parameter\0",
1657 )
1658 }
1659 }
1660 pub const SPEC_VERSION: u32 = 1u32;
1661}
1662#[derive(Clone)]
1663pub struct AmdShaderExplicitVertexParameterFn {}
1664unsafe impl Send for AmdShaderExplicitVertexParameterFn {}
1665unsafe impl Sync for AmdShaderExplicitVertexParameterFn {}
1666impl AmdShaderExplicitVertexParameterFn {
1667 pub fn load<F>(mut _f: F) -> Self
1668 where
1669 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1670 {
1671 Self {}
1672 }
1673}
1674impl ExtDebugMarkerFn {
1675 pub const fn name() -> &'static ::std::ffi::CStr {
1676 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_marker\0") }
1677 }
1678 pub const SPEC_VERSION: u32 = 4u32;
1679}
1680#[allow(non_camel_case_types)]
1681pub type PFN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn(
1682 device: Device,
1683 p_tag_info: *const DebugMarkerObjectTagInfoEXT,
1684) -> Result;
1685#[allow(non_camel_case_types)]
1686pub type PFN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn(
1687 device: Device,
1688 p_name_info: *const DebugMarkerObjectNameInfoEXT,
1689) -> Result;
1690#[allow(non_camel_case_types)]
1691pub type PFN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn(
1692 command_buffer: CommandBuffer,
1693 p_marker_info: *const DebugMarkerMarkerInfoEXT,
1694);
1695#[allow(non_camel_case_types)]
1696pub type PFN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(command_buffer: CommandBuffer);
1697#[allow(non_camel_case_types)]
1698pub type PFN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn(
1699 command_buffer: CommandBuffer,
1700 p_marker_info: *const DebugMarkerMarkerInfoEXT,
1701);
1702#[derive(Clone)]
1703pub struct ExtDebugMarkerFn {
1704 pub debug_marker_set_object_tag_ext: PFN_vkDebugMarkerSetObjectTagEXT,
1705 pub debug_marker_set_object_name_ext: PFN_vkDebugMarkerSetObjectNameEXT,
1706 pub cmd_debug_marker_begin_ext: PFN_vkCmdDebugMarkerBeginEXT,
1707 pub cmd_debug_marker_end_ext: PFN_vkCmdDebugMarkerEndEXT,
1708 pub cmd_debug_marker_insert_ext: PFN_vkCmdDebugMarkerInsertEXT,
1709}
1710unsafe impl Send for ExtDebugMarkerFn {}
1711unsafe impl Sync for ExtDebugMarkerFn {}
1712impl ExtDebugMarkerFn {
1713 pub fn load<F>(mut _f: F) -> Self
1714 where
1715 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1716 {
1717 Self {
1718 debug_marker_set_object_tag_ext: unsafe {
1719 unsafe extern "system" fn debug_marker_set_object_tag_ext(
1720 _device: Device,
1721 _p_tag_info: *const DebugMarkerObjectTagInfoEXT,
1722 ) -> Result {
1723 panic!(concat!(
1724 "Unable to load ",
1725 stringify!(debug_marker_set_object_tag_ext)
1726 ))
1727 }
1728 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1729 b"vkDebugMarkerSetObjectTagEXT\0",
1730 );
1731 let val = _f(cname);
1732 if val.is_null() {
1733 debug_marker_set_object_tag_ext
1734 } else {
1735 ::std::mem::transmute(val)
1736 }
1737 },
1738 debug_marker_set_object_name_ext: unsafe {
1739 unsafe extern "system" fn debug_marker_set_object_name_ext(
1740 _device: Device,
1741 _p_name_info: *const DebugMarkerObjectNameInfoEXT,
1742 ) -> Result {
1743 panic!(concat!(
1744 "Unable to load ",
1745 stringify!(debug_marker_set_object_name_ext)
1746 ))
1747 }
1748 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1749 b"vkDebugMarkerSetObjectNameEXT\0",
1750 );
1751 let val = _f(cname);
1752 if val.is_null() {
1753 debug_marker_set_object_name_ext
1754 } else {
1755 ::std::mem::transmute(val)
1756 }
1757 },
1758 cmd_debug_marker_begin_ext: unsafe {
1759 unsafe extern "system" fn cmd_debug_marker_begin_ext(
1760 _command_buffer: CommandBuffer,
1761 _p_marker_info: *const DebugMarkerMarkerInfoEXT,
1762 ) {
1763 panic!(concat!(
1764 "Unable to load ",
1765 stringify!(cmd_debug_marker_begin_ext)
1766 ))
1767 }
1768 let cname =
1769 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerBeginEXT\0");
1770 let val = _f(cname);
1771 if val.is_null() {
1772 cmd_debug_marker_begin_ext
1773 } else {
1774 ::std::mem::transmute(val)
1775 }
1776 },
1777 cmd_debug_marker_end_ext: unsafe {
1778 unsafe extern "system" fn cmd_debug_marker_end_ext(_command_buffer: CommandBuffer) {
1779 panic!(concat!(
1780 "Unable to load ",
1781 stringify!(cmd_debug_marker_end_ext)
1782 ))
1783 }
1784 let cname =
1785 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerEndEXT\0");
1786 let val = _f(cname);
1787 if val.is_null() {
1788 cmd_debug_marker_end_ext
1789 } else {
1790 ::std::mem::transmute(val)
1791 }
1792 },
1793 cmd_debug_marker_insert_ext: unsafe {
1794 unsafe extern "system" fn cmd_debug_marker_insert_ext(
1795 _command_buffer: CommandBuffer,
1796 _p_marker_info: *const DebugMarkerMarkerInfoEXT,
1797 ) {
1798 panic!(concat!(
1799 "Unable to load ",
1800 stringify!(cmd_debug_marker_insert_ext)
1801 ))
1802 }
1803 let cname =
1804 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDebugMarkerInsertEXT\0");
1805 let val = _f(cname);
1806 if val.is_null() {
1807 cmd_debug_marker_insert_ext
1808 } else {
1809 ::std::mem::transmute(val)
1810 }
1811 },
1812 }
1813 }
1814}
1815#[doc = "Generated from 'VK_EXT_debug_marker'"]
1816impl StructureType {
1817 pub const DEBUG_MARKER_OBJECT_NAME_INFO_EXT: Self = Self(1_000_022_000);
1818 pub const DEBUG_MARKER_OBJECT_TAG_INFO_EXT: Self = Self(1_000_022_001);
1819 pub const DEBUG_MARKER_MARKER_INFO_EXT: Self = Self(1_000_022_002);
1820}
1821impl KhrVideoQueueFn {
1822 pub const fn name() -> &'static ::std::ffi::CStr {
1823 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_queue\0") }
1824 }
1825 pub const SPEC_VERSION: u32 = 3u32;
1826}
1827#[allow(non_camel_case_types)]
1828pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(
1829 physical_device: PhysicalDevice,
1830 p_video_profile: *const VideoProfileKHR,
1831 p_capabilities: *mut VideoCapabilitiesKHR,
1832) -> Result;
1833#[allow(non_camel_case_types)]
1834pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn(
1835 physical_device: PhysicalDevice,
1836 p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR,
1837 p_video_format_property_count: *mut u32,
1838 p_video_format_properties: *mut VideoFormatPropertiesKHR,
1839) -> Result;
1840#[allow(non_camel_case_types)]
1841pub type PFN_vkCreateVideoSessionKHR = unsafe extern "system" fn(
1842 device: Device,
1843 p_create_info: *const VideoSessionCreateInfoKHR,
1844 p_allocator: *const AllocationCallbacks,
1845 p_video_session: *mut VideoSessionKHR,
1846) -> Result;
1847#[allow(non_camel_case_types)]
1848pub type PFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(
1849 device: Device,
1850 video_session: VideoSessionKHR,
1851 p_allocator: *const AllocationCallbacks,
1852);
1853#[allow(non_camel_case_types)]
1854pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(
1855 device: Device,
1856 video_session: VideoSessionKHR,
1857 p_video_session_memory_requirements_count: *mut u32,
1858 p_video_session_memory_requirements: *mut VideoGetMemoryPropertiesKHR,
1859) -> Result;
1860#[allow(non_camel_case_types)]
1861pub type PFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(
1862 device: Device,
1863 video_session: VideoSessionKHR,
1864 video_session_bind_memory_count: u32,
1865 p_video_session_bind_memories: *const VideoBindMemoryKHR,
1866) -> Result;
1867#[allow(non_camel_case_types)]
1868pub type PFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(
1869 device: Device,
1870 p_create_info: *const VideoSessionParametersCreateInfoKHR,
1871 p_allocator: *const AllocationCallbacks,
1872 p_video_session_parameters: *mut VideoSessionParametersKHR,
1873) -> Result;
1874#[allow(non_camel_case_types)]
1875pub type PFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn(
1876 device: Device,
1877 video_session_parameters: VideoSessionParametersKHR,
1878 p_update_info: *const VideoSessionParametersUpdateInfoKHR,
1879) -> Result;
1880#[allow(non_camel_case_types)]
1881pub type PFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn(
1882 device: Device,
1883 video_session_parameters: VideoSessionParametersKHR,
1884 p_allocator: *const AllocationCallbacks,
1885);
1886#[allow(non_camel_case_types)]
1887pub type PFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn(
1888 command_buffer: CommandBuffer,
1889 p_begin_info: *const VideoBeginCodingInfoKHR,
1890);
1891#[allow(non_camel_case_types)]
1892pub type PFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn(
1893 command_buffer: CommandBuffer,
1894 p_end_coding_info: *const VideoEndCodingInfoKHR,
1895);
1896#[allow(non_camel_case_types)]
1897pub type PFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn(
1898 command_buffer: CommandBuffer,
1899 p_coding_control_info: *const VideoCodingControlInfoKHR,
1900);
1901#[derive(Clone)]
1902pub struct KhrVideoQueueFn {
1903 pub get_physical_device_video_capabilities_khr: PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR,
1904 pub get_physical_device_video_format_properties_khr:
1905 PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR,
1906 pub create_video_session_khr: PFN_vkCreateVideoSessionKHR,
1907 pub destroy_video_session_khr: PFN_vkDestroyVideoSessionKHR,
1908 pub get_video_session_memory_requirements_khr: PFN_vkGetVideoSessionMemoryRequirementsKHR,
1909 pub bind_video_session_memory_khr: PFN_vkBindVideoSessionMemoryKHR,
1910 pub create_video_session_parameters_khr: PFN_vkCreateVideoSessionParametersKHR,
1911 pub update_video_session_parameters_khr: PFN_vkUpdateVideoSessionParametersKHR,
1912 pub destroy_video_session_parameters_khr: PFN_vkDestroyVideoSessionParametersKHR,
1913 pub cmd_begin_video_coding_khr: PFN_vkCmdBeginVideoCodingKHR,
1914 pub cmd_end_video_coding_khr: PFN_vkCmdEndVideoCodingKHR,
1915 pub cmd_control_video_coding_khr: PFN_vkCmdControlVideoCodingKHR,
1916}
1917unsafe impl Send for KhrVideoQueueFn {}
1918unsafe impl Sync for KhrVideoQueueFn {}
1919impl KhrVideoQueueFn {
1920 pub fn load<F>(mut _f: F) -> Self
1921 where
1922 F: FnMut(&::std::ffi::CStr) -> *const c_void,
1923 {
1924 Self {
1925 get_physical_device_video_capabilities_khr: unsafe {
1926 unsafe extern "system" fn get_physical_device_video_capabilities_khr(
1927 _physical_device: PhysicalDevice,
1928 _p_video_profile: *const VideoProfileKHR,
1929 _p_capabilities: *mut VideoCapabilitiesKHR,
1930 ) -> Result {
1931 panic!(concat!(
1932 "Unable to load ",
1933 stringify!(get_physical_device_video_capabilities_khr)
1934 ))
1935 }
1936 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1937 b"vkGetPhysicalDeviceVideoCapabilitiesKHR\0",
1938 );
1939 let val = _f(cname);
1940 if val.is_null() {
1941 get_physical_device_video_capabilities_khr
1942 } else {
1943 ::std::mem::transmute(val)
1944 }
1945 },
1946 get_physical_device_video_format_properties_khr: unsafe {
1947 unsafe extern "system" fn get_physical_device_video_format_properties_khr(
1948 _physical_device: PhysicalDevice,
1949 _p_video_format_info: *const PhysicalDeviceVideoFormatInfoKHR,
1950 _p_video_format_property_count: *mut u32,
1951 _p_video_format_properties: *mut VideoFormatPropertiesKHR,
1952 ) -> Result {
1953 panic!(concat!(
1954 "Unable to load ",
1955 stringify!(get_physical_device_video_format_properties_khr)
1956 ))
1957 }
1958 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
1959 b"vkGetPhysicalDeviceVideoFormatPropertiesKHR\0",
1960 );
1961 let val = _f(cname);
1962 if val.is_null() {
1963 get_physical_device_video_format_properties_khr
1964 } else {
1965 ::std::mem::transmute(val)
1966 }
1967 },
1968 create_video_session_khr: unsafe {
1969 unsafe extern "system" fn create_video_session_khr(
1970 _device: Device,
1971 _p_create_info: *const VideoSessionCreateInfoKHR,
1972 _p_allocator: *const AllocationCallbacks,
1973 _p_video_session: *mut VideoSessionKHR,
1974 ) -> Result {
1975 panic!(concat!(
1976 "Unable to load ",
1977 stringify!(create_video_session_khr)
1978 ))
1979 }
1980 let cname =
1981 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateVideoSessionKHR\0");
1982 let val = _f(cname);
1983 if val.is_null() {
1984 create_video_session_khr
1985 } else {
1986 ::std::mem::transmute(val)
1987 }
1988 },
1989 destroy_video_session_khr: unsafe {
1990 unsafe extern "system" fn destroy_video_session_khr(
1991 _device: Device,
1992 _video_session: VideoSessionKHR,
1993 _p_allocator: *const AllocationCallbacks,
1994 ) {
1995 panic!(concat!(
1996 "Unable to load ",
1997 stringify!(destroy_video_session_khr)
1998 ))
1999 }
2000 let cname =
2001 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyVideoSessionKHR\0");
2002 let val = _f(cname);
2003 if val.is_null() {
2004 destroy_video_session_khr
2005 } else {
2006 ::std::mem::transmute(val)
2007 }
2008 },
2009 get_video_session_memory_requirements_khr: unsafe {
2010 unsafe extern "system" fn get_video_session_memory_requirements_khr(
2011 _device: Device,
2012 _video_session: VideoSessionKHR,
2013 _p_video_session_memory_requirements_count: *mut u32,
2014 _p_video_session_memory_requirements: *mut VideoGetMemoryPropertiesKHR,
2015 ) -> Result {
2016 panic!(concat!(
2017 "Unable to load ",
2018 stringify!(get_video_session_memory_requirements_khr)
2019 ))
2020 }
2021 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2022 b"vkGetVideoSessionMemoryRequirementsKHR\0",
2023 );
2024 let val = _f(cname);
2025 if val.is_null() {
2026 get_video_session_memory_requirements_khr
2027 } else {
2028 ::std::mem::transmute(val)
2029 }
2030 },
2031 bind_video_session_memory_khr: unsafe {
2032 unsafe extern "system" fn bind_video_session_memory_khr(
2033 _device: Device,
2034 _video_session: VideoSessionKHR,
2035 _video_session_bind_memory_count: u32,
2036 _p_video_session_bind_memories: *const VideoBindMemoryKHR,
2037 ) -> Result {
2038 panic!(concat!(
2039 "Unable to load ",
2040 stringify!(bind_video_session_memory_khr)
2041 ))
2042 }
2043 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2044 b"vkBindVideoSessionMemoryKHR\0",
2045 );
2046 let val = _f(cname);
2047 if val.is_null() {
2048 bind_video_session_memory_khr
2049 } else {
2050 ::std::mem::transmute(val)
2051 }
2052 },
2053 create_video_session_parameters_khr: unsafe {
2054 unsafe extern "system" fn create_video_session_parameters_khr(
2055 _device: Device,
2056 _p_create_info: *const VideoSessionParametersCreateInfoKHR,
2057 _p_allocator: *const AllocationCallbacks,
2058 _p_video_session_parameters: *mut VideoSessionParametersKHR,
2059 ) -> Result {
2060 panic!(concat!(
2061 "Unable to load ",
2062 stringify!(create_video_session_parameters_khr)
2063 ))
2064 }
2065 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2066 b"vkCreateVideoSessionParametersKHR\0",
2067 );
2068 let val = _f(cname);
2069 if val.is_null() {
2070 create_video_session_parameters_khr
2071 } else {
2072 ::std::mem::transmute(val)
2073 }
2074 },
2075 update_video_session_parameters_khr: unsafe {
2076 unsafe extern "system" fn update_video_session_parameters_khr(
2077 _device: Device,
2078 _video_session_parameters: VideoSessionParametersKHR,
2079 _p_update_info: *const VideoSessionParametersUpdateInfoKHR,
2080 ) -> Result {
2081 panic!(concat!(
2082 "Unable to load ",
2083 stringify!(update_video_session_parameters_khr)
2084 ))
2085 }
2086 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2087 b"vkUpdateVideoSessionParametersKHR\0",
2088 );
2089 let val = _f(cname);
2090 if val.is_null() {
2091 update_video_session_parameters_khr
2092 } else {
2093 ::std::mem::transmute(val)
2094 }
2095 },
2096 destroy_video_session_parameters_khr: unsafe {
2097 unsafe extern "system" fn destroy_video_session_parameters_khr(
2098 _device: Device,
2099 _video_session_parameters: VideoSessionParametersKHR,
2100 _p_allocator: *const AllocationCallbacks,
2101 ) {
2102 panic!(concat!(
2103 "Unable to load ",
2104 stringify!(destroy_video_session_parameters_khr)
2105 ))
2106 }
2107 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2108 b"vkDestroyVideoSessionParametersKHR\0",
2109 );
2110 let val = _f(cname);
2111 if val.is_null() {
2112 destroy_video_session_parameters_khr
2113 } else {
2114 ::std::mem::transmute(val)
2115 }
2116 },
2117 cmd_begin_video_coding_khr: unsafe {
2118 unsafe extern "system" fn cmd_begin_video_coding_khr(
2119 _command_buffer: CommandBuffer,
2120 _p_begin_info: *const VideoBeginCodingInfoKHR,
2121 ) {
2122 panic!(concat!(
2123 "Unable to load ",
2124 stringify!(cmd_begin_video_coding_khr)
2125 ))
2126 }
2127 let cname =
2128 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginVideoCodingKHR\0");
2129 let val = _f(cname);
2130 if val.is_null() {
2131 cmd_begin_video_coding_khr
2132 } else {
2133 ::std::mem::transmute(val)
2134 }
2135 },
2136 cmd_end_video_coding_khr: unsafe {
2137 unsafe extern "system" fn cmd_end_video_coding_khr(
2138 _command_buffer: CommandBuffer,
2139 _p_end_coding_info: *const VideoEndCodingInfoKHR,
2140 ) {
2141 panic!(concat!(
2142 "Unable to load ",
2143 stringify!(cmd_end_video_coding_khr)
2144 ))
2145 }
2146 let cname =
2147 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndVideoCodingKHR\0");
2148 let val = _f(cname);
2149 if val.is_null() {
2150 cmd_end_video_coding_khr
2151 } else {
2152 ::std::mem::transmute(val)
2153 }
2154 },
2155 cmd_control_video_coding_khr: unsafe {
2156 unsafe extern "system" fn cmd_control_video_coding_khr(
2157 _command_buffer: CommandBuffer,
2158 _p_coding_control_info: *const VideoCodingControlInfoKHR,
2159 ) {
2160 panic!(concat!(
2161 "Unable to load ",
2162 stringify!(cmd_control_video_coding_khr)
2163 ))
2164 }
2165 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2166 b"vkCmdControlVideoCodingKHR\0",
2167 );
2168 let val = _f(cname);
2169 if val.is_null() {
2170 cmd_control_video_coding_khr
2171 } else {
2172 ::std::mem::transmute(val)
2173 }
2174 },
2175 }
2176 }
2177}
2178#[doc = "Generated from 'VK_KHR_video_queue'"]
2179impl ObjectType {
2180 #[doc = "VkVideoSessionKHR"]
2181 pub const VIDEO_SESSION_KHR: Self = Self(1_000_023_000);
2182 #[doc = "VkVideoSessionParametersKHR"]
2183 pub const VIDEO_SESSION_PARAMETERS_KHR: Self = Self(1_000_023_001);
2184}
2185#[doc = "Generated from 'VK_KHR_video_queue'"]
2186impl QueryResultFlags {
2187 pub const WITH_STATUS_KHR: Self = Self(0b1_0000);
2188}
2189#[doc = "Generated from 'VK_KHR_video_queue'"]
2190impl QueryType {
2191 pub const RESULT_STATUS_ONLY_KHR: Self = Self(1_000_023_000);
2192}
2193#[doc = "Generated from 'VK_KHR_video_queue'"]
2194impl StructureType {
2195 pub const VIDEO_PROFILE_KHR: Self = Self(1_000_023_000);
2196 pub const VIDEO_CAPABILITIES_KHR: Self = Self(1_000_023_001);
2197 pub const VIDEO_PICTURE_RESOURCE_KHR: Self = Self(1_000_023_002);
2198 pub const VIDEO_GET_MEMORY_PROPERTIES_KHR: Self = Self(1_000_023_003);
2199 pub const VIDEO_BIND_MEMORY_KHR: Self = Self(1_000_023_004);
2200 pub const VIDEO_SESSION_CREATE_INFO_KHR: Self = Self(1_000_023_005);
2201 pub const VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: Self = Self(1_000_023_006);
2202 pub const VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: Self = Self(1_000_023_007);
2203 pub const VIDEO_BEGIN_CODING_INFO_KHR: Self = Self(1_000_023_008);
2204 pub const VIDEO_END_CODING_INFO_KHR: Self = Self(1_000_023_009);
2205 pub const VIDEO_CODING_CONTROL_INFO_KHR: Self = Self(1_000_023_010);
2206 pub const VIDEO_REFERENCE_SLOT_KHR: Self = Self(1_000_023_011);
2207 pub const VIDEO_QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self(1_000_023_012);
2208 pub const VIDEO_PROFILES_KHR: Self = Self(1_000_023_013);
2209 pub const PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: Self = Self(1_000_023_014);
2210 pub const VIDEO_FORMAT_PROPERTIES_KHR: Self = Self(1_000_023_015);
2211 pub const QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_2_KHR: Self = Self(1_000_023_016);
2212}
2213impl KhrVideoDecodeQueueFn {
2214 pub const fn name() -> &'static ::std::ffi::CStr {
2215 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_decode_queue\0") }
2216 }
2217 pub const SPEC_VERSION: u32 = 3u32;
2218}
2219#[allow(non_camel_case_types)]
2220pub type PFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn(
2221 command_buffer: CommandBuffer,
2222 p_frame_info: *const VideoDecodeInfoKHR,
2223);
2224#[derive(Clone)]
2225pub struct KhrVideoDecodeQueueFn {
2226 pub cmd_decode_video_khr: PFN_vkCmdDecodeVideoKHR,
2227}
2228unsafe impl Send for KhrVideoDecodeQueueFn {}
2229unsafe impl Sync for KhrVideoDecodeQueueFn {}
2230impl KhrVideoDecodeQueueFn {
2231 pub fn load<F>(mut _f: F) -> Self
2232 where
2233 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2234 {
2235 Self {
2236 cmd_decode_video_khr: unsafe {
2237 unsafe extern "system" fn cmd_decode_video_khr(
2238 _command_buffer: CommandBuffer,
2239 _p_frame_info: *const VideoDecodeInfoKHR,
2240 ) {
2241 panic!(concat!("Unable to load ", stringify!(cmd_decode_video_khr)))
2242 }
2243 let cname =
2244 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDecodeVideoKHR\0");
2245 let val = _f(cname);
2246 if val.is_null() {
2247 cmd_decode_video_khr
2248 } else {
2249 ::std::mem::transmute(val)
2250 }
2251 },
2252 }
2253 }
2254}
2255#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2256impl AccessFlags2 {
2257 pub const VIDEO_DECODE_READ_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
2258 pub const VIDEO_DECODE_WRITE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
2259}
2260#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2261impl BufferUsageFlags {
2262 pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b10_0000_0000_0000);
2263 pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000_0000);
2264}
2265#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2266impl FormatFeatureFlags {
2267 pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
2268 pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2269}
2270#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2271impl FormatFeatureFlags2 {
2272 pub const VIDEO_DECODE_OUTPUT_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
2273 pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2274}
2275#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2276impl ImageLayout {
2277 pub const VIDEO_DECODE_DST_KHR: Self = Self(1_000_024_000);
2278 pub const VIDEO_DECODE_SRC_KHR: Self = Self(1_000_024_001);
2279 pub const VIDEO_DECODE_DPB_KHR: Self = Self(1_000_024_002);
2280}
2281#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2282impl ImageUsageFlags {
2283 pub const VIDEO_DECODE_DST_KHR: Self = Self(0b100_0000_0000);
2284 pub const VIDEO_DECODE_SRC_KHR: Self = Self(0b1000_0000_0000);
2285 pub const VIDEO_DECODE_DPB_KHR: Self = Self(0b1_0000_0000_0000);
2286}
2287#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2288impl PipelineStageFlags2 {
2289 pub const VIDEO_DECODE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2290}
2291#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2292impl QueueFlags {
2293 pub const VIDEO_DECODE_KHR: Self = Self(0b10_0000);
2294}
2295#[doc = "Generated from 'VK_KHR_video_decode_queue'"]
2296impl StructureType {
2297 pub const VIDEO_DECODE_INFO_KHR: Self = Self(1_000_024_000);
2298 pub const VIDEO_DECODE_CAPABILITIES_KHR: Self = Self(1_000_024_001);
2299}
2300impl AmdGcnShaderFn {
2301 pub const fn name() -> &'static ::std::ffi::CStr {
2302 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gcn_shader\0") }
2303 }
2304 pub const SPEC_VERSION: u32 = 1u32;
2305}
2306#[derive(Clone)]
2307pub struct AmdGcnShaderFn {}
2308unsafe impl Send for AmdGcnShaderFn {}
2309unsafe impl Sync for AmdGcnShaderFn {}
2310impl AmdGcnShaderFn {
2311 pub fn load<F>(mut _f: F) -> Self
2312 where
2313 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2314 {
2315 Self {}
2316 }
2317}
2318impl NvDedicatedAllocationFn {
2319 pub const fn name() -> &'static ::std::ffi::CStr {
2320 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_dedicated_allocation\0") }
2321 }
2322 pub const SPEC_VERSION: u32 = 1u32;
2323}
2324#[derive(Clone)]
2325pub struct NvDedicatedAllocationFn {}
2326unsafe impl Send for NvDedicatedAllocationFn {}
2327unsafe impl Sync for NvDedicatedAllocationFn {}
2328impl NvDedicatedAllocationFn {
2329 pub fn load<F>(mut _f: F) -> Self
2330 where
2331 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2332 {
2333 Self {}
2334 }
2335}
2336#[doc = "Generated from 'VK_NV_dedicated_allocation'"]
2337impl StructureType {
2338 pub const DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: Self = Self(1_000_026_000);
2339 pub const DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: Self = Self(1_000_026_001);
2340 pub const DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_026_002);
2341}
2342impl ExtExtension28Fn {
2343 pub const fn name() -> &'static ::std::ffi::CStr {
2344 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_28\0") }
2345 }
2346 pub const SPEC_VERSION: u32 = 0u32;
2347}
2348#[derive(Clone)]
2349pub struct ExtExtension28Fn {}
2350unsafe impl Send for ExtExtension28Fn {}
2351unsafe impl Sync for ExtExtension28Fn {}
2352impl ExtExtension28Fn {
2353 pub fn load<F>(mut _f: F) -> Self
2354 where
2355 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2356 {
2357 Self {}
2358 }
2359}
2360impl ExtTransformFeedbackFn {
2361 pub const fn name() -> &'static ::std::ffi::CStr {
2362 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_transform_feedback\0") }
2363 }
2364 pub const SPEC_VERSION: u32 = 1u32;
2365}
2366#[allow(non_camel_case_types)]
2367pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn(
2368 command_buffer: CommandBuffer,
2369 first_binding: u32,
2370 binding_count: u32,
2371 p_buffers: *const Buffer,
2372 p_offsets: *const DeviceSize,
2373 p_sizes: *const DeviceSize,
2374);
2375#[allow(non_camel_case_types)]
2376pub type PFN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn(
2377 command_buffer: CommandBuffer,
2378 first_counter_buffer: u32,
2379 counter_buffer_count: u32,
2380 p_counter_buffers: *const Buffer,
2381 p_counter_buffer_offsets: *const DeviceSize,
2382);
2383#[allow(non_camel_case_types)]
2384pub type PFN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn(
2385 command_buffer: CommandBuffer,
2386 first_counter_buffer: u32,
2387 counter_buffer_count: u32,
2388 p_counter_buffers: *const Buffer,
2389 p_counter_buffer_offsets: *const DeviceSize,
2390);
2391#[allow(non_camel_case_types)]
2392pub type PFN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn(
2393 command_buffer: CommandBuffer,
2394 query_pool: QueryPool,
2395 query: u32,
2396 flags: QueryControlFlags,
2397 index: u32,
2398);
2399#[allow(non_camel_case_types)]
2400pub type PFN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn(
2401 command_buffer: CommandBuffer,
2402 query_pool: QueryPool,
2403 query: u32,
2404 index: u32,
2405);
2406#[allow(non_camel_case_types)]
2407pub type PFN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn(
2408 command_buffer: CommandBuffer,
2409 instance_count: u32,
2410 first_instance: u32,
2411 counter_buffer: Buffer,
2412 counter_buffer_offset: DeviceSize,
2413 counter_offset: u32,
2414 vertex_stride: u32,
2415);
2416#[derive(Clone)]
2417pub struct ExtTransformFeedbackFn {
2418 pub cmd_bind_transform_feedback_buffers_ext: PFN_vkCmdBindTransformFeedbackBuffersEXT,
2419 pub cmd_begin_transform_feedback_ext: PFN_vkCmdBeginTransformFeedbackEXT,
2420 pub cmd_end_transform_feedback_ext: PFN_vkCmdEndTransformFeedbackEXT,
2421 pub cmd_begin_query_indexed_ext: PFN_vkCmdBeginQueryIndexedEXT,
2422 pub cmd_end_query_indexed_ext: PFN_vkCmdEndQueryIndexedEXT,
2423 pub cmd_draw_indirect_byte_count_ext: PFN_vkCmdDrawIndirectByteCountEXT,
2424}
2425unsafe impl Send for ExtTransformFeedbackFn {}
2426unsafe impl Sync for ExtTransformFeedbackFn {}
2427impl ExtTransformFeedbackFn {
2428 pub fn load<F>(mut _f: F) -> Self
2429 where
2430 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2431 {
2432 Self {
2433 cmd_bind_transform_feedback_buffers_ext: unsafe {
2434 unsafe extern "system" fn cmd_bind_transform_feedback_buffers_ext(
2435 _command_buffer: CommandBuffer,
2436 _first_binding: u32,
2437 _binding_count: u32,
2438 _p_buffers: *const Buffer,
2439 _p_offsets: *const DeviceSize,
2440 _p_sizes: *const DeviceSize,
2441 ) {
2442 panic!(concat!(
2443 "Unable to load ",
2444 stringify!(cmd_bind_transform_feedback_buffers_ext)
2445 ))
2446 }
2447 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2448 b"vkCmdBindTransformFeedbackBuffersEXT\0",
2449 );
2450 let val = _f(cname);
2451 if val.is_null() {
2452 cmd_bind_transform_feedback_buffers_ext
2453 } else {
2454 ::std::mem::transmute(val)
2455 }
2456 },
2457 cmd_begin_transform_feedback_ext: unsafe {
2458 unsafe extern "system" fn cmd_begin_transform_feedback_ext(
2459 _command_buffer: CommandBuffer,
2460 _first_counter_buffer: u32,
2461 _counter_buffer_count: u32,
2462 _p_counter_buffers: *const Buffer,
2463 _p_counter_buffer_offsets: *const DeviceSize,
2464 ) {
2465 panic!(concat!(
2466 "Unable to load ",
2467 stringify!(cmd_begin_transform_feedback_ext)
2468 ))
2469 }
2470 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2471 b"vkCmdBeginTransformFeedbackEXT\0",
2472 );
2473 let val = _f(cname);
2474 if val.is_null() {
2475 cmd_begin_transform_feedback_ext
2476 } else {
2477 ::std::mem::transmute(val)
2478 }
2479 },
2480 cmd_end_transform_feedback_ext: unsafe {
2481 unsafe extern "system" fn cmd_end_transform_feedback_ext(
2482 _command_buffer: CommandBuffer,
2483 _first_counter_buffer: u32,
2484 _counter_buffer_count: u32,
2485 _p_counter_buffers: *const Buffer,
2486 _p_counter_buffer_offsets: *const DeviceSize,
2487 ) {
2488 panic!(concat!(
2489 "Unable to load ",
2490 stringify!(cmd_end_transform_feedback_ext)
2491 ))
2492 }
2493 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2494 b"vkCmdEndTransformFeedbackEXT\0",
2495 );
2496 let val = _f(cname);
2497 if val.is_null() {
2498 cmd_end_transform_feedback_ext
2499 } else {
2500 ::std::mem::transmute(val)
2501 }
2502 },
2503 cmd_begin_query_indexed_ext: unsafe {
2504 unsafe extern "system" fn cmd_begin_query_indexed_ext(
2505 _command_buffer: CommandBuffer,
2506 _query_pool: QueryPool,
2507 _query: u32,
2508 _flags: QueryControlFlags,
2509 _index: u32,
2510 ) {
2511 panic!(concat!(
2512 "Unable to load ",
2513 stringify!(cmd_begin_query_indexed_ext)
2514 ))
2515 }
2516 let cname =
2517 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginQueryIndexedEXT\0");
2518 let val = _f(cname);
2519 if val.is_null() {
2520 cmd_begin_query_indexed_ext
2521 } else {
2522 ::std::mem::transmute(val)
2523 }
2524 },
2525 cmd_end_query_indexed_ext: unsafe {
2526 unsafe extern "system" fn cmd_end_query_indexed_ext(
2527 _command_buffer: CommandBuffer,
2528 _query_pool: QueryPool,
2529 _query: u32,
2530 _index: u32,
2531 ) {
2532 panic!(concat!(
2533 "Unable to load ",
2534 stringify!(cmd_end_query_indexed_ext)
2535 ))
2536 }
2537 let cname =
2538 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndQueryIndexedEXT\0");
2539 let val = _f(cname);
2540 if val.is_null() {
2541 cmd_end_query_indexed_ext
2542 } else {
2543 ::std::mem::transmute(val)
2544 }
2545 },
2546 cmd_draw_indirect_byte_count_ext: unsafe {
2547 unsafe extern "system" fn cmd_draw_indirect_byte_count_ext(
2548 _command_buffer: CommandBuffer,
2549 _instance_count: u32,
2550 _first_instance: u32,
2551 _counter_buffer: Buffer,
2552 _counter_buffer_offset: DeviceSize,
2553 _counter_offset: u32,
2554 _vertex_stride: u32,
2555 ) {
2556 panic!(concat!(
2557 "Unable to load ",
2558 stringify!(cmd_draw_indirect_byte_count_ext)
2559 ))
2560 }
2561 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2562 b"vkCmdDrawIndirectByteCountEXT\0",
2563 );
2564 let val = _f(cname);
2565 if val.is_null() {
2566 cmd_draw_indirect_byte_count_ext
2567 } else {
2568 ::std::mem::transmute(val)
2569 }
2570 },
2571 }
2572 }
2573}
2574#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2575impl AccessFlags {
2576 pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
2577 pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
2578 pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self =
2579 Self(0b1000_0000_0000_0000_0000_0000_0000);
2580}
2581#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2582impl BufferUsageFlags {
2583 pub const TRANSFORM_FEEDBACK_BUFFER_EXT: Self = Self(0b1000_0000_0000);
2584 pub const TRANSFORM_FEEDBACK_COUNTER_BUFFER_EXT: Self = Self(0b1_0000_0000_0000);
2585}
2586#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2587impl PipelineStageFlags {
2588 pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
2589}
2590#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2591impl QueryType {
2592 pub const TRANSFORM_FEEDBACK_STREAM_EXT: Self = Self(1_000_028_004);
2593}
2594#[doc = "Generated from 'VK_EXT_transform_feedback'"]
2595impl StructureType {
2596 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: Self = Self(1_000_028_000);
2597 pub const PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: Self = Self(1_000_028_001);
2598 pub const PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: Self = Self(1_000_028_002);
2599}
2600impl NvxBinaryImportFn {
2601 pub const fn name() -> &'static ::std::ffi::CStr {
2602 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_binary_import\0") }
2603 }
2604 pub const SPEC_VERSION: u32 = 1u32;
2605}
2606#[allow(non_camel_case_types)]
2607pub type PFN_vkCreateCuModuleNVX = unsafe extern "system" fn(
2608 device: Device,
2609 p_create_info: *const CuModuleCreateInfoNVX,
2610 p_allocator: *const AllocationCallbacks,
2611 p_module: *mut CuModuleNVX,
2612) -> Result;
2613#[allow(non_camel_case_types)]
2614pub type PFN_vkCreateCuFunctionNVX = unsafe extern "system" fn(
2615 device: Device,
2616 p_create_info: *const CuFunctionCreateInfoNVX,
2617 p_allocator: *const AllocationCallbacks,
2618 p_function: *mut CuFunctionNVX,
2619) -> Result;
2620#[allow(non_camel_case_types)]
2621pub type PFN_vkDestroyCuModuleNVX = unsafe extern "system" fn(
2622 device: Device,
2623 module: CuModuleNVX,
2624 p_allocator: *const AllocationCallbacks,
2625);
2626#[allow(non_camel_case_types)]
2627pub type PFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn(
2628 device: Device,
2629 function: CuFunctionNVX,
2630 p_allocator: *const AllocationCallbacks,
2631);
2632#[allow(non_camel_case_types)]
2633pub type PFN_vkCmdCuLaunchKernelNVX =
2634 unsafe extern "system" fn(command_buffer: CommandBuffer, p_launch_info: *const CuLaunchInfoNVX);
2635#[derive(Clone)]
2636pub struct NvxBinaryImportFn {
2637 pub create_cu_module_nvx: PFN_vkCreateCuModuleNVX,
2638 pub create_cu_function_nvx: PFN_vkCreateCuFunctionNVX,
2639 pub destroy_cu_module_nvx: PFN_vkDestroyCuModuleNVX,
2640 pub destroy_cu_function_nvx: PFN_vkDestroyCuFunctionNVX,
2641 pub cmd_cu_launch_kernel_nvx: PFN_vkCmdCuLaunchKernelNVX,
2642}
2643unsafe impl Send for NvxBinaryImportFn {}
2644unsafe impl Sync for NvxBinaryImportFn {}
2645impl NvxBinaryImportFn {
2646 pub fn load<F>(mut _f: F) -> Self
2647 where
2648 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2649 {
2650 Self {
2651 create_cu_module_nvx: unsafe {
2652 unsafe extern "system" fn create_cu_module_nvx(
2653 _device: Device,
2654 _p_create_info: *const CuModuleCreateInfoNVX,
2655 _p_allocator: *const AllocationCallbacks,
2656 _p_module: *mut CuModuleNVX,
2657 ) -> Result {
2658 panic!(concat!("Unable to load ", stringify!(create_cu_module_nvx)))
2659 }
2660 let cname =
2661 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuModuleNVX\0");
2662 let val = _f(cname);
2663 if val.is_null() {
2664 create_cu_module_nvx
2665 } else {
2666 ::std::mem::transmute(val)
2667 }
2668 },
2669 create_cu_function_nvx: unsafe {
2670 unsafe extern "system" fn create_cu_function_nvx(
2671 _device: Device,
2672 _p_create_info: *const CuFunctionCreateInfoNVX,
2673 _p_allocator: *const AllocationCallbacks,
2674 _p_function: *mut CuFunctionNVX,
2675 ) -> Result {
2676 panic!(concat!(
2677 "Unable to load ",
2678 stringify!(create_cu_function_nvx)
2679 ))
2680 }
2681 let cname =
2682 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateCuFunctionNVX\0");
2683 let val = _f(cname);
2684 if val.is_null() {
2685 create_cu_function_nvx
2686 } else {
2687 ::std::mem::transmute(val)
2688 }
2689 },
2690 destroy_cu_module_nvx: unsafe {
2691 unsafe extern "system" fn destroy_cu_module_nvx(
2692 _device: Device,
2693 _module: CuModuleNVX,
2694 _p_allocator: *const AllocationCallbacks,
2695 ) {
2696 panic!(concat!(
2697 "Unable to load ",
2698 stringify!(destroy_cu_module_nvx)
2699 ))
2700 }
2701 let cname =
2702 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuModuleNVX\0");
2703 let val = _f(cname);
2704 if val.is_null() {
2705 destroy_cu_module_nvx
2706 } else {
2707 ::std::mem::transmute(val)
2708 }
2709 },
2710 destroy_cu_function_nvx: unsafe {
2711 unsafe extern "system" fn destroy_cu_function_nvx(
2712 _device: Device,
2713 _function: CuFunctionNVX,
2714 _p_allocator: *const AllocationCallbacks,
2715 ) {
2716 panic!(concat!(
2717 "Unable to load ",
2718 stringify!(destroy_cu_function_nvx)
2719 ))
2720 }
2721 let cname =
2722 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDestroyCuFunctionNVX\0");
2723 let val = _f(cname);
2724 if val.is_null() {
2725 destroy_cu_function_nvx
2726 } else {
2727 ::std::mem::transmute(val)
2728 }
2729 },
2730 cmd_cu_launch_kernel_nvx: unsafe {
2731 unsafe extern "system" fn cmd_cu_launch_kernel_nvx(
2732 _command_buffer: CommandBuffer,
2733 _p_launch_info: *const CuLaunchInfoNVX,
2734 ) {
2735 panic!(concat!(
2736 "Unable to load ",
2737 stringify!(cmd_cu_launch_kernel_nvx)
2738 ))
2739 }
2740 let cname =
2741 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCuLaunchKernelNVX\0");
2742 let val = _f(cname);
2743 if val.is_null() {
2744 cmd_cu_launch_kernel_nvx
2745 } else {
2746 ::std::mem::transmute(val)
2747 }
2748 },
2749 }
2750 }
2751}
2752#[doc = "Generated from 'VK_NVX_binary_import'"]
2753impl DebugReportObjectTypeEXT {
2754 pub const CU_MODULE_NVX: Self = Self(1_000_029_000);
2755 pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001);
2756}
2757#[doc = "Generated from 'VK_NVX_binary_import'"]
2758impl ObjectType {
2759 pub const CU_MODULE_NVX: Self = Self(1_000_029_000);
2760 pub const CU_FUNCTION_NVX: Self = Self(1_000_029_001);
2761}
2762#[doc = "Generated from 'VK_NVX_binary_import'"]
2763impl StructureType {
2764 pub const CU_MODULE_CREATE_INFO_NVX: Self = Self(1_000_029_000);
2765 pub const CU_FUNCTION_CREATE_INFO_NVX: Self = Self(1_000_029_001);
2766 pub const CU_LAUNCH_INFO_NVX: Self = Self(1_000_029_002);
2767}
2768impl NvxImageViewHandleFn {
2769 pub const fn name() -> &'static ::std::ffi::CStr {
2770 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_image_view_handle\0") }
2771 }
2772 pub const SPEC_VERSION: u32 = 2u32;
2773}
2774#[allow(non_camel_case_types)]
2775pub type PFN_vkGetImageViewHandleNVX =
2776 unsafe extern "system" fn(device: Device, p_info: *const ImageViewHandleInfoNVX) -> u32;
2777#[allow(non_camel_case_types)]
2778pub type PFN_vkGetImageViewAddressNVX = unsafe extern "system" fn(
2779 device: Device,
2780 image_view: ImageView,
2781 p_properties: *mut ImageViewAddressPropertiesNVX,
2782) -> Result;
2783#[derive(Clone)]
2784pub struct NvxImageViewHandleFn {
2785 pub get_image_view_handle_nvx: PFN_vkGetImageViewHandleNVX,
2786 pub get_image_view_address_nvx: PFN_vkGetImageViewAddressNVX,
2787}
2788unsafe impl Send for NvxImageViewHandleFn {}
2789unsafe impl Sync for NvxImageViewHandleFn {}
2790impl NvxImageViewHandleFn {
2791 pub fn load<F>(mut _f: F) -> Self
2792 where
2793 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2794 {
2795 Self {
2796 get_image_view_handle_nvx: unsafe {
2797 unsafe extern "system" fn get_image_view_handle_nvx(
2798 _device: Device,
2799 _p_info: *const ImageViewHandleInfoNVX,
2800 ) -> u32 {
2801 panic!(concat!(
2802 "Unable to load ",
2803 stringify!(get_image_view_handle_nvx)
2804 ))
2805 }
2806 let cname =
2807 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewHandleNVX\0");
2808 let val = _f(cname);
2809 if val.is_null() {
2810 get_image_view_handle_nvx
2811 } else {
2812 ::std::mem::transmute(val)
2813 }
2814 },
2815 get_image_view_address_nvx: unsafe {
2816 unsafe extern "system" fn get_image_view_address_nvx(
2817 _device: Device,
2818 _image_view: ImageView,
2819 _p_properties: *mut ImageViewAddressPropertiesNVX,
2820 ) -> Result {
2821 panic!(concat!(
2822 "Unable to load ",
2823 stringify!(get_image_view_address_nvx)
2824 ))
2825 }
2826 let cname =
2827 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetImageViewAddressNVX\0");
2828 let val = _f(cname);
2829 if val.is_null() {
2830 get_image_view_address_nvx
2831 } else {
2832 ::std::mem::transmute(val)
2833 }
2834 },
2835 }
2836 }
2837}
2838#[doc = "Generated from 'VK_NVX_image_view_handle'"]
2839impl StructureType {
2840 pub const IMAGE_VIEW_HANDLE_INFO_NVX: Self = Self(1_000_030_000);
2841 pub const IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: Self = Self(1_000_030_001);
2842}
2843impl AmdExtension32Fn {
2844 pub const fn name() -> &'static ::std::ffi::CStr {
2845 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_32\0") }
2846 }
2847 pub const SPEC_VERSION: u32 = 0u32;
2848}
2849#[derive(Clone)]
2850pub struct AmdExtension32Fn {}
2851unsafe impl Send for AmdExtension32Fn {}
2852unsafe impl Sync for AmdExtension32Fn {}
2853impl AmdExtension32Fn {
2854 pub fn load<F>(mut _f: F) -> Self
2855 where
2856 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2857 {
2858 Self {}
2859 }
2860}
2861impl AmdExtension33Fn {
2862 pub const fn name() -> &'static ::std::ffi::CStr {
2863 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_33\0") }
2864 }
2865 pub const SPEC_VERSION: u32 = 0u32;
2866}
2867#[derive(Clone)]
2868pub struct AmdExtension33Fn {}
2869unsafe impl Send for AmdExtension33Fn {}
2870unsafe impl Sync for AmdExtension33Fn {}
2871impl AmdExtension33Fn {
2872 pub fn load<F>(mut _f: F) -> Self
2873 where
2874 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2875 {
2876 Self {}
2877 }
2878}
2879impl AmdDrawIndirectCountFn {
2880 pub const fn name() -> &'static ::std::ffi::CStr {
2881 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_draw_indirect_count\0") }
2882 }
2883 pub const SPEC_VERSION: u32 = 2u32;
2884}
2885#[allow(non_camel_case_types)]
2886pub type PFN_vkCmdDrawIndirectCount = unsafe extern "system" fn(
2887 command_buffer: CommandBuffer,
2888 buffer: Buffer,
2889 offset: DeviceSize,
2890 count_buffer: Buffer,
2891 count_buffer_offset: DeviceSize,
2892 max_draw_count: u32,
2893 stride: u32,
2894);
2895#[allow(non_camel_case_types)]
2896pub type PFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn(
2897 command_buffer: CommandBuffer,
2898 buffer: Buffer,
2899 offset: DeviceSize,
2900 count_buffer: Buffer,
2901 count_buffer_offset: DeviceSize,
2902 max_draw_count: u32,
2903 stride: u32,
2904);
2905#[derive(Clone)]
2906pub struct AmdDrawIndirectCountFn {
2907 pub cmd_draw_indirect_count_amd: PFN_vkCmdDrawIndirectCount,
2908 pub cmd_draw_indexed_indirect_count_amd: PFN_vkCmdDrawIndexedIndirectCount,
2909}
2910unsafe impl Send for AmdDrawIndirectCountFn {}
2911unsafe impl Sync for AmdDrawIndirectCountFn {}
2912impl AmdDrawIndirectCountFn {
2913 pub fn load<F>(mut _f: F) -> Self
2914 where
2915 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2916 {
2917 Self {
2918 cmd_draw_indirect_count_amd: unsafe {
2919 unsafe extern "system" fn cmd_draw_indirect_count_amd(
2920 _command_buffer: CommandBuffer,
2921 _buffer: Buffer,
2922 _offset: DeviceSize,
2923 _count_buffer: Buffer,
2924 _count_buffer_offset: DeviceSize,
2925 _max_draw_count: u32,
2926 _stride: u32,
2927 ) {
2928 panic!(concat!(
2929 "Unable to load ",
2930 stringify!(cmd_draw_indirect_count_amd)
2931 ))
2932 }
2933 let cname =
2934 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountAMD\0");
2935 let val = _f(cname);
2936 if val.is_null() {
2937 cmd_draw_indirect_count_amd
2938 } else {
2939 ::std::mem::transmute(val)
2940 }
2941 },
2942 cmd_draw_indexed_indirect_count_amd: unsafe {
2943 unsafe extern "system" fn cmd_draw_indexed_indirect_count_amd(
2944 _command_buffer: CommandBuffer,
2945 _buffer: Buffer,
2946 _offset: DeviceSize,
2947 _count_buffer: Buffer,
2948 _count_buffer_offset: DeviceSize,
2949 _max_draw_count: u32,
2950 _stride: u32,
2951 ) {
2952 panic!(concat!(
2953 "Unable to load ",
2954 stringify!(cmd_draw_indexed_indirect_count_amd)
2955 ))
2956 }
2957 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
2958 b"vkCmdDrawIndexedIndirectCountAMD\0",
2959 );
2960 let val = _f(cname);
2961 if val.is_null() {
2962 cmd_draw_indexed_indirect_count_amd
2963 } else {
2964 ::std::mem::transmute(val)
2965 }
2966 },
2967 }
2968 }
2969}
2970impl AmdExtension35Fn {
2971 pub const fn name() -> &'static ::std::ffi::CStr {
2972 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_35\0") }
2973 }
2974 pub const SPEC_VERSION: u32 = 0u32;
2975}
2976#[derive(Clone)]
2977pub struct AmdExtension35Fn {}
2978unsafe impl Send for AmdExtension35Fn {}
2979unsafe impl Sync for AmdExtension35Fn {}
2980impl AmdExtension35Fn {
2981 pub fn load<F>(mut _f: F) -> Self
2982 where
2983 F: FnMut(&::std::ffi::CStr) -> *const c_void,
2984 {
2985 Self {}
2986 }
2987}
2988impl AmdNegativeViewportHeightFn {
2989 pub const fn name() -> &'static ::std::ffi::CStr {
2990 unsafe {
2991 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_negative_viewport_height\0")
2992 }
2993 }
2994 pub const SPEC_VERSION: u32 = 1u32;
2995}
2996#[derive(Clone)]
2997pub struct AmdNegativeViewportHeightFn {}
2998unsafe impl Send for AmdNegativeViewportHeightFn {}
2999unsafe impl Sync for AmdNegativeViewportHeightFn {}
3000impl AmdNegativeViewportHeightFn {
3001 pub fn load<F>(mut _f: F) -> Self
3002 where
3003 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3004 {
3005 Self {}
3006 }
3007}
3008impl AmdGpuShaderHalfFloatFn {
3009 pub const fn name() -> &'static ::std::ffi::CStr {
3010 unsafe {
3011 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_half_float\0")
3012 }
3013 }
3014 pub const SPEC_VERSION: u32 = 2u32;
3015}
3016#[derive(Clone)]
3017pub struct AmdGpuShaderHalfFloatFn {}
3018unsafe impl Send for AmdGpuShaderHalfFloatFn {}
3019unsafe impl Sync for AmdGpuShaderHalfFloatFn {}
3020impl AmdGpuShaderHalfFloatFn {
3021 pub fn load<F>(mut _f: F) -> Self
3022 where
3023 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3024 {
3025 Self {}
3026 }
3027}
3028impl AmdShaderBallotFn {
3029 pub const fn name() -> &'static ::std::ffi::CStr {
3030 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_ballot\0") }
3031 }
3032 pub const SPEC_VERSION: u32 = 1u32;
3033}
3034#[derive(Clone)]
3035pub struct AmdShaderBallotFn {}
3036unsafe impl Send for AmdShaderBallotFn {}
3037unsafe impl Sync for AmdShaderBallotFn {}
3038impl AmdShaderBallotFn {
3039 pub fn load<F>(mut _f: F) -> Self
3040 where
3041 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3042 {
3043 Self {}
3044 }
3045}
3046impl ExtVideoEncodeH264Fn {
3047 pub const fn name() -> &'static ::std::ffi::CStr {
3048 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h264\0") }
3049 }
3050 pub const SPEC_VERSION: u32 = 6u32;
3051}
3052#[derive(Clone)]
3053pub struct ExtVideoEncodeH264Fn {}
3054unsafe impl Send for ExtVideoEncodeH264Fn {}
3055unsafe impl Sync for ExtVideoEncodeH264Fn {}
3056impl ExtVideoEncodeH264Fn {
3057 pub fn load<F>(mut _f: F) -> Self
3058 where
3059 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3060 {
3061 Self {}
3062 }
3063}
3064#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
3065impl StructureType {
3066 pub const VIDEO_ENCODE_H264_CAPABILITIES_EXT: Self = Self(1_000_038_000);
3067 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_038_001);
3068 pub const VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_038_002);
3069 pub const VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: Self = Self(1_000_038_003);
3070 pub const VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_038_004);
3071 pub const VIDEO_ENCODE_H264_NALU_SLICE_EXT: Self = Self(1_000_038_005);
3072 pub const VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_038_006);
3073 pub const VIDEO_ENCODE_H264_PROFILE_EXT: Self = Self(1_000_038_007);
3074 pub const VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: Self = Self(1_000_038_008);
3075 pub const VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_038_009);
3076 pub const VIDEO_ENCODE_H264_REFERENCE_LISTS_EXT: Self = Self(1_000_038_010);
3077}
3078#[doc = "Generated from 'VK_EXT_video_encode_h264'"]
3079impl VideoCodecOperationFlagsKHR {
3080 pub const ENCODE_H264_EXT: Self = Self(0b1_0000_0000_0000_0000);
3081}
3082impl ExtVideoEncodeH265Fn {
3083 pub const fn name() -> &'static ::std::ffi::CStr {
3084 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_encode_h265\0") }
3085 }
3086 pub const SPEC_VERSION: u32 = 6u32;
3087}
3088#[derive(Clone)]
3089pub struct ExtVideoEncodeH265Fn {}
3090unsafe impl Send for ExtVideoEncodeH265Fn {}
3091unsafe impl Sync for ExtVideoEncodeH265Fn {}
3092impl ExtVideoEncodeH265Fn {
3093 pub fn load<F>(mut _f: F) -> Self
3094 where
3095 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3096 {
3097 Self {}
3098 }
3099}
3100#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
3101impl StructureType {
3102 pub const VIDEO_ENCODE_H265_CAPABILITIES_EXT: Self = Self(1_000_039_000);
3103 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_039_001);
3104 pub const VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_039_002);
3105 pub const VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: Self = Self(1_000_039_003);
3106 pub const VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_039_004);
3107 pub const VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_EXT: Self = Self(1_000_039_005);
3108 pub const VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_EXT: Self = Self(1_000_039_006);
3109 pub const VIDEO_ENCODE_H265_PROFILE_EXT: Self = Self(1_000_039_007);
3110 pub const VIDEO_ENCODE_H265_REFERENCE_LISTS_EXT: Self = Self(1_000_039_008);
3111 pub const VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: Self = Self(1_000_039_009);
3112 pub const VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: Self = Self(1_000_039_010);
3113}
3114#[doc = "Generated from 'VK_EXT_video_encode_h265'"]
3115impl VideoCodecOperationFlagsKHR {
3116 pub const ENCODE_H265_EXT: Self = Self(0b10_0000_0000_0000_0000);
3117}
3118impl ExtVideoDecodeH264Fn {
3119 pub const fn name() -> &'static ::std::ffi::CStr {
3120 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h264\0") }
3121 }
3122 pub const SPEC_VERSION: u32 = 4u32;
3123}
3124#[derive(Clone)]
3125pub struct ExtVideoDecodeH264Fn {}
3126unsafe impl Send for ExtVideoDecodeH264Fn {}
3127unsafe impl Sync for ExtVideoDecodeH264Fn {}
3128impl ExtVideoDecodeH264Fn {
3129 pub fn load<F>(mut _f: F) -> Self
3130 where
3131 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3132 {
3133 Self {}
3134 }
3135}
3136#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
3137impl StructureType {
3138 pub const VIDEO_DECODE_H264_CAPABILITIES_EXT: Self = Self(1_000_040_000);
3139 pub const VIDEO_DECODE_H264_PICTURE_INFO_EXT: Self = Self(1_000_040_001);
3140 pub const VIDEO_DECODE_H264_MVC_EXT: Self = Self(1_000_040_002);
3141 pub const VIDEO_DECODE_H264_PROFILE_EXT: Self = Self(1_000_040_003);
3142 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_040_004);
3143 pub const VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_040_005);
3144 pub const VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: Self = Self(1_000_040_006);
3145}
3146#[doc = "Generated from 'VK_EXT_video_decode_h264'"]
3147impl VideoCodecOperationFlagsKHR {
3148 pub const DECODE_H264_EXT: Self = Self(0b1);
3149}
3150impl AmdTextureGatherBiasLodFn {
3151 pub const fn name() -> &'static ::std::ffi::CStr {
3152 unsafe {
3153 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_texture_gather_bias_lod\0")
3154 }
3155 }
3156 pub const SPEC_VERSION: u32 = 1u32;
3157}
3158#[derive(Clone)]
3159pub struct AmdTextureGatherBiasLodFn {}
3160unsafe impl Send for AmdTextureGatherBiasLodFn {}
3161unsafe impl Sync for AmdTextureGatherBiasLodFn {}
3162impl AmdTextureGatherBiasLodFn {
3163 pub fn load<F>(mut _f: F) -> Self
3164 where
3165 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3166 {
3167 Self {}
3168 }
3169}
3170#[doc = "Generated from 'VK_AMD_texture_gather_bias_lod'"]
3171impl StructureType {
3172 pub const TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: Self = Self(1_000_041_000);
3173}
3174impl AmdShaderInfoFn {
3175 pub const fn name() -> &'static ::std::ffi::CStr {
3176 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_info\0") }
3177 }
3178 pub const SPEC_VERSION: u32 = 1u32;
3179}
3180#[allow(non_camel_case_types)]
3181pub type PFN_vkGetShaderInfoAMD = unsafe extern "system" fn(
3182 device: Device,
3183 pipeline: Pipeline,
3184 shader_stage: ShaderStageFlags,
3185 info_type: ShaderInfoTypeAMD,
3186 p_info_size: *mut usize,
3187 p_info: *mut c_void,
3188) -> Result;
3189#[derive(Clone)]
3190pub struct AmdShaderInfoFn {
3191 pub get_shader_info_amd: PFN_vkGetShaderInfoAMD,
3192}
3193unsafe impl Send for AmdShaderInfoFn {}
3194unsafe impl Sync for AmdShaderInfoFn {}
3195impl AmdShaderInfoFn {
3196 pub fn load<F>(mut _f: F) -> Self
3197 where
3198 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3199 {
3200 Self {
3201 get_shader_info_amd: unsafe {
3202 unsafe extern "system" fn get_shader_info_amd(
3203 _device: Device,
3204 _pipeline: Pipeline,
3205 _shader_stage: ShaderStageFlags,
3206 _info_type: ShaderInfoTypeAMD,
3207 _p_info_size: *mut usize,
3208 _p_info: *mut c_void,
3209 ) -> Result {
3210 panic!(concat!("Unable to load ", stringify!(get_shader_info_amd)))
3211 }
3212 let cname =
3213 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetShaderInfoAMD\0");
3214 let val = _f(cname);
3215 if val.is_null() {
3216 get_shader_info_amd
3217 } else {
3218 ::std::mem::transmute(val)
3219 }
3220 },
3221 }
3222 }
3223}
3224impl AmdExtension44Fn {
3225 pub const fn name() -> &'static ::std::ffi::CStr {
3226 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_44\0") }
3227 }
3228 pub const SPEC_VERSION: u32 = 0u32;
3229}
3230#[derive(Clone)]
3231pub struct AmdExtension44Fn {}
3232unsafe impl Send for AmdExtension44Fn {}
3233unsafe impl Sync for AmdExtension44Fn {}
3234impl AmdExtension44Fn {
3235 pub fn load<F>(mut _f: F) -> Self
3236 where
3237 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3238 {
3239 Self {}
3240 }
3241}
3242impl KhrDynamicRenderingFn {
3243 pub const fn name() -> &'static ::std::ffi::CStr {
3244 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dynamic_rendering\0") }
3245 }
3246 pub const SPEC_VERSION: u32 = 1u32;
3247}
3248#[allow(non_camel_case_types)]
3249pub type PFN_vkCmdBeginRendering = unsafe extern "system" fn(
3250 command_buffer: CommandBuffer,
3251 p_rendering_info: *const RenderingInfo,
3252);
3253#[allow(non_camel_case_types)]
3254pub type PFN_vkCmdEndRendering = unsafe extern "system" fn(command_buffer: CommandBuffer);
3255#[derive(Clone)]
3256pub struct KhrDynamicRenderingFn {
3257 pub cmd_begin_rendering_khr: PFN_vkCmdBeginRendering,
3258 pub cmd_end_rendering_khr: PFN_vkCmdEndRendering,
3259}
3260unsafe impl Send for KhrDynamicRenderingFn {}
3261unsafe impl Sync for KhrDynamicRenderingFn {}
3262impl KhrDynamicRenderingFn {
3263 pub fn load<F>(mut _f: F) -> Self
3264 where
3265 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3266 {
3267 Self {
3268 cmd_begin_rendering_khr: unsafe {
3269 unsafe extern "system" fn cmd_begin_rendering_khr(
3270 _command_buffer: CommandBuffer,
3271 _p_rendering_info: *const RenderingInfo,
3272 ) {
3273 panic!(concat!(
3274 "Unable to load ",
3275 stringify!(cmd_begin_rendering_khr)
3276 ))
3277 }
3278 let cname =
3279 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderingKHR\0");
3280 let val = _f(cname);
3281 if val.is_null() {
3282 cmd_begin_rendering_khr
3283 } else {
3284 ::std::mem::transmute(val)
3285 }
3286 },
3287 cmd_end_rendering_khr: unsafe {
3288 unsafe extern "system" fn cmd_end_rendering_khr(_command_buffer: CommandBuffer) {
3289 panic!(concat!(
3290 "Unable to load ",
3291 stringify!(cmd_end_rendering_khr)
3292 ))
3293 }
3294 let cname =
3295 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderingKHR\0");
3296 let val = _f(cname);
3297 if val.is_null() {
3298 cmd_end_rendering_khr
3299 } else {
3300 ::std::mem::transmute(val)
3301 }
3302 },
3303 }
3304 }
3305}
3306#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
3307impl AttachmentStoreOp {
3308 pub const NONE_KHR: Self = Self::NONE;
3309}
3310#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
3311impl PipelineCreateFlags {
3312 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
3313 Self(0b10_0000_0000_0000_0000_0000);
3314 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_EXT: Self =
3315 Self(0b100_0000_0000_0000_0000_0000);
3316}
3317#[doc = "Generated from 'VK_KHR_dynamic_rendering'"]
3318impl StructureType {
3319 pub const RENDERING_INFO_KHR: Self = Self::RENDERING_INFO;
3320 pub const RENDERING_ATTACHMENT_INFO_KHR: Self = Self::RENDERING_ATTACHMENT_INFO;
3321 pub const PIPELINE_RENDERING_CREATE_INFO_KHR: Self = Self::PIPELINE_RENDERING_CREATE_INFO;
3322 pub const PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: Self =
3323 Self::PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
3324 pub const COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: Self =
3325 Self::COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
3326 pub const RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_044_006);
3327 pub const RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: Self = Self(1_000_044_007);
3328 pub const ATTACHMENT_SAMPLE_COUNT_INFO_AMD: Self = Self(1_000_044_008);
3329 pub const ATTACHMENT_SAMPLE_COUNT_INFO_NV: Self = Self::ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
3330 pub const MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: Self = Self(1_000_044_009);
3331}
3332impl AmdExtension46Fn {
3333 pub const fn name() -> &'static ::std::ffi::CStr {
3334 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_46\0") }
3335 }
3336 pub const SPEC_VERSION: u32 = 0u32;
3337}
3338#[derive(Clone)]
3339pub struct AmdExtension46Fn {}
3340unsafe impl Send for AmdExtension46Fn {}
3341unsafe impl Sync for AmdExtension46Fn {}
3342impl AmdExtension46Fn {
3343 pub fn load<F>(mut _f: F) -> Self
3344 where
3345 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3346 {
3347 Self {}
3348 }
3349}
3350impl AmdShaderImageLoadStoreLodFn {
3351 pub const fn name() -> &'static ::std::ffi::CStr {
3352 unsafe {
3353 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_image_load_store_lod\0")
3354 }
3355 }
3356 pub const SPEC_VERSION: u32 = 1u32;
3357}
3358#[derive(Clone)]
3359pub struct AmdShaderImageLoadStoreLodFn {}
3360unsafe impl Send for AmdShaderImageLoadStoreLodFn {}
3361unsafe impl Sync for AmdShaderImageLoadStoreLodFn {}
3362impl AmdShaderImageLoadStoreLodFn {
3363 pub fn load<F>(mut _f: F) -> Self
3364 where
3365 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3366 {
3367 Self {}
3368 }
3369}
3370impl NvxExtension48Fn {
3371 pub const fn name() -> &'static ::std::ffi::CStr {
3372 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_extension_48\0") }
3373 }
3374 pub const SPEC_VERSION: u32 = 0u32;
3375}
3376#[derive(Clone)]
3377pub struct NvxExtension48Fn {}
3378unsafe impl Send for NvxExtension48Fn {}
3379unsafe impl Sync for NvxExtension48Fn {}
3380impl NvxExtension48Fn {
3381 pub fn load<F>(mut _f: F) -> Self
3382 where
3383 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3384 {
3385 Self {}
3386 }
3387}
3388impl GoogleExtension49Fn {
3389 pub const fn name() -> &'static ::std::ffi::CStr {
3390 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_49\0") }
3391 }
3392 pub const SPEC_VERSION: u32 = 0u32;
3393}
3394#[derive(Clone)]
3395pub struct GoogleExtension49Fn {}
3396unsafe impl Send for GoogleExtension49Fn {}
3397unsafe impl Sync for GoogleExtension49Fn {}
3398impl GoogleExtension49Fn {
3399 pub fn load<F>(mut _f: F) -> Self
3400 where
3401 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3402 {
3403 Self {}
3404 }
3405}
3406impl GgpStreamDescriptorSurfaceFn {
3407 pub const fn name() -> &'static ::std::ffi::CStr {
3408 unsafe {
3409 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_stream_descriptor_surface\0")
3410 }
3411 }
3412 pub const SPEC_VERSION: u32 = 1u32;
3413}
3414#[allow(non_camel_case_types)]
3415pub type PFN_vkCreateStreamDescriptorSurfaceGGP = unsafe extern "system" fn(
3416 instance: Instance,
3417 p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP,
3418 p_allocator: *const AllocationCallbacks,
3419 p_surface: *mut SurfaceKHR,
3420) -> Result;
3421#[derive(Clone)]
3422pub struct GgpStreamDescriptorSurfaceFn {
3423 pub create_stream_descriptor_surface_ggp: PFN_vkCreateStreamDescriptorSurfaceGGP,
3424}
3425unsafe impl Send for GgpStreamDescriptorSurfaceFn {}
3426unsafe impl Sync for GgpStreamDescriptorSurfaceFn {}
3427impl GgpStreamDescriptorSurfaceFn {
3428 pub fn load<F>(mut _f: F) -> Self
3429 where
3430 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3431 {
3432 Self {
3433 create_stream_descriptor_surface_ggp: unsafe {
3434 unsafe extern "system" fn create_stream_descriptor_surface_ggp(
3435 _instance: Instance,
3436 _p_create_info: *const StreamDescriptorSurfaceCreateInfoGGP,
3437 _p_allocator: *const AllocationCallbacks,
3438 _p_surface: *mut SurfaceKHR,
3439 ) -> Result {
3440 panic!(concat!(
3441 "Unable to load ",
3442 stringify!(create_stream_descriptor_surface_ggp)
3443 ))
3444 }
3445 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3446 b"vkCreateStreamDescriptorSurfaceGGP\0",
3447 );
3448 let val = _f(cname);
3449 if val.is_null() {
3450 create_stream_descriptor_surface_ggp
3451 } else {
3452 ::std::mem::transmute(val)
3453 }
3454 },
3455 }
3456 }
3457}
3458#[doc = "Generated from 'VK_GGP_stream_descriptor_surface'"]
3459impl StructureType {
3460 pub const STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: Self = Self(1_000_049_000);
3461}
3462impl NvCornerSampledImageFn {
3463 pub const fn name() -> &'static ::std::ffi::CStr {
3464 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_corner_sampled_image\0") }
3465 }
3466 pub const SPEC_VERSION: u32 = 2u32;
3467}
3468#[derive(Clone)]
3469pub struct NvCornerSampledImageFn {}
3470unsafe impl Send for NvCornerSampledImageFn {}
3471unsafe impl Sync for NvCornerSampledImageFn {}
3472impl NvCornerSampledImageFn {
3473 pub fn load<F>(mut _f: F) -> Self
3474 where
3475 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3476 {
3477 Self {}
3478 }
3479}
3480#[doc = "Generated from 'VK_NV_corner_sampled_image'"]
3481impl ImageCreateFlags {
3482 pub const CORNER_SAMPLED_NV: Self = Self(0b10_0000_0000_0000);
3483}
3484#[doc = "Generated from 'VK_NV_corner_sampled_image'"]
3485impl StructureType {
3486 pub const PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: Self = Self(1_000_050_000);
3487}
3488impl NvExtension52Fn {
3489 pub const fn name() -> &'static ::std::ffi::CStr {
3490 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_52\0") }
3491 }
3492 pub const SPEC_VERSION: u32 = 0u32;
3493}
3494#[derive(Clone)]
3495pub struct NvExtension52Fn {}
3496unsafe impl Send for NvExtension52Fn {}
3497unsafe impl Sync for NvExtension52Fn {}
3498impl NvExtension52Fn {
3499 pub fn load<F>(mut _f: F) -> Self
3500 where
3501 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3502 {
3503 Self {}
3504 }
3505}
3506#[doc = "Generated from 'VK_NV_extension_52'"]
3507impl PipelineShaderStageCreateFlags {
3508 pub const RESERVED_2_NV: Self = Self(0b100);
3509}
3510#[doc = "Generated from 'VK_NV_extension_52'"]
3511impl ShaderModuleCreateFlags {
3512 pub const RESERVED_0_NV: Self = Self(0b1);
3513}
3514impl NvExtension53Fn {
3515 pub const fn name() -> &'static ::std::ffi::CStr {
3516 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_53\0") }
3517 }
3518 pub const SPEC_VERSION: u32 = 0u32;
3519}
3520#[derive(Clone)]
3521pub struct NvExtension53Fn {}
3522unsafe impl Send for NvExtension53Fn {}
3523unsafe impl Sync for NvExtension53Fn {}
3524impl NvExtension53Fn {
3525 pub fn load<F>(mut _f: F) -> Self
3526 where
3527 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3528 {
3529 Self {}
3530 }
3531}
3532impl KhrMultiviewFn {
3533 pub const fn name() -> &'static ::std::ffi::CStr {
3534 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_multiview\0") }
3535 }
3536 pub const SPEC_VERSION: u32 = 1u32;
3537}
3538#[derive(Clone)]
3539pub struct KhrMultiviewFn {}
3540unsafe impl Send for KhrMultiviewFn {}
3541unsafe impl Sync for KhrMultiviewFn {}
3542impl KhrMultiviewFn {
3543 pub fn load<F>(mut _f: F) -> Self
3544 where
3545 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3546 {
3547 Self {}
3548 }
3549}
3550#[doc = "Generated from 'VK_KHR_multiview'"]
3551impl DependencyFlags {
3552 pub const VIEW_LOCAL_KHR: Self = Self::VIEW_LOCAL;
3553}
3554#[doc = "Generated from 'VK_KHR_multiview'"]
3555impl StructureType {
3556 pub const RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: Self = Self::RENDER_PASS_MULTIVIEW_CREATE_INFO;
3557 pub const PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: Self =
3558 Self::PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
3559 pub const PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: Self =
3560 Self::PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
3561}
3562impl ImgFormatPvrtcFn {
3563 pub const fn name() -> &'static ::std::ffi::CStr {
3564 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_format_pvrtc\0") }
3565 }
3566 pub const SPEC_VERSION: u32 = 1u32;
3567}
3568#[derive(Clone)]
3569pub struct ImgFormatPvrtcFn {}
3570unsafe impl Send for ImgFormatPvrtcFn {}
3571unsafe impl Sync for ImgFormatPvrtcFn {}
3572impl ImgFormatPvrtcFn {
3573 pub fn load<F>(mut _f: F) -> Self
3574 where
3575 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3576 {
3577 Self {}
3578 }
3579}
3580#[doc = "Generated from 'VK_IMG_format_pvrtc'"]
3581impl Format {
3582 pub const PVRTC1_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_000);
3583 pub const PVRTC1_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_001);
3584 pub const PVRTC2_2BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_002);
3585 pub const PVRTC2_4BPP_UNORM_BLOCK_IMG: Self = Self(1_000_054_003);
3586 pub const PVRTC1_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_004);
3587 pub const PVRTC1_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_005);
3588 pub const PVRTC2_2BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_006);
3589 pub const PVRTC2_4BPP_SRGB_BLOCK_IMG: Self = Self(1_000_054_007);
3590}
3591impl NvExternalMemoryCapabilitiesFn {
3592 pub const fn name() -> &'static ::std::ffi::CStr {
3593 unsafe {
3594 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_capabilities\0")
3595 }
3596 }
3597 pub const SPEC_VERSION: u32 = 1u32;
3598}
3599#[allow(non_camel_case_types)]
3600pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV =
3601 unsafe extern "system" fn(
3602 physical_device: PhysicalDevice,
3603 format: Format,
3604 ty: ImageType,
3605 tiling: ImageTiling,
3606 usage: ImageUsageFlags,
3607 flags: ImageCreateFlags,
3608 external_handle_type: ExternalMemoryHandleTypeFlagsNV,
3609 p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV,
3610 ) -> Result;
3611#[derive(Clone)]
3612pub struct NvExternalMemoryCapabilitiesFn {
3613 pub get_physical_device_external_image_format_properties_nv:
3614 PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV,
3615}
3616unsafe impl Send for NvExternalMemoryCapabilitiesFn {}
3617unsafe impl Sync for NvExternalMemoryCapabilitiesFn {}
3618impl NvExternalMemoryCapabilitiesFn {
3619 pub fn load<F>(mut _f: F) -> Self
3620 where
3621 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3622 {
3623 Self {
3624 get_physical_device_external_image_format_properties_nv: unsafe {
3625 unsafe extern "system" fn get_physical_device_external_image_format_properties_nv(
3626 _physical_device: PhysicalDevice,
3627 _format: Format,
3628 _ty: ImageType,
3629 _tiling: ImageTiling,
3630 _usage: ImageUsageFlags,
3631 _flags: ImageCreateFlags,
3632 _external_handle_type: ExternalMemoryHandleTypeFlagsNV,
3633 _p_external_image_format_properties: *mut ExternalImageFormatPropertiesNV,
3634 ) -> Result {
3635 panic!(concat!(
3636 "Unable to load ",
3637 stringify!(get_physical_device_external_image_format_properties_nv)
3638 ))
3639 }
3640 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3641 b"vkGetPhysicalDeviceExternalImageFormatPropertiesNV\0",
3642 );
3643 let val = _f(cname);
3644 if val.is_null() {
3645 get_physical_device_external_image_format_properties_nv
3646 } else {
3647 ::std::mem::transmute(val)
3648 }
3649 },
3650 }
3651 }
3652}
3653impl NvExternalMemoryFn {
3654 pub const fn name() -> &'static ::std::ffi::CStr {
3655 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory\0") }
3656 }
3657 pub const SPEC_VERSION: u32 = 1u32;
3658}
3659#[derive(Clone)]
3660pub struct NvExternalMemoryFn {}
3661unsafe impl Send for NvExternalMemoryFn {}
3662unsafe impl Sync for NvExternalMemoryFn {}
3663impl NvExternalMemoryFn {
3664 pub fn load<F>(mut _f: F) -> Self
3665 where
3666 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3667 {
3668 Self {}
3669 }
3670}
3671#[doc = "Generated from 'VK_NV_external_memory'"]
3672impl StructureType {
3673 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: Self = Self(1_000_056_000);
3674 pub const EXPORT_MEMORY_ALLOCATE_INFO_NV: Self = Self(1_000_056_001);
3675}
3676impl NvExternalMemoryWin32Fn {
3677 pub const fn name() -> &'static ::std::ffi::CStr {
3678 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_win32\0") }
3679 }
3680 pub const SPEC_VERSION: u32 = 1u32;
3681}
3682#[allow(non_camel_case_types)]
3683pub type PFN_vkGetMemoryWin32HandleNV = unsafe extern "system" fn(
3684 device: Device,
3685 memory: DeviceMemory,
3686 handle_type: ExternalMemoryHandleTypeFlagsNV,
3687 p_handle: *mut HANDLE,
3688) -> Result;
3689#[derive(Clone)]
3690pub struct NvExternalMemoryWin32Fn {
3691 pub get_memory_win32_handle_nv: PFN_vkGetMemoryWin32HandleNV,
3692}
3693unsafe impl Send for NvExternalMemoryWin32Fn {}
3694unsafe impl Sync for NvExternalMemoryWin32Fn {}
3695impl NvExternalMemoryWin32Fn {
3696 pub fn load<F>(mut _f: F) -> Self
3697 where
3698 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3699 {
3700 Self {
3701 get_memory_win32_handle_nv: unsafe {
3702 unsafe extern "system" fn get_memory_win32_handle_nv(
3703 _device: Device,
3704 _memory: DeviceMemory,
3705 _handle_type: ExternalMemoryHandleTypeFlagsNV,
3706 _p_handle: *mut HANDLE,
3707 ) -> Result {
3708 panic!(concat!(
3709 "Unable to load ",
3710 stringify!(get_memory_win32_handle_nv)
3711 ))
3712 }
3713 let cname =
3714 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleNV\0");
3715 let val = _f(cname);
3716 if val.is_null() {
3717 get_memory_win32_handle_nv
3718 } else {
3719 ::std::mem::transmute(val)
3720 }
3721 },
3722 }
3723 }
3724}
3725#[doc = "Generated from 'VK_NV_external_memory_win32'"]
3726impl StructureType {
3727 pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_000);
3728 pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: Self = Self(1_000_057_001);
3729}
3730impl NvWin32KeyedMutexFn {
3731 pub const fn name() -> &'static ::std::ffi::CStr {
3732 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_win32_keyed_mutex\0") }
3733 }
3734 pub const SPEC_VERSION: u32 = 2u32;
3735}
3736#[derive(Clone)]
3737pub struct NvWin32KeyedMutexFn {}
3738unsafe impl Send for NvWin32KeyedMutexFn {}
3739unsafe impl Sync for NvWin32KeyedMutexFn {}
3740impl NvWin32KeyedMutexFn {
3741 pub fn load<F>(mut _f: F) -> Self
3742 where
3743 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3744 {
3745 Self {}
3746 }
3747}
3748#[doc = "Generated from 'VK_NV_win32_keyed_mutex'"]
3749impl StructureType {
3750 pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: Self = Self(1_000_058_000);
3751}
3752impl KhrGetPhysicalDeviceProperties2Fn {
3753 pub const fn name() -> &'static ::std::ffi::CStr {
3754 unsafe {
3755 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3756 b"VK_KHR_get_physical_device_properties2\0",
3757 )
3758 }
3759 }
3760 pub const SPEC_VERSION: u32 = 2u32;
3761}
3762#[allow(non_camel_case_types)]
3763pub type PFN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn(
3764 physical_device: PhysicalDevice,
3765 p_features: *mut PhysicalDeviceFeatures2,
3766);
3767#[allow(non_camel_case_types)]
3768pub type PFN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn(
3769 physical_device: PhysicalDevice,
3770 p_properties: *mut PhysicalDeviceProperties2,
3771);
3772#[allow(non_camel_case_types)]
3773pub type PFN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn(
3774 physical_device: PhysicalDevice,
3775 format: Format,
3776 p_format_properties: *mut FormatProperties2,
3777);
3778#[allow(non_camel_case_types)]
3779pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn(
3780 physical_device: PhysicalDevice,
3781 p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
3782 p_image_format_properties: *mut ImageFormatProperties2,
3783) -> Result;
3784#[allow(non_camel_case_types)]
3785pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn(
3786 physical_device: PhysicalDevice,
3787 p_queue_family_property_count: *mut u32,
3788 p_queue_family_properties: *mut QueueFamilyProperties2,
3789);
3790#[allow(non_camel_case_types)]
3791pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn(
3792 physical_device: PhysicalDevice,
3793 p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
3794);
3795#[allow(non_camel_case_types)]
3796pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn(
3797 physical_device: PhysicalDevice,
3798 p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
3799 p_property_count: *mut u32,
3800 p_properties: *mut SparseImageFormatProperties2,
3801);
3802#[derive(Clone)]
3803pub struct KhrGetPhysicalDeviceProperties2Fn {
3804 pub get_physical_device_features2_khr: PFN_vkGetPhysicalDeviceFeatures2,
3805 pub get_physical_device_properties2_khr: PFN_vkGetPhysicalDeviceProperties2,
3806 pub get_physical_device_format_properties2_khr: PFN_vkGetPhysicalDeviceFormatProperties2,
3807 pub get_physical_device_image_format_properties2_khr:
3808 PFN_vkGetPhysicalDeviceImageFormatProperties2,
3809 pub get_physical_device_queue_family_properties2_khr:
3810 PFN_vkGetPhysicalDeviceQueueFamilyProperties2,
3811 pub get_physical_device_memory_properties2_khr: PFN_vkGetPhysicalDeviceMemoryProperties2,
3812 pub get_physical_device_sparse_image_format_properties2_khr:
3813 PFN_vkGetPhysicalDeviceSparseImageFormatProperties2,
3814}
3815unsafe impl Send for KhrGetPhysicalDeviceProperties2Fn {}
3816unsafe impl Sync for KhrGetPhysicalDeviceProperties2Fn {}
3817impl KhrGetPhysicalDeviceProperties2Fn {
3818 pub fn load<F>(mut _f: F) -> Self
3819 where
3820 F: FnMut(&::std::ffi::CStr) -> *const c_void,
3821 {
3822 Self {
3823 get_physical_device_features2_khr: unsafe {
3824 unsafe extern "system" fn get_physical_device_features2_khr(
3825 _physical_device: PhysicalDevice,
3826 _p_features: *mut PhysicalDeviceFeatures2,
3827 ) {
3828 panic!(concat!(
3829 "Unable to load ",
3830 stringify!(get_physical_device_features2_khr)
3831 ))
3832 }
3833 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3834 b"vkGetPhysicalDeviceFeatures2KHR\0",
3835 );
3836 let val = _f(cname);
3837 if val.is_null() {
3838 get_physical_device_features2_khr
3839 } else {
3840 ::std::mem::transmute(val)
3841 }
3842 },
3843 get_physical_device_properties2_khr: unsafe {
3844 unsafe extern "system" fn get_physical_device_properties2_khr(
3845 _physical_device: PhysicalDevice,
3846 _p_properties: *mut PhysicalDeviceProperties2,
3847 ) {
3848 panic!(concat!(
3849 "Unable to load ",
3850 stringify!(get_physical_device_properties2_khr)
3851 ))
3852 }
3853 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3854 b"vkGetPhysicalDeviceProperties2KHR\0",
3855 );
3856 let val = _f(cname);
3857 if val.is_null() {
3858 get_physical_device_properties2_khr
3859 } else {
3860 ::std::mem::transmute(val)
3861 }
3862 },
3863 get_physical_device_format_properties2_khr: unsafe {
3864 unsafe extern "system" fn get_physical_device_format_properties2_khr(
3865 _physical_device: PhysicalDevice,
3866 _format: Format,
3867 _p_format_properties: *mut FormatProperties2,
3868 ) {
3869 panic!(concat!(
3870 "Unable to load ",
3871 stringify!(get_physical_device_format_properties2_khr)
3872 ))
3873 }
3874 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3875 b"vkGetPhysicalDeviceFormatProperties2KHR\0",
3876 );
3877 let val = _f(cname);
3878 if val.is_null() {
3879 get_physical_device_format_properties2_khr
3880 } else {
3881 ::std::mem::transmute(val)
3882 }
3883 },
3884 get_physical_device_image_format_properties2_khr: unsafe {
3885 unsafe extern "system" fn get_physical_device_image_format_properties2_khr(
3886 _physical_device: PhysicalDevice,
3887 _p_image_format_info: *const PhysicalDeviceImageFormatInfo2,
3888 _p_image_format_properties: *mut ImageFormatProperties2,
3889 ) -> Result {
3890 panic!(concat!(
3891 "Unable to load ",
3892 stringify!(get_physical_device_image_format_properties2_khr)
3893 ))
3894 }
3895 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3896 b"vkGetPhysicalDeviceImageFormatProperties2KHR\0",
3897 );
3898 let val = _f(cname);
3899 if val.is_null() {
3900 get_physical_device_image_format_properties2_khr
3901 } else {
3902 ::std::mem::transmute(val)
3903 }
3904 },
3905 get_physical_device_queue_family_properties2_khr: unsafe {
3906 unsafe extern "system" fn get_physical_device_queue_family_properties2_khr(
3907 _physical_device: PhysicalDevice,
3908 _p_queue_family_property_count: *mut u32,
3909 _p_queue_family_properties: *mut QueueFamilyProperties2,
3910 ) {
3911 panic!(concat!(
3912 "Unable to load ",
3913 stringify!(get_physical_device_queue_family_properties2_khr)
3914 ))
3915 }
3916 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3917 b"vkGetPhysicalDeviceQueueFamilyProperties2KHR\0",
3918 );
3919 let val = _f(cname);
3920 if val.is_null() {
3921 get_physical_device_queue_family_properties2_khr
3922 } else {
3923 ::std::mem::transmute(val)
3924 }
3925 },
3926 get_physical_device_memory_properties2_khr: unsafe {
3927 unsafe extern "system" fn get_physical_device_memory_properties2_khr(
3928 _physical_device: PhysicalDevice,
3929 _p_memory_properties: *mut PhysicalDeviceMemoryProperties2,
3930 ) {
3931 panic!(concat!(
3932 "Unable to load ",
3933 stringify!(get_physical_device_memory_properties2_khr)
3934 ))
3935 }
3936 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3937 b"vkGetPhysicalDeviceMemoryProperties2KHR\0",
3938 );
3939 let val = _f(cname);
3940 if val.is_null() {
3941 get_physical_device_memory_properties2_khr
3942 } else {
3943 ::std::mem::transmute(val)
3944 }
3945 },
3946 get_physical_device_sparse_image_format_properties2_khr: unsafe {
3947 unsafe extern "system" fn get_physical_device_sparse_image_format_properties2_khr(
3948 _physical_device: PhysicalDevice,
3949 _p_format_info: *const PhysicalDeviceSparseImageFormatInfo2,
3950 _p_property_count: *mut u32,
3951 _p_properties: *mut SparseImageFormatProperties2,
3952 ) {
3953 panic!(concat!(
3954 "Unable to load ",
3955 stringify!(get_physical_device_sparse_image_format_properties2_khr)
3956 ))
3957 }
3958 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
3959 b"vkGetPhysicalDeviceSparseImageFormatProperties2KHR\0",
3960 );
3961 let val = _f(cname);
3962 if val.is_null() {
3963 get_physical_device_sparse_image_format_properties2_khr
3964 } else {
3965 ::std::mem::transmute(val)
3966 }
3967 },
3968 }
3969 }
3970}
3971#[doc = "Generated from 'VK_KHR_get_physical_device_properties2'"]
3972impl StructureType {
3973 pub const PHYSICAL_DEVICE_FEATURES_2_KHR: Self = Self::PHYSICAL_DEVICE_FEATURES_2;
3974 pub const PHYSICAL_DEVICE_PROPERTIES_2_KHR: Self = Self::PHYSICAL_DEVICE_PROPERTIES_2;
3975 pub const FORMAT_PROPERTIES_2_KHR: Self = Self::FORMAT_PROPERTIES_2;
3976 pub const IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::IMAGE_FORMAT_PROPERTIES_2;
3977 pub const PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: Self =
3978 Self::PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
3979 pub const QUEUE_FAMILY_PROPERTIES_2_KHR: Self = Self::QUEUE_FAMILY_PROPERTIES_2;
3980 pub const PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: Self =
3981 Self::PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
3982 pub const SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: Self = Self::SPARSE_IMAGE_FORMAT_PROPERTIES_2;
3983 pub const PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: Self =
3984 Self::PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
3985}
3986impl KhrDeviceGroupFn {
3987 pub const fn name() -> &'static ::std::ffi::CStr {
3988 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group\0") }
3989 }
3990 pub const SPEC_VERSION: u32 = 4u32;
3991}
3992#[allow(non_camel_case_types)]
3993pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn(
3994 device: Device,
3995 heap_index: u32,
3996 local_device_index: u32,
3997 remote_device_index: u32,
3998 p_peer_memory_features: *mut PeerMemoryFeatureFlags,
3999);
4000#[allow(non_camel_case_types)]
4001pub type PFN_vkCmdSetDeviceMask =
4002 unsafe extern "system" fn(command_buffer: CommandBuffer, device_mask: u32);
4003#[allow(non_camel_case_types)]
4004pub type PFN_vkCmdDispatchBase = unsafe extern "system" fn(
4005 command_buffer: CommandBuffer,
4006 base_group_x: u32,
4007 base_group_y: u32,
4008 base_group_z: u32,
4009 group_count_x: u32,
4010 group_count_y: u32,
4011 group_count_z: u32,
4012);
4013#[derive(Clone)]
4014pub struct KhrDeviceGroupFn {
4015 pub get_device_group_peer_memory_features_khr: PFN_vkGetDeviceGroupPeerMemoryFeatures,
4016 pub cmd_set_device_mask_khr: PFN_vkCmdSetDeviceMask,
4017 pub cmd_dispatch_base_khr: PFN_vkCmdDispatchBase,
4018 pub get_device_group_present_capabilities_khr:
4019 crate::vk::PFN_vkGetDeviceGroupPresentCapabilitiesKHR,
4020 pub get_device_group_surface_present_modes_khr:
4021 crate::vk::PFN_vkGetDeviceGroupSurfacePresentModesKHR,
4022 pub get_physical_device_present_rectangles_khr:
4023 crate::vk::PFN_vkGetPhysicalDevicePresentRectanglesKHR,
4024 pub acquire_next_image2_khr: crate::vk::PFN_vkAcquireNextImage2KHR,
4025}
4026unsafe impl Send for KhrDeviceGroupFn {}
4027unsafe impl Sync for KhrDeviceGroupFn {}
4028impl KhrDeviceGroupFn {
4029 pub fn load<F>(mut _f: F) -> Self
4030 where
4031 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4032 {
4033 Self {
4034 get_device_group_peer_memory_features_khr: unsafe {
4035 unsafe extern "system" fn get_device_group_peer_memory_features_khr(
4036 _device: Device,
4037 _heap_index: u32,
4038 _local_device_index: u32,
4039 _remote_device_index: u32,
4040 _p_peer_memory_features: *mut PeerMemoryFeatureFlags,
4041 ) {
4042 panic!(concat!(
4043 "Unable to load ",
4044 stringify!(get_device_group_peer_memory_features_khr)
4045 ))
4046 }
4047 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4048 b"vkGetDeviceGroupPeerMemoryFeaturesKHR\0",
4049 );
4050 let val = _f(cname);
4051 if val.is_null() {
4052 get_device_group_peer_memory_features_khr
4053 } else {
4054 ::std::mem::transmute(val)
4055 }
4056 },
4057 cmd_set_device_mask_khr: unsafe {
4058 unsafe extern "system" fn cmd_set_device_mask_khr(
4059 _command_buffer: CommandBuffer,
4060 _device_mask: u32,
4061 ) {
4062 panic!(concat!(
4063 "Unable to load ",
4064 stringify!(cmd_set_device_mask_khr)
4065 ))
4066 }
4067 let cname =
4068 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDeviceMaskKHR\0");
4069 let val = _f(cname);
4070 if val.is_null() {
4071 cmd_set_device_mask_khr
4072 } else {
4073 ::std::mem::transmute(val)
4074 }
4075 },
4076 cmd_dispatch_base_khr: unsafe {
4077 unsafe extern "system" fn cmd_dispatch_base_khr(
4078 _command_buffer: CommandBuffer,
4079 _base_group_x: u32,
4080 _base_group_y: u32,
4081 _base_group_z: u32,
4082 _group_count_x: u32,
4083 _group_count_y: u32,
4084 _group_count_z: u32,
4085 ) {
4086 panic!(concat!(
4087 "Unable to load ",
4088 stringify!(cmd_dispatch_base_khr)
4089 ))
4090 }
4091 let cname =
4092 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDispatchBaseKHR\0");
4093 let val = _f(cname);
4094 if val.is_null() {
4095 cmd_dispatch_base_khr
4096 } else {
4097 ::std::mem::transmute(val)
4098 }
4099 },
4100 get_device_group_present_capabilities_khr: unsafe {
4101 unsafe extern "system" fn get_device_group_present_capabilities_khr(
4102 _device: Device,
4103 _p_device_group_present_capabilities: *mut DeviceGroupPresentCapabilitiesKHR,
4104 ) -> Result {
4105 panic!(concat!(
4106 "Unable to load ",
4107 stringify!(get_device_group_present_capabilities_khr)
4108 ))
4109 }
4110 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4111 b"vkGetDeviceGroupPresentCapabilitiesKHR\0",
4112 );
4113 let val = _f(cname);
4114 if val.is_null() {
4115 get_device_group_present_capabilities_khr
4116 } else {
4117 ::std::mem::transmute(val)
4118 }
4119 },
4120 get_device_group_surface_present_modes_khr: unsafe {
4121 unsafe extern "system" fn get_device_group_surface_present_modes_khr(
4122 _device: Device,
4123 _surface: SurfaceKHR,
4124 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
4125 ) -> Result {
4126 panic!(concat!(
4127 "Unable to load ",
4128 stringify!(get_device_group_surface_present_modes_khr)
4129 ))
4130 }
4131 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4132 b"vkGetDeviceGroupSurfacePresentModesKHR\0",
4133 );
4134 let val = _f(cname);
4135 if val.is_null() {
4136 get_device_group_surface_present_modes_khr
4137 } else {
4138 ::std::mem::transmute(val)
4139 }
4140 },
4141 get_physical_device_present_rectangles_khr: unsafe {
4142 unsafe extern "system" fn get_physical_device_present_rectangles_khr(
4143 _physical_device: PhysicalDevice,
4144 _surface: SurfaceKHR,
4145 _p_rect_count: *mut u32,
4146 _p_rects: *mut Rect2D,
4147 ) -> Result {
4148 panic!(concat!(
4149 "Unable to load ",
4150 stringify!(get_physical_device_present_rectangles_khr)
4151 ))
4152 }
4153 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4154 b"vkGetPhysicalDevicePresentRectanglesKHR\0",
4155 );
4156 let val = _f(cname);
4157 if val.is_null() {
4158 get_physical_device_present_rectangles_khr
4159 } else {
4160 ::std::mem::transmute(val)
4161 }
4162 },
4163 acquire_next_image2_khr: unsafe {
4164 unsafe extern "system" fn acquire_next_image2_khr(
4165 _device: Device,
4166 _p_acquire_info: *const AcquireNextImageInfoKHR,
4167 _p_image_index: *mut u32,
4168 ) -> Result {
4169 panic!(concat!(
4170 "Unable to load ",
4171 stringify!(acquire_next_image2_khr)
4172 ))
4173 }
4174 let cname =
4175 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireNextImage2KHR\0");
4176 let val = _f(cname);
4177 if val.is_null() {
4178 acquire_next_image2_khr
4179 } else {
4180 ::std::mem::transmute(val)
4181 }
4182 },
4183 }
4184 }
4185}
4186#[doc = "Generated from 'VK_KHR_device_group'"]
4187impl DependencyFlags {
4188 pub const DEVICE_GROUP_KHR: Self = Self::DEVICE_GROUP;
4189}
4190#[doc = "Generated from 'VK_KHR_device_group'"]
4191impl ImageCreateFlags {
4192 pub const SPLIT_INSTANCE_BIND_REGIONS_KHR: Self = Self::SPLIT_INSTANCE_BIND_REGIONS;
4193}
4194#[doc = "Generated from 'VK_KHR_device_group'"]
4195impl MemoryAllocateFlags {
4196 pub const DEVICE_MASK_KHR: Self = Self::DEVICE_MASK;
4197}
4198#[doc = "Generated from 'VK_KHR_device_group'"]
4199impl PeerMemoryFeatureFlags {
4200 pub const COPY_SRC_KHR: Self = Self::COPY_SRC;
4201 pub const COPY_DST_KHR: Self = Self::COPY_DST;
4202 pub const GENERIC_SRC_KHR: Self = Self::GENERIC_SRC;
4203 pub const GENERIC_DST_KHR: Self = Self::GENERIC_DST;
4204}
4205#[doc = "Generated from 'VK_KHR_device_group'"]
4206impl PipelineCreateFlags {
4207 pub const VIEW_INDEX_FROM_DEVICE_INDEX_KHR: Self = Self::VIEW_INDEX_FROM_DEVICE_INDEX;
4208}
4209#[doc = "Generated from 'VK_KHR_device_group'"]
4210impl StructureType {
4211 pub const MEMORY_ALLOCATE_FLAGS_INFO_KHR: Self = Self::MEMORY_ALLOCATE_FLAGS_INFO;
4212 pub const DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: Self =
4213 Self::DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
4214 pub const DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: Self =
4215 Self::DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
4216 pub const DEVICE_GROUP_SUBMIT_INFO_KHR: Self = Self::DEVICE_GROUP_SUBMIT_INFO;
4217 pub const DEVICE_GROUP_BIND_SPARSE_INFO_KHR: Self = Self::DEVICE_GROUP_BIND_SPARSE_INFO;
4218 pub const BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: Self =
4219 Self::BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
4220 pub const BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: Self =
4221 Self::BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
4222}
4223impl ExtValidationFlagsFn {
4224 pub const fn name() -> &'static ::std::ffi::CStr {
4225 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_flags\0") }
4226 }
4227 pub const SPEC_VERSION: u32 = 2u32;
4228}
4229#[derive(Clone)]
4230pub struct ExtValidationFlagsFn {}
4231unsafe impl Send for ExtValidationFlagsFn {}
4232unsafe impl Sync for ExtValidationFlagsFn {}
4233impl ExtValidationFlagsFn {
4234 pub fn load<F>(mut _f: F) -> Self
4235 where
4236 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4237 {
4238 Self {}
4239 }
4240}
4241#[doc = "Generated from 'VK_EXT_validation_flags'"]
4242impl StructureType {
4243 pub const VALIDATION_FLAGS_EXT: Self = Self(1_000_061_000);
4244}
4245impl NnViSurfaceFn {
4246 pub const fn name() -> &'static ::std::ffi::CStr {
4247 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NN_vi_surface\0") }
4248 }
4249 pub const SPEC_VERSION: u32 = 1u32;
4250}
4251#[allow(non_camel_case_types)]
4252pub type PFN_vkCreateViSurfaceNN = unsafe extern "system" fn(
4253 instance: Instance,
4254 p_create_info: *const ViSurfaceCreateInfoNN,
4255 p_allocator: *const AllocationCallbacks,
4256 p_surface: *mut SurfaceKHR,
4257) -> Result;
4258#[derive(Clone)]
4259pub struct NnViSurfaceFn {
4260 pub create_vi_surface_nn: PFN_vkCreateViSurfaceNN,
4261}
4262unsafe impl Send for NnViSurfaceFn {}
4263unsafe impl Sync for NnViSurfaceFn {}
4264impl NnViSurfaceFn {
4265 pub fn load<F>(mut _f: F) -> Self
4266 where
4267 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4268 {
4269 Self {
4270 create_vi_surface_nn: unsafe {
4271 unsafe extern "system" fn create_vi_surface_nn(
4272 _instance: Instance,
4273 _p_create_info: *const ViSurfaceCreateInfoNN,
4274 _p_allocator: *const AllocationCallbacks,
4275 _p_surface: *mut SurfaceKHR,
4276 ) -> Result {
4277 panic!(concat!("Unable to load ", stringify!(create_vi_surface_nn)))
4278 }
4279 let cname =
4280 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateViSurfaceNN\0");
4281 let val = _f(cname);
4282 if val.is_null() {
4283 create_vi_surface_nn
4284 } else {
4285 ::std::mem::transmute(val)
4286 }
4287 },
4288 }
4289 }
4290}
4291#[doc = "Generated from 'VK_NN_vi_surface'"]
4292impl StructureType {
4293 pub const VI_SURFACE_CREATE_INFO_NN: Self = Self(1_000_062_000);
4294}
4295impl KhrShaderDrawParametersFn {
4296 pub const fn name() -> &'static ::std::ffi::CStr {
4297 unsafe {
4298 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_draw_parameters\0")
4299 }
4300 }
4301 pub const SPEC_VERSION: u32 = 1u32;
4302}
4303#[derive(Clone)]
4304pub struct KhrShaderDrawParametersFn {}
4305unsafe impl Send for KhrShaderDrawParametersFn {}
4306unsafe impl Sync for KhrShaderDrawParametersFn {}
4307impl KhrShaderDrawParametersFn {
4308 pub fn load<F>(mut _f: F) -> Self
4309 where
4310 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4311 {
4312 Self {}
4313 }
4314}
4315impl ExtShaderSubgroupBallotFn {
4316 pub const fn name() -> &'static ::std::ffi::CStr {
4317 unsafe {
4318 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_ballot\0")
4319 }
4320 }
4321 pub const SPEC_VERSION: u32 = 1u32;
4322}
4323#[derive(Clone)]
4324pub struct ExtShaderSubgroupBallotFn {}
4325unsafe impl Send for ExtShaderSubgroupBallotFn {}
4326unsafe impl Sync for ExtShaderSubgroupBallotFn {}
4327impl ExtShaderSubgroupBallotFn {
4328 pub fn load<F>(mut _f: F) -> Self
4329 where
4330 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4331 {
4332 Self {}
4333 }
4334}
4335impl ExtShaderSubgroupVoteFn {
4336 pub const fn name() -> &'static ::std::ffi::CStr {
4337 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_subgroup_vote\0") }
4338 }
4339 pub const SPEC_VERSION: u32 = 1u32;
4340}
4341#[derive(Clone)]
4342pub struct ExtShaderSubgroupVoteFn {}
4343unsafe impl Send for ExtShaderSubgroupVoteFn {}
4344unsafe impl Sync for ExtShaderSubgroupVoteFn {}
4345impl ExtShaderSubgroupVoteFn {
4346 pub fn load<F>(mut _f: F) -> Self
4347 where
4348 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4349 {
4350 Self {}
4351 }
4352}
4353impl ExtTextureCompressionAstcHdrFn {
4354 pub const fn name() -> &'static ::std::ffi::CStr {
4355 unsafe {
4356 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4357 b"VK_EXT_texture_compression_astc_hdr\0",
4358 )
4359 }
4360 }
4361 pub const SPEC_VERSION: u32 = 1u32;
4362}
4363#[derive(Clone)]
4364pub struct ExtTextureCompressionAstcHdrFn {}
4365unsafe impl Send for ExtTextureCompressionAstcHdrFn {}
4366unsafe impl Sync for ExtTextureCompressionAstcHdrFn {}
4367impl ExtTextureCompressionAstcHdrFn {
4368 pub fn load<F>(mut _f: F) -> Self
4369 where
4370 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4371 {
4372 Self {}
4373 }
4374}
4375#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
4376impl Format {
4377 pub const ASTC_4X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_4X4_SFLOAT_BLOCK;
4378 pub const ASTC_5X4_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X4_SFLOAT_BLOCK;
4379 pub const ASTC_5X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_5X5_SFLOAT_BLOCK;
4380 pub const ASTC_6X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X5_SFLOAT_BLOCK;
4381 pub const ASTC_6X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_6X6_SFLOAT_BLOCK;
4382 pub const ASTC_8X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X5_SFLOAT_BLOCK;
4383 pub const ASTC_8X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X6_SFLOAT_BLOCK;
4384 pub const ASTC_8X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_8X8_SFLOAT_BLOCK;
4385 pub const ASTC_10X5_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X5_SFLOAT_BLOCK;
4386 pub const ASTC_10X6_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X6_SFLOAT_BLOCK;
4387 pub const ASTC_10X8_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X8_SFLOAT_BLOCK;
4388 pub const ASTC_10X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_10X10_SFLOAT_BLOCK;
4389 pub const ASTC_12X10_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X10_SFLOAT_BLOCK;
4390 pub const ASTC_12X12_SFLOAT_BLOCK_EXT: Self = Self::ASTC_12X12_SFLOAT_BLOCK;
4391}
4392#[doc = "Generated from 'VK_EXT_texture_compression_astc_hdr'"]
4393impl StructureType {
4394 pub const PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: Self =
4395 Self::PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
4396}
4397impl ExtAstcDecodeModeFn {
4398 pub const fn name() -> &'static ::std::ffi::CStr {
4399 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_astc_decode_mode\0") }
4400 }
4401 pub const SPEC_VERSION: u32 = 1u32;
4402}
4403#[derive(Clone)]
4404pub struct ExtAstcDecodeModeFn {}
4405unsafe impl Send for ExtAstcDecodeModeFn {}
4406unsafe impl Sync for ExtAstcDecodeModeFn {}
4407impl ExtAstcDecodeModeFn {
4408 pub fn load<F>(mut _f: F) -> Self
4409 where
4410 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4411 {
4412 Self {}
4413 }
4414}
4415#[doc = "Generated from 'VK_EXT_astc_decode_mode'"]
4416impl StructureType {
4417 pub const IMAGE_VIEW_ASTC_DECODE_MODE_EXT: Self = Self(1_000_067_000);
4418 pub const PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: Self = Self(1_000_067_001);
4419}
4420impl ImgExtension69Fn {
4421 pub const fn name() -> &'static ::std::ffi::CStr {
4422 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_69\0") }
4423 }
4424 pub const SPEC_VERSION: u32 = 0u32;
4425}
4426#[derive(Clone)]
4427pub struct ImgExtension69Fn {}
4428unsafe impl Send for ImgExtension69Fn {}
4429unsafe impl Sync for ImgExtension69Fn {}
4430impl ImgExtension69Fn {
4431 pub fn load<F>(mut _f: F) -> Self
4432 where
4433 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4434 {
4435 Self {}
4436 }
4437}
4438impl KhrMaintenance1Fn {
4439 pub const fn name() -> &'static ::std::ffi::CStr {
4440 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance1\0") }
4441 }
4442 pub const SPEC_VERSION: u32 = 2u32;
4443}
4444#[allow(non_camel_case_types)]
4445pub type PFN_vkTrimCommandPool = unsafe extern "system" fn(
4446 device: Device,
4447 command_pool: CommandPool,
4448 flags: CommandPoolTrimFlags,
4449);
4450#[derive(Clone)]
4451pub struct KhrMaintenance1Fn {
4452 pub trim_command_pool_khr: PFN_vkTrimCommandPool,
4453}
4454unsafe impl Send for KhrMaintenance1Fn {}
4455unsafe impl Sync for KhrMaintenance1Fn {}
4456impl KhrMaintenance1Fn {
4457 pub fn load<F>(mut _f: F) -> Self
4458 where
4459 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4460 {
4461 Self {
4462 trim_command_pool_khr: unsafe {
4463 unsafe extern "system" fn trim_command_pool_khr(
4464 _device: Device,
4465 _command_pool: CommandPool,
4466 _flags: CommandPoolTrimFlags,
4467 ) {
4468 panic!(concat!(
4469 "Unable to load ",
4470 stringify!(trim_command_pool_khr)
4471 ))
4472 }
4473 let cname =
4474 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkTrimCommandPoolKHR\0");
4475 let val = _f(cname);
4476 if val.is_null() {
4477 trim_command_pool_khr
4478 } else {
4479 ::std::mem::transmute(val)
4480 }
4481 },
4482 }
4483 }
4484}
4485#[doc = "Generated from 'VK_KHR_maintenance1'"]
4486impl FormatFeatureFlags {
4487 pub const TRANSFER_SRC_KHR: Self = Self::TRANSFER_SRC;
4488 pub const TRANSFER_DST_KHR: Self = Self::TRANSFER_DST;
4489}
4490#[doc = "Generated from 'VK_KHR_maintenance1'"]
4491impl ImageCreateFlags {
4492 pub const TYPE_2D_ARRAY_COMPATIBLE_KHR: Self = Self::TYPE_2D_ARRAY_COMPATIBLE;
4493}
4494#[doc = "Generated from 'VK_KHR_maintenance1'"]
4495impl Result {
4496 pub const ERROR_OUT_OF_POOL_MEMORY_KHR: Self = Self::ERROR_OUT_OF_POOL_MEMORY;
4497}
4498impl KhrDeviceGroupCreationFn {
4499 pub const fn name() -> &'static ::std::ffi::CStr {
4500 unsafe {
4501 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_device_group_creation\0")
4502 }
4503 }
4504 pub const SPEC_VERSION: u32 = 1u32;
4505}
4506#[allow(non_camel_case_types)]
4507pub type PFN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn(
4508 instance: Instance,
4509 p_physical_device_group_count: *mut u32,
4510 p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
4511) -> Result;
4512#[derive(Clone)]
4513pub struct KhrDeviceGroupCreationFn {
4514 pub enumerate_physical_device_groups_khr: PFN_vkEnumeratePhysicalDeviceGroups,
4515}
4516unsafe impl Send for KhrDeviceGroupCreationFn {}
4517unsafe impl Sync for KhrDeviceGroupCreationFn {}
4518impl KhrDeviceGroupCreationFn {
4519 pub fn load<F>(mut _f: F) -> Self
4520 where
4521 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4522 {
4523 Self {
4524 enumerate_physical_device_groups_khr: unsafe {
4525 unsafe extern "system" fn enumerate_physical_device_groups_khr(
4526 _instance: Instance,
4527 _p_physical_device_group_count: *mut u32,
4528 _p_physical_device_group_properties: *mut PhysicalDeviceGroupProperties,
4529 ) -> Result {
4530 panic!(concat!(
4531 "Unable to load ",
4532 stringify!(enumerate_physical_device_groups_khr)
4533 ))
4534 }
4535 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4536 b"vkEnumeratePhysicalDeviceGroupsKHR\0",
4537 );
4538 let val = _f(cname);
4539 if val.is_null() {
4540 enumerate_physical_device_groups_khr
4541 } else {
4542 ::std::mem::transmute(val)
4543 }
4544 },
4545 }
4546 }
4547}
4548#[doc = "Generated from 'VK_KHR_device_group_creation'"]
4549impl MemoryHeapFlags {
4550 pub const MULTI_INSTANCE_KHR: Self = Self::MULTI_INSTANCE;
4551}
4552#[doc = "Generated from 'VK_KHR_device_group_creation'"]
4553impl StructureType {
4554 pub const PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_GROUP_PROPERTIES;
4555 pub const DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: Self = Self::DEVICE_GROUP_DEVICE_CREATE_INFO;
4556}
4557impl KhrExternalMemoryCapabilitiesFn {
4558 pub const fn name() -> &'static ::std::ffi::CStr {
4559 unsafe {
4560 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4561 b"VK_KHR_external_memory_capabilities\0",
4562 )
4563 }
4564 }
4565 pub const SPEC_VERSION: u32 = 1u32;
4566}
4567#[allow(non_camel_case_types)]
4568pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn(
4569 physical_device: PhysicalDevice,
4570 p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
4571 p_external_buffer_properties: *mut ExternalBufferProperties,
4572);
4573#[derive(Clone)]
4574pub struct KhrExternalMemoryCapabilitiesFn {
4575 pub get_physical_device_external_buffer_properties_khr:
4576 PFN_vkGetPhysicalDeviceExternalBufferProperties,
4577}
4578unsafe impl Send for KhrExternalMemoryCapabilitiesFn {}
4579unsafe impl Sync for KhrExternalMemoryCapabilitiesFn {}
4580impl KhrExternalMemoryCapabilitiesFn {
4581 pub fn load<F>(mut _f: F) -> Self
4582 where
4583 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4584 {
4585 Self {
4586 get_physical_device_external_buffer_properties_khr: unsafe {
4587 unsafe extern "system" fn get_physical_device_external_buffer_properties_khr(
4588 _physical_device: PhysicalDevice,
4589 _p_external_buffer_info: *const PhysicalDeviceExternalBufferInfo,
4590 _p_external_buffer_properties: *mut ExternalBufferProperties,
4591 ) {
4592 panic!(concat!(
4593 "Unable to load ",
4594 stringify!(get_physical_device_external_buffer_properties_khr)
4595 ))
4596 }
4597 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4598 b"vkGetPhysicalDeviceExternalBufferPropertiesKHR\0",
4599 );
4600 let val = _f(cname);
4601 if val.is_null() {
4602 get_physical_device_external_buffer_properties_khr
4603 } else {
4604 ::std::mem::transmute(val)
4605 }
4606 },
4607 }
4608 }
4609}
4610#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
4611impl ExternalMemoryFeatureFlags {
4612 pub const DEDICATED_ONLY_KHR: Self = Self::DEDICATED_ONLY;
4613 pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
4614 pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
4615}
4616#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
4617impl ExternalMemoryHandleTypeFlags {
4618 pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
4619 pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
4620 pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
4621 pub const D3D11_TEXTURE_KHR: Self = Self::D3D11_TEXTURE;
4622 pub const D3D11_TEXTURE_KMT_KHR: Self = Self::D3D11_TEXTURE_KMT;
4623 pub const D3D12_HEAP_KHR: Self = Self::D3D12_HEAP;
4624 pub const D3D12_RESOURCE_KHR: Self = Self::D3D12_RESOURCE;
4625}
4626#[doc = "Generated from 'VK_KHR_external_memory_capabilities'"]
4627impl StructureType {
4628 pub const PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: Self =
4629 Self::PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
4630 pub const EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: Self = Self::EXTERNAL_IMAGE_FORMAT_PROPERTIES;
4631 pub const PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: Self =
4632 Self::PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
4633 pub const EXTERNAL_BUFFER_PROPERTIES_KHR: Self = Self::EXTERNAL_BUFFER_PROPERTIES;
4634 pub const PHYSICAL_DEVICE_ID_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_ID_PROPERTIES;
4635}
4636impl KhrExternalMemoryFn {
4637 pub const fn name() -> &'static ::std::ffi::CStr {
4638 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory\0") }
4639 }
4640 pub const SPEC_VERSION: u32 = 1u32;
4641}
4642#[derive(Clone)]
4643pub struct KhrExternalMemoryFn {}
4644unsafe impl Send for KhrExternalMemoryFn {}
4645unsafe impl Sync for KhrExternalMemoryFn {}
4646impl KhrExternalMemoryFn {
4647 pub fn load<F>(mut _f: F) -> Self
4648 where
4649 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4650 {
4651 Self {}
4652 }
4653}
4654#[doc = "Generated from 'VK_KHR_external_memory'"]
4655impl Result {
4656 pub const ERROR_INVALID_EXTERNAL_HANDLE_KHR: Self = Self::ERROR_INVALID_EXTERNAL_HANDLE;
4657}
4658#[doc = "Generated from 'VK_KHR_external_memory'"]
4659impl StructureType {
4660 pub const EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: Self =
4661 Self::EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
4662 pub const EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: Self = Self::EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
4663 pub const EXPORT_MEMORY_ALLOCATE_INFO_KHR: Self = Self::EXPORT_MEMORY_ALLOCATE_INFO;
4664}
4665impl KhrExternalMemoryWin32Fn {
4666 pub const fn name() -> &'static ::std::ffi::CStr {
4667 unsafe {
4668 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_win32\0")
4669 }
4670 }
4671 pub const SPEC_VERSION: u32 = 1u32;
4672}
4673#[allow(non_camel_case_types)]
4674pub type PFN_vkGetMemoryWin32HandleKHR = unsafe extern "system" fn(
4675 device: Device,
4676 p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR,
4677 p_handle: *mut HANDLE,
4678) -> Result;
4679#[allow(non_camel_case_types)]
4680pub type PFN_vkGetMemoryWin32HandlePropertiesKHR = unsafe extern "system" fn(
4681 device: Device,
4682 handle_type: ExternalMemoryHandleTypeFlags,
4683 handle: HANDLE,
4684 p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR,
4685) -> Result;
4686#[derive(Clone)]
4687pub struct KhrExternalMemoryWin32Fn {
4688 pub get_memory_win32_handle_khr: PFN_vkGetMemoryWin32HandleKHR,
4689 pub get_memory_win32_handle_properties_khr: PFN_vkGetMemoryWin32HandlePropertiesKHR,
4690}
4691unsafe impl Send for KhrExternalMemoryWin32Fn {}
4692unsafe impl Sync for KhrExternalMemoryWin32Fn {}
4693impl KhrExternalMemoryWin32Fn {
4694 pub fn load<F>(mut _f: F) -> Self
4695 where
4696 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4697 {
4698 Self {
4699 get_memory_win32_handle_khr: unsafe {
4700 unsafe extern "system" fn get_memory_win32_handle_khr(
4701 _device: Device,
4702 _p_get_win32_handle_info: *const MemoryGetWin32HandleInfoKHR,
4703 _p_handle: *mut HANDLE,
4704 ) -> Result {
4705 panic!(concat!(
4706 "Unable to load ",
4707 stringify!(get_memory_win32_handle_khr)
4708 ))
4709 }
4710 let cname =
4711 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryWin32HandleKHR\0");
4712 let val = _f(cname);
4713 if val.is_null() {
4714 get_memory_win32_handle_khr
4715 } else {
4716 ::std::mem::transmute(val)
4717 }
4718 },
4719 get_memory_win32_handle_properties_khr: unsafe {
4720 unsafe extern "system" fn get_memory_win32_handle_properties_khr(
4721 _device: Device,
4722 _handle_type: ExternalMemoryHandleTypeFlags,
4723 _handle: HANDLE,
4724 _p_memory_win32_handle_properties: *mut MemoryWin32HandlePropertiesKHR,
4725 ) -> Result {
4726 panic!(concat!(
4727 "Unable to load ",
4728 stringify!(get_memory_win32_handle_properties_khr)
4729 ))
4730 }
4731 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4732 b"vkGetMemoryWin32HandlePropertiesKHR\0",
4733 );
4734 let val = _f(cname);
4735 if val.is_null() {
4736 get_memory_win32_handle_properties_khr
4737 } else {
4738 ::std::mem::transmute(val)
4739 }
4740 },
4741 }
4742 }
4743}
4744#[doc = "Generated from 'VK_KHR_external_memory_win32'"]
4745impl StructureType {
4746 pub const IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_000);
4747 pub const EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_001);
4748 pub const MEMORY_WIN32_HANDLE_PROPERTIES_KHR: Self = Self(1_000_073_002);
4749 pub const MEMORY_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_073_003);
4750}
4751impl KhrExternalMemoryFdFn {
4752 pub const fn name() -> &'static ::std::ffi::CStr {
4753 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_memory_fd\0") }
4754 }
4755 pub const SPEC_VERSION: u32 = 1u32;
4756}
4757#[allow(non_camel_case_types)]
4758pub type PFN_vkGetMemoryFdKHR = unsafe extern "system" fn(
4759 device: Device,
4760 p_get_fd_info: *const MemoryGetFdInfoKHR,
4761 p_fd: *mut c_int,
4762) -> Result;
4763#[allow(non_camel_case_types)]
4764pub type PFN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn(
4765 device: Device,
4766 handle_type: ExternalMemoryHandleTypeFlags,
4767 fd: c_int,
4768 p_memory_fd_properties: *mut MemoryFdPropertiesKHR,
4769) -> Result;
4770#[derive(Clone)]
4771pub struct KhrExternalMemoryFdFn {
4772 pub get_memory_fd_khr: PFN_vkGetMemoryFdKHR,
4773 pub get_memory_fd_properties_khr: PFN_vkGetMemoryFdPropertiesKHR,
4774}
4775unsafe impl Send for KhrExternalMemoryFdFn {}
4776unsafe impl Sync for KhrExternalMemoryFdFn {}
4777impl KhrExternalMemoryFdFn {
4778 pub fn load<F>(mut _f: F) -> Self
4779 where
4780 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4781 {
4782 Self {
4783 get_memory_fd_khr: unsafe {
4784 unsafe extern "system" fn get_memory_fd_khr(
4785 _device: Device,
4786 _p_get_fd_info: *const MemoryGetFdInfoKHR,
4787 _p_fd: *mut c_int,
4788 ) -> Result {
4789 panic!(concat!("Unable to load ", stringify!(get_memory_fd_khr)))
4790 }
4791 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetMemoryFdKHR\0");
4792 let val = _f(cname);
4793 if val.is_null() {
4794 get_memory_fd_khr
4795 } else {
4796 ::std::mem::transmute(val)
4797 }
4798 },
4799 get_memory_fd_properties_khr: unsafe {
4800 unsafe extern "system" fn get_memory_fd_properties_khr(
4801 _device: Device,
4802 _handle_type: ExternalMemoryHandleTypeFlags,
4803 _fd: c_int,
4804 _p_memory_fd_properties: *mut MemoryFdPropertiesKHR,
4805 ) -> Result {
4806 panic!(concat!(
4807 "Unable to load ",
4808 stringify!(get_memory_fd_properties_khr)
4809 ))
4810 }
4811 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4812 b"vkGetMemoryFdPropertiesKHR\0",
4813 );
4814 let val = _f(cname);
4815 if val.is_null() {
4816 get_memory_fd_properties_khr
4817 } else {
4818 ::std::mem::transmute(val)
4819 }
4820 },
4821 }
4822 }
4823}
4824#[doc = "Generated from 'VK_KHR_external_memory_fd'"]
4825impl StructureType {
4826 pub const IMPORT_MEMORY_FD_INFO_KHR: Self = Self(1_000_074_000);
4827 pub const MEMORY_FD_PROPERTIES_KHR: Self = Self(1_000_074_001);
4828 pub const MEMORY_GET_FD_INFO_KHR: Self = Self(1_000_074_002);
4829}
4830impl KhrWin32KeyedMutexFn {
4831 pub const fn name() -> &'static ::std::ffi::CStr {
4832 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_win32_keyed_mutex\0") }
4833 }
4834 pub const SPEC_VERSION: u32 = 1u32;
4835}
4836#[derive(Clone)]
4837pub struct KhrWin32KeyedMutexFn {}
4838unsafe impl Send for KhrWin32KeyedMutexFn {}
4839unsafe impl Sync for KhrWin32KeyedMutexFn {}
4840impl KhrWin32KeyedMutexFn {
4841 pub fn load<F>(mut _f: F) -> Self
4842 where
4843 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4844 {
4845 Self {}
4846 }
4847}
4848#[doc = "Generated from 'VK_KHR_win32_keyed_mutex'"]
4849impl StructureType {
4850 pub const WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: Self = Self(1_000_075_000);
4851}
4852impl KhrExternalSemaphoreCapabilitiesFn {
4853 pub const fn name() -> &'static ::std::ffi::CStr {
4854 unsafe {
4855 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4856 b"VK_KHR_external_semaphore_capabilities\0",
4857 )
4858 }
4859 }
4860 pub const SPEC_VERSION: u32 = 1u32;
4861}
4862#[allow(non_camel_case_types)]
4863pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn(
4864 physical_device: PhysicalDevice,
4865 p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
4866 p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
4867);
4868#[derive(Clone)]
4869pub struct KhrExternalSemaphoreCapabilitiesFn {
4870 pub get_physical_device_external_semaphore_properties_khr:
4871 PFN_vkGetPhysicalDeviceExternalSemaphoreProperties,
4872}
4873unsafe impl Send for KhrExternalSemaphoreCapabilitiesFn {}
4874unsafe impl Sync for KhrExternalSemaphoreCapabilitiesFn {}
4875impl KhrExternalSemaphoreCapabilitiesFn {
4876 pub fn load<F>(mut _f: F) -> Self
4877 where
4878 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4879 {
4880 Self {
4881 get_physical_device_external_semaphore_properties_khr: unsafe {
4882 unsafe extern "system" fn get_physical_device_external_semaphore_properties_khr(
4883 _physical_device: PhysicalDevice,
4884 _p_external_semaphore_info: *const PhysicalDeviceExternalSemaphoreInfo,
4885 _p_external_semaphore_properties: *mut ExternalSemaphoreProperties,
4886 ) {
4887 panic!(concat!(
4888 "Unable to load ",
4889 stringify!(get_physical_device_external_semaphore_properties_khr)
4890 ))
4891 }
4892 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4893 b"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR\0",
4894 );
4895 let val = _f(cname);
4896 if val.is_null() {
4897 get_physical_device_external_semaphore_properties_khr
4898 } else {
4899 ::std::mem::transmute(val)
4900 }
4901 },
4902 }
4903 }
4904}
4905#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
4906impl ExternalSemaphoreFeatureFlags {
4907 pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
4908 pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
4909}
4910#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
4911impl ExternalSemaphoreHandleTypeFlags {
4912 pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
4913 pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
4914 pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
4915 pub const D3D12_FENCE_KHR: Self = Self::D3D12_FENCE;
4916 pub const SYNC_FD_KHR: Self = Self::SYNC_FD;
4917}
4918#[doc = "Generated from 'VK_KHR_external_semaphore_capabilities'"]
4919impl StructureType {
4920 pub const PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: Self =
4921 Self::PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
4922 pub const EXTERNAL_SEMAPHORE_PROPERTIES_KHR: Self = Self::EXTERNAL_SEMAPHORE_PROPERTIES;
4923}
4924impl KhrExternalSemaphoreFn {
4925 pub const fn name() -> &'static ::std::ffi::CStr {
4926 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore\0") }
4927 }
4928 pub const SPEC_VERSION: u32 = 1u32;
4929}
4930#[derive(Clone)]
4931pub struct KhrExternalSemaphoreFn {}
4932unsafe impl Send for KhrExternalSemaphoreFn {}
4933unsafe impl Sync for KhrExternalSemaphoreFn {}
4934impl KhrExternalSemaphoreFn {
4935 pub fn load<F>(mut _f: F) -> Self
4936 where
4937 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4938 {
4939 Self {}
4940 }
4941}
4942#[doc = "Generated from 'VK_KHR_external_semaphore'"]
4943impl SemaphoreImportFlags {
4944 pub const TEMPORARY_KHR: Self = Self::TEMPORARY;
4945}
4946#[doc = "Generated from 'VK_KHR_external_semaphore'"]
4947impl StructureType {
4948 pub const EXPORT_SEMAPHORE_CREATE_INFO_KHR: Self = Self::EXPORT_SEMAPHORE_CREATE_INFO;
4949}
4950impl KhrExternalSemaphoreWin32Fn {
4951 pub const fn name() -> &'static ::std::ffi::CStr {
4952 unsafe {
4953 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_win32\0")
4954 }
4955 }
4956 pub const SPEC_VERSION: u32 = 1u32;
4957}
4958#[allow(non_camel_case_types)]
4959pub type PFN_vkImportSemaphoreWin32HandleKHR = unsafe extern "system" fn(
4960 device: Device,
4961 p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR,
4962) -> Result;
4963#[allow(non_camel_case_types)]
4964pub type PFN_vkGetSemaphoreWin32HandleKHR = unsafe extern "system" fn(
4965 device: Device,
4966 p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR,
4967 p_handle: *mut HANDLE,
4968) -> Result;
4969#[derive(Clone)]
4970pub struct KhrExternalSemaphoreWin32Fn {
4971 pub import_semaphore_win32_handle_khr: PFN_vkImportSemaphoreWin32HandleKHR,
4972 pub get_semaphore_win32_handle_khr: PFN_vkGetSemaphoreWin32HandleKHR,
4973}
4974unsafe impl Send for KhrExternalSemaphoreWin32Fn {}
4975unsafe impl Sync for KhrExternalSemaphoreWin32Fn {}
4976impl KhrExternalSemaphoreWin32Fn {
4977 pub fn load<F>(mut _f: F) -> Self
4978 where
4979 F: FnMut(&::std::ffi::CStr) -> *const c_void,
4980 {
4981 Self {
4982 import_semaphore_win32_handle_khr: unsafe {
4983 unsafe extern "system" fn import_semaphore_win32_handle_khr(
4984 _device: Device,
4985 _p_import_semaphore_win32_handle_info: *const ImportSemaphoreWin32HandleInfoKHR,
4986 ) -> Result {
4987 panic!(concat!(
4988 "Unable to load ",
4989 stringify!(import_semaphore_win32_handle_khr)
4990 ))
4991 }
4992 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
4993 b"vkImportSemaphoreWin32HandleKHR\0",
4994 );
4995 let val = _f(cname);
4996 if val.is_null() {
4997 import_semaphore_win32_handle_khr
4998 } else {
4999 ::std::mem::transmute(val)
5000 }
5001 },
5002 get_semaphore_win32_handle_khr: unsafe {
5003 unsafe extern "system" fn get_semaphore_win32_handle_khr(
5004 _device: Device,
5005 _p_get_win32_handle_info: *const SemaphoreGetWin32HandleInfoKHR,
5006 _p_handle: *mut HANDLE,
5007 ) -> Result {
5008 panic!(concat!(
5009 "Unable to load ",
5010 stringify!(get_semaphore_win32_handle_khr)
5011 ))
5012 }
5013 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5014 b"vkGetSemaphoreWin32HandleKHR\0",
5015 );
5016 let val = _f(cname);
5017 if val.is_null() {
5018 get_semaphore_win32_handle_khr
5019 } else {
5020 ::std::mem::transmute(val)
5021 }
5022 },
5023 }
5024 }
5025}
5026#[doc = "Generated from 'VK_KHR_external_semaphore_win32'"]
5027impl StructureType {
5028 pub const IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_000);
5029 pub const EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_001);
5030 pub const D3D12_FENCE_SUBMIT_INFO_KHR: Self = Self(1_000_078_002);
5031 pub const SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_078_003);
5032}
5033impl KhrExternalSemaphoreFdFn {
5034 pub const fn name() -> &'static ::std::ffi::CStr {
5035 unsafe {
5036 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_semaphore_fd\0")
5037 }
5038 }
5039 pub const SPEC_VERSION: u32 = 1u32;
5040}
5041#[allow(non_camel_case_types)]
5042pub type PFN_vkImportSemaphoreFdKHR = unsafe extern "system" fn(
5043 device: Device,
5044 p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR,
5045) -> Result;
5046#[allow(non_camel_case_types)]
5047pub type PFN_vkGetSemaphoreFdKHR = unsafe extern "system" fn(
5048 device: Device,
5049 p_get_fd_info: *const SemaphoreGetFdInfoKHR,
5050 p_fd: *mut c_int,
5051) -> Result;
5052#[derive(Clone)]
5053pub struct KhrExternalSemaphoreFdFn {
5054 pub import_semaphore_fd_khr: PFN_vkImportSemaphoreFdKHR,
5055 pub get_semaphore_fd_khr: PFN_vkGetSemaphoreFdKHR,
5056}
5057unsafe impl Send for KhrExternalSemaphoreFdFn {}
5058unsafe impl Sync for KhrExternalSemaphoreFdFn {}
5059impl KhrExternalSemaphoreFdFn {
5060 pub fn load<F>(mut _f: F) -> Self
5061 where
5062 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5063 {
5064 Self {
5065 import_semaphore_fd_khr: unsafe {
5066 unsafe extern "system" fn import_semaphore_fd_khr(
5067 _device: Device,
5068 _p_import_semaphore_fd_info: *const ImportSemaphoreFdInfoKHR,
5069 ) -> Result {
5070 panic!(concat!(
5071 "Unable to load ",
5072 stringify!(import_semaphore_fd_khr)
5073 ))
5074 }
5075 let cname =
5076 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportSemaphoreFdKHR\0");
5077 let val = _f(cname);
5078 if val.is_null() {
5079 import_semaphore_fd_khr
5080 } else {
5081 ::std::mem::transmute(val)
5082 }
5083 },
5084 get_semaphore_fd_khr: unsafe {
5085 unsafe extern "system" fn get_semaphore_fd_khr(
5086 _device: Device,
5087 _p_get_fd_info: *const SemaphoreGetFdInfoKHR,
5088 _p_fd: *mut c_int,
5089 ) -> Result {
5090 panic!(concat!("Unable to load ", stringify!(get_semaphore_fd_khr)))
5091 }
5092 let cname =
5093 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSemaphoreFdKHR\0");
5094 let val = _f(cname);
5095 if val.is_null() {
5096 get_semaphore_fd_khr
5097 } else {
5098 ::std::mem::transmute(val)
5099 }
5100 },
5101 }
5102 }
5103}
5104#[doc = "Generated from 'VK_KHR_external_semaphore_fd'"]
5105impl StructureType {
5106 pub const IMPORT_SEMAPHORE_FD_INFO_KHR: Self = Self(1_000_079_000);
5107 pub const SEMAPHORE_GET_FD_INFO_KHR: Self = Self(1_000_079_001);
5108}
5109impl KhrPushDescriptorFn {
5110 pub const fn name() -> &'static ::std::ffi::CStr {
5111 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_push_descriptor\0") }
5112 }
5113 pub const SPEC_VERSION: u32 = 2u32;
5114}
5115#[allow(non_camel_case_types)]
5116pub type PFN_vkCmdPushDescriptorSetKHR = unsafe extern "system" fn(
5117 command_buffer: CommandBuffer,
5118 pipeline_bind_point: PipelineBindPoint,
5119 layout: PipelineLayout,
5120 set: u32,
5121 descriptor_write_count: u32,
5122 p_descriptor_writes: *const WriteDescriptorSet,
5123);
5124#[allow(non_camel_case_types)]
5125pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = unsafe extern "system" fn(
5126 command_buffer: CommandBuffer,
5127 descriptor_update_template: DescriptorUpdateTemplate,
5128 layout: PipelineLayout,
5129 set: u32,
5130 p_data: *const c_void,
5131);
5132#[derive(Clone)]
5133pub struct KhrPushDescriptorFn {
5134 pub cmd_push_descriptor_set_khr: PFN_vkCmdPushDescriptorSetKHR,
5135 pub cmd_push_descriptor_set_with_template_khr: PFN_vkCmdPushDescriptorSetWithTemplateKHR,
5136}
5137unsafe impl Send for KhrPushDescriptorFn {}
5138unsafe impl Sync for KhrPushDescriptorFn {}
5139impl KhrPushDescriptorFn {
5140 pub fn load<F>(mut _f: F) -> Self
5141 where
5142 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5143 {
5144 Self {
5145 cmd_push_descriptor_set_khr: unsafe {
5146 unsafe extern "system" fn cmd_push_descriptor_set_khr(
5147 _command_buffer: CommandBuffer,
5148 _pipeline_bind_point: PipelineBindPoint,
5149 _layout: PipelineLayout,
5150 _set: u32,
5151 _descriptor_write_count: u32,
5152 _p_descriptor_writes: *const WriteDescriptorSet,
5153 ) {
5154 panic!(concat!(
5155 "Unable to load ",
5156 stringify!(cmd_push_descriptor_set_khr)
5157 ))
5158 }
5159 let cname =
5160 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPushDescriptorSetKHR\0");
5161 let val = _f(cname);
5162 if val.is_null() {
5163 cmd_push_descriptor_set_khr
5164 } else {
5165 ::std::mem::transmute(val)
5166 }
5167 },
5168 cmd_push_descriptor_set_with_template_khr: unsafe {
5169 unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr(
5170 _command_buffer: CommandBuffer,
5171 _descriptor_update_template: DescriptorUpdateTemplate,
5172 _layout: PipelineLayout,
5173 _set: u32,
5174 _p_data: *const c_void,
5175 ) {
5176 panic!(concat!(
5177 "Unable to load ",
5178 stringify!(cmd_push_descriptor_set_with_template_khr)
5179 ))
5180 }
5181 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5182 b"vkCmdPushDescriptorSetWithTemplateKHR\0",
5183 );
5184 let val = _f(cname);
5185 if val.is_null() {
5186 cmd_push_descriptor_set_with_template_khr
5187 } else {
5188 ::std::mem::transmute(val)
5189 }
5190 },
5191 }
5192 }
5193}
5194#[doc = "Generated from 'VK_KHR_push_descriptor'"]
5195impl DescriptorSetLayoutCreateFlags {
5196 #[doc = "Descriptors are pushed via flink:vkCmdPushDescriptorSetKHR"]
5197 pub const PUSH_DESCRIPTOR_KHR: Self = Self(0b1);
5198}
5199#[doc = "Generated from 'VK_KHR_push_descriptor'"]
5200impl DescriptorUpdateTemplateType {
5201 #[doc = "Create descriptor update template for pushed descriptor updates"]
5202 pub const PUSH_DESCRIPTORS_KHR: Self = Self(1);
5203}
5204#[doc = "Generated from 'VK_KHR_push_descriptor'"]
5205impl StructureType {
5206 pub const PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: Self = Self(1_000_080_000);
5207}
5208impl ExtConditionalRenderingFn {
5209 pub const fn name() -> &'static ::std::ffi::CStr {
5210 unsafe {
5211 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conditional_rendering\0")
5212 }
5213 }
5214 pub const SPEC_VERSION: u32 = 2u32;
5215}
5216#[allow(non_camel_case_types)]
5217pub type PFN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn(
5218 command_buffer: CommandBuffer,
5219 p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT,
5220);
5221#[allow(non_camel_case_types)]
5222pub type PFN_vkCmdEndConditionalRenderingEXT =
5223 unsafe extern "system" fn(command_buffer: CommandBuffer);
5224#[derive(Clone)]
5225pub struct ExtConditionalRenderingFn {
5226 pub cmd_begin_conditional_rendering_ext: PFN_vkCmdBeginConditionalRenderingEXT,
5227 pub cmd_end_conditional_rendering_ext: PFN_vkCmdEndConditionalRenderingEXT,
5228}
5229unsafe impl Send for ExtConditionalRenderingFn {}
5230unsafe impl Sync for ExtConditionalRenderingFn {}
5231impl ExtConditionalRenderingFn {
5232 pub fn load<F>(mut _f: F) -> Self
5233 where
5234 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5235 {
5236 Self {
5237 cmd_begin_conditional_rendering_ext: unsafe {
5238 unsafe extern "system" fn cmd_begin_conditional_rendering_ext(
5239 _command_buffer: CommandBuffer,
5240 _p_conditional_rendering_begin: *const ConditionalRenderingBeginInfoEXT,
5241 ) {
5242 panic!(concat!(
5243 "Unable to load ",
5244 stringify!(cmd_begin_conditional_rendering_ext)
5245 ))
5246 }
5247 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5248 b"vkCmdBeginConditionalRenderingEXT\0",
5249 );
5250 let val = _f(cname);
5251 if val.is_null() {
5252 cmd_begin_conditional_rendering_ext
5253 } else {
5254 ::std::mem::transmute(val)
5255 }
5256 },
5257 cmd_end_conditional_rendering_ext: unsafe {
5258 unsafe extern "system" fn cmd_end_conditional_rendering_ext(
5259 _command_buffer: CommandBuffer,
5260 ) {
5261 panic!(concat!(
5262 "Unable to load ",
5263 stringify!(cmd_end_conditional_rendering_ext)
5264 ))
5265 }
5266 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5267 b"vkCmdEndConditionalRenderingEXT\0",
5268 );
5269 let val = _f(cname);
5270 if val.is_null() {
5271 cmd_end_conditional_rendering_ext
5272 } else {
5273 ::std::mem::transmute(val)
5274 }
5275 },
5276 }
5277 }
5278}
5279#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5280impl AccessFlags {
5281 #[doc = "read access flag for reading conditional rendering predicate"]
5282 pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
5283}
5284#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5285impl BufferUsageFlags {
5286 #[doc = "Specifies the buffer can be used as predicate in conditional rendering"]
5287 pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b10_0000_0000);
5288}
5289#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5290impl PipelineStageFlags {
5291 #[doc = "A pipeline stage for conditional rendering predicate fetch"]
5292 pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000);
5293}
5294#[doc = "Generated from 'VK_EXT_conditional_rendering'"]
5295impl StructureType {
5296 pub const COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: Self = Self(1_000_081_000);
5297 pub const PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: Self = Self(1_000_081_001);
5298 pub const CONDITIONAL_RENDERING_BEGIN_INFO_EXT: Self = Self(1_000_081_002);
5299}
5300impl KhrShaderFloat16Int8Fn {
5301 pub const fn name() -> &'static ::std::ffi::CStr {
5302 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float16_int8\0") }
5303 }
5304 pub const SPEC_VERSION: u32 = 1u32;
5305}
5306#[derive(Clone)]
5307pub struct KhrShaderFloat16Int8Fn {}
5308unsafe impl Send for KhrShaderFloat16Int8Fn {}
5309unsafe impl Sync for KhrShaderFloat16Int8Fn {}
5310impl KhrShaderFloat16Int8Fn {
5311 pub fn load<F>(mut _f: F) -> Self
5312 where
5313 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5314 {
5315 Self {}
5316 }
5317}
5318#[doc = "Generated from 'VK_KHR_shader_float16_int8'"]
5319impl StructureType {
5320 pub const PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: Self =
5321 Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
5322 pub const PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: Self =
5323 Self::PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
5324}
5325impl Khr16bitStorageFn {
5326 pub const fn name() -> &'static ::std::ffi::CStr {
5327 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_16bit_storage\0") }
5328 }
5329 pub const SPEC_VERSION: u32 = 1u32;
5330}
5331#[derive(Clone)]
5332pub struct Khr16bitStorageFn {}
5333unsafe impl Send for Khr16bitStorageFn {}
5334unsafe impl Sync for Khr16bitStorageFn {}
5335impl Khr16bitStorageFn {
5336 pub fn load<F>(mut _f: F) -> Self
5337 where
5338 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5339 {
5340 Self {}
5341 }
5342}
5343#[doc = "Generated from 'VK_KHR_16bit_storage'"]
5344impl StructureType {
5345 pub const PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: Self =
5346 Self::PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
5347}
5348impl KhrIncrementalPresentFn {
5349 pub const fn name() -> &'static ::std::ffi::CStr {
5350 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_incremental_present\0") }
5351 }
5352 pub const SPEC_VERSION: u32 = 2u32;
5353}
5354#[derive(Clone)]
5355pub struct KhrIncrementalPresentFn {}
5356unsafe impl Send for KhrIncrementalPresentFn {}
5357unsafe impl Sync for KhrIncrementalPresentFn {}
5358impl KhrIncrementalPresentFn {
5359 pub fn load<F>(mut _f: F) -> Self
5360 where
5361 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5362 {
5363 Self {}
5364 }
5365}
5366#[doc = "Generated from 'VK_KHR_incremental_present'"]
5367impl StructureType {
5368 pub const PRESENT_REGIONS_KHR: Self = Self(1_000_084_000);
5369}
5370impl KhrDescriptorUpdateTemplateFn {
5371 pub const fn name() -> &'static ::std::ffi::CStr {
5372 unsafe {
5373 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_descriptor_update_template\0")
5374 }
5375 }
5376 pub const SPEC_VERSION: u32 = 1u32;
5377}
5378#[allow(non_camel_case_types)]
5379pub type PFN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn(
5380 device: Device,
5381 p_create_info: *const DescriptorUpdateTemplateCreateInfo,
5382 p_allocator: *const AllocationCallbacks,
5383 p_descriptor_update_template: *mut DescriptorUpdateTemplate,
5384) -> Result;
5385#[allow(non_camel_case_types)]
5386pub type PFN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn(
5387 device: Device,
5388 descriptor_update_template: DescriptorUpdateTemplate,
5389 p_allocator: *const AllocationCallbacks,
5390);
5391#[allow(non_camel_case_types)]
5392pub type PFN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn(
5393 device: Device,
5394 descriptor_set: DescriptorSet,
5395 descriptor_update_template: DescriptorUpdateTemplate,
5396 p_data: *const c_void,
5397);
5398#[derive(Clone)]
5399pub struct KhrDescriptorUpdateTemplateFn {
5400 pub create_descriptor_update_template_khr: PFN_vkCreateDescriptorUpdateTemplate,
5401 pub destroy_descriptor_update_template_khr: PFN_vkDestroyDescriptorUpdateTemplate,
5402 pub update_descriptor_set_with_template_khr: PFN_vkUpdateDescriptorSetWithTemplate,
5403 pub cmd_push_descriptor_set_with_template_khr:
5404 crate::vk::PFN_vkCmdPushDescriptorSetWithTemplateKHR,
5405}
5406unsafe impl Send for KhrDescriptorUpdateTemplateFn {}
5407unsafe impl Sync for KhrDescriptorUpdateTemplateFn {}
5408impl KhrDescriptorUpdateTemplateFn {
5409 pub fn load<F>(mut _f: F) -> Self
5410 where
5411 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5412 {
5413 Self {
5414 create_descriptor_update_template_khr: unsafe {
5415 unsafe extern "system" fn create_descriptor_update_template_khr(
5416 _device: Device,
5417 _p_create_info: *const DescriptorUpdateTemplateCreateInfo,
5418 _p_allocator: *const AllocationCallbacks,
5419 _p_descriptor_update_template: *mut DescriptorUpdateTemplate,
5420 ) -> Result {
5421 panic!(concat!(
5422 "Unable to load ",
5423 stringify!(create_descriptor_update_template_khr)
5424 ))
5425 }
5426 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5427 b"vkCreateDescriptorUpdateTemplateKHR\0",
5428 );
5429 let val = _f(cname);
5430 if val.is_null() {
5431 create_descriptor_update_template_khr
5432 } else {
5433 ::std::mem::transmute(val)
5434 }
5435 },
5436 destroy_descriptor_update_template_khr: unsafe {
5437 unsafe extern "system" fn destroy_descriptor_update_template_khr(
5438 _device: Device,
5439 _descriptor_update_template: DescriptorUpdateTemplate,
5440 _p_allocator: *const AllocationCallbacks,
5441 ) {
5442 panic!(concat!(
5443 "Unable to load ",
5444 stringify!(destroy_descriptor_update_template_khr)
5445 ))
5446 }
5447 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5448 b"vkDestroyDescriptorUpdateTemplateKHR\0",
5449 );
5450 let val = _f(cname);
5451 if val.is_null() {
5452 destroy_descriptor_update_template_khr
5453 } else {
5454 ::std::mem::transmute(val)
5455 }
5456 },
5457 update_descriptor_set_with_template_khr: unsafe {
5458 unsafe extern "system" fn update_descriptor_set_with_template_khr(
5459 _device: Device,
5460 _descriptor_set: DescriptorSet,
5461 _descriptor_update_template: DescriptorUpdateTemplate,
5462 _p_data: *const c_void,
5463 ) {
5464 panic!(concat!(
5465 "Unable to load ",
5466 stringify!(update_descriptor_set_with_template_khr)
5467 ))
5468 }
5469 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5470 b"vkUpdateDescriptorSetWithTemplateKHR\0",
5471 );
5472 let val = _f(cname);
5473 if val.is_null() {
5474 update_descriptor_set_with_template_khr
5475 } else {
5476 ::std::mem::transmute(val)
5477 }
5478 },
5479 cmd_push_descriptor_set_with_template_khr: unsafe {
5480 unsafe extern "system" fn cmd_push_descriptor_set_with_template_khr(
5481 _command_buffer: CommandBuffer,
5482 _descriptor_update_template: DescriptorUpdateTemplate,
5483 _layout: PipelineLayout,
5484 _set: u32,
5485 _p_data: *const c_void,
5486 ) {
5487 panic!(concat!(
5488 "Unable to load ",
5489 stringify!(cmd_push_descriptor_set_with_template_khr)
5490 ))
5491 }
5492 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5493 b"vkCmdPushDescriptorSetWithTemplateKHR\0",
5494 );
5495 let val = _f(cname);
5496 if val.is_null() {
5497 cmd_push_descriptor_set_with_template_khr
5498 } else {
5499 ::std::mem::transmute(val)
5500 }
5501 },
5502 }
5503 }
5504}
5505#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5506impl DebugReportObjectTypeEXT {
5507 pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
5508}
5509#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5510impl DescriptorUpdateTemplateType {
5511 pub const DESCRIPTOR_SET_KHR: Self = Self::DESCRIPTOR_SET;
5512}
5513#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5514impl ObjectType {
5515 pub const DESCRIPTOR_UPDATE_TEMPLATE_KHR: Self = Self::DESCRIPTOR_UPDATE_TEMPLATE;
5516}
5517#[doc = "Generated from 'VK_KHR_descriptor_update_template'"]
5518impl StructureType {
5519 pub const DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: Self =
5520 Self::DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
5521}
5522impl NvxDeviceGeneratedCommandsFn {
5523 pub const fn name() -> &'static ::std::ffi::CStr {
5524 unsafe {
5525 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NVX_device_generated_commands\0")
5526 }
5527 }
5528 pub const SPEC_VERSION: u32 = 3u32;
5529}
5530#[derive(Clone)]
5531pub struct NvxDeviceGeneratedCommandsFn {}
5532unsafe impl Send for NvxDeviceGeneratedCommandsFn {}
5533unsafe impl Sync for NvxDeviceGeneratedCommandsFn {}
5534impl NvxDeviceGeneratedCommandsFn {
5535 pub fn load<F>(mut _f: F) -> Self
5536 where
5537 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5538 {
5539 Self {}
5540 }
5541}
5542impl NvClipSpaceWScalingFn {
5543 pub const fn name() -> &'static ::std::ffi::CStr {
5544 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_clip_space_w_scaling\0") }
5545 }
5546 pub const SPEC_VERSION: u32 = 1u32;
5547}
5548#[allow(non_camel_case_types)]
5549pub type PFN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn(
5550 command_buffer: CommandBuffer,
5551 first_viewport: u32,
5552 viewport_count: u32,
5553 p_viewport_w_scalings: *const ViewportWScalingNV,
5554);
5555#[derive(Clone)]
5556pub struct NvClipSpaceWScalingFn {
5557 pub cmd_set_viewport_w_scaling_nv: PFN_vkCmdSetViewportWScalingNV,
5558}
5559unsafe impl Send for NvClipSpaceWScalingFn {}
5560unsafe impl Sync for NvClipSpaceWScalingFn {}
5561impl NvClipSpaceWScalingFn {
5562 pub fn load<F>(mut _f: F) -> Self
5563 where
5564 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5565 {
5566 Self {
5567 cmd_set_viewport_w_scaling_nv: unsafe {
5568 unsafe extern "system" fn cmd_set_viewport_w_scaling_nv(
5569 _command_buffer: CommandBuffer,
5570 _first_viewport: u32,
5571 _viewport_count: u32,
5572 _p_viewport_w_scalings: *const ViewportWScalingNV,
5573 ) {
5574 panic!(concat!(
5575 "Unable to load ",
5576 stringify!(cmd_set_viewport_w_scaling_nv)
5577 ))
5578 }
5579 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5580 b"vkCmdSetViewportWScalingNV\0",
5581 );
5582 let val = _f(cname);
5583 if val.is_null() {
5584 cmd_set_viewport_w_scaling_nv
5585 } else {
5586 ::std::mem::transmute(val)
5587 }
5588 },
5589 }
5590 }
5591}
5592#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"]
5593impl DynamicState {
5594 pub const VIEWPORT_W_SCALING_NV: Self = Self(1_000_087_000);
5595}
5596#[doc = "Generated from 'VK_NV_clip_space_w_scaling'"]
5597impl StructureType {
5598 pub const PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: Self = Self(1_000_087_000);
5599}
5600impl ExtDirectModeDisplayFn {
5601 pub const fn name() -> &'static ::std::ffi::CStr {
5602 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_direct_mode_display\0") }
5603 }
5604 pub const SPEC_VERSION: u32 = 1u32;
5605}
5606#[allow(non_camel_case_types)]
5607pub type PFN_vkReleaseDisplayEXT =
5608 unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result;
5609#[derive(Clone)]
5610pub struct ExtDirectModeDisplayFn {
5611 pub release_display_ext: PFN_vkReleaseDisplayEXT,
5612}
5613unsafe impl Send for ExtDirectModeDisplayFn {}
5614unsafe impl Sync for ExtDirectModeDisplayFn {}
5615impl ExtDirectModeDisplayFn {
5616 pub fn load<F>(mut _f: F) -> Self
5617 where
5618 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5619 {
5620 Self {
5621 release_display_ext: unsafe {
5622 unsafe extern "system" fn release_display_ext(
5623 _physical_device: PhysicalDevice,
5624 _display: DisplayKHR,
5625 ) -> Result {
5626 panic!(concat!("Unable to load ", stringify!(release_display_ext)))
5627 }
5628 let cname =
5629 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseDisplayEXT\0");
5630 let val = _f(cname);
5631 if val.is_null() {
5632 release_display_ext
5633 } else {
5634 ::std::mem::transmute(val)
5635 }
5636 },
5637 }
5638 }
5639}
5640impl ExtAcquireXlibDisplayFn {
5641 pub const fn name() -> &'static ::std::ffi::CStr {
5642 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_xlib_display\0") }
5643 }
5644 pub const SPEC_VERSION: u32 = 1u32;
5645}
5646#[allow(non_camel_case_types)]
5647pub type PFN_vkAcquireXlibDisplayEXT = unsafe extern "system" fn(
5648 physical_device: PhysicalDevice,
5649 dpy: *mut Display,
5650 display: DisplayKHR,
5651) -> Result;
5652#[allow(non_camel_case_types)]
5653pub type PFN_vkGetRandROutputDisplayEXT = unsafe extern "system" fn(
5654 physical_device: PhysicalDevice,
5655 dpy: *mut Display,
5656 rr_output: RROutput,
5657 p_display: *mut DisplayKHR,
5658) -> Result;
5659#[derive(Clone)]
5660pub struct ExtAcquireXlibDisplayFn {
5661 pub acquire_xlib_display_ext: PFN_vkAcquireXlibDisplayEXT,
5662 pub get_rand_r_output_display_ext: PFN_vkGetRandROutputDisplayEXT,
5663}
5664unsafe impl Send for ExtAcquireXlibDisplayFn {}
5665unsafe impl Sync for ExtAcquireXlibDisplayFn {}
5666impl ExtAcquireXlibDisplayFn {
5667 pub fn load<F>(mut _f: F) -> Self
5668 where
5669 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5670 {
5671 Self {
5672 acquire_xlib_display_ext: unsafe {
5673 unsafe extern "system" fn acquire_xlib_display_ext(
5674 _physical_device: PhysicalDevice,
5675 _dpy: *mut Display,
5676 _display: DisplayKHR,
5677 ) -> Result {
5678 panic!(concat!(
5679 "Unable to load ",
5680 stringify!(acquire_xlib_display_ext)
5681 ))
5682 }
5683 let cname =
5684 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireXlibDisplayEXT\0");
5685 let val = _f(cname);
5686 if val.is_null() {
5687 acquire_xlib_display_ext
5688 } else {
5689 ::std::mem::transmute(val)
5690 }
5691 },
5692 get_rand_r_output_display_ext: unsafe {
5693 unsafe extern "system" fn get_rand_r_output_display_ext(
5694 _physical_device: PhysicalDevice,
5695 _dpy: *mut Display,
5696 _rr_output: RROutput,
5697 _p_display: *mut DisplayKHR,
5698 ) -> Result {
5699 panic!(concat!(
5700 "Unable to load ",
5701 stringify!(get_rand_r_output_display_ext)
5702 ))
5703 }
5704 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5705 b"vkGetRandROutputDisplayEXT\0",
5706 );
5707 let val = _f(cname);
5708 if val.is_null() {
5709 get_rand_r_output_display_ext
5710 } else {
5711 ::std::mem::transmute(val)
5712 }
5713 },
5714 }
5715 }
5716}
5717impl ExtDisplaySurfaceCounterFn {
5718 pub const fn name() -> &'static ::std::ffi::CStr {
5719 unsafe {
5720 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_surface_counter\0")
5721 }
5722 }
5723 pub const SPEC_VERSION: u32 = 1u32;
5724}
5725#[allow(non_camel_case_types)]
5726pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn(
5727 physical_device: PhysicalDevice,
5728 surface: SurfaceKHR,
5729 p_surface_capabilities: *mut SurfaceCapabilities2EXT,
5730) -> Result;
5731#[derive(Clone)]
5732pub struct ExtDisplaySurfaceCounterFn {
5733 pub get_physical_device_surface_capabilities2_ext:
5734 PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT,
5735}
5736unsafe impl Send for ExtDisplaySurfaceCounterFn {}
5737unsafe impl Sync for ExtDisplaySurfaceCounterFn {}
5738impl ExtDisplaySurfaceCounterFn {
5739 pub fn load<F>(mut _f: F) -> Self
5740 where
5741 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5742 {
5743 Self {
5744 get_physical_device_surface_capabilities2_ext: unsafe {
5745 unsafe extern "system" fn get_physical_device_surface_capabilities2_ext(
5746 _physical_device: PhysicalDevice,
5747 _surface: SurfaceKHR,
5748 _p_surface_capabilities: *mut SurfaceCapabilities2EXT,
5749 ) -> Result {
5750 panic!(concat!(
5751 "Unable to load ",
5752 stringify!(get_physical_device_surface_capabilities2_ext)
5753 ))
5754 }
5755 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5756 b"vkGetPhysicalDeviceSurfaceCapabilities2EXT\0",
5757 );
5758 let val = _f(cname);
5759 if val.is_null() {
5760 get_physical_device_surface_capabilities2_ext
5761 } else {
5762 ::std::mem::transmute(val)
5763 }
5764 },
5765 }
5766 }
5767}
5768#[doc = "Generated from 'VK_EXT_display_surface_counter'"]
5769impl StructureType {
5770 pub const SURFACE_CAPABILITIES_2_EXT: Self = Self(1_000_090_000);
5771}
5772impl ExtDisplayControlFn {
5773 pub const fn name() -> &'static ::std::ffi::CStr {
5774 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_display_control\0") }
5775 }
5776 pub const SPEC_VERSION: u32 = 1u32;
5777}
5778#[allow(non_camel_case_types)]
5779pub type PFN_vkDisplayPowerControlEXT = unsafe extern "system" fn(
5780 device: Device,
5781 display: DisplayKHR,
5782 p_display_power_info: *const DisplayPowerInfoEXT,
5783) -> Result;
5784#[allow(non_camel_case_types)]
5785pub type PFN_vkRegisterDeviceEventEXT = unsafe extern "system" fn(
5786 device: Device,
5787 p_device_event_info: *const DeviceEventInfoEXT,
5788 p_allocator: *const AllocationCallbacks,
5789 p_fence: *mut Fence,
5790) -> Result;
5791#[allow(non_camel_case_types)]
5792pub type PFN_vkRegisterDisplayEventEXT = unsafe extern "system" fn(
5793 device: Device,
5794 display: DisplayKHR,
5795 p_display_event_info: *const DisplayEventInfoEXT,
5796 p_allocator: *const AllocationCallbacks,
5797 p_fence: *mut Fence,
5798) -> Result;
5799#[allow(non_camel_case_types)]
5800pub type PFN_vkGetSwapchainCounterEXT = unsafe extern "system" fn(
5801 device: Device,
5802 swapchain: SwapchainKHR,
5803 counter: SurfaceCounterFlagsEXT,
5804 p_counter_value: *mut u64,
5805) -> Result;
5806#[derive(Clone)]
5807pub struct ExtDisplayControlFn {
5808 pub display_power_control_ext: PFN_vkDisplayPowerControlEXT,
5809 pub register_device_event_ext: PFN_vkRegisterDeviceEventEXT,
5810 pub register_display_event_ext: PFN_vkRegisterDisplayEventEXT,
5811 pub get_swapchain_counter_ext: PFN_vkGetSwapchainCounterEXT,
5812}
5813unsafe impl Send for ExtDisplayControlFn {}
5814unsafe impl Sync for ExtDisplayControlFn {}
5815impl ExtDisplayControlFn {
5816 pub fn load<F>(mut _f: F) -> Self
5817 where
5818 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5819 {
5820 Self {
5821 display_power_control_ext: unsafe {
5822 unsafe extern "system" fn display_power_control_ext(
5823 _device: Device,
5824 _display: DisplayKHR,
5825 _p_display_power_info: *const DisplayPowerInfoEXT,
5826 ) -> Result {
5827 panic!(concat!(
5828 "Unable to load ",
5829 stringify!(display_power_control_ext)
5830 ))
5831 }
5832 let cname =
5833 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkDisplayPowerControlEXT\0");
5834 let val = _f(cname);
5835 if val.is_null() {
5836 display_power_control_ext
5837 } else {
5838 ::std::mem::transmute(val)
5839 }
5840 },
5841 register_device_event_ext: unsafe {
5842 unsafe extern "system" fn register_device_event_ext(
5843 _device: Device,
5844 _p_device_event_info: *const DeviceEventInfoEXT,
5845 _p_allocator: *const AllocationCallbacks,
5846 _p_fence: *mut Fence,
5847 ) -> Result {
5848 panic!(concat!(
5849 "Unable to load ",
5850 stringify!(register_device_event_ext)
5851 ))
5852 }
5853 let cname =
5854 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDeviceEventEXT\0");
5855 let val = _f(cname);
5856 if val.is_null() {
5857 register_device_event_ext
5858 } else {
5859 ::std::mem::transmute(val)
5860 }
5861 },
5862 register_display_event_ext: unsafe {
5863 unsafe extern "system" fn register_display_event_ext(
5864 _device: Device,
5865 _display: DisplayKHR,
5866 _p_display_event_info: *const DisplayEventInfoEXT,
5867 _p_allocator: *const AllocationCallbacks,
5868 _p_fence: *mut Fence,
5869 ) -> Result {
5870 panic!(concat!(
5871 "Unable to load ",
5872 stringify!(register_display_event_ext)
5873 ))
5874 }
5875 let cname =
5876 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkRegisterDisplayEventEXT\0");
5877 let val = _f(cname);
5878 if val.is_null() {
5879 register_display_event_ext
5880 } else {
5881 ::std::mem::transmute(val)
5882 }
5883 },
5884 get_swapchain_counter_ext: unsafe {
5885 unsafe extern "system" fn get_swapchain_counter_ext(
5886 _device: Device,
5887 _swapchain: SwapchainKHR,
5888 _counter: SurfaceCounterFlagsEXT,
5889 _p_counter_value: *mut u64,
5890 ) -> Result {
5891 panic!(concat!(
5892 "Unable to load ",
5893 stringify!(get_swapchain_counter_ext)
5894 ))
5895 }
5896 let cname =
5897 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainCounterEXT\0");
5898 let val = _f(cname);
5899 if val.is_null() {
5900 get_swapchain_counter_ext
5901 } else {
5902 ::std::mem::transmute(val)
5903 }
5904 },
5905 }
5906 }
5907}
5908#[doc = "Generated from 'VK_EXT_display_control'"]
5909impl StructureType {
5910 pub const DISPLAY_POWER_INFO_EXT: Self = Self(1_000_091_000);
5911 pub const DEVICE_EVENT_INFO_EXT: Self = Self(1_000_091_001);
5912 pub const DISPLAY_EVENT_INFO_EXT: Self = Self(1_000_091_002);
5913 pub const SWAPCHAIN_COUNTER_CREATE_INFO_EXT: Self = Self(1_000_091_003);
5914}
5915impl GoogleDisplayTimingFn {
5916 pub const fn name() -> &'static ::std::ffi::CStr {
5917 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_display_timing\0") }
5918 }
5919 pub const SPEC_VERSION: u32 = 1u32;
5920}
5921#[allow(non_camel_case_types)]
5922pub type PFN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn(
5923 device: Device,
5924 swapchain: SwapchainKHR,
5925 p_display_timing_properties: *mut RefreshCycleDurationGOOGLE,
5926) -> Result;
5927#[allow(non_camel_case_types)]
5928pub type PFN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn(
5929 device: Device,
5930 swapchain: SwapchainKHR,
5931 p_presentation_timing_count: *mut u32,
5932 p_presentation_timings: *mut PastPresentationTimingGOOGLE,
5933) -> Result;
5934#[derive(Clone)]
5935pub struct GoogleDisplayTimingFn {
5936 pub get_refresh_cycle_duration_google: PFN_vkGetRefreshCycleDurationGOOGLE,
5937 pub get_past_presentation_timing_google: PFN_vkGetPastPresentationTimingGOOGLE,
5938}
5939unsafe impl Send for GoogleDisplayTimingFn {}
5940unsafe impl Sync for GoogleDisplayTimingFn {}
5941impl GoogleDisplayTimingFn {
5942 pub fn load<F>(mut _f: F) -> Self
5943 where
5944 F: FnMut(&::std::ffi::CStr) -> *const c_void,
5945 {
5946 Self {
5947 get_refresh_cycle_duration_google: unsafe {
5948 unsafe extern "system" fn get_refresh_cycle_duration_google(
5949 _device: Device,
5950 _swapchain: SwapchainKHR,
5951 _p_display_timing_properties: *mut RefreshCycleDurationGOOGLE,
5952 ) -> Result {
5953 panic!(concat!(
5954 "Unable to load ",
5955 stringify!(get_refresh_cycle_duration_google)
5956 ))
5957 }
5958 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5959 b"vkGetRefreshCycleDurationGOOGLE\0",
5960 );
5961 let val = _f(cname);
5962 if val.is_null() {
5963 get_refresh_cycle_duration_google
5964 } else {
5965 ::std::mem::transmute(val)
5966 }
5967 },
5968 get_past_presentation_timing_google: unsafe {
5969 unsafe extern "system" fn get_past_presentation_timing_google(
5970 _device: Device,
5971 _swapchain: SwapchainKHR,
5972 _p_presentation_timing_count: *mut u32,
5973 _p_presentation_timings: *mut PastPresentationTimingGOOGLE,
5974 ) -> Result {
5975 panic!(concat!(
5976 "Unable to load ",
5977 stringify!(get_past_presentation_timing_google)
5978 ))
5979 }
5980 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
5981 b"vkGetPastPresentationTimingGOOGLE\0",
5982 );
5983 let val = _f(cname);
5984 if val.is_null() {
5985 get_past_presentation_timing_google
5986 } else {
5987 ::std::mem::transmute(val)
5988 }
5989 },
5990 }
5991 }
5992}
5993#[doc = "Generated from 'VK_GOOGLE_display_timing'"]
5994impl StructureType {
5995 pub const PRESENT_TIMES_INFO_GOOGLE: Self = Self(1_000_092_000);
5996}
5997impl NvSampleMaskOverrideCoverageFn {
5998 pub const fn name() -> &'static ::std::ffi::CStr {
5999 unsafe {
6000 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6001 b"VK_NV_sample_mask_override_coverage\0",
6002 )
6003 }
6004 }
6005 pub const SPEC_VERSION: u32 = 1u32;
6006}
6007#[derive(Clone)]
6008pub struct NvSampleMaskOverrideCoverageFn {}
6009unsafe impl Send for NvSampleMaskOverrideCoverageFn {}
6010unsafe impl Sync for NvSampleMaskOverrideCoverageFn {}
6011impl NvSampleMaskOverrideCoverageFn {
6012 pub fn load<F>(mut _f: F) -> Self
6013 where
6014 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6015 {
6016 Self {}
6017 }
6018}
6019impl NvGeometryShaderPassthroughFn {
6020 pub const fn name() -> &'static ::std::ffi::CStr {
6021 unsafe {
6022 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_geometry_shader_passthrough\0")
6023 }
6024 }
6025 pub const SPEC_VERSION: u32 = 1u32;
6026}
6027#[derive(Clone)]
6028pub struct NvGeometryShaderPassthroughFn {}
6029unsafe impl Send for NvGeometryShaderPassthroughFn {}
6030unsafe impl Sync for NvGeometryShaderPassthroughFn {}
6031impl NvGeometryShaderPassthroughFn {
6032 pub fn load<F>(mut _f: F) -> Self
6033 where
6034 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6035 {
6036 Self {}
6037 }
6038}
6039impl NvViewportArray2Fn {
6040 pub const fn name() -> &'static ::std::ffi::CStr {
6041 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_array2\0") }
6042 }
6043 pub const SPEC_VERSION: u32 = 1u32;
6044}
6045#[derive(Clone)]
6046pub struct NvViewportArray2Fn {}
6047unsafe impl Send for NvViewportArray2Fn {}
6048unsafe impl Sync for NvViewportArray2Fn {}
6049impl NvViewportArray2Fn {
6050 pub fn load<F>(mut _f: F) -> Self
6051 where
6052 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6053 {
6054 Self {}
6055 }
6056}
6057impl NvxMultiviewPerViewAttributesFn {
6058 pub const fn name() -> &'static ::std::ffi::CStr {
6059 unsafe {
6060 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6061 b"VK_NVX_multiview_per_view_attributes\0",
6062 )
6063 }
6064 }
6065 pub const SPEC_VERSION: u32 = 1u32;
6066}
6067#[derive(Clone)]
6068pub struct NvxMultiviewPerViewAttributesFn {}
6069unsafe impl Send for NvxMultiviewPerViewAttributesFn {}
6070unsafe impl Sync for NvxMultiviewPerViewAttributesFn {}
6071impl NvxMultiviewPerViewAttributesFn {
6072 pub fn load<F>(mut _f: F) -> Self
6073 where
6074 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6075 {
6076 Self {}
6077 }
6078}
6079#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"]
6080impl StructureType {
6081 pub const PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: Self =
6082 Self(1_000_097_000);
6083}
6084#[doc = "Generated from 'VK_NVX_multiview_per_view_attributes'"]
6085impl SubpassDescriptionFlags {
6086 pub const PER_VIEW_ATTRIBUTES_NVX: Self = Self(0b1);
6087 pub const PER_VIEW_POSITION_X_ONLY_NVX: Self = Self(0b10);
6088}
6089impl NvViewportSwizzleFn {
6090 pub const fn name() -> &'static ::std::ffi::CStr {
6091 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_viewport_swizzle\0") }
6092 }
6093 pub const SPEC_VERSION: u32 = 1u32;
6094}
6095#[derive(Clone)]
6096pub struct NvViewportSwizzleFn {}
6097unsafe impl Send for NvViewportSwizzleFn {}
6098unsafe impl Sync for NvViewportSwizzleFn {}
6099impl NvViewportSwizzleFn {
6100 pub fn load<F>(mut _f: F) -> Self
6101 where
6102 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6103 {
6104 Self {}
6105 }
6106}
6107#[doc = "Generated from 'VK_NV_viewport_swizzle'"]
6108impl StructureType {
6109 pub const PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: Self = Self(1_000_098_000);
6110}
6111impl ExtDiscardRectanglesFn {
6112 pub const fn name() -> &'static ::std::ffi::CStr {
6113 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_discard_rectangles\0") }
6114 }
6115 pub const SPEC_VERSION: u32 = 1u32;
6116}
6117#[allow(non_camel_case_types)]
6118pub type PFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(
6119 command_buffer: CommandBuffer,
6120 first_discard_rectangle: u32,
6121 discard_rectangle_count: u32,
6122 p_discard_rectangles: *const Rect2D,
6123);
6124#[derive(Clone)]
6125pub struct ExtDiscardRectanglesFn {
6126 pub cmd_set_discard_rectangle_ext: PFN_vkCmdSetDiscardRectangleEXT,
6127}
6128unsafe impl Send for ExtDiscardRectanglesFn {}
6129unsafe impl Sync for ExtDiscardRectanglesFn {}
6130impl ExtDiscardRectanglesFn {
6131 pub fn load<F>(mut _f: F) -> Self
6132 where
6133 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6134 {
6135 Self {
6136 cmd_set_discard_rectangle_ext: unsafe {
6137 unsafe extern "system" fn cmd_set_discard_rectangle_ext(
6138 _command_buffer: CommandBuffer,
6139 _first_discard_rectangle: u32,
6140 _discard_rectangle_count: u32,
6141 _p_discard_rectangles: *const Rect2D,
6142 ) {
6143 panic!(concat!(
6144 "Unable to load ",
6145 stringify!(cmd_set_discard_rectangle_ext)
6146 ))
6147 }
6148 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6149 b"vkCmdSetDiscardRectangleEXT\0",
6150 );
6151 let val = _f(cname);
6152 if val.is_null() {
6153 cmd_set_discard_rectangle_ext
6154 } else {
6155 ::std::mem::transmute(val)
6156 }
6157 },
6158 }
6159 }
6160}
6161#[doc = "Generated from 'VK_EXT_discard_rectangles'"]
6162impl DynamicState {
6163 pub const DISCARD_RECTANGLE_EXT: Self = Self(1_000_099_000);
6164}
6165#[doc = "Generated from 'VK_EXT_discard_rectangles'"]
6166impl StructureType {
6167 pub const PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: Self = Self(1_000_099_000);
6168 pub const PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: Self = Self(1_000_099_001);
6169}
6170impl NvExtension101Fn {
6171 pub const fn name() -> &'static ::std::ffi::CStr {
6172 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_101\0") }
6173 }
6174 pub const SPEC_VERSION: u32 = 0u32;
6175}
6176#[derive(Clone)]
6177pub struct NvExtension101Fn {}
6178unsafe impl Send for NvExtension101Fn {}
6179unsafe impl Sync for NvExtension101Fn {}
6180impl NvExtension101Fn {
6181 pub fn load<F>(mut _f: F) -> Self
6182 where
6183 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6184 {
6185 Self {}
6186 }
6187}
6188impl ExtConservativeRasterizationFn {
6189 pub const fn name() -> &'static ::std::ffi::CStr {
6190 unsafe {
6191 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_conservative_rasterization\0")
6192 }
6193 }
6194 pub const SPEC_VERSION: u32 = 1u32;
6195}
6196#[derive(Clone)]
6197pub struct ExtConservativeRasterizationFn {}
6198unsafe impl Send for ExtConservativeRasterizationFn {}
6199unsafe impl Sync for ExtConservativeRasterizationFn {}
6200impl ExtConservativeRasterizationFn {
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_EXT_conservative_rasterization'"]
6209impl StructureType {
6210 pub const PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_101_000);
6211 pub const PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: Self = Self(1_000_101_001);
6212}
6213impl ExtDepthClipEnableFn {
6214 pub const fn name() -> &'static ::std::ffi::CStr {
6215 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_enable\0") }
6216 }
6217 pub const SPEC_VERSION: u32 = 1u32;
6218}
6219#[derive(Clone)]
6220pub struct ExtDepthClipEnableFn {}
6221unsafe impl Send for ExtDepthClipEnableFn {}
6222unsafe impl Sync for ExtDepthClipEnableFn {}
6223impl ExtDepthClipEnableFn {
6224 pub fn load<F>(mut _f: F) -> Self
6225 where
6226 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6227 {
6228 Self {}
6229 }
6230}
6231#[doc = "Generated from 'VK_EXT_depth_clip_enable'"]
6232impl StructureType {
6233 pub const PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: Self = Self(1_000_102_000);
6234 pub const PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: Self = Self(1_000_102_001);
6235}
6236impl NvExtension104Fn {
6237 pub const fn name() -> &'static ::std::ffi::CStr {
6238 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_104\0") }
6239 }
6240 pub const SPEC_VERSION: u32 = 0u32;
6241}
6242#[derive(Clone)]
6243pub struct NvExtension104Fn {}
6244unsafe impl Send for NvExtension104Fn {}
6245unsafe impl Sync for NvExtension104Fn {}
6246impl NvExtension104Fn {
6247 pub fn load<F>(mut _f: F) -> Self
6248 where
6249 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6250 {
6251 Self {}
6252 }
6253}
6254impl ExtSwapchainColorspaceFn {
6255 pub const fn name() -> &'static ::std::ffi::CStr {
6256 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_swapchain_colorspace\0") }
6257 }
6258 pub const SPEC_VERSION: u32 = 4u32;
6259}
6260#[derive(Clone)]
6261pub struct ExtSwapchainColorspaceFn {}
6262unsafe impl Send for ExtSwapchainColorspaceFn {}
6263unsafe impl Sync for ExtSwapchainColorspaceFn {}
6264impl ExtSwapchainColorspaceFn {
6265 pub fn load<F>(mut _f: F) -> Self
6266 where
6267 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6268 {
6269 Self {}
6270 }
6271}
6272#[doc = "Generated from 'VK_EXT_swapchain_colorspace'"]
6273impl ColorSpaceKHR {
6274 pub const DISPLAY_P3_NONLINEAR_EXT: Self = Self(1_000_104_001);
6275 pub const EXTENDED_SRGB_LINEAR_EXT: Self = Self(1_000_104_002);
6276 pub const DISPLAY_P3_LINEAR_EXT: Self = Self(1_000_104_003);
6277 pub const DCI_P3_NONLINEAR_EXT: Self = Self(1_000_104_004);
6278 pub const BT709_LINEAR_EXT: Self = Self(1_000_104_005);
6279 pub const BT709_NONLINEAR_EXT: Self = Self(1_000_104_006);
6280 pub const BT2020_LINEAR_EXT: Self = Self(1_000_104_007);
6281 pub const HDR10_ST2084_EXT: Self = Self(1_000_104_008);
6282 pub const DOLBYVISION_EXT: Self = Self(1_000_104_009);
6283 pub const HDR10_HLG_EXT: Self = Self(1_000_104_010);
6284 pub const ADOBERGB_LINEAR_EXT: Self = Self(1_000_104_011);
6285 pub const ADOBERGB_NONLINEAR_EXT: Self = Self(1_000_104_012);
6286 pub const PASS_THROUGH_EXT: Self = Self(1_000_104_013);
6287 pub const EXTENDED_SRGB_NONLINEAR_EXT: Self = Self(1_000_104_014);
6288}
6289impl ExtHdrMetadataFn {
6290 pub const fn name() -> &'static ::std::ffi::CStr {
6291 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_hdr_metadata\0") }
6292 }
6293 pub const SPEC_VERSION: u32 = 2u32;
6294}
6295#[allow(non_camel_case_types)]
6296pub type PFN_vkSetHdrMetadataEXT = unsafe extern "system" fn(
6297 device: Device,
6298 swapchain_count: u32,
6299 p_swapchains: *const SwapchainKHR,
6300 p_metadata: *const HdrMetadataEXT,
6301);
6302#[derive(Clone)]
6303pub struct ExtHdrMetadataFn {
6304 pub set_hdr_metadata_ext: PFN_vkSetHdrMetadataEXT,
6305}
6306unsafe impl Send for ExtHdrMetadataFn {}
6307unsafe impl Sync for ExtHdrMetadataFn {}
6308impl ExtHdrMetadataFn {
6309 pub fn load<F>(mut _f: F) -> Self
6310 where
6311 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6312 {
6313 Self {
6314 set_hdr_metadata_ext: unsafe {
6315 unsafe extern "system" fn set_hdr_metadata_ext(
6316 _device: Device,
6317 _swapchain_count: u32,
6318 _p_swapchains: *const SwapchainKHR,
6319 _p_metadata: *const HdrMetadataEXT,
6320 ) {
6321 panic!(concat!("Unable to load ", stringify!(set_hdr_metadata_ext)))
6322 }
6323 let cname =
6324 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetHdrMetadataEXT\0");
6325 let val = _f(cname);
6326 if val.is_null() {
6327 set_hdr_metadata_ext
6328 } else {
6329 ::std::mem::transmute(val)
6330 }
6331 },
6332 }
6333 }
6334}
6335#[doc = "Generated from 'VK_EXT_hdr_metadata'"]
6336impl StructureType {
6337 pub const HDR_METADATA_EXT: Self = Self(1_000_105_000);
6338}
6339impl ImgExtension107Fn {
6340 pub const fn name() -> &'static ::std::ffi::CStr {
6341 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_107\0") }
6342 }
6343 pub const SPEC_VERSION: u32 = 0u32;
6344}
6345#[derive(Clone)]
6346pub struct ImgExtension107Fn {}
6347unsafe impl Send for ImgExtension107Fn {}
6348unsafe impl Sync for ImgExtension107Fn {}
6349impl ImgExtension107Fn {
6350 pub fn load<F>(mut _f: F) -> Self
6351 where
6352 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6353 {
6354 Self {}
6355 }
6356}
6357impl ImgExtension108Fn {
6358 pub const fn name() -> &'static ::std::ffi::CStr {
6359 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_108\0") }
6360 }
6361 pub const SPEC_VERSION: u32 = 0u32;
6362}
6363#[derive(Clone)]
6364pub struct ImgExtension108Fn {}
6365unsafe impl Send for ImgExtension108Fn {}
6366unsafe impl Sync for ImgExtension108Fn {}
6367impl ImgExtension108Fn {
6368 pub fn load<F>(mut _f: F) -> Self
6369 where
6370 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6371 {
6372 Self {}
6373 }
6374}
6375impl KhrImagelessFramebufferFn {
6376 pub const fn name() -> &'static ::std::ffi::CStr {
6377 unsafe {
6378 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_imageless_framebuffer\0")
6379 }
6380 }
6381 pub const SPEC_VERSION: u32 = 1u32;
6382}
6383#[derive(Clone)]
6384pub struct KhrImagelessFramebufferFn {}
6385unsafe impl Send for KhrImagelessFramebufferFn {}
6386unsafe impl Sync for KhrImagelessFramebufferFn {}
6387impl KhrImagelessFramebufferFn {
6388 pub fn load<F>(mut _f: F) -> Self
6389 where
6390 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6391 {
6392 Self {}
6393 }
6394}
6395#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
6396impl FramebufferCreateFlags {
6397 pub const IMAGELESS_KHR: Self = Self::IMAGELESS;
6398}
6399#[doc = "Generated from 'VK_KHR_imageless_framebuffer'"]
6400impl StructureType {
6401 pub const PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: Self =
6402 Self::PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
6403 pub const FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: Self =
6404 Self::FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
6405 pub const FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: Self = Self::FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
6406 pub const RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: Self = Self::RENDER_PASS_ATTACHMENT_BEGIN_INFO;
6407}
6408impl KhrCreateRenderpass2Fn {
6409 pub const fn name() -> &'static ::std::ffi::CStr {
6410 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_create_renderpass2\0") }
6411 }
6412 pub const SPEC_VERSION: u32 = 1u32;
6413}
6414#[allow(non_camel_case_types)]
6415pub type PFN_vkCreateRenderPass2 = unsafe extern "system" fn(
6416 device: Device,
6417 p_create_info: *const RenderPassCreateInfo2,
6418 p_allocator: *const AllocationCallbacks,
6419 p_render_pass: *mut RenderPass,
6420) -> Result;
6421#[allow(non_camel_case_types)]
6422pub type PFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn(
6423 command_buffer: CommandBuffer,
6424 p_render_pass_begin: *const RenderPassBeginInfo,
6425 p_subpass_begin_info: *const SubpassBeginInfo,
6426);
6427#[allow(non_camel_case_types)]
6428pub type PFN_vkCmdNextSubpass2 = unsafe extern "system" fn(
6429 command_buffer: CommandBuffer,
6430 p_subpass_begin_info: *const SubpassBeginInfo,
6431 p_subpass_end_info: *const SubpassEndInfo,
6432);
6433#[allow(non_camel_case_types)]
6434pub type PFN_vkCmdEndRenderPass2 = unsafe extern "system" fn(
6435 command_buffer: CommandBuffer,
6436 p_subpass_end_info: *const SubpassEndInfo,
6437);
6438#[derive(Clone)]
6439pub struct KhrCreateRenderpass2Fn {
6440 pub create_render_pass2_khr: PFN_vkCreateRenderPass2,
6441 pub cmd_begin_render_pass2_khr: PFN_vkCmdBeginRenderPass2,
6442 pub cmd_next_subpass2_khr: PFN_vkCmdNextSubpass2,
6443 pub cmd_end_render_pass2_khr: PFN_vkCmdEndRenderPass2,
6444}
6445unsafe impl Send for KhrCreateRenderpass2Fn {}
6446unsafe impl Sync for KhrCreateRenderpass2Fn {}
6447impl KhrCreateRenderpass2Fn {
6448 pub fn load<F>(mut _f: F) -> Self
6449 where
6450 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6451 {
6452 Self {
6453 create_render_pass2_khr: unsafe {
6454 unsafe extern "system" fn create_render_pass2_khr(
6455 _device: Device,
6456 _p_create_info: *const RenderPassCreateInfo2,
6457 _p_allocator: *const AllocationCallbacks,
6458 _p_render_pass: *mut RenderPass,
6459 ) -> Result {
6460 panic!(concat!(
6461 "Unable to load ",
6462 stringify!(create_render_pass2_khr)
6463 ))
6464 }
6465 let cname =
6466 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateRenderPass2KHR\0");
6467 let val = _f(cname);
6468 if val.is_null() {
6469 create_render_pass2_khr
6470 } else {
6471 ::std::mem::transmute(val)
6472 }
6473 },
6474 cmd_begin_render_pass2_khr: unsafe {
6475 unsafe extern "system" fn cmd_begin_render_pass2_khr(
6476 _command_buffer: CommandBuffer,
6477 _p_render_pass_begin: *const RenderPassBeginInfo,
6478 _p_subpass_begin_info: *const SubpassBeginInfo,
6479 ) {
6480 panic!(concat!(
6481 "Unable to load ",
6482 stringify!(cmd_begin_render_pass2_khr)
6483 ))
6484 }
6485 let cname =
6486 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBeginRenderPass2KHR\0");
6487 let val = _f(cname);
6488 if val.is_null() {
6489 cmd_begin_render_pass2_khr
6490 } else {
6491 ::std::mem::transmute(val)
6492 }
6493 },
6494 cmd_next_subpass2_khr: unsafe {
6495 unsafe extern "system" fn cmd_next_subpass2_khr(
6496 _command_buffer: CommandBuffer,
6497 _p_subpass_begin_info: *const SubpassBeginInfo,
6498 _p_subpass_end_info: *const SubpassEndInfo,
6499 ) {
6500 panic!(concat!(
6501 "Unable to load ",
6502 stringify!(cmd_next_subpass2_khr)
6503 ))
6504 }
6505 let cname =
6506 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdNextSubpass2KHR\0");
6507 let val = _f(cname);
6508 if val.is_null() {
6509 cmd_next_subpass2_khr
6510 } else {
6511 ::std::mem::transmute(val)
6512 }
6513 },
6514 cmd_end_render_pass2_khr: unsafe {
6515 unsafe extern "system" fn cmd_end_render_pass2_khr(
6516 _command_buffer: CommandBuffer,
6517 _p_subpass_end_info: *const SubpassEndInfo,
6518 ) {
6519 panic!(concat!(
6520 "Unable to load ",
6521 stringify!(cmd_end_render_pass2_khr)
6522 ))
6523 }
6524 let cname =
6525 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEndRenderPass2KHR\0");
6526 let val = _f(cname);
6527 if val.is_null() {
6528 cmd_end_render_pass2_khr
6529 } else {
6530 ::std::mem::transmute(val)
6531 }
6532 },
6533 }
6534 }
6535}
6536#[doc = "Generated from 'VK_KHR_create_renderpass2'"]
6537impl StructureType {
6538 pub const ATTACHMENT_DESCRIPTION_2_KHR: Self = Self::ATTACHMENT_DESCRIPTION_2;
6539 pub const ATTACHMENT_REFERENCE_2_KHR: Self = Self::ATTACHMENT_REFERENCE_2;
6540 pub const SUBPASS_DESCRIPTION_2_KHR: Self = Self::SUBPASS_DESCRIPTION_2;
6541 pub const SUBPASS_DEPENDENCY_2_KHR: Self = Self::SUBPASS_DEPENDENCY_2;
6542 pub const RENDER_PASS_CREATE_INFO_2_KHR: Self = Self::RENDER_PASS_CREATE_INFO_2;
6543 pub const SUBPASS_BEGIN_INFO_KHR: Self = Self::SUBPASS_BEGIN_INFO;
6544 pub const SUBPASS_END_INFO_KHR: Self = Self::SUBPASS_END_INFO;
6545}
6546impl ImgExtension111Fn {
6547 pub const fn name() -> &'static ::std::ffi::CStr {
6548 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_IMG_extension_111\0") }
6549 }
6550 pub const SPEC_VERSION: u32 = 0u32;
6551}
6552#[derive(Clone)]
6553pub struct ImgExtension111Fn {}
6554unsafe impl Send for ImgExtension111Fn {}
6555unsafe impl Sync for ImgExtension111Fn {}
6556impl ImgExtension111Fn {
6557 pub fn load<F>(mut _f: F) -> Self
6558 where
6559 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6560 {
6561 Self {}
6562 }
6563}
6564impl KhrSharedPresentableImageFn {
6565 pub const fn name() -> &'static ::std::ffi::CStr {
6566 unsafe {
6567 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shared_presentable_image\0")
6568 }
6569 }
6570 pub const SPEC_VERSION: u32 = 1u32;
6571}
6572#[allow(non_camel_case_types)]
6573pub type PFN_vkGetSwapchainStatusKHR =
6574 unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result;
6575#[derive(Clone)]
6576pub struct KhrSharedPresentableImageFn {
6577 pub get_swapchain_status_khr: PFN_vkGetSwapchainStatusKHR,
6578}
6579unsafe impl Send for KhrSharedPresentableImageFn {}
6580unsafe impl Sync for KhrSharedPresentableImageFn {}
6581impl KhrSharedPresentableImageFn {
6582 pub fn load<F>(mut _f: F) -> Self
6583 where
6584 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6585 {
6586 Self {
6587 get_swapchain_status_khr: unsafe {
6588 unsafe extern "system" fn get_swapchain_status_khr(
6589 _device: Device,
6590 _swapchain: SwapchainKHR,
6591 ) -> Result {
6592 panic!(concat!(
6593 "Unable to load ",
6594 stringify!(get_swapchain_status_khr)
6595 ))
6596 }
6597 let cname =
6598 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetSwapchainStatusKHR\0");
6599 let val = _f(cname);
6600 if val.is_null() {
6601 get_swapchain_status_khr
6602 } else {
6603 ::std::mem::transmute(val)
6604 }
6605 },
6606 }
6607 }
6608}
6609#[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
6610impl ImageLayout {
6611 pub const SHARED_PRESENT_KHR: Self = Self(1_000_111_000);
6612}
6613#[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
6614impl PresentModeKHR {
6615 pub const SHARED_DEMAND_REFRESH: Self = Self(1_000_111_000);
6616 pub const SHARED_CONTINUOUS_REFRESH: Self = Self(1_000_111_001);
6617}
6618#[doc = "Generated from 'VK_KHR_shared_presentable_image'"]
6619impl StructureType {
6620 pub const SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: Self = Self(1_000_111_000);
6621}
6622impl KhrExternalFenceCapabilitiesFn {
6623 pub const fn name() -> &'static ::std::ffi::CStr {
6624 unsafe {
6625 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_capabilities\0")
6626 }
6627 }
6628 pub const SPEC_VERSION: u32 = 1u32;
6629}
6630#[allow(non_camel_case_types)]
6631pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn(
6632 physical_device: PhysicalDevice,
6633 p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
6634 p_external_fence_properties: *mut ExternalFenceProperties,
6635);
6636#[derive(Clone)]
6637pub struct KhrExternalFenceCapabilitiesFn {
6638 pub get_physical_device_external_fence_properties_khr:
6639 PFN_vkGetPhysicalDeviceExternalFenceProperties,
6640}
6641unsafe impl Send for KhrExternalFenceCapabilitiesFn {}
6642unsafe impl Sync for KhrExternalFenceCapabilitiesFn {}
6643impl KhrExternalFenceCapabilitiesFn {
6644 pub fn load<F>(mut _f: F) -> Self
6645 where
6646 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6647 {
6648 Self {
6649 get_physical_device_external_fence_properties_khr: unsafe {
6650 unsafe extern "system" fn get_physical_device_external_fence_properties_khr(
6651 _physical_device: PhysicalDevice,
6652 _p_external_fence_info: *const PhysicalDeviceExternalFenceInfo,
6653 _p_external_fence_properties: *mut ExternalFenceProperties,
6654 ) {
6655 panic!(concat!(
6656 "Unable to load ",
6657 stringify!(get_physical_device_external_fence_properties_khr)
6658 ))
6659 }
6660 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6661 b"vkGetPhysicalDeviceExternalFencePropertiesKHR\0",
6662 );
6663 let val = _f(cname);
6664 if val.is_null() {
6665 get_physical_device_external_fence_properties_khr
6666 } else {
6667 ::std::mem::transmute(val)
6668 }
6669 },
6670 }
6671 }
6672}
6673#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
6674impl ExternalFenceFeatureFlags {
6675 pub const EXPORTABLE_KHR: Self = Self::EXPORTABLE;
6676 pub const IMPORTABLE_KHR: Self = Self::IMPORTABLE;
6677}
6678#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
6679impl ExternalFenceHandleTypeFlags {
6680 pub const OPAQUE_FD_KHR: Self = Self::OPAQUE_FD;
6681 pub const OPAQUE_WIN32_KHR: Self = Self::OPAQUE_WIN32;
6682 pub const OPAQUE_WIN32_KMT_KHR: Self = Self::OPAQUE_WIN32_KMT;
6683 pub const SYNC_FD_KHR: Self = Self::SYNC_FD;
6684}
6685#[doc = "Generated from 'VK_KHR_external_fence_capabilities'"]
6686impl StructureType {
6687 pub const PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: Self =
6688 Self::PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
6689 pub const EXTERNAL_FENCE_PROPERTIES_KHR: Self = Self::EXTERNAL_FENCE_PROPERTIES;
6690}
6691impl KhrExternalFenceFn {
6692 pub const fn name() -> &'static ::std::ffi::CStr {
6693 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence\0") }
6694 }
6695 pub const SPEC_VERSION: u32 = 1u32;
6696}
6697#[derive(Clone)]
6698pub struct KhrExternalFenceFn {}
6699unsafe impl Send for KhrExternalFenceFn {}
6700unsafe impl Sync for KhrExternalFenceFn {}
6701impl KhrExternalFenceFn {
6702 pub fn load<F>(mut _f: F) -> Self
6703 where
6704 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6705 {
6706 Self {}
6707 }
6708}
6709#[doc = "Generated from 'VK_KHR_external_fence'"]
6710impl FenceImportFlags {
6711 pub const TEMPORARY_KHR: Self = Self::TEMPORARY;
6712}
6713#[doc = "Generated from 'VK_KHR_external_fence'"]
6714impl StructureType {
6715 pub const EXPORT_FENCE_CREATE_INFO_KHR: Self = Self::EXPORT_FENCE_CREATE_INFO;
6716}
6717impl KhrExternalFenceWin32Fn {
6718 pub const fn name() -> &'static ::std::ffi::CStr {
6719 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_win32\0") }
6720 }
6721 pub const SPEC_VERSION: u32 = 1u32;
6722}
6723#[allow(non_camel_case_types)]
6724pub type PFN_vkImportFenceWin32HandleKHR = unsafe extern "system" fn(
6725 device: Device,
6726 p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR,
6727) -> Result;
6728#[allow(non_camel_case_types)]
6729pub type PFN_vkGetFenceWin32HandleKHR = unsafe extern "system" fn(
6730 device: Device,
6731 p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR,
6732 p_handle: *mut HANDLE,
6733) -> Result;
6734#[derive(Clone)]
6735pub struct KhrExternalFenceWin32Fn {
6736 pub import_fence_win32_handle_khr: PFN_vkImportFenceWin32HandleKHR,
6737 pub get_fence_win32_handle_khr: PFN_vkGetFenceWin32HandleKHR,
6738}
6739unsafe impl Send for KhrExternalFenceWin32Fn {}
6740unsafe impl Sync for KhrExternalFenceWin32Fn {}
6741impl KhrExternalFenceWin32Fn {
6742 pub fn load<F>(mut _f: F) -> Self
6743 where
6744 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6745 {
6746 Self {
6747 import_fence_win32_handle_khr: unsafe {
6748 unsafe extern "system" fn import_fence_win32_handle_khr(
6749 _device: Device,
6750 _p_import_fence_win32_handle_info: *const ImportFenceWin32HandleInfoKHR,
6751 ) -> Result {
6752 panic!(concat!(
6753 "Unable to load ",
6754 stringify!(import_fence_win32_handle_khr)
6755 ))
6756 }
6757 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6758 b"vkImportFenceWin32HandleKHR\0",
6759 );
6760 let val = _f(cname);
6761 if val.is_null() {
6762 import_fence_win32_handle_khr
6763 } else {
6764 ::std::mem::transmute(val)
6765 }
6766 },
6767 get_fence_win32_handle_khr: unsafe {
6768 unsafe extern "system" fn get_fence_win32_handle_khr(
6769 _device: Device,
6770 _p_get_win32_handle_info: *const FenceGetWin32HandleInfoKHR,
6771 _p_handle: *mut HANDLE,
6772 ) -> Result {
6773 panic!(concat!(
6774 "Unable to load ",
6775 stringify!(get_fence_win32_handle_khr)
6776 ))
6777 }
6778 let cname =
6779 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceWin32HandleKHR\0");
6780 let val = _f(cname);
6781 if val.is_null() {
6782 get_fence_win32_handle_khr
6783 } else {
6784 ::std::mem::transmute(val)
6785 }
6786 },
6787 }
6788 }
6789}
6790#[doc = "Generated from 'VK_KHR_external_fence_win32'"]
6791impl StructureType {
6792 pub const IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_000);
6793 pub const EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_001);
6794 pub const FENCE_GET_WIN32_HANDLE_INFO_KHR: Self = Self(1_000_114_002);
6795}
6796impl KhrExternalFenceFdFn {
6797 pub const fn name() -> &'static ::std::ffi::CStr {
6798 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_external_fence_fd\0") }
6799 }
6800 pub const SPEC_VERSION: u32 = 1u32;
6801}
6802#[allow(non_camel_case_types)]
6803pub type PFN_vkImportFenceFdKHR = unsafe extern "system" fn(
6804 device: Device,
6805 p_import_fence_fd_info: *const ImportFenceFdInfoKHR,
6806) -> Result;
6807#[allow(non_camel_case_types)]
6808pub type PFN_vkGetFenceFdKHR = unsafe extern "system" fn(
6809 device: Device,
6810 p_get_fd_info: *const FenceGetFdInfoKHR,
6811 p_fd: *mut c_int,
6812) -> Result;
6813#[derive(Clone)]
6814pub struct KhrExternalFenceFdFn {
6815 pub import_fence_fd_khr: PFN_vkImportFenceFdKHR,
6816 pub get_fence_fd_khr: PFN_vkGetFenceFdKHR,
6817}
6818unsafe impl Send for KhrExternalFenceFdFn {}
6819unsafe impl Sync for KhrExternalFenceFdFn {}
6820impl KhrExternalFenceFdFn {
6821 pub fn load<F>(mut _f: F) -> Self
6822 where
6823 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6824 {
6825 Self {
6826 import_fence_fd_khr: unsafe {
6827 unsafe extern "system" fn import_fence_fd_khr(
6828 _device: Device,
6829 _p_import_fence_fd_info: *const ImportFenceFdInfoKHR,
6830 ) -> Result {
6831 panic!(concat!("Unable to load ", stringify!(import_fence_fd_khr)))
6832 }
6833 let cname =
6834 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkImportFenceFdKHR\0");
6835 let val = _f(cname);
6836 if val.is_null() {
6837 import_fence_fd_khr
6838 } else {
6839 ::std::mem::transmute(val)
6840 }
6841 },
6842 get_fence_fd_khr: unsafe {
6843 unsafe extern "system" fn get_fence_fd_khr(
6844 _device: Device,
6845 _p_get_fd_info: *const FenceGetFdInfoKHR,
6846 _p_fd: *mut c_int,
6847 ) -> Result {
6848 panic!(concat!("Unable to load ", stringify!(get_fence_fd_khr)))
6849 }
6850 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetFenceFdKHR\0");
6851 let val = _f(cname);
6852 if val.is_null() {
6853 get_fence_fd_khr
6854 } else {
6855 ::std::mem::transmute(val)
6856 }
6857 },
6858 }
6859 }
6860}
6861#[doc = "Generated from 'VK_KHR_external_fence_fd'"]
6862impl StructureType {
6863 pub const IMPORT_FENCE_FD_INFO_KHR: Self = Self(1_000_115_000);
6864 pub const FENCE_GET_FD_INFO_KHR: Self = Self(1_000_115_001);
6865}
6866impl KhrPerformanceQueryFn {
6867 pub const fn name() -> &'static ::std::ffi::CStr {
6868 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_performance_query\0") }
6869 }
6870 pub const SPEC_VERSION: u32 = 1u32;
6871}
6872#[allow(non_camel_case_types)]
6873pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR =
6874 unsafe extern "system" fn(
6875 physical_device: PhysicalDevice,
6876 queue_family_index: u32,
6877 p_counter_count: *mut u32,
6878 p_counters: *mut PerformanceCounterKHR,
6879 p_counter_descriptions: *mut PerformanceCounterDescriptionKHR,
6880 ) -> Result;
6881#[allow(non_camel_case_types)]
6882pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR =
6883 unsafe extern "system" fn(
6884 physical_device: PhysicalDevice,
6885 p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR,
6886 p_num_passes: *mut u32,
6887 );
6888#[allow(non_camel_case_types)]
6889pub type PFN_vkAcquireProfilingLockKHR =
6890 unsafe extern "system" fn(device: Device, p_info: *const AcquireProfilingLockInfoKHR) -> Result;
6891#[allow(non_camel_case_types)]
6892pub type PFN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: Device);
6893#[derive(Clone)]
6894pub struct KhrPerformanceQueryFn {
6895 pub enumerate_physical_device_queue_family_performance_query_counters_khr:
6896 PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR,
6897 pub get_physical_device_queue_family_performance_query_passes_khr:
6898 PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR,
6899 pub acquire_profiling_lock_khr: PFN_vkAcquireProfilingLockKHR,
6900 pub release_profiling_lock_khr: PFN_vkReleaseProfilingLockKHR,
6901}
6902unsafe impl Send for KhrPerformanceQueryFn {}
6903unsafe impl Sync for KhrPerformanceQueryFn {}
6904impl KhrPerformanceQueryFn {
6905 pub fn load<F>(mut _f: F) -> Self
6906 where
6907 F: FnMut(&::std::ffi::CStr) -> *const c_void,
6908 {
6909 Self {
6910 enumerate_physical_device_queue_family_performance_query_counters_khr: unsafe {
6911 unsafe extern "system" fn enumerate_physical_device_queue_family_performance_query_counters_khr(
6912 _physical_device: PhysicalDevice,
6913 _queue_family_index: u32,
6914 _p_counter_count: *mut u32,
6915 _p_counters: *mut PerformanceCounterKHR,
6916 _p_counter_descriptions: *mut PerformanceCounterDescriptionKHR,
6917 ) -> Result {
6918 panic!(concat!(
6919 "Unable to load ",
6920 stringify!(
6921 enumerate_physical_device_queue_family_performance_query_counters_khr
6922 )
6923 ))
6924 }
6925 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6926 b"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR\0",
6927 );
6928 let val = _f(cname);
6929 if val.is_null() {
6930 enumerate_physical_device_queue_family_performance_query_counters_khr
6931 } else {
6932 ::std::mem::transmute(val)
6933 }
6934 },
6935 get_physical_device_queue_family_performance_query_passes_khr: unsafe {
6936 unsafe extern "system" fn get_physical_device_queue_family_performance_query_passes_khr(
6937 _physical_device: PhysicalDevice,
6938 _p_performance_query_create_info: *const QueryPoolPerformanceCreateInfoKHR,
6939 _p_num_passes: *mut u32,
6940 ) {
6941 panic!(concat!(
6942 "Unable to load ",
6943 stringify!(get_physical_device_queue_family_performance_query_passes_khr)
6944 ))
6945 }
6946 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
6947 b"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR\0",
6948 );
6949 let val = _f(cname);
6950 if val.is_null() {
6951 get_physical_device_queue_family_performance_query_passes_khr
6952 } else {
6953 ::std::mem::transmute(val)
6954 }
6955 },
6956 acquire_profiling_lock_khr: unsafe {
6957 unsafe extern "system" fn acquire_profiling_lock_khr(
6958 _device: Device,
6959 _p_info: *const AcquireProfilingLockInfoKHR,
6960 ) -> Result {
6961 panic!(concat!(
6962 "Unable to load ",
6963 stringify!(acquire_profiling_lock_khr)
6964 ))
6965 }
6966 let cname =
6967 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireProfilingLockKHR\0");
6968 let val = _f(cname);
6969 if val.is_null() {
6970 acquire_profiling_lock_khr
6971 } else {
6972 ::std::mem::transmute(val)
6973 }
6974 },
6975 release_profiling_lock_khr: unsafe {
6976 unsafe extern "system" fn release_profiling_lock_khr(_device: Device) {
6977 panic!(concat!(
6978 "Unable to load ",
6979 stringify!(release_profiling_lock_khr)
6980 ))
6981 }
6982 let cname =
6983 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkReleaseProfilingLockKHR\0");
6984 let val = _f(cname);
6985 if val.is_null() {
6986 release_profiling_lock_khr
6987 } else {
6988 ::std::mem::transmute(val)
6989 }
6990 },
6991 }
6992 }
6993}
6994#[doc = "Generated from 'VK_KHR_performance_query'"]
6995impl QueryType {
6996 pub const PERFORMANCE_QUERY_KHR: Self = Self(1_000_116_000);
6997}
6998#[doc = "Generated from 'VK_KHR_performance_query'"]
6999impl StructureType {
7000 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: Self = Self(1_000_116_000);
7001 pub const PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: Self = Self(1_000_116_001);
7002 pub const QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: Self = Self(1_000_116_002);
7003 pub const PERFORMANCE_QUERY_SUBMIT_INFO_KHR: Self = Self(1_000_116_003);
7004 pub const ACQUIRE_PROFILING_LOCK_INFO_KHR: Self = Self(1_000_116_004);
7005 pub const PERFORMANCE_COUNTER_KHR: Self = Self(1_000_116_005);
7006 pub const PERFORMANCE_COUNTER_DESCRIPTION_KHR: Self = Self(1_000_116_006);
7007}
7008impl KhrMaintenance2Fn {
7009 pub const fn name() -> &'static ::std::ffi::CStr {
7010 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance2\0") }
7011 }
7012 pub const SPEC_VERSION: u32 = 1u32;
7013}
7014#[derive(Clone)]
7015pub struct KhrMaintenance2Fn {}
7016unsafe impl Send for KhrMaintenance2Fn {}
7017unsafe impl Sync for KhrMaintenance2Fn {}
7018impl KhrMaintenance2Fn {
7019 pub fn load<F>(mut _f: F) -> Self
7020 where
7021 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7022 {
7023 Self {}
7024 }
7025}
7026#[doc = "Generated from 'VK_KHR_maintenance2'"]
7027impl ImageCreateFlags {
7028 pub const BLOCK_TEXEL_VIEW_COMPATIBLE_KHR: Self = Self::BLOCK_TEXEL_VIEW_COMPATIBLE;
7029 pub const EXTENDED_USAGE_KHR: Self = Self::EXTENDED_USAGE;
7030}
7031#[doc = "Generated from 'VK_KHR_maintenance2'"]
7032impl ImageLayout {
7033 pub const DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: Self =
7034 Self::DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
7035 pub const DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: Self =
7036 Self::DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
7037}
7038#[doc = "Generated from 'VK_KHR_maintenance2'"]
7039impl PointClippingBehavior {
7040 pub const ALL_CLIP_PLANES_KHR: Self = Self::ALL_CLIP_PLANES;
7041 pub const USER_CLIP_PLANES_ONLY_KHR: Self = Self::USER_CLIP_PLANES_ONLY;
7042}
7043#[doc = "Generated from 'VK_KHR_maintenance2'"]
7044impl StructureType {
7045 pub const PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: Self =
7046 Self::PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
7047 pub const RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: Self =
7048 Self::RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
7049 pub const IMAGE_VIEW_USAGE_CREATE_INFO_KHR: Self = Self::IMAGE_VIEW_USAGE_CREATE_INFO;
7050 pub const PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: Self =
7051 Self::PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
7052}
7053#[doc = "Generated from 'VK_KHR_maintenance2'"]
7054impl TessellationDomainOrigin {
7055 pub const UPPER_LEFT_KHR: Self = Self::UPPER_LEFT;
7056 pub const LOWER_LEFT_KHR: Self = Self::LOWER_LEFT;
7057}
7058impl KhrExtension119Fn {
7059 pub const fn name() -> &'static ::std::ffi::CStr {
7060 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_119\0") }
7061 }
7062 pub const SPEC_VERSION: u32 = 0u32;
7063}
7064#[derive(Clone)]
7065pub struct KhrExtension119Fn {}
7066unsafe impl Send for KhrExtension119Fn {}
7067unsafe impl Sync for KhrExtension119Fn {}
7068impl KhrExtension119Fn {
7069 pub fn load<F>(mut _f: F) -> Self
7070 where
7071 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7072 {
7073 Self {}
7074 }
7075}
7076impl KhrGetSurfaceCapabilities2Fn {
7077 pub const fn name() -> &'static ::std::ffi::CStr {
7078 unsafe {
7079 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_surface_capabilities2\0")
7080 }
7081 }
7082 pub const SPEC_VERSION: u32 = 1u32;
7083}
7084#[allow(non_camel_case_types)]
7085pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn(
7086 physical_device: PhysicalDevice,
7087 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7088 p_surface_capabilities: *mut SurfaceCapabilities2KHR,
7089) -> Result;
7090#[allow(non_camel_case_types)]
7091pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn(
7092 physical_device: PhysicalDevice,
7093 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7094 p_surface_format_count: *mut u32,
7095 p_surface_formats: *mut SurfaceFormat2KHR,
7096) -> Result;
7097#[derive(Clone)]
7098pub struct KhrGetSurfaceCapabilities2Fn {
7099 pub get_physical_device_surface_capabilities2_khr:
7100 PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR,
7101 pub get_physical_device_surface_formats2_khr: PFN_vkGetPhysicalDeviceSurfaceFormats2KHR,
7102}
7103unsafe impl Send for KhrGetSurfaceCapabilities2Fn {}
7104unsafe impl Sync for KhrGetSurfaceCapabilities2Fn {}
7105impl KhrGetSurfaceCapabilities2Fn {
7106 pub fn load<F>(mut _f: F) -> Self
7107 where
7108 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7109 {
7110 Self {
7111 get_physical_device_surface_capabilities2_khr: unsafe {
7112 unsafe extern "system" fn get_physical_device_surface_capabilities2_khr(
7113 _physical_device: PhysicalDevice,
7114 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7115 _p_surface_capabilities: *mut SurfaceCapabilities2KHR,
7116 ) -> Result {
7117 panic!(concat!(
7118 "Unable to load ",
7119 stringify!(get_physical_device_surface_capabilities2_khr)
7120 ))
7121 }
7122 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7123 b"vkGetPhysicalDeviceSurfaceCapabilities2KHR\0",
7124 );
7125 let val = _f(cname);
7126 if val.is_null() {
7127 get_physical_device_surface_capabilities2_khr
7128 } else {
7129 ::std::mem::transmute(val)
7130 }
7131 },
7132 get_physical_device_surface_formats2_khr: unsafe {
7133 unsafe extern "system" fn get_physical_device_surface_formats2_khr(
7134 _physical_device: PhysicalDevice,
7135 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
7136 _p_surface_format_count: *mut u32,
7137 _p_surface_formats: *mut SurfaceFormat2KHR,
7138 ) -> Result {
7139 panic!(concat!(
7140 "Unable to load ",
7141 stringify!(get_physical_device_surface_formats2_khr)
7142 ))
7143 }
7144 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7145 b"vkGetPhysicalDeviceSurfaceFormats2KHR\0",
7146 );
7147 let val = _f(cname);
7148 if val.is_null() {
7149 get_physical_device_surface_formats2_khr
7150 } else {
7151 ::std::mem::transmute(val)
7152 }
7153 },
7154 }
7155 }
7156}
7157#[doc = "Generated from 'VK_KHR_get_surface_capabilities2'"]
7158impl StructureType {
7159 pub const PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: Self = Self(1_000_119_000);
7160 pub const SURFACE_CAPABILITIES_2_KHR: Self = Self(1_000_119_001);
7161 pub const SURFACE_FORMAT_2_KHR: Self = Self(1_000_119_002);
7162}
7163impl KhrVariablePointersFn {
7164 pub const fn name() -> &'static ::std::ffi::CStr {
7165 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_variable_pointers\0") }
7166 }
7167 pub const SPEC_VERSION: u32 = 1u32;
7168}
7169#[derive(Clone)]
7170pub struct KhrVariablePointersFn {}
7171unsafe impl Send for KhrVariablePointersFn {}
7172unsafe impl Sync for KhrVariablePointersFn {}
7173impl KhrVariablePointersFn {
7174 pub fn load<F>(mut _f: F) -> Self
7175 where
7176 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7177 {
7178 Self {}
7179 }
7180}
7181#[doc = "Generated from 'VK_KHR_variable_pointers'"]
7182impl StructureType {
7183 pub const PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: Self =
7184 Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
7185 pub const PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: Self =
7186 Self::PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
7187}
7188impl KhrGetDisplayProperties2Fn {
7189 pub const fn name() -> &'static ::std::ffi::CStr {
7190 unsafe {
7191 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_display_properties2\0")
7192 }
7193 }
7194 pub const SPEC_VERSION: u32 = 1u32;
7195}
7196#[allow(non_camel_case_types)]
7197pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn(
7198 physical_device: PhysicalDevice,
7199 p_property_count: *mut u32,
7200 p_properties: *mut DisplayProperties2KHR,
7201) -> Result;
7202#[allow(non_camel_case_types)]
7203pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn(
7204 physical_device: PhysicalDevice,
7205 p_property_count: *mut u32,
7206 p_properties: *mut DisplayPlaneProperties2KHR,
7207) -> Result;
7208#[allow(non_camel_case_types)]
7209pub type PFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn(
7210 physical_device: PhysicalDevice,
7211 display: DisplayKHR,
7212 p_property_count: *mut u32,
7213 p_properties: *mut DisplayModeProperties2KHR,
7214) -> Result;
7215#[allow(non_camel_case_types)]
7216pub type PFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn(
7217 physical_device: PhysicalDevice,
7218 p_display_plane_info: *const DisplayPlaneInfo2KHR,
7219 p_capabilities: *mut DisplayPlaneCapabilities2KHR,
7220) -> Result;
7221#[derive(Clone)]
7222pub struct KhrGetDisplayProperties2Fn {
7223 pub get_physical_device_display_properties2_khr: PFN_vkGetPhysicalDeviceDisplayProperties2KHR,
7224 pub get_physical_device_display_plane_properties2_khr:
7225 PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR,
7226 pub get_display_mode_properties2_khr: PFN_vkGetDisplayModeProperties2KHR,
7227 pub get_display_plane_capabilities2_khr: PFN_vkGetDisplayPlaneCapabilities2KHR,
7228}
7229unsafe impl Send for KhrGetDisplayProperties2Fn {}
7230unsafe impl Sync for KhrGetDisplayProperties2Fn {}
7231impl KhrGetDisplayProperties2Fn {
7232 pub fn load<F>(mut _f: F) -> Self
7233 where
7234 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7235 {
7236 Self {
7237 get_physical_device_display_properties2_khr: unsafe {
7238 unsafe extern "system" fn get_physical_device_display_properties2_khr(
7239 _physical_device: PhysicalDevice,
7240 _p_property_count: *mut u32,
7241 _p_properties: *mut DisplayProperties2KHR,
7242 ) -> Result {
7243 panic!(concat!(
7244 "Unable to load ",
7245 stringify!(get_physical_device_display_properties2_khr)
7246 ))
7247 }
7248 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7249 b"vkGetPhysicalDeviceDisplayProperties2KHR\0",
7250 );
7251 let val = _f(cname);
7252 if val.is_null() {
7253 get_physical_device_display_properties2_khr
7254 } else {
7255 ::std::mem::transmute(val)
7256 }
7257 },
7258 get_physical_device_display_plane_properties2_khr: unsafe {
7259 unsafe extern "system" fn get_physical_device_display_plane_properties2_khr(
7260 _physical_device: PhysicalDevice,
7261 _p_property_count: *mut u32,
7262 _p_properties: *mut DisplayPlaneProperties2KHR,
7263 ) -> Result {
7264 panic!(concat!(
7265 "Unable to load ",
7266 stringify!(get_physical_device_display_plane_properties2_khr)
7267 ))
7268 }
7269 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7270 b"vkGetPhysicalDeviceDisplayPlaneProperties2KHR\0",
7271 );
7272 let val = _f(cname);
7273 if val.is_null() {
7274 get_physical_device_display_plane_properties2_khr
7275 } else {
7276 ::std::mem::transmute(val)
7277 }
7278 },
7279 get_display_mode_properties2_khr: unsafe {
7280 unsafe extern "system" fn get_display_mode_properties2_khr(
7281 _physical_device: PhysicalDevice,
7282 _display: DisplayKHR,
7283 _p_property_count: *mut u32,
7284 _p_properties: *mut DisplayModeProperties2KHR,
7285 ) -> Result {
7286 panic!(concat!(
7287 "Unable to load ",
7288 stringify!(get_display_mode_properties2_khr)
7289 ))
7290 }
7291 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7292 b"vkGetDisplayModeProperties2KHR\0",
7293 );
7294 let val = _f(cname);
7295 if val.is_null() {
7296 get_display_mode_properties2_khr
7297 } else {
7298 ::std::mem::transmute(val)
7299 }
7300 },
7301 get_display_plane_capabilities2_khr: unsafe {
7302 unsafe extern "system" fn get_display_plane_capabilities2_khr(
7303 _physical_device: PhysicalDevice,
7304 _p_display_plane_info: *const DisplayPlaneInfo2KHR,
7305 _p_capabilities: *mut DisplayPlaneCapabilities2KHR,
7306 ) -> Result {
7307 panic!(concat!(
7308 "Unable to load ",
7309 stringify!(get_display_plane_capabilities2_khr)
7310 ))
7311 }
7312 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7313 b"vkGetDisplayPlaneCapabilities2KHR\0",
7314 );
7315 let val = _f(cname);
7316 if val.is_null() {
7317 get_display_plane_capabilities2_khr
7318 } else {
7319 ::std::mem::transmute(val)
7320 }
7321 },
7322 }
7323 }
7324}
7325#[doc = "Generated from 'VK_KHR_get_display_properties2'"]
7326impl StructureType {
7327 pub const DISPLAY_PROPERTIES_2_KHR: Self = Self(1_000_121_000);
7328 pub const DISPLAY_PLANE_PROPERTIES_2_KHR: Self = Self(1_000_121_001);
7329 pub const DISPLAY_MODE_PROPERTIES_2_KHR: Self = Self(1_000_121_002);
7330 pub const DISPLAY_PLANE_INFO_2_KHR: Self = Self(1_000_121_003);
7331 pub const DISPLAY_PLANE_CAPABILITIES_2_KHR: Self = Self(1_000_121_004);
7332}
7333impl MvkIosSurfaceFn {
7334 pub const fn name() -> &'static ::std::ffi::CStr {
7335 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_ios_surface\0") }
7336 }
7337 pub const SPEC_VERSION: u32 = 3u32;
7338}
7339#[allow(non_camel_case_types)]
7340pub type PFN_vkCreateIOSSurfaceMVK = unsafe extern "system" fn(
7341 instance: Instance,
7342 p_create_info: *const IOSSurfaceCreateInfoMVK,
7343 p_allocator: *const AllocationCallbacks,
7344 p_surface: *mut SurfaceKHR,
7345) -> Result;
7346#[derive(Clone)]
7347pub struct MvkIosSurfaceFn {
7348 pub create_ios_surface_mvk: PFN_vkCreateIOSSurfaceMVK,
7349}
7350unsafe impl Send for MvkIosSurfaceFn {}
7351unsafe impl Sync for MvkIosSurfaceFn {}
7352impl MvkIosSurfaceFn {
7353 pub fn load<F>(mut _f: F) -> Self
7354 where
7355 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7356 {
7357 Self {
7358 create_ios_surface_mvk: unsafe {
7359 unsafe extern "system" fn create_ios_surface_mvk(
7360 _instance: Instance,
7361 _p_create_info: *const IOSSurfaceCreateInfoMVK,
7362 _p_allocator: *const AllocationCallbacks,
7363 _p_surface: *mut SurfaceKHR,
7364 ) -> Result {
7365 panic!(concat!(
7366 "Unable to load ",
7367 stringify!(create_ios_surface_mvk)
7368 ))
7369 }
7370 let cname =
7371 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateIOSSurfaceMVK\0");
7372 let val = _f(cname);
7373 if val.is_null() {
7374 create_ios_surface_mvk
7375 } else {
7376 ::std::mem::transmute(val)
7377 }
7378 },
7379 }
7380 }
7381}
7382#[doc = "Generated from 'VK_MVK_ios_surface'"]
7383impl StructureType {
7384 pub const IOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_122_000);
7385}
7386impl MvkMacosSurfaceFn {
7387 pub const fn name() -> &'static ::std::ffi::CStr {
7388 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_macos_surface\0") }
7389 }
7390 pub const SPEC_VERSION: u32 = 3u32;
7391}
7392#[allow(non_camel_case_types)]
7393pub type PFN_vkCreateMacOSSurfaceMVK = unsafe extern "system" fn(
7394 instance: Instance,
7395 p_create_info: *const MacOSSurfaceCreateInfoMVK,
7396 p_allocator: *const AllocationCallbacks,
7397 p_surface: *mut SurfaceKHR,
7398) -> Result;
7399#[derive(Clone)]
7400pub struct MvkMacosSurfaceFn {
7401 pub create_mac_os_surface_mvk: PFN_vkCreateMacOSSurfaceMVK,
7402}
7403unsafe impl Send for MvkMacosSurfaceFn {}
7404unsafe impl Sync for MvkMacosSurfaceFn {}
7405impl MvkMacosSurfaceFn {
7406 pub fn load<F>(mut _f: F) -> Self
7407 where
7408 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7409 {
7410 Self {
7411 create_mac_os_surface_mvk: unsafe {
7412 unsafe extern "system" fn create_mac_os_surface_mvk(
7413 _instance: Instance,
7414 _p_create_info: *const MacOSSurfaceCreateInfoMVK,
7415 _p_allocator: *const AllocationCallbacks,
7416 _p_surface: *mut SurfaceKHR,
7417 ) -> Result {
7418 panic!(concat!(
7419 "Unable to load ",
7420 stringify!(create_mac_os_surface_mvk)
7421 ))
7422 }
7423 let cname =
7424 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMacOSSurfaceMVK\0");
7425 let val = _f(cname);
7426 if val.is_null() {
7427 create_mac_os_surface_mvk
7428 } else {
7429 ::std::mem::transmute(val)
7430 }
7431 },
7432 }
7433 }
7434}
7435#[doc = "Generated from 'VK_MVK_macos_surface'"]
7436impl StructureType {
7437 pub const MACOS_SURFACE_CREATE_INFO_MVK: Self = Self(1_000_123_000);
7438}
7439impl MvkMoltenvkFn {
7440 pub const fn name() -> &'static ::std::ffi::CStr {
7441 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MVK_moltenvk\0") }
7442 }
7443 pub const SPEC_VERSION: u32 = 0u32;
7444}
7445#[derive(Clone)]
7446pub struct MvkMoltenvkFn {}
7447unsafe impl Send for MvkMoltenvkFn {}
7448unsafe impl Sync for MvkMoltenvkFn {}
7449impl MvkMoltenvkFn {
7450 pub fn load<F>(mut _f: F) -> Self
7451 where
7452 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7453 {
7454 Self {}
7455 }
7456}
7457impl ExtExternalMemoryDmaBufFn {
7458 pub const fn name() -> &'static ::std::ffi::CStr {
7459 unsafe {
7460 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_dma_buf\0")
7461 }
7462 }
7463 pub const SPEC_VERSION: u32 = 1u32;
7464}
7465#[derive(Clone)]
7466pub struct ExtExternalMemoryDmaBufFn {}
7467unsafe impl Send for ExtExternalMemoryDmaBufFn {}
7468unsafe impl Sync for ExtExternalMemoryDmaBufFn {}
7469impl ExtExternalMemoryDmaBufFn {
7470 pub fn load<F>(mut _f: F) -> Self
7471 where
7472 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7473 {
7474 Self {}
7475 }
7476}
7477#[doc = "Generated from 'VK_EXT_external_memory_dma_buf'"]
7478impl ExternalMemoryHandleTypeFlags {
7479 pub const DMA_BUF_EXT: Self = Self(0b10_0000_0000);
7480}
7481impl ExtQueueFamilyForeignFn {
7482 pub const fn name() -> &'static ::std::ffi::CStr {
7483 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_queue_family_foreign\0") }
7484 }
7485 pub const SPEC_VERSION: u32 = 1u32;
7486}
7487#[derive(Clone)]
7488pub struct ExtQueueFamilyForeignFn {}
7489unsafe impl Send for ExtQueueFamilyForeignFn {}
7490unsafe impl Sync for ExtQueueFamilyForeignFn {}
7491impl ExtQueueFamilyForeignFn {
7492 pub fn load<F>(mut _f: F) -> Self
7493 where
7494 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7495 {
7496 Self {}
7497 }
7498}
7499impl KhrDedicatedAllocationFn {
7500 pub const fn name() -> &'static ::std::ffi::CStr {
7501 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_dedicated_allocation\0") }
7502 }
7503 pub const SPEC_VERSION: u32 = 3u32;
7504}
7505#[derive(Clone)]
7506pub struct KhrDedicatedAllocationFn {}
7507unsafe impl Send for KhrDedicatedAllocationFn {}
7508unsafe impl Sync for KhrDedicatedAllocationFn {}
7509impl KhrDedicatedAllocationFn {
7510 pub fn load<F>(mut _f: F) -> Self
7511 where
7512 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7513 {
7514 Self {}
7515 }
7516}
7517#[doc = "Generated from 'VK_KHR_dedicated_allocation'"]
7518impl StructureType {
7519 pub const MEMORY_DEDICATED_REQUIREMENTS_KHR: Self = Self::MEMORY_DEDICATED_REQUIREMENTS;
7520 pub const MEMORY_DEDICATED_ALLOCATE_INFO_KHR: Self = Self::MEMORY_DEDICATED_ALLOCATE_INFO;
7521}
7522impl ExtDebugUtilsFn {
7523 pub const fn name() -> &'static ::std::ffi::CStr {
7524 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_debug_utils\0") }
7525 }
7526 pub const SPEC_VERSION: u32 = 2u32;
7527}
7528#[allow(non_camel_case_types)]
7529pub type PFN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn(
7530 device: Device,
7531 p_name_info: *const DebugUtilsObjectNameInfoEXT,
7532) -> Result;
7533#[allow(non_camel_case_types)]
7534pub type PFN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn(
7535 device: Device,
7536 p_tag_info: *const DebugUtilsObjectTagInfoEXT,
7537) -> Result;
7538#[allow(non_camel_case_types)]
7539pub type PFN_vkQueueBeginDebugUtilsLabelEXT =
7540 unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT);
7541#[allow(non_camel_case_types)]
7542pub type PFN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: Queue);
7543#[allow(non_camel_case_types)]
7544pub type PFN_vkQueueInsertDebugUtilsLabelEXT =
7545 unsafe extern "system" fn(queue: Queue, p_label_info: *const DebugUtilsLabelEXT);
7546#[allow(non_camel_case_types)]
7547pub type PFN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn(
7548 command_buffer: CommandBuffer,
7549 p_label_info: *const DebugUtilsLabelEXT,
7550);
7551#[allow(non_camel_case_types)]
7552pub type PFN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(command_buffer: CommandBuffer);
7553#[allow(non_camel_case_types)]
7554pub type PFN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn(
7555 command_buffer: CommandBuffer,
7556 p_label_info: *const DebugUtilsLabelEXT,
7557);
7558#[allow(non_camel_case_types)]
7559pub type PFN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn(
7560 instance: Instance,
7561 p_create_info: *const DebugUtilsMessengerCreateInfoEXT,
7562 p_allocator: *const AllocationCallbacks,
7563 p_messenger: *mut DebugUtilsMessengerEXT,
7564) -> Result;
7565#[allow(non_camel_case_types)]
7566pub type PFN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn(
7567 instance: Instance,
7568 messenger: DebugUtilsMessengerEXT,
7569 p_allocator: *const AllocationCallbacks,
7570);
7571#[allow(non_camel_case_types)]
7572pub type PFN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn(
7573 instance: Instance,
7574 message_severity: DebugUtilsMessageSeverityFlagsEXT,
7575 message_types: DebugUtilsMessageTypeFlagsEXT,
7576 p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
7577);
7578#[derive(Clone)]
7579pub struct ExtDebugUtilsFn {
7580 pub set_debug_utils_object_name_ext: PFN_vkSetDebugUtilsObjectNameEXT,
7581 pub set_debug_utils_object_tag_ext: PFN_vkSetDebugUtilsObjectTagEXT,
7582 pub queue_begin_debug_utils_label_ext: PFN_vkQueueBeginDebugUtilsLabelEXT,
7583 pub queue_end_debug_utils_label_ext: PFN_vkQueueEndDebugUtilsLabelEXT,
7584 pub queue_insert_debug_utils_label_ext: PFN_vkQueueInsertDebugUtilsLabelEXT,
7585 pub cmd_begin_debug_utils_label_ext: PFN_vkCmdBeginDebugUtilsLabelEXT,
7586 pub cmd_end_debug_utils_label_ext: PFN_vkCmdEndDebugUtilsLabelEXT,
7587 pub cmd_insert_debug_utils_label_ext: PFN_vkCmdInsertDebugUtilsLabelEXT,
7588 pub create_debug_utils_messenger_ext: PFN_vkCreateDebugUtilsMessengerEXT,
7589 pub destroy_debug_utils_messenger_ext: PFN_vkDestroyDebugUtilsMessengerEXT,
7590 pub submit_debug_utils_message_ext: PFN_vkSubmitDebugUtilsMessageEXT,
7591}
7592unsafe impl Send for ExtDebugUtilsFn {}
7593unsafe impl Sync for ExtDebugUtilsFn {}
7594impl ExtDebugUtilsFn {
7595 pub fn load<F>(mut _f: F) -> Self
7596 where
7597 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7598 {
7599 Self {
7600 set_debug_utils_object_name_ext: unsafe {
7601 unsafe extern "system" fn set_debug_utils_object_name_ext(
7602 _device: Device,
7603 _p_name_info: *const DebugUtilsObjectNameInfoEXT,
7604 ) -> Result {
7605 panic!(concat!(
7606 "Unable to load ",
7607 stringify!(set_debug_utils_object_name_ext)
7608 ))
7609 }
7610 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7611 b"vkSetDebugUtilsObjectNameEXT\0",
7612 );
7613 let val = _f(cname);
7614 if val.is_null() {
7615 set_debug_utils_object_name_ext
7616 } else {
7617 ::std::mem::transmute(val)
7618 }
7619 },
7620 set_debug_utils_object_tag_ext: unsafe {
7621 unsafe extern "system" fn set_debug_utils_object_tag_ext(
7622 _device: Device,
7623 _p_tag_info: *const DebugUtilsObjectTagInfoEXT,
7624 ) -> Result {
7625 panic!(concat!(
7626 "Unable to load ",
7627 stringify!(set_debug_utils_object_tag_ext)
7628 ))
7629 }
7630 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7631 b"vkSetDebugUtilsObjectTagEXT\0",
7632 );
7633 let val = _f(cname);
7634 if val.is_null() {
7635 set_debug_utils_object_tag_ext
7636 } else {
7637 ::std::mem::transmute(val)
7638 }
7639 },
7640 queue_begin_debug_utils_label_ext: unsafe {
7641 unsafe extern "system" fn queue_begin_debug_utils_label_ext(
7642 _queue: Queue,
7643 _p_label_info: *const DebugUtilsLabelEXT,
7644 ) {
7645 panic!(concat!(
7646 "Unable to load ",
7647 stringify!(queue_begin_debug_utils_label_ext)
7648 ))
7649 }
7650 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7651 b"vkQueueBeginDebugUtilsLabelEXT\0",
7652 );
7653 let val = _f(cname);
7654 if val.is_null() {
7655 queue_begin_debug_utils_label_ext
7656 } else {
7657 ::std::mem::transmute(val)
7658 }
7659 },
7660 queue_end_debug_utils_label_ext: unsafe {
7661 unsafe extern "system" fn queue_end_debug_utils_label_ext(_queue: Queue) {
7662 panic!(concat!(
7663 "Unable to load ",
7664 stringify!(queue_end_debug_utils_label_ext)
7665 ))
7666 }
7667 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7668 b"vkQueueEndDebugUtilsLabelEXT\0",
7669 );
7670 let val = _f(cname);
7671 if val.is_null() {
7672 queue_end_debug_utils_label_ext
7673 } else {
7674 ::std::mem::transmute(val)
7675 }
7676 },
7677 queue_insert_debug_utils_label_ext: unsafe {
7678 unsafe extern "system" fn queue_insert_debug_utils_label_ext(
7679 _queue: Queue,
7680 _p_label_info: *const DebugUtilsLabelEXT,
7681 ) {
7682 panic!(concat!(
7683 "Unable to load ",
7684 stringify!(queue_insert_debug_utils_label_ext)
7685 ))
7686 }
7687 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7688 b"vkQueueInsertDebugUtilsLabelEXT\0",
7689 );
7690 let val = _f(cname);
7691 if val.is_null() {
7692 queue_insert_debug_utils_label_ext
7693 } else {
7694 ::std::mem::transmute(val)
7695 }
7696 },
7697 cmd_begin_debug_utils_label_ext: unsafe {
7698 unsafe extern "system" fn cmd_begin_debug_utils_label_ext(
7699 _command_buffer: CommandBuffer,
7700 _p_label_info: *const DebugUtilsLabelEXT,
7701 ) {
7702 panic!(concat!(
7703 "Unable to load ",
7704 stringify!(cmd_begin_debug_utils_label_ext)
7705 ))
7706 }
7707 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7708 b"vkCmdBeginDebugUtilsLabelEXT\0",
7709 );
7710 let val = _f(cname);
7711 if val.is_null() {
7712 cmd_begin_debug_utils_label_ext
7713 } else {
7714 ::std::mem::transmute(val)
7715 }
7716 },
7717 cmd_end_debug_utils_label_ext: unsafe {
7718 unsafe extern "system" fn cmd_end_debug_utils_label_ext(
7719 _command_buffer: CommandBuffer,
7720 ) {
7721 panic!(concat!(
7722 "Unable to load ",
7723 stringify!(cmd_end_debug_utils_label_ext)
7724 ))
7725 }
7726 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7727 b"vkCmdEndDebugUtilsLabelEXT\0",
7728 );
7729 let val = _f(cname);
7730 if val.is_null() {
7731 cmd_end_debug_utils_label_ext
7732 } else {
7733 ::std::mem::transmute(val)
7734 }
7735 },
7736 cmd_insert_debug_utils_label_ext: unsafe {
7737 unsafe extern "system" fn cmd_insert_debug_utils_label_ext(
7738 _command_buffer: CommandBuffer,
7739 _p_label_info: *const DebugUtilsLabelEXT,
7740 ) {
7741 panic!(concat!(
7742 "Unable to load ",
7743 stringify!(cmd_insert_debug_utils_label_ext)
7744 ))
7745 }
7746 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7747 b"vkCmdInsertDebugUtilsLabelEXT\0",
7748 );
7749 let val = _f(cname);
7750 if val.is_null() {
7751 cmd_insert_debug_utils_label_ext
7752 } else {
7753 ::std::mem::transmute(val)
7754 }
7755 },
7756 create_debug_utils_messenger_ext: unsafe {
7757 unsafe extern "system" fn create_debug_utils_messenger_ext(
7758 _instance: Instance,
7759 _p_create_info: *const DebugUtilsMessengerCreateInfoEXT,
7760 _p_allocator: *const AllocationCallbacks,
7761 _p_messenger: *mut DebugUtilsMessengerEXT,
7762 ) -> Result {
7763 panic!(concat!(
7764 "Unable to load ",
7765 stringify!(create_debug_utils_messenger_ext)
7766 ))
7767 }
7768 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7769 b"vkCreateDebugUtilsMessengerEXT\0",
7770 );
7771 let val = _f(cname);
7772 if val.is_null() {
7773 create_debug_utils_messenger_ext
7774 } else {
7775 ::std::mem::transmute(val)
7776 }
7777 },
7778 destroy_debug_utils_messenger_ext: unsafe {
7779 unsafe extern "system" fn destroy_debug_utils_messenger_ext(
7780 _instance: Instance,
7781 _messenger: DebugUtilsMessengerEXT,
7782 _p_allocator: *const AllocationCallbacks,
7783 ) {
7784 panic!(concat!(
7785 "Unable to load ",
7786 stringify!(destroy_debug_utils_messenger_ext)
7787 ))
7788 }
7789 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7790 b"vkDestroyDebugUtilsMessengerEXT\0",
7791 );
7792 let val = _f(cname);
7793 if val.is_null() {
7794 destroy_debug_utils_messenger_ext
7795 } else {
7796 ::std::mem::transmute(val)
7797 }
7798 },
7799 submit_debug_utils_message_ext: unsafe {
7800 unsafe extern "system" fn submit_debug_utils_message_ext(
7801 _instance: Instance,
7802 _message_severity: DebugUtilsMessageSeverityFlagsEXT,
7803 _message_types: DebugUtilsMessageTypeFlagsEXT,
7804 _p_callback_data: *const DebugUtilsMessengerCallbackDataEXT,
7805 ) {
7806 panic!(concat!(
7807 "Unable to load ",
7808 stringify!(submit_debug_utils_message_ext)
7809 ))
7810 }
7811 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7812 b"vkSubmitDebugUtilsMessageEXT\0",
7813 );
7814 let val = _f(cname);
7815 if val.is_null() {
7816 submit_debug_utils_message_ext
7817 } else {
7818 ::std::mem::transmute(val)
7819 }
7820 },
7821 }
7822 }
7823}
7824#[doc = "Generated from 'VK_EXT_debug_utils'"]
7825impl ObjectType {
7826 pub const DEBUG_UTILS_MESSENGER_EXT: Self = Self(1_000_128_000);
7827}
7828#[doc = "Generated from 'VK_EXT_debug_utils'"]
7829impl StructureType {
7830 pub const DEBUG_UTILS_OBJECT_NAME_INFO_EXT: Self = Self(1_000_128_000);
7831 pub const DEBUG_UTILS_OBJECT_TAG_INFO_EXT: Self = Self(1_000_128_001);
7832 pub const DEBUG_UTILS_LABEL_EXT: Self = Self(1_000_128_002);
7833 pub const DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: Self = Self(1_000_128_003);
7834 pub const DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: Self = Self(1_000_128_004);
7835}
7836impl AndroidExternalMemoryAndroidHardwareBufferFn {
7837 pub const fn name() -> &'static ::std::ffi::CStr {
7838 unsafe {
7839 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7840 b"VK_ANDROID_external_memory_android_hardware_buffer\0",
7841 )
7842 }
7843 }
7844 pub const SPEC_VERSION: u32 = 5u32;
7845}
7846#[allow(non_camel_case_types)]
7847pub type PFN_vkGetAndroidHardwareBufferPropertiesANDROID = unsafe extern "system" fn(
7848 device: Device,
7849 buffer: *const AHardwareBuffer,
7850 p_properties: *mut AndroidHardwareBufferPropertiesANDROID,
7851) -> Result;
7852#[allow(non_camel_case_types)]
7853pub type PFN_vkGetMemoryAndroidHardwareBufferANDROID = unsafe extern "system" fn(
7854 device: Device,
7855 p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID,
7856 p_buffer: *mut *mut AHardwareBuffer,
7857) -> Result;
7858#[derive(Clone)]
7859pub struct AndroidExternalMemoryAndroidHardwareBufferFn {
7860 pub get_android_hardware_buffer_properties_android:
7861 PFN_vkGetAndroidHardwareBufferPropertiesANDROID,
7862 pub get_memory_android_hardware_buffer_android: PFN_vkGetMemoryAndroidHardwareBufferANDROID,
7863}
7864unsafe impl Send for AndroidExternalMemoryAndroidHardwareBufferFn {}
7865unsafe impl Sync for AndroidExternalMemoryAndroidHardwareBufferFn {}
7866impl AndroidExternalMemoryAndroidHardwareBufferFn {
7867 pub fn load<F>(mut _f: F) -> Self
7868 where
7869 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7870 {
7871 Self {
7872 get_android_hardware_buffer_properties_android: unsafe {
7873 unsafe extern "system" fn get_android_hardware_buffer_properties_android(
7874 _device: Device,
7875 _buffer: *const AHardwareBuffer,
7876 _p_properties: *mut AndroidHardwareBufferPropertiesANDROID,
7877 ) -> Result {
7878 panic!(concat!(
7879 "Unable to load ",
7880 stringify!(get_android_hardware_buffer_properties_android)
7881 ))
7882 }
7883 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7884 b"vkGetAndroidHardwareBufferPropertiesANDROID\0",
7885 );
7886 let val = _f(cname);
7887 if val.is_null() {
7888 get_android_hardware_buffer_properties_android
7889 } else {
7890 ::std::mem::transmute(val)
7891 }
7892 },
7893 get_memory_android_hardware_buffer_android: unsafe {
7894 unsafe extern "system" fn get_memory_android_hardware_buffer_android(
7895 _device: Device,
7896 _p_info: *const MemoryGetAndroidHardwareBufferInfoANDROID,
7897 _p_buffer: *mut *mut AHardwareBuffer,
7898 ) -> Result {
7899 panic!(concat!(
7900 "Unable to load ",
7901 stringify!(get_memory_android_hardware_buffer_android)
7902 ))
7903 }
7904 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7905 b"vkGetMemoryAndroidHardwareBufferANDROID\0",
7906 );
7907 let val = _f(cname);
7908 if val.is_null() {
7909 get_memory_android_hardware_buffer_android
7910 } else {
7911 ::std::mem::transmute(val)
7912 }
7913 },
7914 }
7915 }
7916}
7917#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
7918impl ExternalMemoryHandleTypeFlags {
7919 pub const ANDROID_HARDWARE_BUFFER_ANDROID: Self = Self(0b100_0000_0000);
7920}
7921#[doc = "Generated from 'VK_ANDROID_external_memory_android_hardware_buffer'"]
7922impl StructureType {
7923 pub const ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: Self = Self(1_000_129_000);
7924 pub const ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: Self = Self(1_000_129_001);
7925 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: Self = Self(1_000_129_002);
7926 pub const IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_003);
7927 pub const MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: Self = Self(1_000_129_004);
7928 pub const EXTERNAL_FORMAT_ANDROID: Self = Self(1_000_129_005);
7929 pub const ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID: Self = Self(1_000_129_006);
7930}
7931impl ExtSamplerFilterMinmaxFn {
7932 pub const fn name() -> &'static ::std::ffi::CStr {
7933 unsafe {
7934 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sampler_filter_minmax\0")
7935 }
7936 }
7937 pub const SPEC_VERSION: u32 = 2u32;
7938}
7939#[derive(Clone)]
7940pub struct ExtSamplerFilterMinmaxFn {}
7941unsafe impl Send for ExtSamplerFilterMinmaxFn {}
7942unsafe impl Sync for ExtSamplerFilterMinmaxFn {}
7943impl ExtSamplerFilterMinmaxFn {
7944 pub fn load<F>(mut _f: F) -> Self
7945 where
7946 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7947 {
7948 Self {}
7949 }
7950}
7951#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
7952impl FormatFeatureFlags {
7953 pub const SAMPLED_IMAGE_FILTER_MINMAX_EXT: Self = Self::SAMPLED_IMAGE_FILTER_MINMAX;
7954}
7955#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
7956impl SamplerReductionMode {
7957 pub const WEIGHTED_AVERAGE_EXT: Self = Self::WEIGHTED_AVERAGE;
7958 pub const MIN_EXT: Self = Self::MIN;
7959 pub const MAX_EXT: Self = Self::MAX;
7960}
7961#[doc = "Generated from 'VK_EXT_sampler_filter_minmax'"]
7962impl StructureType {
7963 pub const PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: Self =
7964 Self::PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
7965 pub const SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: Self =
7966 Self::SAMPLER_REDUCTION_MODE_CREATE_INFO;
7967}
7968impl KhrStorageBufferStorageClassFn {
7969 pub const fn name() -> &'static ::std::ffi::CStr {
7970 unsafe {
7971 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
7972 b"VK_KHR_storage_buffer_storage_class\0",
7973 )
7974 }
7975 }
7976 pub const SPEC_VERSION: u32 = 1u32;
7977}
7978#[derive(Clone)]
7979pub struct KhrStorageBufferStorageClassFn {}
7980unsafe impl Send for KhrStorageBufferStorageClassFn {}
7981unsafe impl Sync for KhrStorageBufferStorageClassFn {}
7982impl KhrStorageBufferStorageClassFn {
7983 pub fn load<F>(mut _f: F) -> Self
7984 where
7985 F: FnMut(&::std::ffi::CStr) -> *const c_void,
7986 {
7987 Self {}
7988 }
7989}
7990impl AmdGpuShaderInt16Fn {
7991 pub const fn name() -> &'static ::std::ffi::CStr {
7992 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_gpu_shader_int16\0") }
7993 }
7994 pub const SPEC_VERSION: u32 = 2u32;
7995}
7996#[derive(Clone)]
7997pub struct AmdGpuShaderInt16Fn {}
7998unsafe impl Send for AmdGpuShaderInt16Fn {}
7999unsafe impl Sync for AmdGpuShaderInt16Fn {}
8000impl AmdGpuShaderInt16Fn {
8001 pub fn load<F>(mut _f: F) -> Self
8002 where
8003 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8004 {
8005 Self {}
8006 }
8007}
8008impl AmdExtension134Fn {
8009 pub const fn name() -> &'static ::std::ffi::CStr {
8010 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_134\0") }
8011 }
8012 pub const SPEC_VERSION: u32 = 0u32;
8013}
8014#[derive(Clone)]
8015pub struct AmdExtension134Fn {}
8016unsafe impl Send for AmdExtension134Fn {}
8017unsafe impl Sync for AmdExtension134Fn {}
8018impl AmdExtension134Fn {
8019 pub fn load<F>(mut _f: F) -> Self
8020 where
8021 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8022 {
8023 Self {}
8024 }
8025}
8026impl AmdExtension135Fn {
8027 pub const fn name() -> &'static ::std::ffi::CStr {
8028 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_135\0") }
8029 }
8030 pub const SPEC_VERSION: u32 = 0u32;
8031}
8032#[derive(Clone)]
8033pub struct AmdExtension135Fn {}
8034unsafe impl Send for AmdExtension135Fn {}
8035unsafe impl Sync for AmdExtension135Fn {}
8036impl AmdExtension135Fn {
8037 pub fn load<F>(mut _f: F) -> Self
8038 where
8039 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8040 {
8041 Self {}
8042 }
8043}
8044impl AmdExtension136Fn {
8045 pub const fn name() -> &'static ::std::ffi::CStr {
8046 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_136\0") }
8047 }
8048 pub const SPEC_VERSION: u32 = 0u32;
8049}
8050#[derive(Clone)]
8051pub struct AmdExtension136Fn {}
8052unsafe impl Send for AmdExtension136Fn {}
8053unsafe impl Sync for AmdExtension136Fn {}
8054impl AmdExtension136Fn {
8055 pub fn load<F>(mut _f: F) -> Self
8056 where
8057 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8058 {
8059 Self {}
8060 }
8061}
8062impl AmdMixedAttachmentSamplesFn {
8063 pub const fn name() -> &'static ::std::ffi::CStr {
8064 unsafe {
8065 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_mixed_attachment_samples\0")
8066 }
8067 }
8068 pub const SPEC_VERSION: u32 = 1u32;
8069}
8070#[derive(Clone)]
8071pub struct AmdMixedAttachmentSamplesFn {}
8072unsafe impl Send for AmdMixedAttachmentSamplesFn {}
8073unsafe impl Sync for AmdMixedAttachmentSamplesFn {}
8074impl AmdMixedAttachmentSamplesFn {
8075 pub fn load<F>(mut _f: F) -> Self
8076 where
8077 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8078 {
8079 Self {}
8080 }
8081}
8082impl AmdShaderFragmentMaskFn {
8083 pub const fn name() -> &'static ::std::ffi::CStr {
8084 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_fragment_mask\0") }
8085 }
8086 pub const SPEC_VERSION: u32 = 1u32;
8087}
8088#[derive(Clone)]
8089pub struct AmdShaderFragmentMaskFn {}
8090unsafe impl Send for AmdShaderFragmentMaskFn {}
8091unsafe impl Sync for AmdShaderFragmentMaskFn {}
8092impl AmdShaderFragmentMaskFn {
8093 pub fn load<F>(mut _f: F) -> Self
8094 where
8095 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8096 {
8097 Self {}
8098 }
8099}
8100impl ExtInlineUniformBlockFn {
8101 pub const fn name() -> &'static ::std::ffi::CStr {
8102 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_inline_uniform_block\0") }
8103 }
8104 pub const SPEC_VERSION: u32 = 1u32;
8105}
8106#[derive(Clone)]
8107pub struct ExtInlineUniformBlockFn {}
8108unsafe impl Send for ExtInlineUniformBlockFn {}
8109unsafe impl Sync for ExtInlineUniformBlockFn {}
8110impl ExtInlineUniformBlockFn {
8111 pub fn load<F>(mut _f: F) -> Self
8112 where
8113 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8114 {
8115 Self {}
8116 }
8117}
8118#[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
8119impl DescriptorType {
8120 pub const INLINE_UNIFORM_BLOCK_EXT: Self = Self::INLINE_UNIFORM_BLOCK;
8121}
8122#[doc = "Generated from 'VK_EXT_inline_uniform_block'"]
8123impl StructureType {
8124 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: Self =
8125 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
8126 pub const PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: Self =
8127 Self::PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
8128 pub const WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: Self =
8129 Self::WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
8130 pub const DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: Self =
8131 Self::DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
8132}
8133impl AmdExtension140Fn {
8134 pub const fn name() -> &'static ::std::ffi::CStr {
8135 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_140\0") }
8136 }
8137 pub const SPEC_VERSION: u32 = 0u32;
8138}
8139#[derive(Clone)]
8140pub struct AmdExtension140Fn {}
8141unsafe impl Send for AmdExtension140Fn {}
8142unsafe impl Sync for AmdExtension140Fn {}
8143impl AmdExtension140Fn {
8144 pub fn load<F>(mut _f: F) -> Self
8145 where
8146 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8147 {
8148 Self {}
8149 }
8150}
8151impl ExtShaderStencilExportFn {
8152 pub const fn name() -> &'static ::std::ffi::CStr {
8153 unsafe {
8154 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_stencil_export\0")
8155 }
8156 }
8157 pub const SPEC_VERSION: u32 = 1u32;
8158}
8159#[derive(Clone)]
8160pub struct ExtShaderStencilExportFn {}
8161unsafe impl Send for ExtShaderStencilExportFn {}
8162unsafe impl Sync for ExtShaderStencilExportFn {}
8163impl ExtShaderStencilExportFn {
8164 pub fn load<F>(mut _f: F) -> Self
8165 where
8166 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8167 {
8168 Self {}
8169 }
8170}
8171impl AmdExtension142Fn {
8172 pub const fn name() -> &'static ::std::ffi::CStr {
8173 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_142\0") }
8174 }
8175 pub const SPEC_VERSION: u32 = 0u32;
8176}
8177#[derive(Clone)]
8178pub struct AmdExtension142Fn {}
8179unsafe impl Send for AmdExtension142Fn {}
8180unsafe impl Sync for AmdExtension142Fn {}
8181impl AmdExtension142Fn {
8182 pub fn load<F>(mut _f: F) -> Self
8183 where
8184 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8185 {
8186 Self {}
8187 }
8188}
8189impl AmdExtension143Fn {
8190 pub const fn name() -> &'static ::std::ffi::CStr {
8191 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_143\0") }
8192 }
8193 pub const SPEC_VERSION: u32 = 0u32;
8194}
8195#[derive(Clone)]
8196pub struct AmdExtension143Fn {}
8197unsafe impl Send for AmdExtension143Fn {}
8198unsafe impl Sync for AmdExtension143Fn {}
8199impl AmdExtension143Fn {
8200 pub fn load<F>(mut _f: F) -> Self
8201 where
8202 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8203 {
8204 Self {}
8205 }
8206}
8207impl ExtSampleLocationsFn {
8208 pub const fn name() -> &'static ::std::ffi::CStr {
8209 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_sample_locations\0") }
8210 }
8211 pub const SPEC_VERSION: u32 = 1u32;
8212}
8213#[allow(non_camel_case_types)]
8214pub type PFN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn(
8215 command_buffer: CommandBuffer,
8216 p_sample_locations_info: *const SampleLocationsInfoEXT,
8217);
8218#[allow(non_camel_case_types)]
8219pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn(
8220 physical_device: PhysicalDevice,
8221 samples: SampleCountFlags,
8222 p_multisample_properties: *mut MultisamplePropertiesEXT,
8223);
8224#[derive(Clone)]
8225pub struct ExtSampleLocationsFn {
8226 pub cmd_set_sample_locations_ext: PFN_vkCmdSetSampleLocationsEXT,
8227 pub get_physical_device_multisample_properties_ext:
8228 PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT,
8229}
8230unsafe impl Send for ExtSampleLocationsFn {}
8231unsafe impl Sync for ExtSampleLocationsFn {}
8232impl ExtSampleLocationsFn {
8233 pub fn load<F>(mut _f: F) -> Self
8234 where
8235 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8236 {
8237 Self {
8238 cmd_set_sample_locations_ext: unsafe {
8239 unsafe extern "system" fn cmd_set_sample_locations_ext(
8240 _command_buffer: CommandBuffer,
8241 _p_sample_locations_info: *const SampleLocationsInfoEXT,
8242 ) {
8243 panic!(concat!(
8244 "Unable to load ",
8245 stringify!(cmd_set_sample_locations_ext)
8246 ))
8247 }
8248 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8249 b"vkCmdSetSampleLocationsEXT\0",
8250 );
8251 let val = _f(cname);
8252 if val.is_null() {
8253 cmd_set_sample_locations_ext
8254 } else {
8255 ::std::mem::transmute(val)
8256 }
8257 },
8258 get_physical_device_multisample_properties_ext: unsafe {
8259 unsafe extern "system" fn get_physical_device_multisample_properties_ext(
8260 _physical_device: PhysicalDevice,
8261 _samples: SampleCountFlags,
8262 _p_multisample_properties: *mut MultisamplePropertiesEXT,
8263 ) {
8264 panic!(concat!(
8265 "Unable to load ",
8266 stringify!(get_physical_device_multisample_properties_ext)
8267 ))
8268 }
8269 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8270 b"vkGetPhysicalDeviceMultisamplePropertiesEXT\0",
8271 );
8272 let val = _f(cname);
8273 if val.is_null() {
8274 get_physical_device_multisample_properties_ext
8275 } else {
8276 ::std::mem::transmute(val)
8277 }
8278 },
8279 }
8280 }
8281}
8282#[doc = "Generated from 'VK_EXT_sample_locations'"]
8283impl DynamicState {
8284 pub const SAMPLE_LOCATIONS_EXT: Self = Self(1_000_143_000);
8285}
8286#[doc = "Generated from 'VK_EXT_sample_locations'"]
8287impl ImageCreateFlags {
8288 pub const SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_EXT: Self = Self(0b1_0000_0000_0000);
8289}
8290#[doc = "Generated from 'VK_EXT_sample_locations'"]
8291impl StructureType {
8292 pub const SAMPLE_LOCATIONS_INFO_EXT: Self = Self(1_000_143_000);
8293 pub const RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: Self = Self(1_000_143_001);
8294 pub const PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: Self = Self(1_000_143_002);
8295 pub const PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: Self = Self(1_000_143_003);
8296 pub const MULTISAMPLE_PROPERTIES_EXT: Self = Self(1_000_143_004);
8297}
8298impl KhrRelaxedBlockLayoutFn {
8299 pub const fn name() -> &'static ::std::ffi::CStr {
8300 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_relaxed_block_layout\0") }
8301 }
8302 pub const SPEC_VERSION: u32 = 1u32;
8303}
8304#[derive(Clone)]
8305pub struct KhrRelaxedBlockLayoutFn {}
8306unsafe impl Send for KhrRelaxedBlockLayoutFn {}
8307unsafe impl Sync for KhrRelaxedBlockLayoutFn {}
8308impl KhrRelaxedBlockLayoutFn {
8309 pub fn load<F>(mut _f: F) -> Self
8310 where
8311 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8312 {
8313 Self {}
8314 }
8315}
8316impl KhrGetMemoryRequirements2Fn {
8317 pub const fn name() -> &'static ::std::ffi::CStr {
8318 unsafe {
8319 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_get_memory_requirements2\0")
8320 }
8321 }
8322 pub const SPEC_VERSION: u32 = 1u32;
8323}
8324#[allow(non_camel_case_types)]
8325pub type PFN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn(
8326 device: Device,
8327 p_info: *const ImageMemoryRequirementsInfo2,
8328 p_memory_requirements: *mut MemoryRequirements2,
8329);
8330#[allow(non_camel_case_types)]
8331pub type PFN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn(
8332 device: Device,
8333 p_info: *const BufferMemoryRequirementsInfo2,
8334 p_memory_requirements: *mut MemoryRequirements2,
8335);
8336#[allow(non_camel_case_types)]
8337pub type PFN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn(
8338 device: Device,
8339 p_info: *const ImageSparseMemoryRequirementsInfo2,
8340 p_sparse_memory_requirement_count: *mut u32,
8341 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
8342);
8343#[derive(Clone)]
8344pub struct KhrGetMemoryRequirements2Fn {
8345 pub get_image_memory_requirements2_khr: PFN_vkGetImageMemoryRequirements2,
8346 pub get_buffer_memory_requirements2_khr: PFN_vkGetBufferMemoryRequirements2,
8347 pub get_image_sparse_memory_requirements2_khr: PFN_vkGetImageSparseMemoryRequirements2,
8348}
8349unsafe impl Send for KhrGetMemoryRequirements2Fn {}
8350unsafe impl Sync for KhrGetMemoryRequirements2Fn {}
8351impl KhrGetMemoryRequirements2Fn {
8352 pub fn load<F>(mut _f: F) -> Self
8353 where
8354 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8355 {
8356 Self {
8357 get_image_memory_requirements2_khr: unsafe {
8358 unsafe extern "system" fn get_image_memory_requirements2_khr(
8359 _device: Device,
8360 _p_info: *const ImageMemoryRequirementsInfo2,
8361 _p_memory_requirements: *mut MemoryRequirements2,
8362 ) {
8363 panic!(concat!(
8364 "Unable to load ",
8365 stringify!(get_image_memory_requirements2_khr)
8366 ))
8367 }
8368 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8369 b"vkGetImageMemoryRequirements2KHR\0",
8370 );
8371 let val = _f(cname);
8372 if val.is_null() {
8373 get_image_memory_requirements2_khr
8374 } else {
8375 ::std::mem::transmute(val)
8376 }
8377 },
8378 get_buffer_memory_requirements2_khr: unsafe {
8379 unsafe extern "system" fn get_buffer_memory_requirements2_khr(
8380 _device: Device,
8381 _p_info: *const BufferMemoryRequirementsInfo2,
8382 _p_memory_requirements: *mut MemoryRequirements2,
8383 ) {
8384 panic!(concat!(
8385 "Unable to load ",
8386 stringify!(get_buffer_memory_requirements2_khr)
8387 ))
8388 }
8389 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8390 b"vkGetBufferMemoryRequirements2KHR\0",
8391 );
8392 let val = _f(cname);
8393 if val.is_null() {
8394 get_buffer_memory_requirements2_khr
8395 } else {
8396 ::std::mem::transmute(val)
8397 }
8398 },
8399 get_image_sparse_memory_requirements2_khr: unsafe {
8400 unsafe extern "system" fn get_image_sparse_memory_requirements2_khr(
8401 _device: Device,
8402 _p_info: *const ImageSparseMemoryRequirementsInfo2,
8403 _p_sparse_memory_requirement_count: *mut u32,
8404 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
8405 ) {
8406 panic!(concat!(
8407 "Unable to load ",
8408 stringify!(get_image_sparse_memory_requirements2_khr)
8409 ))
8410 }
8411 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8412 b"vkGetImageSparseMemoryRequirements2KHR\0",
8413 );
8414 let val = _f(cname);
8415 if val.is_null() {
8416 get_image_sparse_memory_requirements2_khr
8417 } else {
8418 ::std::mem::transmute(val)
8419 }
8420 },
8421 }
8422 }
8423}
8424#[doc = "Generated from 'VK_KHR_get_memory_requirements2'"]
8425impl StructureType {
8426 pub const BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::BUFFER_MEMORY_REQUIREMENTS_INFO_2;
8427 pub const IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self = Self::IMAGE_MEMORY_REQUIREMENTS_INFO_2;
8428 pub const IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: Self =
8429 Self::IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
8430 pub const MEMORY_REQUIREMENTS_2_KHR: Self = Self::MEMORY_REQUIREMENTS_2;
8431 pub const SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: Self =
8432 Self::SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
8433}
8434impl KhrImageFormatListFn {
8435 pub const fn name() -> &'static ::std::ffi::CStr {
8436 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_image_format_list\0") }
8437 }
8438 pub const SPEC_VERSION: u32 = 1u32;
8439}
8440#[derive(Clone)]
8441pub struct KhrImageFormatListFn {}
8442unsafe impl Send for KhrImageFormatListFn {}
8443unsafe impl Sync for KhrImageFormatListFn {}
8444impl KhrImageFormatListFn {
8445 pub fn load<F>(mut _f: F) -> Self
8446 where
8447 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8448 {
8449 Self {}
8450 }
8451}
8452#[doc = "Generated from 'VK_KHR_image_format_list'"]
8453impl StructureType {
8454 pub const IMAGE_FORMAT_LIST_CREATE_INFO_KHR: Self = Self::IMAGE_FORMAT_LIST_CREATE_INFO;
8455}
8456impl ExtBlendOperationAdvancedFn {
8457 pub const fn name() -> &'static ::std::ffi::CStr {
8458 unsafe {
8459 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_blend_operation_advanced\0")
8460 }
8461 }
8462 pub const SPEC_VERSION: u32 = 2u32;
8463}
8464#[derive(Clone)]
8465pub struct ExtBlendOperationAdvancedFn {}
8466unsafe impl Send for ExtBlendOperationAdvancedFn {}
8467unsafe impl Sync for ExtBlendOperationAdvancedFn {}
8468impl ExtBlendOperationAdvancedFn {
8469 pub fn load<F>(mut _f: F) -> Self
8470 where
8471 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8472 {
8473 Self {}
8474 }
8475}
8476#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
8477impl AccessFlags {
8478 pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
8479}
8480#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
8481impl BlendOp {
8482 pub const ZERO_EXT: Self = Self(1_000_148_000);
8483 pub const SRC_EXT: Self = Self(1_000_148_001);
8484 pub const DST_EXT: Self = Self(1_000_148_002);
8485 pub const SRC_OVER_EXT: Self = Self(1_000_148_003);
8486 pub const DST_OVER_EXT: Self = Self(1_000_148_004);
8487 pub const SRC_IN_EXT: Self = Self(1_000_148_005);
8488 pub const DST_IN_EXT: Self = Self(1_000_148_006);
8489 pub const SRC_OUT_EXT: Self = Self(1_000_148_007);
8490 pub const DST_OUT_EXT: Self = Self(1_000_148_008);
8491 pub const SRC_ATOP_EXT: Self = Self(1_000_148_009);
8492 pub const DST_ATOP_EXT: Self = Self(1_000_148_010);
8493 pub const XOR_EXT: Self = Self(1_000_148_011);
8494 pub const MULTIPLY_EXT: Self = Self(1_000_148_012);
8495 pub const SCREEN_EXT: Self = Self(1_000_148_013);
8496 pub const OVERLAY_EXT: Self = Self(1_000_148_014);
8497 pub const DARKEN_EXT: Self = Self(1_000_148_015);
8498 pub const LIGHTEN_EXT: Self = Self(1_000_148_016);
8499 pub const COLORDODGE_EXT: Self = Self(1_000_148_017);
8500 pub const COLORBURN_EXT: Self = Self(1_000_148_018);
8501 pub const HARDLIGHT_EXT: Self = Self(1_000_148_019);
8502 pub const SOFTLIGHT_EXT: Self = Self(1_000_148_020);
8503 pub const DIFFERENCE_EXT: Self = Self(1_000_148_021);
8504 pub const EXCLUSION_EXT: Self = Self(1_000_148_022);
8505 pub const INVERT_EXT: Self = Self(1_000_148_023);
8506 pub const INVERT_RGB_EXT: Self = Self(1_000_148_024);
8507 pub const LINEARDODGE_EXT: Self = Self(1_000_148_025);
8508 pub const LINEARBURN_EXT: Self = Self(1_000_148_026);
8509 pub const VIVIDLIGHT_EXT: Self = Self(1_000_148_027);
8510 pub const LINEARLIGHT_EXT: Self = Self(1_000_148_028);
8511 pub const PINLIGHT_EXT: Self = Self(1_000_148_029);
8512 pub const HARDMIX_EXT: Self = Self(1_000_148_030);
8513 pub const HSL_HUE_EXT: Self = Self(1_000_148_031);
8514 pub const HSL_SATURATION_EXT: Self = Self(1_000_148_032);
8515 pub const HSL_COLOR_EXT: Self = Self(1_000_148_033);
8516 pub const HSL_LUMINOSITY_EXT: Self = Self(1_000_148_034);
8517 pub const PLUS_EXT: Self = Self(1_000_148_035);
8518 pub const PLUS_CLAMPED_EXT: Self = Self(1_000_148_036);
8519 pub const PLUS_CLAMPED_ALPHA_EXT: Self = Self(1_000_148_037);
8520 pub const PLUS_DARKER_EXT: Self = Self(1_000_148_038);
8521 pub const MINUS_EXT: Self = Self(1_000_148_039);
8522 pub const MINUS_CLAMPED_EXT: Self = Self(1_000_148_040);
8523 pub const CONTRAST_EXT: Self = Self(1_000_148_041);
8524 pub const INVERT_OVG_EXT: Self = Self(1_000_148_042);
8525 pub const RED_EXT: Self = Self(1_000_148_043);
8526 pub const GREEN_EXT: Self = Self(1_000_148_044);
8527 pub const BLUE_EXT: Self = Self(1_000_148_045);
8528}
8529#[doc = "Generated from 'VK_EXT_blend_operation_advanced'"]
8530impl StructureType {
8531 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: Self = Self(1_000_148_000);
8532 pub const PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: Self = Self(1_000_148_001);
8533 pub const PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: Self = Self(1_000_148_002);
8534}
8535impl NvFragmentCoverageToColorFn {
8536 pub const fn name() -> &'static ::std::ffi::CStr {
8537 unsafe {
8538 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_coverage_to_color\0")
8539 }
8540 }
8541 pub const SPEC_VERSION: u32 = 1u32;
8542}
8543#[derive(Clone)]
8544pub struct NvFragmentCoverageToColorFn {}
8545unsafe impl Send for NvFragmentCoverageToColorFn {}
8546unsafe impl Sync for NvFragmentCoverageToColorFn {}
8547impl NvFragmentCoverageToColorFn {
8548 pub fn load<F>(mut _f: F) -> Self
8549 where
8550 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8551 {
8552 Self {}
8553 }
8554}
8555#[doc = "Generated from 'VK_NV_fragment_coverage_to_color'"]
8556impl StructureType {
8557 pub const PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: Self = Self(1_000_149_000);
8558}
8559impl KhrAccelerationStructureFn {
8560 pub const fn name() -> &'static ::std::ffi::CStr {
8561 unsafe {
8562 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_acceleration_structure\0")
8563 }
8564 }
8565 pub const SPEC_VERSION: u32 = 13u32;
8566}
8567#[allow(non_camel_case_types)]
8568pub type PFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn(
8569 device: Device,
8570 p_create_info: *const AccelerationStructureCreateInfoKHR,
8571 p_allocator: *const AllocationCallbacks,
8572 p_acceleration_structure: *mut AccelerationStructureKHR,
8573) -> Result;
8574#[allow(non_camel_case_types)]
8575pub type PFN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn(
8576 device: Device,
8577 acceleration_structure: AccelerationStructureKHR,
8578 p_allocator: *const AllocationCallbacks,
8579);
8580#[allow(non_camel_case_types)]
8581pub type PFN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn(
8582 command_buffer: CommandBuffer,
8583 info_count: u32,
8584 p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8585 pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
8586);
8587#[allow(non_camel_case_types)]
8588pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn(
8589 command_buffer: CommandBuffer,
8590 info_count: u32,
8591 p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8592 p_indirect_device_addresses: *const DeviceAddress,
8593 p_indirect_strides: *const u32,
8594 pp_max_primitive_counts: *const *const u32,
8595);
8596#[allow(non_camel_case_types)]
8597pub type PFN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn(
8598 device: Device,
8599 deferred_operation: DeferredOperationKHR,
8600 info_count: u32,
8601 p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8602 pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
8603) -> Result;
8604#[allow(non_camel_case_types)]
8605pub type PFN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn(
8606 device: Device,
8607 deferred_operation: DeferredOperationKHR,
8608 p_info: *const CopyAccelerationStructureInfoKHR,
8609) -> Result;
8610#[allow(non_camel_case_types)]
8611pub type PFN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(
8612 device: Device,
8613 deferred_operation: DeferredOperationKHR,
8614 p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
8615) -> Result;
8616#[allow(non_camel_case_types)]
8617pub type PFN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(
8618 device: Device,
8619 deferred_operation: DeferredOperationKHR,
8620 p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
8621) -> Result;
8622#[allow(non_camel_case_types)]
8623pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(
8624 device: Device,
8625 acceleration_structure_count: u32,
8626 p_acceleration_structures: *const AccelerationStructureKHR,
8627 query_type: QueryType,
8628 data_size: usize,
8629 p_data: *mut c_void,
8630 stride: usize,
8631) -> Result;
8632#[allow(non_camel_case_types)]
8633pub type PFN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn(
8634 command_buffer: CommandBuffer,
8635 p_info: *const CopyAccelerationStructureInfoKHR,
8636);
8637#[allow(non_camel_case_types)]
8638pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(
8639 command_buffer: CommandBuffer,
8640 p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
8641);
8642#[allow(non_camel_case_types)]
8643pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(
8644 command_buffer: CommandBuffer,
8645 p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
8646);
8647#[allow(non_camel_case_types)]
8648pub type PFN_vkGetAccelerationStructureDeviceAddressKHR =
8649 unsafe extern "system" fn(
8650 device: Device,
8651 p_info: *const AccelerationStructureDeviceAddressInfoKHR,
8652 ) -> DeviceAddress;
8653#[allow(non_camel_case_types)]
8654pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(
8655 command_buffer: CommandBuffer,
8656 acceleration_structure_count: u32,
8657 p_acceleration_structures: *const AccelerationStructureKHR,
8658 query_type: QueryType,
8659 query_pool: QueryPool,
8660 first_query: u32,
8661);
8662#[allow(non_camel_case_types)]
8663pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn(
8664 device: Device,
8665 p_version_info: *const AccelerationStructureVersionInfoKHR,
8666 p_compatibility: *mut AccelerationStructureCompatibilityKHR,
8667);
8668#[allow(non_camel_case_types)]
8669pub type PFN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn(
8670 device: Device,
8671 build_type: AccelerationStructureBuildTypeKHR,
8672 p_build_info: *const AccelerationStructureBuildGeometryInfoKHR,
8673 p_max_primitive_counts: *const u32,
8674 p_size_info: *mut AccelerationStructureBuildSizesInfoKHR,
8675);
8676#[derive(Clone)]
8677pub struct KhrAccelerationStructureFn {
8678 pub create_acceleration_structure_khr: PFN_vkCreateAccelerationStructureKHR,
8679 pub destroy_acceleration_structure_khr: PFN_vkDestroyAccelerationStructureKHR,
8680 pub cmd_build_acceleration_structures_khr: PFN_vkCmdBuildAccelerationStructuresKHR,
8681 pub cmd_build_acceleration_structures_indirect_khr:
8682 PFN_vkCmdBuildAccelerationStructuresIndirectKHR,
8683 pub build_acceleration_structures_khr: PFN_vkBuildAccelerationStructuresKHR,
8684 pub copy_acceleration_structure_khr: PFN_vkCopyAccelerationStructureKHR,
8685 pub copy_acceleration_structure_to_memory_khr: PFN_vkCopyAccelerationStructureToMemoryKHR,
8686 pub copy_memory_to_acceleration_structure_khr: PFN_vkCopyMemoryToAccelerationStructureKHR,
8687 pub write_acceleration_structures_properties_khr:
8688 PFN_vkWriteAccelerationStructuresPropertiesKHR,
8689 pub cmd_copy_acceleration_structure_khr: PFN_vkCmdCopyAccelerationStructureKHR,
8690 pub cmd_copy_acceleration_structure_to_memory_khr:
8691 PFN_vkCmdCopyAccelerationStructureToMemoryKHR,
8692 pub cmd_copy_memory_to_acceleration_structure_khr:
8693 PFN_vkCmdCopyMemoryToAccelerationStructureKHR,
8694 pub get_acceleration_structure_device_address_khr:
8695 PFN_vkGetAccelerationStructureDeviceAddressKHR,
8696 pub cmd_write_acceleration_structures_properties_khr:
8697 PFN_vkCmdWriteAccelerationStructuresPropertiesKHR,
8698 pub get_device_acceleration_structure_compatibility_khr:
8699 PFN_vkGetDeviceAccelerationStructureCompatibilityKHR,
8700 pub get_acceleration_structure_build_sizes_khr: PFN_vkGetAccelerationStructureBuildSizesKHR,
8701}
8702unsafe impl Send for KhrAccelerationStructureFn {}
8703unsafe impl Sync for KhrAccelerationStructureFn {}
8704impl KhrAccelerationStructureFn {
8705 pub fn load<F>(mut _f: F) -> Self
8706 where
8707 F: FnMut(&::std::ffi::CStr) -> *const c_void,
8708 {
8709 Self {
8710 create_acceleration_structure_khr: unsafe {
8711 unsafe extern "system" fn create_acceleration_structure_khr(
8712 _device: Device,
8713 _p_create_info: *const AccelerationStructureCreateInfoKHR,
8714 _p_allocator: *const AllocationCallbacks,
8715 _p_acceleration_structure: *mut AccelerationStructureKHR,
8716 ) -> Result {
8717 panic!(concat!(
8718 "Unable to load ",
8719 stringify!(create_acceleration_structure_khr)
8720 ))
8721 }
8722 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8723 b"vkCreateAccelerationStructureKHR\0",
8724 );
8725 let val = _f(cname);
8726 if val.is_null() {
8727 create_acceleration_structure_khr
8728 } else {
8729 ::std::mem::transmute(val)
8730 }
8731 },
8732 destroy_acceleration_structure_khr: unsafe {
8733 unsafe extern "system" fn destroy_acceleration_structure_khr(
8734 _device: Device,
8735 _acceleration_structure: AccelerationStructureKHR,
8736 _p_allocator: *const AllocationCallbacks,
8737 ) {
8738 panic!(concat!(
8739 "Unable to load ",
8740 stringify!(destroy_acceleration_structure_khr)
8741 ))
8742 }
8743 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8744 b"vkDestroyAccelerationStructureKHR\0",
8745 );
8746 let val = _f(cname);
8747 if val.is_null() {
8748 destroy_acceleration_structure_khr
8749 } else {
8750 ::std::mem::transmute(val)
8751 }
8752 },
8753 cmd_build_acceleration_structures_khr: unsafe {
8754 unsafe extern "system" fn cmd_build_acceleration_structures_khr(
8755 _command_buffer: CommandBuffer,
8756 _info_count: u32,
8757 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8758 _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
8759 ) {
8760 panic!(concat!(
8761 "Unable to load ",
8762 stringify!(cmd_build_acceleration_structures_khr)
8763 ))
8764 }
8765 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8766 b"vkCmdBuildAccelerationStructuresKHR\0",
8767 );
8768 let val = _f(cname);
8769 if val.is_null() {
8770 cmd_build_acceleration_structures_khr
8771 } else {
8772 ::std::mem::transmute(val)
8773 }
8774 },
8775 cmd_build_acceleration_structures_indirect_khr: unsafe {
8776 unsafe extern "system" fn cmd_build_acceleration_structures_indirect_khr(
8777 _command_buffer: CommandBuffer,
8778 _info_count: u32,
8779 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8780 _p_indirect_device_addresses: *const DeviceAddress,
8781 _p_indirect_strides: *const u32,
8782 _pp_max_primitive_counts: *const *const u32,
8783 ) {
8784 panic!(concat!(
8785 "Unable to load ",
8786 stringify!(cmd_build_acceleration_structures_indirect_khr)
8787 ))
8788 }
8789 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8790 b"vkCmdBuildAccelerationStructuresIndirectKHR\0",
8791 );
8792 let val = _f(cname);
8793 if val.is_null() {
8794 cmd_build_acceleration_structures_indirect_khr
8795 } else {
8796 ::std::mem::transmute(val)
8797 }
8798 },
8799 build_acceleration_structures_khr: unsafe {
8800 unsafe extern "system" fn build_acceleration_structures_khr(
8801 _device: Device,
8802 _deferred_operation: DeferredOperationKHR,
8803 _info_count: u32,
8804 _p_infos: *const AccelerationStructureBuildGeometryInfoKHR,
8805 _pp_build_range_infos: *const *const AccelerationStructureBuildRangeInfoKHR,
8806 ) -> Result {
8807 panic!(concat!(
8808 "Unable to load ",
8809 stringify!(build_acceleration_structures_khr)
8810 ))
8811 }
8812 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8813 b"vkBuildAccelerationStructuresKHR\0",
8814 );
8815 let val = _f(cname);
8816 if val.is_null() {
8817 build_acceleration_structures_khr
8818 } else {
8819 ::std::mem::transmute(val)
8820 }
8821 },
8822 copy_acceleration_structure_khr: unsafe {
8823 unsafe extern "system" fn copy_acceleration_structure_khr(
8824 _device: Device,
8825 _deferred_operation: DeferredOperationKHR,
8826 _p_info: *const CopyAccelerationStructureInfoKHR,
8827 ) -> Result {
8828 panic!(concat!(
8829 "Unable to load ",
8830 stringify!(copy_acceleration_structure_khr)
8831 ))
8832 }
8833 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8834 b"vkCopyAccelerationStructureKHR\0",
8835 );
8836 let val = _f(cname);
8837 if val.is_null() {
8838 copy_acceleration_structure_khr
8839 } else {
8840 ::std::mem::transmute(val)
8841 }
8842 },
8843 copy_acceleration_structure_to_memory_khr: unsafe {
8844 unsafe extern "system" fn copy_acceleration_structure_to_memory_khr(
8845 _device: Device,
8846 _deferred_operation: DeferredOperationKHR,
8847 _p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
8848 ) -> Result {
8849 panic!(concat!(
8850 "Unable to load ",
8851 stringify!(copy_acceleration_structure_to_memory_khr)
8852 ))
8853 }
8854 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8855 b"vkCopyAccelerationStructureToMemoryKHR\0",
8856 );
8857 let val = _f(cname);
8858 if val.is_null() {
8859 copy_acceleration_structure_to_memory_khr
8860 } else {
8861 ::std::mem::transmute(val)
8862 }
8863 },
8864 copy_memory_to_acceleration_structure_khr: unsafe {
8865 unsafe extern "system" fn copy_memory_to_acceleration_structure_khr(
8866 _device: Device,
8867 _deferred_operation: DeferredOperationKHR,
8868 _p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
8869 ) -> Result {
8870 panic!(concat!(
8871 "Unable to load ",
8872 stringify!(copy_memory_to_acceleration_structure_khr)
8873 ))
8874 }
8875 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8876 b"vkCopyMemoryToAccelerationStructureKHR\0",
8877 );
8878 let val = _f(cname);
8879 if val.is_null() {
8880 copy_memory_to_acceleration_structure_khr
8881 } else {
8882 ::std::mem::transmute(val)
8883 }
8884 },
8885 write_acceleration_structures_properties_khr: unsafe {
8886 unsafe extern "system" fn write_acceleration_structures_properties_khr(
8887 _device: Device,
8888 _acceleration_structure_count: u32,
8889 _p_acceleration_structures: *const AccelerationStructureKHR,
8890 _query_type: QueryType,
8891 _data_size: usize,
8892 _p_data: *mut c_void,
8893 _stride: usize,
8894 ) -> Result {
8895 panic!(concat!(
8896 "Unable to load ",
8897 stringify!(write_acceleration_structures_properties_khr)
8898 ))
8899 }
8900 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8901 b"vkWriteAccelerationStructuresPropertiesKHR\0",
8902 );
8903 let val = _f(cname);
8904 if val.is_null() {
8905 write_acceleration_structures_properties_khr
8906 } else {
8907 ::std::mem::transmute(val)
8908 }
8909 },
8910 cmd_copy_acceleration_structure_khr: unsafe {
8911 unsafe extern "system" fn cmd_copy_acceleration_structure_khr(
8912 _command_buffer: CommandBuffer,
8913 _p_info: *const CopyAccelerationStructureInfoKHR,
8914 ) {
8915 panic!(concat!(
8916 "Unable to load ",
8917 stringify!(cmd_copy_acceleration_structure_khr)
8918 ))
8919 }
8920 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8921 b"vkCmdCopyAccelerationStructureKHR\0",
8922 );
8923 let val = _f(cname);
8924 if val.is_null() {
8925 cmd_copy_acceleration_structure_khr
8926 } else {
8927 ::std::mem::transmute(val)
8928 }
8929 },
8930 cmd_copy_acceleration_structure_to_memory_khr: unsafe {
8931 unsafe extern "system" fn cmd_copy_acceleration_structure_to_memory_khr(
8932 _command_buffer: CommandBuffer,
8933 _p_info: *const CopyAccelerationStructureToMemoryInfoKHR,
8934 ) {
8935 panic!(concat!(
8936 "Unable to load ",
8937 stringify!(cmd_copy_acceleration_structure_to_memory_khr)
8938 ))
8939 }
8940 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8941 b"vkCmdCopyAccelerationStructureToMemoryKHR\0",
8942 );
8943 let val = _f(cname);
8944 if val.is_null() {
8945 cmd_copy_acceleration_structure_to_memory_khr
8946 } else {
8947 ::std::mem::transmute(val)
8948 }
8949 },
8950 cmd_copy_memory_to_acceleration_structure_khr: unsafe {
8951 unsafe extern "system" fn cmd_copy_memory_to_acceleration_structure_khr(
8952 _command_buffer: CommandBuffer,
8953 _p_info: *const CopyMemoryToAccelerationStructureInfoKHR,
8954 ) {
8955 panic!(concat!(
8956 "Unable to load ",
8957 stringify!(cmd_copy_memory_to_acceleration_structure_khr)
8958 ))
8959 }
8960 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8961 b"vkCmdCopyMemoryToAccelerationStructureKHR\0",
8962 );
8963 let val = _f(cname);
8964 if val.is_null() {
8965 cmd_copy_memory_to_acceleration_structure_khr
8966 } else {
8967 ::std::mem::transmute(val)
8968 }
8969 },
8970 get_acceleration_structure_device_address_khr: unsafe {
8971 unsafe extern "system" fn get_acceleration_structure_device_address_khr(
8972 _device: Device,
8973 _p_info: *const AccelerationStructureDeviceAddressInfoKHR,
8974 ) -> DeviceAddress {
8975 panic!(concat!(
8976 "Unable to load ",
8977 stringify!(get_acceleration_structure_device_address_khr)
8978 ))
8979 }
8980 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
8981 b"vkGetAccelerationStructureDeviceAddressKHR\0",
8982 );
8983 let val = _f(cname);
8984 if val.is_null() {
8985 get_acceleration_structure_device_address_khr
8986 } else {
8987 ::std::mem::transmute(val)
8988 }
8989 },
8990 cmd_write_acceleration_structures_properties_khr: unsafe {
8991 unsafe extern "system" fn cmd_write_acceleration_structures_properties_khr(
8992 _command_buffer: CommandBuffer,
8993 _acceleration_structure_count: u32,
8994 _p_acceleration_structures: *const AccelerationStructureKHR,
8995 _query_type: QueryType,
8996 _query_pool: QueryPool,
8997 _first_query: u32,
8998 ) {
8999 panic!(concat!(
9000 "Unable to load ",
9001 stringify!(cmd_write_acceleration_structures_properties_khr)
9002 ))
9003 }
9004 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9005 b"vkCmdWriteAccelerationStructuresPropertiesKHR\0",
9006 );
9007 let val = _f(cname);
9008 if val.is_null() {
9009 cmd_write_acceleration_structures_properties_khr
9010 } else {
9011 ::std::mem::transmute(val)
9012 }
9013 },
9014 get_device_acceleration_structure_compatibility_khr: unsafe {
9015 unsafe extern "system" fn get_device_acceleration_structure_compatibility_khr(
9016 _device: Device,
9017 _p_version_info: *const AccelerationStructureVersionInfoKHR,
9018 _p_compatibility: *mut AccelerationStructureCompatibilityKHR,
9019 ) {
9020 panic!(concat!(
9021 "Unable to load ",
9022 stringify!(get_device_acceleration_structure_compatibility_khr)
9023 ))
9024 }
9025 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9026 b"vkGetDeviceAccelerationStructureCompatibilityKHR\0",
9027 );
9028 let val = _f(cname);
9029 if val.is_null() {
9030 get_device_acceleration_structure_compatibility_khr
9031 } else {
9032 ::std::mem::transmute(val)
9033 }
9034 },
9035 get_acceleration_structure_build_sizes_khr: unsafe {
9036 unsafe extern "system" fn get_acceleration_structure_build_sizes_khr(
9037 _device: Device,
9038 _build_type: AccelerationStructureBuildTypeKHR,
9039 _p_build_info: *const AccelerationStructureBuildGeometryInfoKHR,
9040 _p_max_primitive_counts: *const u32,
9041 _p_size_info: *mut AccelerationStructureBuildSizesInfoKHR,
9042 ) {
9043 panic!(concat!(
9044 "Unable to load ",
9045 stringify!(get_acceleration_structure_build_sizes_khr)
9046 ))
9047 }
9048 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9049 b"vkGetAccelerationStructureBuildSizesKHR\0",
9050 );
9051 let val = _f(cname);
9052 if val.is_null() {
9053 get_acceleration_structure_build_sizes_khr
9054 } else {
9055 ::std::mem::transmute(val)
9056 }
9057 },
9058 }
9059 }
9060}
9061#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9062impl AccessFlags {
9063 pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
9064 pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
9065}
9066#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9067impl BufferUsageFlags {
9068 pub const ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_KHR: Self =
9069 Self(0b1000_0000_0000_0000_0000);
9070 pub const ACCELERATION_STRUCTURE_STORAGE_KHR: Self = Self(0b1_0000_0000_0000_0000_0000);
9071}
9072#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9073impl DebugReportObjectTypeEXT {
9074 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
9075}
9076#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9077impl DescriptorType {
9078 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
9079}
9080#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9081impl FormatFeatureFlags {
9082 pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self =
9083 Self(0b10_0000_0000_0000_0000_0000_0000_0000);
9084}
9085#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9086impl FormatFeatureFlags2 {
9087 pub const ACCELERATION_STRUCTURE_VERTEX_BUFFER_KHR: Self =
9088 Self(0b10_0000_0000_0000_0000_0000_0000_0000);
9089}
9090#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9091impl IndexType {
9092 pub const NONE_KHR: Self = Self(1_000_165_000);
9093}
9094#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9095impl ObjectType {
9096 pub const ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_000);
9097}
9098#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9099impl PipelineStageFlags {
9100 pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
9101}
9102#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9103impl QueryType {
9104 pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: Self = Self(1_000_150_000);
9105 pub const ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: Self = Self(1_000_150_001);
9106}
9107#[doc = "Generated from 'VK_KHR_acceleration_structure'"]
9108impl StructureType {
9109 pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: Self = Self(1_000_150_007);
9110 pub const ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: Self = Self(1_000_150_000);
9111 pub const ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: Self = Self(1_000_150_002);
9112 pub const ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: Self = Self(1_000_150_003);
9113 pub const ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: Self = Self(1_000_150_004);
9114 pub const ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: Self = Self(1_000_150_005);
9115 pub const ACCELERATION_STRUCTURE_GEOMETRY_KHR: Self = Self(1_000_150_006);
9116 pub const ACCELERATION_STRUCTURE_VERSION_INFO_KHR: Self = Self(1_000_150_009);
9117 pub const COPY_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_010);
9118 pub const COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: Self = Self(1_000_150_011);
9119 pub const COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: Self = Self(1_000_150_012);
9120 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: Self = Self(1_000_150_013);
9121 pub const PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: Self = Self(1_000_150_014);
9122 pub const ACCELERATION_STRUCTURE_CREATE_INFO_KHR: Self = Self(1_000_150_017);
9123 pub const ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: Self = Self(1_000_150_020);
9124}
9125impl KhrRayTracingPipelineFn {
9126 pub const fn name() -> &'static ::std::ffi::CStr {
9127 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_tracing_pipeline\0") }
9128 }
9129 pub const SPEC_VERSION: u32 = 1u32;
9130}
9131#[allow(non_camel_case_types)]
9132pub type PFN_vkCmdTraceRaysKHR = unsafe extern "system" fn(
9133 command_buffer: CommandBuffer,
9134 p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9135 p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9136 p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9137 p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9138 width: u32,
9139 height: u32,
9140 depth: u32,
9141);
9142#[allow(non_camel_case_types)]
9143pub type PFN_vkCreateRayTracingPipelinesKHR = unsafe extern "system" fn(
9144 device: Device,
9145 deferred_operation: DeferredOperationKHR,
9146 pipeline_cache: PipelineCache,
9147 create_info_count: u32,
9148 p_create_infos: *const RayTracingPipelineCreateInfoKHR,
9149 p_allocator: *const AllocationCallbacks,
9150 p_pipelines: *mut Pipeline,
9151) -> Result;
9152#[allow(non_camel_case_types)]
9153pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn(
9154 device: Device,
9155 pipeline: Pipeline,
9156 first_group: u32,
9157 group_count: u32,
9158 data_size: usize,
9159 p_data: *mut c_void,
9160) -> Result;
9161#[allow(non_camel_case_types)]
9162pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR =
9163 unsafe extern "system" fn(
9164 device: Device,
9165 pipeline: Pipeline,
9166 first_group: u32,
9167 group_count: u32,
9168 data_size: usize,
9169 p_data: *mut c_void,
9170 ) -> Result;
9171#[allow(non_camel_case_types)]
9172pub type PFN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn(
9173 command_buffer: CommandBuffer,
9174 p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9175 p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9176 p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9177 p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9178 indirect_device_address: DeviceAddress,
9179);
9180#[allow(non_camel_case_types)]
9181pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn(
9182 device: Device,
9183 pipeline: Pipeline,
9184 group: u32,
9185 group_shader: ShaderGroupShaderKHR,
9186) -> DeviceSize;
9187#[allow(non_camel_case_types)]
9188pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR =
9189 unsafe extern "system" fn(command_buffer: CommandBuffer, pipeline_stack_size: u32);
9190#[derive(Clone)]
9191pub struct KhrRayTracingPipelineFn {
9192 pub cmd_trace_rays_khr: PFN_vkCmdTraceRaysKHR,
9193 pub create_ray_tracing_pipelines_khr: PFN_vkCreateRayTracingPipelinesKHR,
9194 pub get_ray_tracing_shader_group_handles_khr: PFN_vkGetRayTracingShaderGroupHandlesKHR,
9195 pub get_ray_tracing_capture_replay_shader_group_handles_khr:
9196 PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR,
9197 pub cmd_trace_rays_indirect_khr: PFN_vkCmdTraceRaysIndirectKHR,
9198 pub get_ray_tracing_shader_group_stack_size_khr: PFN_vkGetRayTracingShaderGroupStackSizeKHR,
9199 pub cmd_set_ray_tracing_pipeline_stack_size_khr: PFN_vkCmdSetRayTracingPipelineStackSizeKHR,
9200}
9201unsafe impl Send for KhrRayTracingPipelineFn {}
9202unsafe impl Sync for KhrRayTracingPipelineFn {}
9203impl KhrRayTracingPipelineFn {
9204 pub fn load<F>(mut _f: F) -> Self
9205 where
9206 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9207 {
9208 Self {
9209 cmd_trace_rays_khr: unsafe {
9210 unsafe extern "system" fn cmd_trace_rays_khr(
9211 _command_buffer: CommandBuffer,
9212 _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9213 _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9214 _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9215 _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9216 _width: u32,
9217 _height: u32,
9218 _depth: u32,
9219 ) {
9220 panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_khr)))
9221 }
9222 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysKHR\0");
9223 let val = _f(cname);
9224 if val.is_null() {
9225 cmd_trace_rays_khr
9226 } else {
9227 ::std::mem::transmute(val)
9228 }
9229 },
9230 create_ray_tracing_pipelines_khr: unsafe {
9231 unsafe extern "system" fn create_ray_tracing_pipelines_khr(
9232 _device: Device,
9233 _deferred_operation: DeferredOperationKHR,
9234 _pipeline_cache: PipelineCache,
9235 _create_info_count: u32,
9236 _p_create_infos: *const RayTracingPipelineCreateInfoKHR,
9237 _p_allocator: *const AllocationCallbacks,
9238 _p_pipelines: *mut Pipeline,
9239 ) -> Result {
9240 panic!(concat!(
9241 "Unable to load ",
9242 stringify!(create_ray_tracing_pipelines_khr)
9243 ))
9244 }
9245 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9246 b"vkCreateRayTracingPipelinesKHR\0",
9247 );
9248 let val = _f(cname);
9249 if val.is_null() {
9250 create_ray_tracing_pipelines_khr
9251 } else {
9252 ::std::mem::transmute(val)
9253 }
9254 },
9255 get_ray_tracing_shader_group_handles_khr: unsafe {
9256 unsafe extern "system" fn get_ray_tracing_shader_group_handles_khr(
9257 _device: Device,
9258 _pipeline: Pipeline,
9259 _first_group: u32,
9260 _group_count: u32,
9261 _data_size: usize,
9262 _p_data: *mut c_void,
9263 ) -> Result {
9264 panic!(concat!(
9265 "Unable to load ",
9266 stringify!(get_ray_tracing_shader_group_handles_khr)
9267 ))
9268 }
9269 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9270 b"vkGetRayTracingShaderGroupHandlesKHR\0",
9271 );
9272 let val = _f(cname);
9273 if val.is_null() {
9274 get_ray_tracing_shader_group_handles_khr
9275 } else {
9276 ::std::mem::transmute(val)
9277 }
9278 },
9279 get_ray_tracing_capture_replay_shader_group_handles_khr: unsafe {
9280 unsafe extern "system" fn get_ray_tracing_capture_replay_shader_group_handles_khr(
9281 _device: Device,
9282 _pipeline: Pipeline,
9283 _first_group: u32,
9284 _group_count: u32,
9285 _data_size: usize,
9286 _p_data: *mut c_void,
9287 ) -> Result {
9288 panic!(concat!(
9289 "Unable to load ",
9290 stringify!(get_ray_tracing_capture_replay_shader_group_handles_khr)
9291 ))
9292 }
9293 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9294 b"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR\0",
9295 );
9296 let val = _f(cname);
9297 if val.is_null() {
9298 get_ray_tracing_capture_replay_shader_group_handles_khr
9299 } else {
9300 ::std::mem::transmute(val)
9301 }
9302 },
9303 cmd_trace_rays_indirect_khr: unsafe {
9304 unsafe extern "system" fn cmd_trace_rays_indirect_khr(
9305 _command_buffer: CommandBuffer,
9306 _p_raygen_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9307 _p_miss_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9308 _p_hit_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9309 _p_callable_shader_binding_table: *const StridedDeviceAddressRegionKHR,
9310 _indirect_device_address: DeviceAddress,
9311 ) {
9312 panic!(concat!(
9313 "Unable to load ",
9314 stringify!(cmd_trace_rays_indirect_khr)
9315 ))
9316 }
9317 let cname =
9318 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysIndirectKHR\0");
9319 let val = _f(cname);
9320 if val.is_null() {
9321 cmd_trace_rays_indirect_khr
9322 } else {
9323 ::std::mem::transmute(val)
9324 }
9325 },
9326 get_ray_tracing_shader_group_stack_size_khr: unsafe {
9327 unsafe extern "system" fn get_ray_tracing_shader_group_stack_size_khr(
9328 _device: Device,
9329 _pipeline: Pipeline,
9330 _group: u32,
9331 _group_shader: ShaderGroupShaderKHR,
9332 ) -> DeviceSize {
9333 panic!(concat!(
9334 "Unable to load ",
9335 stringify!(get_ray_tracing_shader_group_stack_size_khr)
9336 ))
9337 }
9338 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9339 b"vkGetRayTracingShaderGroupStackSizeKHR\0",
9340 );
9341 let val = _f(cname);
9342 if val.is_null() {
9343 get_ray_tracing_shader_group_stack_size_khr
9344 } else {
9345 ::std::mem::transmute(val)
9346 }
9347 },
9348 cmd_set_ray_tracing_pipeline_stack_size_khr: unsafe {
9349 unsafe extern "system" fn cmd_set_ray_tracing_pipeline_stack_size_khr(
9350 _command_buffer: CommandBuffer,
9351 _pipeline_stack_size: u32,
9352 ) {
9353 panic!(concat!(
9354 "Unable to load ",
9355 stringify!(cmd_set_ray_tracing_pipeline_stack_size_khr)
9356 ))
9357 }
9358 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9359 b"vkCmdSetRayTracingPipelineStackSizeKHR\0",
9360 );
9361 let val = _f(cname);
9362 if val.is_null() {
9363 cmd_set_ray_tracing_pipeline_stack_size_khr
9364 } else {
9365 ::std::mem::transmute(val)
9366 }
9367 },
9368 }
9369 }
9370}
9371#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9372impl BufferUsageFlags {
9373 pub const SHADER_BINDING_TABLE_KHR: Self = Self(0b100_0000_0000);
9374}
9375#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9376impl DynamicState {
9377 pub const RAY_TRACING_PIPELINE_STACK_SIZE_KHR: Self = Self(1_000_347_000);
9378}
9379#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9380impl PipelineBindPoint {
9381 pub const RAY_TRACING_KHR: Self = Self(1_000_165_000);
9382}
9383#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9384impl PipelineCreateFlags {
9385 pub const RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_KHR: Self = Self(0b100_0000_0000_0000);
9386 pub const RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_KHR: Self = Self(0b1000_0000_0000_0000);
9387 pub const RAY_TRACING_NO_NULL_MISS_SHADERS_KHR: Self = Self(0b1_0000_0000_0000_0000);
9388 pub const RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_KHR: Self = Self(0b10_0000_0000_0000_0000);
9389 pub const RAY_TRACING_SKIP_TRIANGLES_KHR: Self = Self(0b1_0000_0000_0000);
9390 pub const RAY_TRACING_SKIP_AABBS_KHR: Self = Self(0b10_0000_0000_0000);
9391 pub const RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_KHR: Self =
9392 Self(0b1000_0000_0000_0000_0000);
9393}
9394#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9395impl PipelineStageFlags {
9396 pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
9397}
9398#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9399impl ShaderStageFlags {
9400 pub const RAYGEN_KHR: Self = Self(0b1_0000_0000);
9401 pub const ANY_HIT_KHR: Self = Self(0b10_0000_0000);
9402 pub const CLOSEST_HIT_KHR: Self = Self(0b100_0000_0000);
9403 pub const MISS_KHR: Self = Self(0b1000_0000_0000);
9404 pub const INTERSECTION_KHR: Self = Self(0b1_0000_0000_0000);
9405 pub const CALLABLE_KHR: Self = Self(0b10_0000_0000_0000);
9406}
9407#[doc = "Generated from 'VK_KHR_ray_tracing_pipeline'"]
9408impl StructureType {
9409 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: Self = Self(1_000_347_000);
9410 pub const PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: Self = Self(1_000_347_001);
9411 pub const RAY_TRACING_PIPELINE_CREATE_INFO_KHR: Self = Self(1_000_150_015);
9412 pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: Self = Self(1_000_150_016);
9413 pub const RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: Self = Self(1_000_150_018);
9414}
9415impl KhrRayQueryFn {
9416 pub const fn name() -> &'static ::std::ffi::CStr {
9417 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_ray_query\0") }
9418 }
9419 pub const SPEC_VERSION: u32 = 1u32;
9420}
9421#[derive(Clone)]
9422pub struct KhrRayQueryFn {}
9423unsafe impl Send for KhrRayQueryFn {}
9424unsafe impl Sync for KhrRayQueryFn {}
9425impl KhrRayQueryFn {
9426 pub fn load<F>(mut _f: F) -> Self
9427 where
9428 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9429 {
9430 Self {}
9431 }
9432}
9433#[doc = "Generated from 'VK_KHR_ray_query'"]
9434impl StructureType {
9435 pub const PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: Self = Self(1_000_348_013);
9436}
9437impl NvExtension152Fn {
9438 pub const fn name() -> &'static ::std::ffi::CStr {
9439 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_152\0") }
9440 }
9441 pub const SPEC_VERSION: u32 = 0u32;
9442}
9443#[derive(Clone)]
9444pub struct NvExtension152Fn {}
9445unsafe impl Send for NvExtension152Fn {}
9446unsafe impl Sync for NvExtension152Fn {}
9447impl NvExtension152Fn {
9448 pub fn load<F>(mut _f: F) -> Self
9449 where
9450 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9451 {
9452 Self {}
9453 }
9454}
9455impl NvFramebufferMixedSamplesFn {
9456 pub const fn name() -> &'static ::std::ffi::CStr {
9457 unsafe {
9458 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_framebuffer_mixed_samples\0")
9459 }
9460 }
9461 pub const SPEC_VERSION: u32 = 1u32;
9462}
9463#[derive(Clone)]
9464pub struct NvFramebufferMixedSamplesFn {}
9465unsafe impl Send for NvFramebufferMixedSamplesFn {}
9466unsafe impl Sync for NvFramebufferMixedSamplesFn {}
9467impl NvFramebufferMixedSamplesFn {
9468 pub fn load<F>(mut _f: F) -> Self
9469 where
9470 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9471 {
9472 Self {}
9473 }
9474}
9475#[doc = "Generated from 'VK_NV_framebuffer_mixed_samples'"]
9476impl StructureType {
9477 pub const PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: Self = Self(1_000_152_000);
9478}
9479impl NvFillRectangleFn {
9480 pub const fn name() -> &'static ::std::ffi::CStr {
9481 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fill_rectangle\0") }
9482 }
9483 pub const SPEC_VERSION: u32 = 1u32;
9484}
9485#[derive(Clone)]
9486pub struct NvFillRectangleFn {}
9487unsafe impl Send for NvFillRectangleFn {}
9488unsafe impl Sync for NvFillRectangleFn {}
9489impl NvFillRectangleFn {
9490 pub fn load<F>(mut _f: F) -> Self
9491 where
9492 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9493 {
9494 Self {}
9495 }
9496}
9497#[doc = "Generated from 'VK_NV_fill_rectangle'"]
9498impl PolygonMode {
9499 pub const FILL_RECTANGLE_NV: Self = Self(1_000_153_000);
9500}
9501impl NvShaderSmBuiltinsFn {
9502 pub const fn name() -> &'static ::std::ffi::CStr {
9503 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_sm_builtins\0") }
9504 }
9505 pub const SPEC_VERSION: u32 = 1u32;
9506}
9507#[derive(Clone)]
9508pub struct NvShaderSmBuiltinsFn {}
9509unsafe impl Send for NvShaderSmBuiltinsFn {}
9510unsafe impl Sync for NvShaderSmBuiltinsFn {}
9511impl NvShaderSmBuiltinsFn {
9512 pub fn load<F>(mut _f: F) -> Self
9513 where
9514 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9515 {
9516 Self {}
9517 }
9518}
9519#[doc = "Generated from 'VK_NV_shader_sm_builtins'"]
9520impl StructureType {
9521 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: Self = Self(1_000_154_000);
9522 pub const PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: Self = Self(1_000_154_001);
9523}
9524impl ExtPostDepthCoverageFn {
9525 pub const fn name() -> &'static ::std::ffi::CStr {
9526 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_post_depth_coverage\0") }
9527 }
9528 pub const SPEC_VERSION: u32 = 1u32;
9529}
9530#[derive(Clone)]
9531pub struct ExtPostDepthCoverageFn {}
9532unsafe impl Send for ExtPostDepthCoverageFn {}
9533unsafe impl Sync for ExtPostDepthCoverageFn {}
9534impl ExtPostDepthCoverageFn {
9535 pub fn load<F>(mut _f: F) -> Self
9536 where
9537 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9538 {
9539 Self {}
9540 }
9541}
9542impl KhrSamplerYcbcrConversionFn {
9543 pub const fn name() -> &'static ::std::ffi::CStr {
9544 unsafe {
9545 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_sampler_ycbcr_conversion\0")
9546 }
9547 }
9548 pub const SPEC_VERSION: u32 = 14u32;
9549}
9550#[allow(non_camel_case_types)]
9551pub type PFN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn(
9552 device: Device,
9553 p_create_info: *const SamplerYcbcrConversionCreateInfo,
9554 p_allocator: *const AllocationCallbacks,
9555 p_ycbcr_conversion: *mut SamplerYcbcrConversion,
9556) -> Result;
9557#[allow(non_camel_case_types)]
9558pub type PFN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn(
9559 device: Device,
9560 ycbcr_conversion: SamplerYcbcrConversion,
9561 p_allocator: *const AllocationCallbacks,
9562);
9563#[derive(Clone)]
9564pub struct KhrSamplerYcbcrConversionFn {
9565 pub create_sampler_ycbcr_conversion_khr: PFN_vkCreateSamplerYcbcrConversion,
9566 pub destroy_sampler_ycbcr_conversion_khr: PFN_vkDestroySamplerYcbcrConversion,
9567}
9568unsafe impl Send for KhrSamplerYcbcrConversionFn {}
9569unsafe impl Sync for KhrSamplerYcbcrConversionFn {}
9570impl KhrSamplerYcbcrConversionFn {
9571 pub fn load<F>(mut _f: F) -> Self
9572 where
9573 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9574 {
9575 Self {
9576 create_sampler_ycbcr_conversion_khr: unsafe {
9577 unsafe extern "system" fn create_sampler_ycbcr_conversion_khr(
9578 _device: Device,
9579 _p_create_info: *const SamplerYcbcrConversionCreateInfo,
9580 _p_allocator: *const AllocationCallbacks,
9581 _p_ycbcr_conversion: *mut SamplerYcbcrConversion,
9582 ) -> Result {
9583 panic!(concat!(
9584 "Unable to load ",
9585 stringify!(create_sampler_ycbcr_conversion_khr)
9586 ))
9587 }
9588 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9589 b"vkCreateSamplerYcbcrConversionKHR\0",
9590 );
9591 let val = _f(cname);
9592 if val.is_null() {
9593 create_sampler_ycbcr_conversion_khr
9594 } else {
9595 ::std::mem::transmute(val)
9596 }
9597 },
9598 destroy_sampler_ycbcr_conversion_khr: unsafe {
9599 unsafe extern "system" fn destroy_sampler_ycbcr_conversion_khr(
9600 _device: Device,
9601 _ycbcr_conversion: SamplerYcbcrConversion,
9602 _p_allocator: *const AllocationCallbacks,
9603 ) {
9604 panic!(concat!(
9605 "Unable to load ",
9606 stringify!(destroy_sampler_ycbcr_conversion_khr)
9607 ))
9608 }
9609 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9610 b"vkDestroySamplerYcbcrConversionKHR\0",
9611 );
9612 let val = _f(cname);
9613 if val.is_null() {
9614 destroy_sampler_ycbcr_conversion_khr
9615 } else {
9616 ::std::mem::transmute(val)
9617 }
9618 },
9619 }
9620 }
9621}
9622#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9623impl ChromaLocation {
9624 pub const COSITED_EVEN_KHR: Self = Self::COSITED_EVEN;
9625 pub const MIDPOINT_KHR: Self = Self::MIDPOINT;
9626}
9627#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9628impl DebugReportObjectTypeEXT {
9629 pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION;
9630}
9631#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9632impl Format {
9633 pub const G8B8G8R8_422_UNORM_KHR: Self = Self::G8B8G8R8_422_UNORM;
9634 pub const B8G8R8G8_422_UNORM_KHR: Self = Self::B8G8R8G8_422_UNORM;
9635 pub const G8_B8_R8_3PLANE_420_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_420_UNORM;
9636 pub const G8_B8R8_2PLANE_420_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_420_UNORM;
9637 pub const G8_B8_R8_3PLANE_422_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_422_UNORM;
9638 pub const G8_B8R8_2PLANE_422_UNORM_KHR: Self = Self::G8_B8R8_2PLANE_422_UNORM;
9639 pub const G8_B8_R8_3PLANE_444_UNORM_KHR: Self = Self::G8_B8_R8_3PLANE_444_UNORM;
9640 pub const R10X6_UNORM_PACK16_KHR: Self = Self::R10X6_UNORM_PACK16;
9641 pub const R10X6G10X6_UNORM_2PACK16_KHR: Self = Self::R10X6G10X6_UNORM_2PACK16;
9642 pub const R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: Self =
9643 Self::R10X6G10X6B10X6A10X6_UNORM_4PACK16;
9644 pub const G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: Self =
9645 Self::G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
9646 pub const B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: Self =
9647 Self::B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
9648 pub const G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: Self =
9649 Self::G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
9650 pub const G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: Self =
9651 Self::G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
9652 pub const G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: Self =
9653 Self::G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
9654 pub const G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: Self =
9655 Self::G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
9656 pub const G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: Self =
9657 Self::G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
9658 pub const R12X4_UNORM_PACK16_KHR: Self = Self::R12X4_UNORM_PACK16;
9659 pub const R12X4G12X4_UNORM_2PACK16_KHR: Self = Self::R12X4G12X4_UNORM_2PACK16;
9660 pub const R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: Self =
9661 Self::R12X4G12X4B12X4A12X4_UNORM_4PACK16;
9662 pub const G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: Self =
9663 Self::G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
9664 pub const B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: Self =
9665 Self::B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
9666 pub const G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: Self =
9667 Self::G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
9668 pub const G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: Self =
9669 Self::G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
9670 pub const G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: Self =
9671 Self::G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
9672 pub const G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: Self =
9673 Self::G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
9674 pub const G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: Self =
9675 Self::G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
9676 pub const G16B16G16R16_422_UNORM_KHR: Self = Self::G16B16G16R16_422_UNORM;
9677 pub const B16G16R16G16_422_UNORM_KHR: Self = Self::B16G16R16G16_422_UNORM;
9678 pub const G16_B16_R16_3PLANE_420_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_420_UNORM;
9679 pub const G16_B16R16_2PLANE_420_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_420_UNORM;
9680 pub const G16_B16_R16_3PLANE_422_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_422_UNORM;
9681 pub const G16_B16R16_2PLANE_422_UNORM_KHR: Self = Self::G16_B16R16_2PLANE_422_UNORM;
9682 pub const G16_B16_R16_3PLANE_444_UNORM_KHR: Self = Self::G16_B16_R16_3PLANE_444_UNORM;
9683}
9684#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9685impl FormatFeatureFlags {
9686 pub const MIDPOINT_CHROMA_SAMPLES_KHR: Self = Self::MIDPOINT_CHROMA_SAMPLES;
9687 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_KHR: Self =
9688 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER;
9689 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_KHR: Self =
9690 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER;
9691 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_KHR: Self =
9692 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT;
9693 pub const SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_KHR: Self =
9694 Self::SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE;
9695 pub const DISJOINT_KHR: Self = Self::DISJOINT;
9696 pub const COSITED_CHROMA_SAMPLES_KHR: Self = Self::COSITED_CHROMA_SAMPLES;
9697}
9698#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9699impl ImageAspectFlags {
9700 pub const PLANE_0_KHR: Self = Self::PLANE_0;
9701 pub const PLANE_1_KHR: Self = Self::PLANE_1;
9702 pub const PLANE_2_KHR: Self = Self::PLANE_2;
9703}
9704#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9705impl ImageCreateFlags {
9706 pub const DISJOINT_KHR: Self = Self::DISJOINT;
9707}
9708#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9709impl ObjectType {
9710 pub const SAMPLER_YCBCR_CONVERSION_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION;
9711}
9712#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9713impl SamplerYcbcrModelConversion {
9714 pub const RGB_IDENTITY_KHR: Self = Self::RGB_IDENTITY;
9715 pub const YCBCR_IDENTITY_KHR: Self = Self::YCBCR_IDENTITY;
9716 pub const YCBCR_709_KHR: Self = Self::YCBCR_709;
9717 pub const YCBCR_601_KHR: Self = Self::YCBCR_601;
9718 pub const YCBCR_2020_KHR: Self = Self::YCBCR_2020;
9719}
9720#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9721impl SamplerYcbcrRange {
9722 pub const ITU_FULL_KHR: Self = Self::ITU_FULL;
9723 pub const ITU_NARROW_KHR: Self = Self::ITU_NARROW;
9724}
9725#[doc = "Generated from 'VK_KHR_sampler_ycbcr_conversion'"]
9726impl StructureType {
9727 pub const SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: Self =
9728 Self::SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
9729 pub const SAMPLER_YCBCR_CONVERSION_INFO_KHR: Self = Self::SAMPLER_YCBCR_CONVERSION_INFO;
9730 pub const BIND_IMAGE_PLANE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_PLANE_MEMORY_INFO;
9731 pub const IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: Self =
9732 Self::IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
9733 pub const PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: Self =
9734 Self::PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
9735 pub const SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: Self =
9736 Self::SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
9737}
9738impl KhrBindMemory2Fn {
9739 pub const fn name() -> &'static ::std::ffi::CStr {
9740 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_bind_memory2\0") }
9741 }
9742 pub const SPEC_VERSION: u32 = 1u32;
9743}
9744#[allow(non_camel_case_types)]
9745pub type PFN_vkBindBufferMemory2 = unsafe extern "system" fn(
9746 device: Device,
9747 bind_info_count: u32,
9748 p_bind_infos: *const BindBufferMemoryInfo,
9749) -> Result;
9750#[allow(non_camel_case_types)]
9751pub type PFN_vkBindImageMemory2 = unsafe extern "system" fn(
9752 device: Device,
9753 bind_info_count: u32,
9754 p_bind_infos: *const BindImageMemoryInfo,
9755) -> Result;
9756#[derive(Clone)]
9757pub struct KhrBindMemory2Fn {
9758 pub bind_buffer_memory2_khr: PFN_vkBindBufferMemory2,
9759 pub bind_image_memory2_khr: PFN_vkBindImageMemory2,
9760}
9761unsafe impl Send for KhrBindMemory2Fn {}
9762unsafe impl Sync for KhrBindMemory2Fn {}
9763impl KhrBindMemory2Fn {
9764 pub fn load<F>(mut _f: F) -> Self
9765 where
9766 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9767 {
9768 Self {
9769 bind_buffer_memory2_khr: unsafe {
9770 unsafe extern "system" fn bind_buffer_memory2_khr(
9771 _device: Device,
9772 _bind_info_count: u32,
9773 _p_bind_infos: *const BindBufferMemoryInfo,
9774 ) -> Result {
9775 panic!(concat!(
9776 "Unable to load ",
9777 stringify!(bind_buffer_memory2_khr)
9778 ))
9779 }
9780 let cname =
9781 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindBufferMemory2KHR\0");
9782 let val = _f(cname);
9783 if val.is_null() {
9784 bind_buffer_memory2_khr
9785 } else {
9786 ::std::mem::transmute(val)
9787 }
9788 },
9789 bind_image_memory2_khr: unsafe {
9790 unsafe extern "system" fn bind_image_memory2_khr(
9791 _device: Device,
9792 _bind_info_count: u32,
9793 _p_bind_infos: *const BindImageMemoryInfo,
9794 ) -> Result {
9795 panic!(concat!(
9796 "Unable to load ",
9797 stringify!(bind_image_memory2_khr)
9798 ))
9799 }
9800 let cname =
9801 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkBindImageMemory2KHR\0");
9802 let val = _f(cname);
9803 if val.is_null() {
9804 bind_image_memory2_khr
9805 } else {
9806 ::std::mem::transmute(val)
9807 }
9808 },
9809 }
9810 }
9811}
9812#[doc = "Generated from 'VK_KHR_bind_memory2'"]
9813impl ImageCreateFlags {
9814 pub const ALIAS_KHR: Self = Self::ALIAS;
9815}
9816#[doc = "Generated from 'VK_KHR_bind_memory2'"]
9817impl StructureType {
9818 pub const BIND_BUFFER_MEMORY_INFO_KHR: Self = Self::BIND_BUFFER_MEMORY_INFO;
9819 pub const BIND_IMAGE_MEMORY_INFO_KHR: Self = Self::BIND_IMAGE_MEMORY_INFO;
9820}
9821impl ExtImageDrmFormatModifierFn {
9822 pub const fn name() -> &'static ::std::ffi::CStr {
9823 unsafe {
9824 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_drm_format_modifier\0")
9825 }
9826 }
9827 pub const SPEC_VERSION: u32 = 2u32;
9828}
9829#[allow(non_camel_case_types)]
9830pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn(
9831 device: Device,
9832 image: Image,
9833 p_properties: *mut ImageDrmFormatModifierPropertiesEXT,
9834) -> Result;
9835#[derive(Clone)]
9836pub struct ExtImageDrmFormatModifierFn {
9837 pub get_image_drm_format_modifier_properties_ext: PFN_vkGetImageDrmFormatModifierPropertiesEXT,
9838}
9839unsafe impl Send for ExtImageDrmFormatModifierFn {}
9840unsafe impl Sync for ExtImageDrmFormatModifierFn {}
9841impl ExtImageDrmFormatModifierFn {
9842 pub fn load<F>(mut _f: F) -> Self
9843 where
9844 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9845 {
9846 Self {
9847 get_image_drm_format_modifier_properties_ext: unsafe {
9848 unsafe extern "system" fn get_image_drm_format_modifier_properties_ext(
9849 _device: Device,
9850 _image: Image,
9851 _p_properties: *mut ImageDrmFormatModifierPropertiesEXT,
9852 ) -> Result {
9853 panic!(concat!(
9854 "Unable to load ",
9855 stringify!(get_image_drm_format_modifier_properties_ext)
9856 ))
9857 }
9858 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9859 b"vkGetImageDrmFormatModifierPropertiesEXT\0",
9860 );
9861 let val = _f(cname);
9862 if val.is_null() {
9863 get_image_drm_format_modifier_properties_ext
9864 } else {
9865 ::std::mem::transmute(val)
9866 }
9867 },
9868 }
9869 }
9870}
9871#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
9872impl ImageAspectFlags {
9873 pub const MEMORY_PLANE_0_EXT: Self = Self(0b1000_0000);
9874 pub const MEMORY_PLANE_1_EXT: Self = Self(0b1_0000_0000);
9875 pub const MEMORY_PLANE_2_EXT: Self = Self(0b10_0000_0000);
9876 pub const MEMORY_PLANE_3_EXT: Self = Self(0b100_0000_0000);
9877}
9878#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
9879impl ImageTiling {
9880 pub const DRM_FORMAT_MODIFIER_EXT: Self = Self(1_000_158_000);
9881}
9882#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
9883impl Result {
9884 pub const ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: Self = Self(-1_000_158_000);
9885}
9886#[doc = "Generated from 'VK_EXT_image_drm_format_modifier'"]
9887impl StructureType {
9888 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: Self = Self(1_000_158_000);
9889 pub const PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: Self = Self(1_000_158_002);
9890 pub const IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: Self = Self(1_000_158_003);
9891 pub const IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: Self = Self(1_000_158_004);
9892 pub const IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: Self = Self(1_000_158_005);
9893 pub const DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: Self = Self(1_000_158_006);
9894}
9895impl ExtExtension160Fn {
9896 pub const fn name() -> &'static ::std::ffi::CStr {
9897 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_160\0") }
9898 }
9899 pub const SPEC_VERSION: u32 = 0u32;
9900}
9901#[derive(Clone)]
9902pub struct ExtExtension160Fn {}
9903unsafe impl Send for ExtExtension160Fn {}
9904unsafe impl Sync for ExtExtension160Fn {}
9905impl ExtExtension160Fn {
9906 pub fn load<F>(mut _f: F) -> Self
9907 where
9908 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9909 {
9910 Self {}
9911 }
9912}
9913impl ExtValidationCacheFn {
9914 pub const fn name() -> &'static ::std::ffi::CStr {
9915 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_cache\0") }
9916 }
9917 pub const SPEC_VERSION: u32 = 1u32;
9918}
9919#[allow(non_camel_case_types)]
9920pub type PFN_vkCreateValidationCacheEXT = unsafe extern "system" fn(
9921 device: Device,
9922 p_create_info: *const ValidationCacheCreateInfoEXT,
9923 p_allocator: *const AllocationCallbacks,
9924 p_validation_cache: *mut ValidationCacheEXT,
9925) -> Result;
9926#[allow(non_camel_case_types)]
9927pub type PFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn(
9928 device: Device,
9929 validation_cache: ValidationCacheEXT,
9930 p_allocator: *const AllocationCallbacks,
9931);
9932#[allow(non_camel_case_types)]
9933pub type PFN_vkMergeValidationCachesEXT = unsafe extern "system" fn(
9934 device: Device,
9935 dst_cache: ValidationCacheEXT,
9936 src_cache_count: u32,
9937 p_src_caches: *const ValidationCacheEXT,
9938) -> Result;
9939#[allow(non_camel_case_types)]
9940pub type PFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn(
9941 device: Device,
9942 validation_cache: ValidationCacheEXT,
9943 p_data_size: *mut usize,
9944 p_data: *mut c_void,
9945) -> Result;
9946#[derive(Clone)]
9947pub struct ExtValidationCacheFn {
9948 pub create_validation_cache_ext: PFN_vkCreateValidationCacheEXT,
9949 pub destroy_validation_cache_ext: PFN_vkDestroyValidationCacheEXT,
9950 pub merge_validation_caches_ext: PFN_vkMergeValidationCachesEXT,
9951 pub get_validation_cache_data_ext: PFN_vkGetValidationCacheDataEXT,
9952}
9953unsafe impl Send for ExtValidationCacheFn {}
9954unsafe impl Sync for ExtValidationCacheFn {}
9955impl ExtValidationCacheFn {
9956 pub fn load<F>(mut _f: F) -> Self
9957 where
9958 F: FnMut(&::std::ffi::CStr) -> *const c_void,
9959 {
9960 Self {
9961 create_validation_cache_ext: unsafe {
9962 unsafe extern "system" fn create_validation_cache_ext(
9963 _device: Device,
9964 _p_create_info: *const ValidationCacheCreateInfoEXT,
9965 _p_allocator: *const AllocationCallbacks,
9966 _p_validation_cache: *mut ValidationCacheEXT,
9967 ) -> Result {
9968 panic!(concat!(
9969 "Unable to load ",
9970 stringify!(create_validation_cache_ext)
9971 ))
9972 }
9973 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9974 b"vkCreateValidationCacheEXT\0",
9975 );
9976 let val = _f(cname);
9977 if val.is_null() {
9978 create_validation_cache_ext
9979 } else {
9980 ::std::mem::transmute(val)
9981 }
9982 },
9983 destroy_validation_cache_ext: unsafe {
9984 unsafe extern "system" fn destroy_validation_cache_ext(
9985 _device: Device,
9986 _validation_cache: ValidationCacheEXT,
9987 _p_allocator: *const AllocationCallbacks,
9988 ) {
9989 panic!(concat!(
9990 "Unable to load ",
9991 stringify!(destroy_validation_cache_ext)
9992 ))
9993 }
9994 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
9995 b"vkDestroyValidationCacheEXT\0",
9996 );
9997 let val = _f(cname);
9998 if val.is_null() {
9999 destroy_validation_cache_ext
10000 } else {
10001 ::std::mem::transmute(val)
10002 }
10003 },
10004 merge_validation_caches_ext: unsafe {
10005 unsafe extern "system" fn merge_validation_caches_ext(
10006 _device: Device,
10007 _dst_cache: ValidationCacheEXT,
10008 _src_cache_count: u32,
10009 _p_src_caches: *const ValidationCacheEXT,
10010 ) -> Result {
10011 panic!(concat!(
10012 "Unable to load ",
10013 stringify!(merge_validation_caches_ext)
10014 ))
10015 }
10016 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10017 b"vkMergeValidationCachesEXT\0",
10018 );
10019 let val = _f(cname);
10020 if val.is_null() {
10021 merge_validation_caches_ext
10022 } else {
10023 ::std::mem::transmute(val)
10024 }
10025 },
10026 get_validation_cache_data_ext: unsafe {
10027 unsafe extern "system" fn get_validation_cache_data_ext(
10028 _device: Device,
10029 _validation_cache: ValidationCacheEXT,
10030 _p_data_size: *mut usize,
10031 _p_data: *mut c_void,
10032 ) -> Result {
10033 panic!(concat!(
10034 "Unable to load ",
10035 stringify!(get_validation_cache_data_ext)
10036 ))
10037 }
10038 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10039 b"vkGetValidationCacheDataEXT\0",
10040 );
10041 let val = _f(cname);
10042 if val.is_null() {
10043 get_validation_cache_data_ext
10044 } else {
10045 ::std::mem::transmute(val)
10046 }
10047 },
10048 }
10049 }
10050}
10051#[doc = "Generated from 'VK_EXT_validation_cache'"]
10052impl ObjectType {
10053 pub const VALIDATION_CACHE_EXT: Self = Self(1_000_160_000);
10054}
10055#[doc = "Generated from 'VK_EXT_validation_cache'"]
10056impl StructureType {
10057 pub const VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_000);
10058 pub const SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: Self = Self(1_000_160_001);
10059}
10060impl ExtDescriptorIndexingFn {
10061 pub const fn name() -> &'static ::std::ffi::CStr {
10062 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_descriptor_indexing\0") }
10063 }
10064 pub const SPEC_VERSION: u32 = 2u32;
10065}
10066#[derive(Clone)]
10067pub struct ExtDescriptorIndexingFn {}
10068unsafe impl Send for ExtDescriptorIndexingFn {}
10069unsafe impl Sync for ExtDescriptorIndexingFn {}
10070impl ExtDescriptorIndexingFn {
10071 pub fn load<F>(mut _f: F) -> Self
10072 where
10073 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10074 {
10075 Self {}
10076 }
10077}
10078#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10079impl DescriptorBindingFlags {
10080 pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND;
10081 pub const UPDATE_UNUSED_WHILE_PENDING_EXT: Self = Self::UPDATE_UNUSED_WHILE_PENDING;
10082 pub const PARTIALLY_BOUND_EXT: Self = Self::PARTIALLY_BOUND;
10083 pub const VARIABLE_DESCRIPTOR_COUNT_EXT: Self = Self::VARIABLE_DESCRIPTOR_COUNT;
10084}
10085#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10086impl DescriptorPoolCreateFlags {
10087 pub const UPDATE_AFTER_BIND_EXT: Self = Self::UPDATE_AFTER_BIND;
10088}
10089#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10090impl DescriptorSetLayoutCreateFlags {
10091 pub const UPDATE_AFTER_BIND_POOL_EXT: Self = Self::UPDATE_AFTER_BIND_POOL;
10092}
10093#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10094impl Result {
10095 pub const ERROR_FRAGMENTATION_EXT: Self = Self::ERROR_FRAGMENTATION;
10096}
10097#[doc = "Generated from 'VK_EXT_descriptor_indexing'"]
10098impl StructureType {
10099 pub const DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: Self =
10100 Self::DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
10101 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: Self =
10102 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
10103 pub const PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: Self =
10104 Self::PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
10105 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: Self =
10106 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
10107 pub const DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: Self =
10108 Self::DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
10109}
10110impl ExtShaderViewportIndexLayerFn {
10111 pub const fn name() -> &'static ::std::ffi::CStr {
10112 unsafe {
10113 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_viewport_index_layer\0")
10114 }
10115 }
10116 pub const SPEC_VERSION: u32 = 1u32;
10117}
10118#[derive(Clone)]
10119pub struct ExtShaderViewportIndexLayerFn {}
10120unsafe impl Send for ExtShaderViewportIndexLayerFn {}
10121unsafe impl Sync for ExtShaderViewportIndexLayerFn {}
10122impl ExtShaderViewportIndexLayerFn {
10123 pub fn load<F>(mut _f: F) -> Self
10124 where
10125 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10126 {
10127 Self {}
10128 }
10129}
10130impl KhrPortabilitySubsetFn {
10131 pub const fn name() -> &'static ::std::ffi::CStr {
10132 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_subset\0") }
10133 }
10134 pub const SPEC_VERSION: u32 = 1u32;
10135}
10136#[derive(Clone)]
10137pub struct KhrPortabilitySubsetFn {}
10138unsafe impl Send for KhrPortabilitySubsetFn {}
10139unsafe impl Sync for KhrPortabilitySubsetFn {}
10140impl KhrPortabilitySubsetFn {
10141 pub fn load<F>(mut _f: F) -> Self
10142 where
10143 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10144 {
10145 Self {}
10146 }
10147}
10148#[doc = "Generated from 'VK_KHR_portability_subset'"]
10149impl StructureType {
10150 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: Self = Self(1_000_163_000);
10151 pub const PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: Self = Self(1_000_163_001);
10152}
10153impl NvShadingRateImageFn {
10154 pub const fn name() -> &'static ::std::ffi::CStr {
10155 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shading_rate_image\0") }
10156 }
10157 pub const SPEC_VERSION: u32 = 3u32;
10158}
10159#[allow(non_camel_case_types)]
10160pub type PFN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn(
10161 command_buffer: CommandBuffer,
10162 image_view: ImageView,
10163 image_layout: ImageLayout,
10164);
10165#[allow(non_camel_case_types)]
10166pub type PFN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn(
10167 command_buffer: CommandBuffer,
10168 first_viewport: u32,
10169 viewport_count: u32,
10170 p_shading_rate_palettes: *const ShadingRatePaletteNV,
10171);
10172#[allow(non_camel_case_types)]
10173pub type PFN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn(
10174 command_buffer: CommandBuffer,
10175 sample_order_type: CoarseSampleOrderTypeNV,
10176 custom_sample_order_count: u32,
10177 p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
10178);
10179#[derive(Clone)]
10180pub struct NvShadingRateImageFn {
10181 pub cmd_bind_shading_rate_image_nv: PFN_vkCmdBindShadingRateImageNV,
10182 pub cmd_set_viewport_shading_rate_palette_nv: PFN_vkCmdSetViewportShadingRatePaletteNV,
10183 pub cmd_set_coarse_sample_order_nv: PFN_vkCmdSetCoarseSampleOrderNV,
10184}
10185unsafe impl Send for NvShadingRateImageFn {}
10186unsafe impl Sync for NvShadingRateImageFn {}
10187impl NvShadingRateImageFn {
10188 pub fn load<F>(mut _f: F) -> Self
10189 where
10190 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10191 {
10192 Self {
10193 cmd_bind_shading_rate_image_nv: unsafe {
10194 unsafe extern "system" fn cmd_bind_shading_rate_image_nv(
10195 _command_buffer: CommandBuffer,
10196 _image_view: ImageView,
10197 _image_layout: ImageLayout,
10198 ) {
10199 panic!(concat!(
10200 "Unable to load ",
10201 stringify!(cmd_bind_shading_rate_image_nv)
10202 ))
10203 }
10204 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10205 b"vkCmdBindShadingRateImageNV\0",
10206 );
10207 let val = _f(cname);
10208 if val.is_null() {
10209 cmd_bind_shading_rate_image_nv
10210 } else {
10211 ::std::mem::transmute(val)
10212 }
10213 },
10214 cmd_set_viewport_shading_rate_palette_nv: unsafe {
10215 unsafe extern "system" fn cmd_set_viewport_shading_rate_palette_nv(
10216 _command_buffer: CommandBuffer,
10217 _first_viewport: u32,
10218 _viewport_count: u32,
10219 _p_shading_rate_palettes: *const ShadingRatePaletteNV,
10220 ) {
10221 panic!(concat!(
10222 "Unable to load ",
10223 stringify!(cmd_set_viewport_shading_rate_palette_nv)
10224 ))
10225 }
10226 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10227 b"vkCmdSetViewportShadingRatePaletteNV\0",
10228 );
10229 let val = _f(cname);
10230 if val.is_null() {
10231 cmd_set_viewport_shading_rate_palette_nv
10232 } else {
10233 ::std::mem::transmute(val)
10234 }
10235 },
10236 cmd_set_coarse_sample_order_nv: unsafe {
10237 unsafe extern "system" fn cmd_set_coarse_sample_order_nv(
10238 _command_buffer: CommandBuffer,
10239 _sample_order_type: CoarseSampleOrderTypeNV,
10240 _custom_sample_order_count: u32,
10241 _p_custom_sample_orders: *const CoarseSampleOrderCustomNV,
10242 ) {
10243 panic!(concat!(
10244 "Unable to load ",
10245 stringify!(cmd_set_coarse_sample_order_nv)
10246 ))
10247 }
10248 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10249 b"vkCmdSetCoarseSampleOrderNV\0",
10250 );
10251 let val = _f(cname);
10252 if val.is_null() {
10253 cmd_set_coarse_sample_order_nv
10254 } else {
10255 ::std::mem::transmute(val)
10256 }
10257 },
10258 }
10259 }
10260}
10261#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10262impl AccessFlags {
10263 pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR;
10264}
10265#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10266impl DynamicState {
10267 pub const VIEWPORT_SHADING_RATE_PALETTE_NV: Self = Self(1_000_164_004);
10268 pub const VIEWPORT_COARSE_SAMPLE_ORDER_NV: Self = Self(1_000_164_006);
10269}
10270#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10271impl ImageLayout {
10272 pub const SHADING_RATE_OPTIMAL_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
10273}
10274#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10275impl ImageUsageFlags {
10276 pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR;
10277}
10278#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10279impl PipelineStageFlags {
10280 pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR;
10281}
10282#[doc = "Generated from 'VK_NV_shading_rate_image'"]
10283impl StructureType {
10284 pub const PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: Self = Self(1_000_164_000);
10285 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: Self = Self(1_000_164_001);
10286 pub const PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: Self = Self(1_000_164_002);
10287 pub const PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: Self =
10288 Self(1_000_164_005);
10289}
10290impl NvRayTracingFn {
10291 pub const fn name() -> &'static ::std::ffi::CStr {
10292 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing\0") }
10293 }
10294 pub const SPEC_VERSION: u32 = 3u32;
10295}
10296#[allow(non_camel_case_types)]
10297pub type PFN_vkCreateAccelerationStructureNV = unsafe extern "system" fn(
10298 device: Device,
10299 p_create_info: *const AccelerationStructureCreateInfoNV,
10300 p_allocator: *const AllocationCallbacks,
10301 p_acceleration_structure: *mut AccelerationStructureNV,
10302) -> Result;
10303#[allow(non_camel_case_types)]
10304pub type PFN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn(
10305 device: Device,
10306 acceleration_structure: AccelerationStructureNV,
10307 p_allocator: *const AllocationCallbacks,
10308);
10309#[allow(non_camel_case_types)]
10310pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn(
10311 device: Device,
10312 p_info: *const AccelerationStructureMemoryRequirementsInfoNV,
10313 p_memory_requirements: *mut MemoryRequirements2KHR,
10314);
10315#[allow(non_camel_case_types)]
10316pub type PFN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn(
10317 device: Device,
10318 bind_info_count: u32,
10319 p_bind_infos: *const BindAccelerationStructureMemoryInfoNV,
10320) -> Result;
10321#[allow(non_camel_case_types)]
10322pub type PFN_vkCmdBuildAccelerationStructureNV = unsafe extern "system" fn(
10323 command_buffer: CommandBuffer,
10324 p_info: *const AccelerationStructureInfoNV,
10325 instance_data: Buffer,
10326 instance_offset: DeviceSize,
10327 update: Bool32,
10328 dst: AccelerationStructureNV,
10329 src: AccelerationStructureNV,
10330 scratch: Buffer,
10331 scratch_offset: DeviceSize,
10332);
10333#[allow(non_camel_case_types)]
10334pub type PFN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn(
10335 command_buffer: CommandBuffer,
10336 dst: AccelerationStructureNV,
10337 src: AccelerationStructureNV,
10338 mode: CopyAccelerationStructureModeKHR,
10339);
10340#[allow(non_camel_case_types)]
10341pub type PFN_vkCmdTraceRaysNV = unsafe extern "system" fn(
10342 command_buffer: CommandBuffer,
10343 raygen_shader_binding_table_buffer: Buffer,
10344 raygen_shader_binding_offset: DeviceSize,
10345 miss_shader_binding_table_buffer: Buffer,
10346 miss_shader_binding_offset: DeviceSize,
10347 miss_shader_binding_stride: DeviceSize,
10348 hit_shader_binding_table_buffer: Buffer,
10349 hit_shader_binding_offset: DeviceSize,
10350 hit_shader_binding_stride: DeviceSize,
10351 callable_shader_binding_table_buffer: Buffer,
10352 callable_shader_binding_offset: DeviceSize,
10353 callable_shader_binding_stride: DeviceSize,
10354 width: u32,
10355 height: u32,
10356 depth: u32,
10357);
10358#[allow(non_camel_case_types)]
10359pub type PFN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn(
10360 device: Device,
10361 pipeline_cache: PipelineCache,
10362 create_info_count: u32,
10363 p_create_infos: *const RayTracingPipelineCreateInfoNV,
10364 p_allocator: *const AllocationCallbacks,
10365 p_pipelines: *mut Pipeline,
10366) -> Result;
10367#[allow(non_camel_case_types)]
10368pub type PFN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn(
10369 device: Device,
10370 acceleration_structure: AccelerationStructureNV,
10371 data_size: usize,
10372 p_data: *mut c_void,
10373) -> Result;
10374#[allow(non_camel_case_types)]
10375pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn(
10376 command_buffer: CommandBuffer,
10377 acceleration_structure_count: u32,
10378 p_acceleration_structures: *const AccelerationStructureNV,
10379 query_type: QueryType,
10380 query_pool: QueryPool,
10381 first_query: u32,
10382);
10383#[allow(non_camel_case_types)]
10384pub type PFN_vkCompileDeferredNV =
10385 unsafe extern "system" fn(device: Device, pipeline: Pipeline, shader: u32) -> Result;
10386#[derive(Clone)]
10387pub struct NvRayTracingFn {
10388 pub create_acceleration_structure_nv: PFN_vkCreateAccelerationStructureNV,
10389 pub destroy_acceleration_structure_nv: PFN_vkDestroyAccelerationStructureNV,
10390 pub get_acceleration_structure_memory_requirements_nv:
10391 PFN_vkGetAccelerationStructureMemoryRequirementsNV,
10392 pub bind_acceleration_structure_memory_nv: PFN_vkBindAccelerationStructureMemoryNV,
10393 pub cmd_build_acceleration_structure_nv: PFN_vkCmdBuildAccelerationStructureNV,
10394 pub cmd_copy_acceleration_structure_nv: PFN_vkCmdCopyAccelerationStructureNV,
10395 pub cmd_trace_rays_nv: PFN_vkCmdTraceRaysNV,
10396 pub create_ray_tracing_pipelines_nv: PFN_vkCreateRayTracingPipelinesNV,
10397 pub get_ray_tracing_shader_group_handles_nv:
10398 crate::vk::PFN_vkGetRayTracingShaderGroupHandlesKHR,
10399 pub get_acceleration_structure_handle_nv: PFN_vkGetAccelerationStructureHandleNV,
10400 pub cmd_write_acceleration_structures_properties_nv:
10401 PFN_vkCmdWriteAccelerationStructuresPropertiesNV,
10402 pub compile_deferred_nv: PFN_vkCompileDeferredNV,
10403}
10404unsafe impl Send for NvRayTracingFn {}
10405unsafe impl Sync for NvRayTracingFn {}
10406impl NvRayTracingFn {
10407 pub fn load<F>(mut _f: F) -> Self
10408 where
10409 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10410 {
10411 Self {
10412 create_acceleration_structure_nv: unsafe {
10413 unsafe extern "system" fn create_acceleration_structure_nv(
10414 _device: Device,
10415 _p_create_info: *const AccelerationStructureCreateInfoNV,
10416 _p_allocator: *const AllocationCallbacks,
10417 _p_acceleration_structure: *mut AccelerationStructureNV,
10418 ) -> Result {
10419 panic!(concat!(
10420 "Unable to load ",
10421 stringify!(create_acceleration_structure_nv)
10422 ))
10423 }
10424 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10425 b"vkCreateAccelerationStructureNV\0",
10426 );
10427 let val = _f(cname);
10428 if val.is_null() {
10429 create_acceleration_structure_nv
10430 } else {
10431 ::std::mem::transmute(val)
10432 }
10433 },
10434 destroy_acceleration_structure_nv: unsafe {
10435 unsafe extern "system" fn destroy_acceleration_structure_nv(
10436 _device: Device,
10437 _acceleration_structure: AccelerationStructureNV,
10438 _p_allocator: *const AllocationCallbacks,
10439 ) {
10440 panic!(concat!(
10441 "Unable to load ",
10442 stringify!(destroy_acceleration_structure_nv)
10443 ))
10444 }
10445 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10446 b"vkDestroyAccelerationStructureNV\0",
10447 );
10448 let val = _f(cname);
10449 if val.is_null() {
10450 destroy_acceleration_structure_nv
10451 } else {
10452 ::std::mem::transmute(val)
10453 }
10454 },
10455 get_acceleration_structure_memory_requirements_nv: unsafe {
10456 unsafe extern "system" fn get_acceleration_structure_memory_requirements_nv(
10457 _device: Device,
10458 _p_info: *const AccelerationStructureMemoryRequirementsInfoNV,
10459 _p_memory_requirements: *mut MemoryRequirements2KHR,
10460 ) {
10461 panic!(concat!(
10462 "Unable to load ",
10463 stringify!(get_acceleration_structure_memory_requirements_nv)
10464 ))
10465 }
10466 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10467 b"vkGetAccelerationStructureMemoryRequirementsNV\0",
10468 );
10469 let val = _f(cname);
10470 if val.is_null() {
10471 get_acceleration_structure_memory_requirements_nv
10472 } else {
10473 ::std::mem::transmute(val)
10474 }
10475 },
10476 bind_acceleration_structure_memory_nv: unsafe {
10477 unsafe extern "system" fn bind_acceleration_structure_memory_nv(
10478 _device: Device,
10479 _bind_info_count: u32,
10480 _p_bind_infos: *const BindAccelerationStructureMemoryInfoNV,
10481 ) -> Result {
10482 panic!(concat!(
10483 "Unable to load ",
10484 stringify!(bind_acceleration_structure_memory_nv)
10485 ))
10486 }
10487 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10488 b"vkBindAccelerationStructureMemoryNV\0",
10489 );
10490 let val = _f(cname);
10491 if val.is_null() {
10492 bind_acceleration_structure_memory_nv
10493 } else {
10494 ::std::mem::transmute(val)
10495 }
10496 },
10497 cmd_build_acceleration_structure_nv: unsafe {
10498 unsafe extern "system" fn cmd_build_acceleration_structure_nv(
10499 _command_buffer: CommandBuffer,
10500 _p_info: *const AccelerationStructureInfoNV,
10501 _instance_data: Buffer,
10502 _instance_offset: DeviceSize,
10503 _update: Bool32,
10504 _dst: AccelerationStructureNV,
10505 _src: AccelerationStructureNV,
10506 _scratch: Buffer,
10507 _scratch_offset: DeviceSize,
10508 ) {
10509 panic!(concat!(
10510 "Unable to load ",
10511 stringify!(cmd_build_acceleration_structure_nv)
10512 ))
10513 }
10514 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10515 b"vkCmdBuildAccelerationStructureNV\0",
10516 );
10517 let val = _f(cname);
10518 if val.is_null() {
10519 cmd_build_acceleration_structure_nv
10520 } else {
10521 ::std::mem::transmute(val)
10522 }
10523 },
10524 cmd_copy_acceleration_structure_nv: unsafe {
10525 unsafe extern "system" fn cmd_copy_acceleration_structure_nv(
10526 _command_buffer: CommandBuffer,
10527 _dst: AccelerationStructureNV,
10528 _src: AccelerationStructureNV,
10529 _mode: CopyAccelerationStructureModeKHR,
10530 ) {
10531 panic!(concat!(
10532 "Unable to load ",
10533 stringify!(cmd_copy_acceleration_structure_nv)
10534 ))
10535 }
10536 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10537 b"vkCmdCopyAccelerationStructureNV\0",
10538 );
10539 let val = _f(cname);
10540 if val.is_null() {
10541 cmd_copy_acceleration_structure_nv
10542 } else {
10543 ::std::mem::transmute(val)
10544 }
10545 },
10546 cmd_trace_rays_nv: unsafe {
10547 unsafe extern "system" fn cmd_trace_rays_nv(
10548 _command_buffer: CommandBuffer,
10549 _raygen_shader_binding_table_buffer: Buffer,
10550 _raygen_shader_binding_offset: DeviceSize,
10551 _miss_shader_binding_table_buffer: Buffer,
10552 _miss_shader_binding_offset: DeviceSize,
10553 _miss_shader_binding_stride: DeviceSize,
10554 _hit_shader_binding_table_buffer: Buffer,
10555 _hit_shader_binding_offset: DeviceSize,
10556 _hit_shader_binding_stride: DeviceSize,
10557 _callable_shader_binding_table_buffer: Buffer,
10558 _callable_shader_binding_offset: DeviceSize,
10559 _callable_shader_binding_stride: DeviceSize,
10560 _width: u32,
10561 _height: u32,
10562 _depth: u32,
10563 ) {
10564 panic!(concat!("Unable to load ", stringify!(cmd_trace_rays_nv)))
10565 }
10566 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdTraceRaysNV\0");
10567 let val = _f(cname);
10568 if val.is_null() {
10569 cmd_trace_rays_nv
10570 } else {
10571 ::std::mem::transmute(val)
10572 }
10573 },
10574 create_ray_tracing_pipelines_nv: unsafe {
10575 unsafe extern "system" fn create_ray_tracing_pipelines_nv(
10576 _device: Device,
10577 _pipeline_cache: PipelineCache,
10578 _create_info_count: u32,
10579 _p_create_infos: *const RayTracingPipelineCreateInfoNV,
10580 _p_allocator: *const AllocationCallbacks,
10581 _p_pipelines: *mut Pipeline,
10582 ) -> Result {
10583 panic!(concat!(
10584 "Unable to load ",
10585 stringify!(create_ray_tracing_pipelines_nv)
10586 ))
10587 }
10588 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10589 b"vkCreateRayTracingPipelinesNV\0",
10590 );
10591 let val = _f(cname);
10592 if val.is_null() {
10593 create_ray_tracing_pipelines_nv
10594 } else {
10595 ::std::mem::transmute(val)
10596 }
10597 },
10598 get_ray_tracing_shader_group_handles_nv: unsafe {
10599 unsafe extern "system" fn get_ray_tracing_shader_group_handles_nv(
10600 _device: Device,
10601 _pipeline: Pipeline,
10602 _first_group: u32,
10603 _group_count: u32,
10604 _data_size: usize,
10605 _p_data: *mut c_void,
10606 ) -> Result {
10607 panic!(concat!(
10608 "Unable to load ",
10609 stringify!(get_ray_tracing_shader_group_handles_nv)
10610 ))
10611 }
10612 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10613 b"vkGetRayTracingShaderGroupHandlesNV\0",
10614 );
10615 let val = _f(cname);
10616 if val.is_null() {
10617 get_ray_tracing_shader_group_handles_nv
10618 } else {
10619 ::std::mem::transmute(val)
10620 }
10621 },
10622 get_acceleration_structure_handle_nv: unsafe {
10623 unsafe extern "system" fn get_acceleration_structure_handle_nv(
10624 _device: Device,
10625 _acceleration_structure: AccelerationStructureNV,
10626 _data_size: usize,
10627 _p_data: *mut c_void,
10628 ) -> Result {
10629 panic!(concat!(
10630 "Unable to load ",
10631 stringify!(get_acceleration_structure_handle_nv)
10632 ))
10633 }
10634 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10635 b"vkGetAccelerationStructureHandleNV\0",
10636 );
10637 let val = _f(cname);
10638 if val.is_null() {
10639 get_acceleration_structure_handle_nv
10640 } else {
10641 ::std::mem::transmute(val)
10642 }
10643 },
10644 cmd_write_acceleration_structures_properties_nv: unsafe {
10645 unsafe extern "system" fn cmd_write_acceleration_structures_properties_nv(
10646 _command_buffer: CommandBuffer,
10647 _acceleration_structure_count: u32,
10648 _p_acceleration_structures: *const AccelerationStructureNV,
10649 _query_type: QueryType,
10650 _query_pool: QueryPool,
10651 _first_query: u32,
10652 ) {
10653 panic!(concat!(
10654 "Unable to load ",
10655 stringify!(cmd_write_acceleration_structures_properties_nv)
10656 ))
10657 }
10658 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10659 b"vkCmdWriteAccelerationStructuresPropertiesNV\0",
10660 );
10661 let val = _f(cname);
10662 if val.is_null() {
10663 cmd_write_acceleration_structures_properties_nv
10664 } else {
10665 ::std::mem::transmute(val)
10666 }
10667 },
10668 compile_deferred_nv: unsafe {
10669 unsafe extern "system" fn compile_deferred_nv(
10670 _device: Device,
10671 _pipeline: Pipeline,
10672 _shader: u32,
10673 ) -> Result {
10674 panic!(concat!("Unable to load ", stringify!(compile_deferred_nv)))
10675 }
10676 let cname =
10677 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCompileDeferredNV\0");
10678 let val = _f(cname);
10679 if val.is_null() {
10680 compile_deferred_nv
10681 } else {
10682 ::std::mem::transmute(val)
10683 }
10684 },
10685 }
10686 }
10687}
10688#[doc = "Generated from 'VK_NV_ray_tracing'"]
10689impl AccelerationStructureTypeKHR {
10690 pub const TOP_LEVEL_NV: Self = Self::TOP_LEVEL;
10691 pub const BOTTOM_LEVEL_NV: Self = Self::BOTTOM_LEVEL;
10692}
10693#[doc = "Generated from 'VK_NV_ray_tracing'"]
10694impl AccessFlags {
10695 pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR;
10696 pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR;
10697}
10698#[doc = "Generated from 'VK_NV_ray_tracing'"]
10699impl BufferUsageFlags {
10700 pub const RAY_TRACING_NV: Self = Self::SHADER_BINDING_TABLE_KHR;
10701}
10702#[doc = "Generated from 'VK_NV_ray_tracing'"]
10703impl BuildAccelerationStructureFlagsKHR {
10704 pub const ALLOW_UPDATE_NV: Self = Self::ALLOW_UPDATE;
10705 pub const ALLOW_COMPACTION_NV: Self = Self::ALLOW_COMPACTION;
10706 pub const PREFER_FAST_TRACE_NV: Self = Self::PREFER_FAST_TRACE;
10707 pub const PREFER_FAST_BUILD_NV: Self = Self::PREFER_FAST_BUILD;
10708 pub const LOW_MEMORY_NV: Self = Self::LOW_MEMORY;
10709}
10710#[doc = "Generated from 'VK_NV_ray_tracing'"]
10711impl CopyAccelerationStructureModeKHR {
10712 pub const CLONE_NV: Self = Self::CLONE;
10713 pub const COMPACT_NV: Self = Self::COMPACT;
10714}
10715#[doc = "Generated from 'VK_NV_ray_tracing'"]
10716impl DebugReportObjectTypeEXT {
10717 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
10718}
10719#[doc = "Generated from 'VK_NV_ray_tracing'"]
10720impl DescriptorType {
10721 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
10722}
10723#[doc = "Generated from 'VK_NV_ray_tracing'"]
10724impl GeometryFlagsKHR {
10725 pub const OPAQUE_NV: Self = Self::OPAQUE;
10726 pub const NO_DUPLICATE_ANY_HIT_INVOCATION_NV: Self = Self::NO_DUPLICATE_ANY_HIT_INVOCATION;
10727}
10728#[doc = "Generated from 'VK_NV_ray_tracing'"]
10729impl GeometryInstanceFlagsKHR {
10730 pub const TRIANGLE_CULL_DISABLE_NV: Self = Self::TRIANGLE_FACING_CULL_DISABLE;
10731 pub const TRIANGLE_FRONT_COUNTERCLOCKWISE_NV: Self = Self::TRIANGLE_FRONT_COUNTERCLOCKWISE;
10732 pub const FORCE_OPAQUE_NV: Self = Self::FORCE_OPAQUE;
10733 pub const FORCE_NO_OPAQUE_NV: Self = Self::FORCE_NO_OPAQUE;
10734}
10735#[doc = "Generated from 'VK_NV_ray_tracing'"]
10736impl GeometryTypeKHR {
10737 pub const TRIANGLES_NV: Self = Self::TRIANGLES;
10738 pub const AABBS_NV: Self = Self::AABBS;
10739}
10740#[doc = "Generated from 'VK_NV_ray_tracing'"]
10741impl IndexType {
10742 pub const NONE_NV: Self = Self::NONE_KHR;
10743}
10744#[doc = "Generated from 'VK_NV_ray_tracing'"]
10745impl ObjectType {
10746 pub const ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_000);
10747}
10748#[doc = "Generated from 'VK_NV_ray_tracing'"]
10749impl PipelineBindPoint {
10750 pub const RAY_TRACING_NV: Self = Self::RAY_TRACING_KHR;
10751}
10752#[doc = "Generated from 'VK_NV_ray_tracing'"]
10753impl PipelineCreateFlags {
10754 pub const DEFER_COMPILE_NV: Self = Self(0b10_0000);
10755}
10756#[doc = "Generated from 'VK_NV_ray_tracing'"]
10757impl PipelineStageFlags {
10758 pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR;
10759 pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR;
10760}
10761#[doc = "Generated from 'VK_NV_ray_tracing'"]
10762impl QueryType {
10763 pub const ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: Self = Self(1_000_165_000);
10764}
10765#[doc = "Generated from 'VK_NV_ray_tracing'"]
10766impl RayTracingShaderGroupTypeKHR {
10767 pub const GENERAL_NV: Self = Self::GENERAL;
10768 pub const TRIANGLES_HIT_GROUP_NV: Self = Self::TRIANGLES_HIT_GROUP;
10769 pub const PROCEDURAL_HIT_GROUP_NV: Self = Self::PROCEDURAL_HIT_GROUP;
10770}
10771#[doc = "Generated from 'VK_NV_ray_tracing'"]
10772impl ShaderStageFlags {
10773 pub const RAYGEN_NV: Self = Self::RAYGEN_KHR;
10774 pub const ANY_HIT_NV: Self = Self::ANY_HIT_KHR;
10775 pub const CLOSEST_HIT_NV: Self = Self::CLOSEST_HIT_KHR;
10776 pub const MISS_NV: Self = Self::MISS_KHR;
10777 pub const INTERSECTION_NV: Self = Self::INTERSECTION_KHR;
10778 pub const CALLABLE_NV: Self = Self::CALLABLE_KHR;
10779}
10780#[doc = "Generated from 'VK_NV_ray_tracing'"]
10781impl StructureType {
10782 pub const RAY_TRACING_PIPELINE_CREATE_INFO_NV: Self = Self(1_000_165_000);
10783 pub const ACCELERATION_STRUCTURE_CREATE_INFO_NV: Self = Self(1_000_165_001);
10784 pub const GEOMETRY_NV: Self = Self(1_000_165_003);
10785 pub const GEOMETRY_TRIANGLES_NV: Self = Self(1_000_165_004);
10786 pub const GEOMETRY_AABB_NV: Self = Self(1_000_165_005);
10787 pub const BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: Self = Self(1_000_165_006);
10788 pub const WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: Self = Self(1_000_165_007);
10789 pub const ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_165_008);
10790 pub const PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: Self = Self(1_000_165_009);
10791 pub const RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_165_011);
10792 pub const ACCELERATION_STRUCTURE_INFO_NV: Self = Self(1_000_165_012);
10793}
10794impl NvRepresentativeFragmentTestFn {
10795 pub const fn name() -> &'static ::std::ffi::CStr {
10796 unsafe {
10797 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_representative_fragment_test\0")
10798 }
10799 }
10800 pub const SPEC_VERSION: u32 = 2u32;
10801}
10802#[derive(Clone)]
10803pub struct NvRepresentativeFragmentTestFn {}
10804unsafe impl Send for NvRepresentativeFragmentTestFn {}
10805unsafe impl Sync for NvRepresentativeFragmentTestFn {}
10806impl NvRepresentativeFragmentTestFn {
10807 pub fn load<F>(mut _f: F) -> Self
10808 where
10809 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10810 {
10811 Self {}
10812 }
10813}
10814#[doc = "Generated from 'VK_NV_representative_fragment_test'"]
10815impl StructureType {
10816 pub const PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: Self = Self(1_000_166_000);
10817 pub const PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: Self =
10818 Self(1_000_166_001);
10819}
10820impl NvExtension168Fn {
10821 pub const fn name() -> &'static ::std::ffi::CStr {
10822 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_168\0") }
10823 }
10824 pub const SPEC_VERSION: u32 = 0u32;
10825}
10826#[derive(Clone)]
10827pub struct NvExtension168Fn {}
10828unsafe impl Send for NvExtension168Fn {}
10829unsafe impl Sync for NvExtension168Fn {}
10830impl NvExtension168Fn {
10831 pub fn load<F>(mut _f: F) -> Self
10832 where
10833 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10834 {
10835 Self {}
10836 }
10837}
10838impl KhrMaintenance3Fn {
10839 pub const fn name() -> &'static ::std::ffi::CStr {
10840 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance3\0") }
10841 }
10842 pub const SPEC_VERSION: u32 = 1u32;
10843}
10844#[allow(non_camel_case_types)]
10845pub type PFN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn(
10846 device: Device,
10847 p_create_info: *const DescriptorSetLayoutCreateInfo,
10848 p_support: *mut DescriptorSetLayoutSupport,
10849);
10850#[derive(Clone)]
10851pub struct KhrMaintenance3Fn {
10852 pub get_descriptor_set_layout_support_khr: PFN_vkGetDescriptorSetLayoutSupport,
10853}
10854unsafe impl Send for KhrMaintenance3Fn {}
10855unsafe impl Sync for KhrMaintenance3Fn {}
10856impl KhrMaintenance3Fn {
10857 pub fn load<F>(mut _f: F) -> Self
10858 where
10859 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10860 {
10861 Self {
10862 get_descriptor_set_layout_support_khr: unsafe {
10863 unsafe extern "system" fn get_descriptor_set_layout_support_khr(
10864 _device: Device,
10865 _p_create_info: *const DescriptorSetLayoutCreateInfo,
10866 _p_support: *mut DescriptorSetLayoutSupport,
10867 ) {
10868 panic!(concat!(
10869 "Unable to load ",
10870 stringify!(get_descriptor_set_layout_support_khr)
10871 ))
10872 }
10873 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10874 b"vkGetDescriptorSetLayoutSupportKHR\0",
10875 );
10876 let val = _f(cname);
10877 if val.is_null() {
10878 get_descriptor_set_layout_support_khr
10879 } else {
10880 ::std::mem::transmute(val)
10881 }
10882 },
10883 }
10884 }
10885}
10886#[doc = "Generated from 'VK_KHR_maintenance3'"]
10887impl StructureType {
10888 pub const PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: Self =
10889 Self::PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
10890 pub const DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: Self = Self::DESCRIPTOR_SET_LAYOUT_SUPPORT;
10891}
10892impl KhrDrawIndirectCountFn {
10893 pub const fn name() -> &'static ::std::ffi::CStr {
10894 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_draw_indirect_count\0") }
10895 }
10896 pub const SPEC_VERSION: u32 = 1u32;
10897}
10898#[derive(Clone)]
10899pub struct KhrDrawIndirectCountFn {
10900 pub cmd_draw_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndirectCount,
10901 pub cmd_draw_indexed_indirect_count_khr: crate::vk::PFN_vkCmdDrawIndexedIndirectCount,
10902}
10903unsafe impl Send for KhrDrawIndirectCountFn {}
10904unsafe impl Sync for KhrDrawIndirectCountFn {}
10905impl KhrDrawIndirectCountFn {
10906 pub fn load<F>(mut _f: F) -> Self
10907 where
10908 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10909 {
10910 Self {
10911 cmd_draw_indirect_count_khr: unsafe {
10912 unsafe extern "system" fn cmd_draw_indirect_count_khr(
10913 _command_buffer: CommandBuffer,
10914 _buffer: Buffer,
10915 _offset: DeviceSize,
10916 _count_buffer: Buffer,
10917 _count_buffer_offset: DeviceSize,
10918 _max_draw_count: u32,
10919 _stride: u32,
10920 ) {
10921 panic!(concat!(
10922 "Unable to load ",
10923 stringify!(cmd_draw_indirect_count_khr)
10924 ))
10925 }
10926 let cname =
10927 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawIndirectCountKHR\0");
10928 let val = _f(cname);
10929 if val.is_null() {
10930 cmd_draw_indirect_count_khr
10931 } else {
10932 ::std::mem::transmute(val)
10933 }
10934 },
10935 cmd_draw_indexed_indirect_count_khr: unsafe {
10936 unsafe extern "system" fn cmd_draw_indexed_indirect_count_khr(
10937 _command_buffer: CommandBuffer,
10938 _buffer: Buffer,
10939 _offset: DeviceSize,
10940 _count_buffer: Buffer,
10941 _count_buffer_offset: DeviceSize,
10942 _max_draw_count: u32,
10943 _stride: u32,
10944 ) {
10945 panic!(concat!(
10946 "Unable to load ",
10947 stringify!(cmd_draw_indexed_indirect_count_khr)
10948 ))
10949 }
10950 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
10951 b"vkCmdDrawIndexedIndirectCountKHR\0",
10952 );
10953 let val = _f(cname);
10954 if val.is_null() {
10955 cmd_draw_indexed_indirect_count_khr
10956 } else {
10957 ::std::mem::transmute(val)
10958 }
10959 },
10960 }
10961 }
10962}
10963impl ExtFilterCubicFn {
10964 pub const fn name() -> &'static ::std::ffi::CStr {
10965 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_filter_cubic\0") }
10966 }
10967 pub const SPEC_VERSION: u32 = 3u32;
10968}
10969#[derive(Clone)]
10970pub struct ExtFilterCubicFn {}
10971unsafe impl Send for ExtFilterCubicFn {}
10972unsafe impl Sync for ExtFilterCubicFn {}
10973impl ExtFilterCubicFn {
10974 pub fn load<F>(mut _f: F) -> Self
10975 where
10976 F: FnMut(&::std::ffi::CStr) -> *const c_void,
10977 {
10978 Self {}
10979 }
10980}
10981#[doc = "Generated from 'VK_EXT_filter_cubic'"]
10982impl Filter {
10983 pub const CUBIC_EXT: Self = Self::CUBIC_IMG;
10984}
10985#[doc = "Generated from 'VK_EXT_filter_cubic'"]
10986impl FormatFeatureFlags {
10987 pub const SAMPLED_IMAGE_FILTER_CUBIC_EXT: Self = Self::SAMPLED_IMAGE_FILTER_CUBIC_IMG;
10988}
10989#[doc = "Generated from 'VK_EXT_filter_cubic'"]
10990impl StructureType {
10991 pub const PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: Self = Self(1_000_170_000);
10992 pub const FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: Self = Self(1_000_170_001);
10993}
10994impl QcomRenderPassShaderResolveFn {
10995 pub const fn name() -> &'static ::std::ffi::CStr {
10996 unsafe {
10997 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_shader_resolve\0")
10998 }
10999 }
11000 pub const SPEC_VERSION: u32 = 4u32;
11001}
11002#[derive(Clone)]
11003pub struct QcomRenderPassShaderResolveFn {}
11004unsafe impl Send for QcomRenderPassShaderResolveFn {}
11005unsafe impl Sync for QcomRenderPassShaderResolveFn {}
11006impl QcomRenderPassShaderResolveFn {
11007 pub fn load<F>(mut _f: F) -> Self
11008 where
11009 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11010 {
11011 Self {}
11012 }
11013}
11014#[doc = "Generated from 'VK_QCOM_render_pass_shader_resolve'"]
11015impl SubpassDescriptionFlags {
11016 pub const FRAGMENT_REGION_QCOM: Self = Self(0b100);
11017 pub const SHADER_RESOLVE_QCOM: Self = Self(0b1000);
11018}
11019impl QcomExtension173Fn {
11020 pub const fn name() -> &'static ::std::ffi::CStr {
11021 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_173\0") }
11022 }
11023 pub const SPEC_VERSION: u32 = 0u32;
11024}
11025#[derive(Clone)]
11026pub struct QcomExtension173Fn {}
11027unsafe impl Send for QcomExtension173Fn {}
11028unsafe impl Sync for QcomExtension173Fn {}
11029impl QcomExtension173Fn {
11030 pub fn load<F>(mut _f: F) -> Self
11031 where
11032 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11033 {
11034 Self {}
11035 }
11036}
11037#[doc = "Generated from 'VK_QCOM_extension_173'"]
11038impl BufferUsageFlags {
11039 pub const RESERVED_18_QCOM: Self = Self(0b100_0000_0000_0000_0000);
11040}
11041#[doc = "Generated from 'VK_QCOM_extension_173'"]
11042impl ImageUsageFlags {
11043 pub const RESERVED_16_QCOM: Self = Self(0b1_0000_0000_0000_0000);
11044 pub const RESERVED_17_QCOM: Self = Self(0b10_0000_0000_0000_0000);
11045}
11046impl QcomExtension174Fn {
11047 pub const fn name() -> &'static ::std::ffi::CStr {
11048 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_174\0") }
11049 }
11050 pub const SPEC_VERSION: u32 = 0u32;
11051}
11052#[derive(Clone)]
11053pub struct QcomExtension174Fn {}
11054unsafe impl Send for QcomExtension174Fn {}
11055unsafe impl Sync for QcomExtension174Fn {}
11056impl QcomExtension174Fn {
11057 pub fn load<F>(mut _f: F) -> Self
11058 where
11059 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11060 {
11061 Self {}
11062 }
11063}
11064impl ExtGlobalPriorityFn {
11065 pub const fn name() -> &'static ::std::ffi::CStr {
11066 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority\0") }
11067 }
11068 pub const SPEC_VERSION: u32 = 2u32;
11069}
11070#[derive(Clone)]
11071pub struct ExtGlobalPriorityFn {}
11072unsafe impl Send for ExtGlobalPriorityFn {}
11073unsafe impl Sync for ExtGlobalPriorityFn {}
11074impl ExtGlobalPriorityFn {
11075 pub fn load<F>(mut _f: F) -> Self
11076 where
11077 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11078 {
11079 Self {}
11080 }
11081}
11082#[doc = "Generated from 'VK_EXT_global_priority'"]
11083impl Result {
11084 pub const ERROR_NOT_PERMITTED_EXT: Self = Self::ERROR_NOT_PERMITTED_KHR;
11085}
11086#[doc = "Generated from 'VK_EXT_global_priority'"]
11087impl StructureType {
11088 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: Self =
11089 Self::DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR;
11090}
11091impl KhrShaderSubgroupExtendedTypesFn {
11092 pub const fn name() -> &'static ::std::ffi::CStr {
11093 unsafe {
11094 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11095 b"VK_KHR_shader_subgroup_extended_types\0",
11096 )
11097 }
11098 }
11099 pub const SPEC_VERSION: u32 = 1u32;
11100}
11101#[derive(Clone)]
11102pub struct KhrShaderSubgroupExtendedTypesFn {}
11103unsafe impl Send for KhrShaderSubgroupExtendedTypesFn {}
11104unsafe impl Sync for KhrShaderSubgroupExtendedTypesFn {}
11105impl KhrShaderSubgroupExtendedTypesFn {
11106 pub fn load<F>(mut _f: F) -> Self
11107 where
11108 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11109 {
11110 Self {}
11111 }
11112}
11113#[doc = "Generated from 'VK_KHR_shader_subgroup_extended_types'"]
11114impl StructureType {
11115 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: Self =
11116 Self::PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
11117}
11118impl ExtExtension177Fn {
11119 pub const fn name() -> &'static ::std::ffi::CStr {
11120 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_177\0") }
11121 }
11122 pub const SPEC_VERSION: u32 = 0u32;
11123}
11124#[derive(Clone)]
11125pub struct ExtExtension177Fn {}
11126unsafe impl Send for ExtExtension177Fn {}
11127unsafe impl Sync for ExtExtension177Fn {}
11128impl ExtExtension177Fn {
11129 pub fn load<F>(mut _f: F) -> Self
11130 where
11131 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11132 {
11133 Self {}
11134 }
11135}
11136impl Khr8bitStorageFn {
11137 pub const fn name() -> &'static ::std::ffi::CStr {
11138 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_8bit_storage\0") }
11139 }
11140 pub const SPEC_VERSION: u32 = 1u32;
11141}
11142#[derive(Clone)]
11143pub struct Khr8bitStorageFn {}
11144unsafe impl Send for Khr8bitStorageFn {}
11145unsafe impl Sync for Khr8bitStorageFn {}
11146impl Khr8bitStorageFn {
11147 pub fn load<F>(mut _f: F) -> Self
11148 where
11149 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11150 {
11151 Self {}
11152 }
11153}
11154#[doc = "Generated from 'VK_KHR_8bit_storage'"]
11155impl StructureType {
11156 pub const PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: Self =
11157 Self::PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
11158}
11159impl ExtExternalMemoryHostFn {
11160 pub const fn name() -> &'static ::std::ffi::CStr {
11161 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_external_memory_host\0") }
11162 }
11163 pub const SPEC_VERSION: u32 = 1u32;
11164}
11165#[allow(non_camel_case_types)]
11166pub type PFN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn(
11167 device: Device,
11168 handle_type: ExternalMemoryHandleTypeFlags,
11169 p_host_pointer: *const c_void,
11170 p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT,
11171) -> Result;
11172#[derive(Clone)]
11173pub struct ExtExternalMemoryHostFn {
11174 pub get_memory_host_pointer_properties_ext: PFN_vkGetMemoryHostPointerPropertiesEXT,
11175}
11176unsafe impl Send for ExtExternalMemoryHostFn {}
11177unsafe impl Sync for ExtExternalMemoryHostFn {}
11178impl ExtExternalMemoryHostFn {
11179 pub fn load<F>(mut _f: F) -> Self
11180 where
11181 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11182 {
11183 Self {
11184 get_memory_host_pointer_properties_ext: unsafe {
11185 unsafe extern "system" fn get_memory_host_pointer_properties_ext(
11186 _device: Device,
11187 _handle_type: ExternalMemoryHandleTypeFlags,
11188 _p_host_pointer: *const c_void,
11189 _p_memory_host_pointer_properties: *mut MemoryHostPointerPropertiesEXT,
11190 ) -> Result {
11191 panic!(concat!(
11192 "Unable to load ",
11193 stringify!(get_memory_host_pointer_properties_ext)
11194 ))
11195 }
11196 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11197 b"vkGetMemoryHostPointerPropertiesEXT\0",
11198 );
11199 let val = _f(cname);
11200 if val.is_null() {
11201 get_memory_host_pointer_properties_ext
11202 } else {
11203 ::std::mem::transmute(val)
11204 }
11205 },
11206 }
11207 }
11208}
11209#[doc = "Generated from 'VK_EXT_external_memory_host'"]
11210impl ExternalMemoryHandleTypeFlags {
11211 pub const HOST_ALLOCATION_EXT: Self = Self(0b1000_0000);
11212 pub const HOST_MAPPED_FOREIGN_MEMORY_EXT: Self = Self(0b1_0000_0000);
11213}
11214#[doc = "Generated from 'VK_EXT_external_memory_host'"]
11215impl StructureType {
11216 pub const IMPORT_MEMORY_HOST_POINTER_INFO_EXT: Self = Self(1_000_178_000);
11217 pub const MEMORY_HOST_POINTER_PROPERTIES_EXT: Self = Self(1_000_178_001);
11218 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: Self = Self(1_000_178_002);
11219}
11220impl AmdBufferMarkerFn {
11221 pub const fn name() -> &'static ::std::ffi::CStr {
11222 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_buffer_marker\0") }
11223 }
11224 pub const SPEC_VERSION: u32 = 1u32;
11225}
11226#[allow(non_camel_case_types)]
11227pub type PFN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn(
11228 command_buffer: CommandBuffer,
11229 pipeline_stage: PipelineStageFlags,
11230 dst_buffer: Buffer,
11231 dst_offset: DeviceSize,
11232 marker: u32,
11233);
11234#[derive(Clone)]
11235pub struct AmdBufferMarkerFn {
11236 pub cmd_write_buffer_marker_amd: PFN_vkCmdWriteBufferMarkerAMD,
11237}
11238unsafe impl Send for AmdBufferMarkerFn {}
11239unsafe impl Sync for AmdBufferMarkerFn {}
11240impl AmdBufferMarkerFn {
11241 pub fn load<F>(mut _f: F) -> Self
11242 where
11243 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11244 {
11245 Self {
11246 cmd_write_buffer_marker_amd: unsafe {
11247 unsafe extern "system" fn cmd_write_buffer_marker_amd(
11248 _command_buffer: CommandBuffer,
11249 _pipeline_stage: PipelineStageFlags,
11250 _dst_buffer: Buffer,
11251 _dst_offset: DeviceSize,
11252 _marker: u32,
11253 ) {
11254 panic!(concat!(
11255 "Unable to load ",
11256 stringify!(cmd_write_buffer_marker_amd)
11257 ))
11258 }
11259 let cname =
11260 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteBufferMarkerAMD\0");
11261 let val = _f(cname);
11262 if val.is_null() {
11263 cmd_write_buffer_marker_amd
11264 } else {
11265 ::std::mem::transmute(val)
11266 }
11267 },
11268 }
11269 }
11270}
11271impl KhrShaderAtomicInt64Fn {
11272 pub const fn name() -> &'static ::std::ffi::CStr {
11273 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_atomic_int64\0") }
11274 }
11275 pub const SPEC_VERSION: u32 = 1u32;
11276}
11277#[derive(Clone)]
11278pub struct KhrShaderAtomicInt64Fn {}
11279unsafe impl Send for KhrShaderAtomicInt64Fn {}
11280unsafe impl Sync for KhrShaderAtomicInt64Fn {}
11281impl KhrShaderAtomicInt64Fn {
11282 pub fn load<F>(mut _f: F) -> Self
11283 where
11284 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11285 {
11286 Self {}
11287 }
11288}
11289#[doc = "Generated from 'VK_KHR_shader_atomic_int64'"]
11290impl StructureType {
11291 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: Self =
11292 Self::PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
11293}
11294impl KhrShaderClockFn {
11295 pub const fn name() -> &'static ::std::ffi::CStr {
11296 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_clock\0") }
11297 }
11298 pub const SPEC_VERSION: u32 = 1u32;
11299}
11300#[derive(Clone)]
11301pub struct KhrShaderClockFn {}
11302unsafe impl Send for KhrShaderClockFn {}
11303unsafe impl Sync for KhrShaderClockFn {}
11304impl KhrShaderClockFn {
11305 pub fn load<F>(mut _f: F) -> Self
11306 where
11307 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11308 {
11309 Self {}
11310 }
11311}
11312#[doc = "Generated from 'VK_KHR_shader_clock'"]
11313impl StructureType {
11314 pub const PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: Self = Self(1_000_181_000);
11315}
11316impl AmdExtension183Fn {
11317 pub const fn name() -> &'static ::std::ffi::CStr {
11318 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_183\0") }
11319 }
11320 pub const SPEC_VERSION: u32 = 0u32;
11321}
11322#[derive(Clone)]
11323pub struct AmdExtension183Fn {}
11324unsafe impl Send for AmdExtension183Fn {}
11325unsafe impl Sync for AmdExtension183Fn {}
11326impl AmdExtension183Fn {
11327 pub fn load<F>(mut _f: F) -> Self
11328 where
11329 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11330 {
11331 Self {}
11332 }
11333}
11334impl AmdPipelineCompilerControlFn {
11335 pub const fn name() -> &'static ::std::ffi::CStr {
11336 unsafe {
11337 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_pipeline_compiler_control\0")
11338 }
11339 }
11340 pub const SPEC_VERSION: u32 = 1u32;
11341}
11342#[derive(Clone)]
11343pub struct AmdPipelineCompilerControlFn {}
11344unsafe impl Send for AmdPipelineCompilerControlFn {}
11345unsafe impl Sync for AmdPipelineCompilerControlFn {}
11346impl AmdPipelineCompilerControlFn {
11347 pub fn load<F>(mut _f: F) -> Self
11348 where
11349 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11350 {
11351 Self {}
11352 }
11353}
11354#[doc = "Generated from 'VK_AMD_pipeline_compiler_control'"]
11355impl StructureType {
11356 pub const PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: Self = Self(1_000_183_000);
11357}
11358impl ExtCalibratedTimestampsFn {
11359 pub const fn name() -> &'static ::std::ffi::CStr {
11360 unsafe {
11361 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_calibrated_timestamps\0")
11362 }
11363 }
11364 pub const SPEC_VERSION: u32 = 2u32;
11365}
11366#[allow(non_camel_case_types)]
11367pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn(
11368 physical_device: PhysicalDevice,
11369 p_time_domain_count: *mut u32,
11370 p_time_domains: *mut TimeDomainEXT,
11371) -> Result;
11372#[allow(non_camel_case_types)]
11373pub type PFN_vkGetCalibratedTimestampsEXT = unsafe extern "system" fn(
11374 device: Device,
11375 timestamp_count: u32,
11376 p_timestamp_infos: *const CalibratedTimestampInfoEXT,
11377 p_timestamps: *mut u64,
11378 p_max_deviation: *mut u64,
11379) -> Result;
11380#[derive(Clone)]
11381pub struct ExtCalibratedTimestampsFn {
11382 pub get_physical_device_calibrateable_time_domains_ext:
11383 PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT,
11384 pub get_calibrated_timestamps_ext: PFN_vkGetCalibratedTimestampsEXT,
11385}
11386unsafe impl Send for ExtCalibratedTimestampsFn {}
11387unsafe impl Sync for ExtCalibratedTimestampsFn {}
11388impl ExtCalibratedTimestampsFn {
11389 pub fn load<F>(mut _f: F) -> Self
11390 where
11391 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11392 {
11393 Self {
11394 get_physical_device_calibrateable_time_domains_ext: unsafe {
11395 unsafe extern "system" fn get_physical_device_calibrateable_time_domains_ext(
11396 _physical_device: PhysicalDevice,
11397 _p_time_domain_count: *mut u32,
11398 _p_time_domains: *mut TimeDomainEXT,
11399 ) -> Result {
11400 panic!(concat!(
11401 "Unable to load ",
11402 stringify!(get_physical_device_calibrateable_time_domains_ext)
11403 ))
11404 }
11405 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11406 b"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT\0",
11407 );
11408 let val = _f(cname);
11409 if val.is_null() {
11410 get_physical_device_calibrateable_time_domains_ext
11411 } else {
11412 ::std::mem::transmute(val)
11413 }
11414 },
11415 get_calibrated_timestamps_ext: unsafe {
11416 unsafe extern "system" fn get_calibrated_timestamps_ext(
11417 _device: Device,
11418 _timestamp_count: u32,
11419 _p_timestamp_infos: *const CalibratedTimestampInfoEXT,
11420 _p_timestamps: *mut u64,
11421 _p_max_deviation: *mut u64,
11422 ) -> Result {
11423 panic!(concat!(
11424 "Unable to load ",
11425 stringify!(get_calibrated_timestamps_ext)
11426 ))
11427 }
11428 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11429 b"vkGetCalibratedTimestampsEXT\0",
11430 );
11431 let val = _f(cname);
11432 if val.is_null() {
11433 get_calibrated_timestamps_ext
11434 } else {
11435 ::std::mem::transmute(val)
11436 }
11437 },
11438 }
11439 }
11440}
11441#[doc = "Generated from 'VK_EXT_calibrated_timestamps'"]
11442impl StructureType {
11443 pub const CALIBRATED_TIMESTAMP_INFO_EXT: Self = Self(1_000_184_000);
11444}
11445impl AmdShaderCorePropertiesFn {
11446 pub const fn name() -> &'static ::std::ffi::CStr {
11447 unsafe {
11448 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties\0")
11449 }
11450 }
11451 pub const SPEC_VERSION: u32 = 2u32;
11452}
11453#[derive(Clone)]
11454pub struct AmdShaderCorePropertiesFn {}
11455unsafe impl Send for AmdShaderCorePropertiesFn {}
11456unsafe impl Sync for AmdShaderCorePropertiesFn {}
11457impl AmdShaderCorePropertiesFn {
11458 pub fn load<F>(mut _f: F) -> Self
11459 where
11460 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11461 {
11462 Self {}
11463 }
11464}
11465#[doc = "Generated from 'VK_AMD_shader_core_properties'"]
11466impl StructureType {
11467 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: Self = Self(1_000_185_000);
11468}
11469impl AmdExtension187Fn {
11470 pub const fn name() -> &'static ::std::ffi::CStr {
11471 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_187\0") }
11472 }
11473 pub const SPEC_VERSION: u32 = 0u32;
11474}
11475#[derive(Clone)]
11476pub struct AmdExtension187Fn {}
11477unsafe impl Send for AmdExtension187Fn {}
11478unsafe impl Sync for AmdExtension187Fn {}
11479impl AmdExtension187Fn {
11480 pub fn load<F>(mut _f: F) -> Self
11481 where
11482 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11483 {
11484 Self {}
11485 }
11486}
11487impl ExtVideoDecodeH265Fn {
11488 pub const fn name() -> &'static ::std::ffi::CStr {
11489 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_video_decode_h265\0") }
11490 }
11491 pub const SPEC_VERSION: u32 = 2u32;
11492}
11493#[derive(Clone)]
11494pub struct ExtVideoDecodeH265Fn {}
11495unsafe impl Send for ExtVideoDecodeH265Fn {}
11496unsafe impl Sync for ExtVideoDecodeH265Fn {}
11497impl ExtVideoDecodeH265Fn {
11498 pub fn load<F>(mut _f: F) -> Self
11499 where
11500 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11501 {
11502 Self {}
11503 }
11504}
11505#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
11506impl StructureType {
11507 pub const VIDEO_DECODE_H265_CAPABILITIES_EXT: Self = Self(1_000_187_000);
11508 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: Self = Self(1_000_187_001);
11509 pub const VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: Self = Self(1_000_187_002);
11510 pub const VIDEO_DECODE_H265_PROFILE_EXT: Self = Self(1_000_187_003);
11511 pub const VIDEO_DECODE_H265_PICTURE_INFO_EXT: Self = Self(1_000_187_004);
11512 pub const VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: Self = Self(1_000_187_005);
11513}
11514#[doc = "Generated from 'VK_EXT_video_decode_h265'"]
11515impl VideoCodecOperationFlagsKHR {
11516 pub const DECODE_H265_EXT: Self = Self(0b10);
11517}
11518impl KhrGlobalPriorityFn {
11519 pub const fn name() -> &'static ::std::ffi::CStr {
11520 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_global_priority\0") }
11521 }
11522 pub const SPEC_VERSION: u32 = 1u32;
11523}
11524#[derive(Clone)]
11525pub struct KhrGlobalPriorityFn {}
11526unsafe impl Send for KhrGlobalPriorityFn {}
11527unsafe impl Sync for KhrGlobalPriorityFn {}
11528impl KhrGlobalPriorityFn {
11529 pub fn load<F>(mut _f: F) -> Self
11530 where
11531 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11532 {
11533 Self {}
11534 }
11535}
11536#[doc = "Generated from 'VK_KHR_global_priority'"]
11537impl Result {
11538 pub const ERROR_NOT_PERMITTED_KHR: Self = Self(-1_000_174_001);
11539}
11540#[doc = "Generated from 'VK_KHR_global_priority'"]
11541impl StructureType {
11542 pub const DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: Self = Self(1_000_174_000);
11543 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: Self = Self(1_000_388_000);
11544 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: Self = Self(1_000_388_001);
11545}
11546impl AmdMemoryOverallocationBehaviorFn {
11547 pub const fn name() -> &'static ::std::ffi::CStr {
11548 unsafe {
11549 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11550 b"VK_AMD_memory_overallocation_behavior\0",
11551 )
11552 }
11553 }
11554 pub const SPEC_VERSION: u32 = 1u32;
11555}
11556#[derive(Clone)]
11557pub struct AmdMemoryOverallocationBehaviorFn {}
11558unsafe impl Send for AmdMemoryOverallocationBehaviorFn {}
11559unsafe impl Sync for AmdMemoryOverallocationBehaviorFn {}
11560impl AmdMemoryOverallocationBehaviorFn {
11561 pub fn load<F>(mut _f: F) -> Self
11562 where
11563 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11564 {
11565 Self {}
11566 }
11567}
11568#[doc = "Generated from 'VK_AMD_memory_overallocation_behavior'"]
11569impl StructureType {
11570 pub const DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: Self = Self(1_000_189_000);
11571}
11572impl ExtVertexAttributeDivisorFn {
11573 pub const fn name() -> &'static ::std::ffi::CStr {
11574 unsafe {
11575 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_attribute_divisor\0")
11576 }
11577 }
11578 pub const SPEC_VERSION: u32 = 3u32;
11579}
11580#[derive(Clone)]
11581pub struct ExtVertexAttributeDivisorFn {}
11582unsafe impl Send for ExtVertexAttributeDivisorFn {}
11583unsafe impl Sync for ExtVertexAttributeDivisorFn {}
11584impl ExtVertexAttributeDivisorFn {
11585 pub fn load<F>(mut _f: F) -> Self
11586 where
11587 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11588 {
11589 Self {}
11590 }
11591}
11592#[doc = "Generated from 'VK_EXT_vertex_attribute_divisor'"]
11593impl StructureType {
11594 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: Self = Self(1_000_190_000);
11595 pub const PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: Self = Self(1_000_190_001);
11596 pub const PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: Self = Self(1_000_190_002);
11597}
11598impl GgpFrameTokenFn {
11599 pub const fn name() -> &'static ::std::ffi::CStr {
11600 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_frame_token\0") }
11601 }
11602 pub const SPEC_VERSION: u32 = 1u32;
11603}
11604#[derive(Clone)]
11605pub struct GgpFrameTokenFn {}
11606unsafe impl Send for GgpFrameTokenFn {}
11607unsafe impl Sync for GgpFrameTokenFn {}
11608impl GgpFrameTokenFn {
11609 pub fn load<F>(mut _f: F) -> Self
11610 where
11611 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11612 {
11613 Self {}
11614 }
11615}
11616#[doc = "Generated from 'VK_GGP_frame_token'"]
11617impl StructureType {
11618 pub const PRESENT_FRAME_TOKEN_GGP: Self = Self(1_000_191_000);
11619}
11620impl ExtPipelineCreationFeedbackFn {
11621 pub const fn name() -> &'static ::std::ffi::CStr {
11622 unsafe {
11623 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pipeline_creation_feedback\0")
11624 }
11625 }
11626 pub const SPEC_VERSION: u32 = 1u32;
11627}
11628#[derive(Clone)]
11629pub struct ExtPipelineCreationFeedbackFn {}
11630unsafe impl Send for ExtPipelineCreationFeedbackFn {}
11631unsafe impl Sync for ExtPipelineCreationFeedbackFn {}
11632impl ExtPipelineCreationFeedbackFn {
11633 pub fn load<F>(mut _f: F) -> Self
11634 where
11635 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11636 {
11637 Self {}
11638 }
11639}
11640#[doc = "Generated from 'VK_EXT_pipeline_creation_feedback'"]
11641impl StructureType {
11642 pub const PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: Self =
11643 Self::PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
11644}
11645impl GoogleExtension194Fn {
11646 pub const fn name() -> &'static ::std::ffi::CStr {
11647 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_194\0") }
11648 }
11649 pub const SPEC_VERSION: u32 = 0u32;
11650}
11651#[derive(Clone)]
11652pub struct GoogleExtension194Fn {}
11653unsafe impl Send for GoogleExtension194Fn {}
11654unsafe impl Sync for GoogleExtension194Fn {}
11655impl GoogleExtension194Fn {
11656 pub fn load<F>(mut _f: F) -> Self
11657 where
11658 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11659 {
11660 Self {}
11661 }
11662}
11663impl GoogleExtension195Fn {
11664 pub const fn name() -> &'static ::std::ffi::CStr {
11665 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_195\0") }
11666 }
11667 pub const SPEC_VERSION: u32 = 0u32;
11668}
11669#[derive(Clone)]
11670pub struct GoogleExtension195Fn {}
11671unsafe impl Send for GoogleExtension195Fn {}
11672unsafe impl Sync for GoogleExtension195Fn {}
11673impl GoogleExtension195Fn {
11674 pub fn load<F>(mut _f: F) -> Self
11675 where
11676 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11677 {
11678 Self {}
11679 }
11680}
11681impl GoogleExtension196Fn {
11682 pub const fn name() -> &'static ::std::ffi::CStr {
11683 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_196\0") }
11684 }
11685 pub const SPEC_VERSION: u32 = 0u32;
11686}
11687#[derive(Clone)]
11688pub struct GoogleExtension196Fn {}
11689unsafe impl Send for GoogleExtension196Fn {}
11690unsafe impl Sync for GoogleExtension196Fn {}
11691impl GoogleExtension196Fn {
11692 pub fn load<F>(mut _f: F) -> Self
11693 where
11694 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11695 {
11696 Self {}
11697 }
11698}
11699#[doc = "Generated from 'VK_GOOGLE_extension_196'"]
11700impl PipelineCacheCreateFlags {
11701 pub const RESERVED_1_EXT: Self = Self(0b10);
11702}
11703impl KhrDriverPropertiesFn {
11704 pub const fn name() -> &'static ::std::ffi::CStr {
11705 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_driver_properties\0") }
11706 }
11707 pub const SPEC_VERSION: u32 = 1u32;
11708}
11709#[derive(Clone)]
11710pub struct KhrDriverPropertiesFn {}
11711unsafe impl Send for KhrDriverPropertiesFn {}
11712unsafe impl Sync for KhrDriverPropertiesFn {}
11713impl KhrDriverPropertiesFn {
11714 pub fn load<F>(mut _f: F) -> Self
11715 where
11716 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11717 {
11718 Self {}
11719 }
11720}
11721#[doc = "Generated from 'VK_KHR_driver_properties'"]
11722impl DriverId {
11723 pub const AMD_PROPRIETARY_KHR: Self = Self::AMD_PROPRIETARY;
11724 pub const AMD_OPEN_SOURCE_KHR: Self = Self::AMD_OPEN_SOURCE;
11725 pub const MESA_RADV_KHR: Self = Self::MESA_RADV;
11726 pub const NVIDIA_PROPRIETARY_KHR: Self = Self::NVIDIA_PROPRIETARY;
11727 pub const INTEL_PROPRIETARY_WINDOWS_KHR: Self = Self::INTEL_PROPRIETARY_WINDOWS;
11728 pub const INTEL_OPEN_SOURCE_MESA_KHR: Self = Self::INTEL_OPEN_SOURCE_MESA;
11729 pub const IMAGINATION_PROPRIETARY_KHR: Self = Self::IMAGINATION_PROPRIETARY;
11730 pub const QUALCOMM_PROPRIETARY_KHR: Self = Self::QUALCOMM_PROPRIETARY;
11731 pub const ARM_PROPRIETARY_KHR: Self = Self::ARM_PROPRIETARY;
11732 pub const GOOGLE_SWIFTSHADER_KHR: Self = Self::GOOGLE_SWIFTSHADER;
11733 pub const GGP_PROPRIETARY_KHR: Self = Self::GGP_PROPRIETARY;
11734 pub const BROADCOM_PROPRIETARY_KHR: Self = Self::BROADCOM_PROPRIETARY;
11735}
11736#[doc = "Generated from 'VK_KHR_driver_properties'"]
11737impl StructureType {
11738 pub const PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: Self = Self::PHYSICAL_DEVICE_DRIVER_PROPERTIES;
11739}
11740impl KhrShaderFloatControlsFn {
11741 pub const fn name() -> &'static ::std::ffi::CStr {
11742 unsafe {
11743 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_float_controls\0")
11744 }
11745 }
11746 pub const SPEC_VERSION: u32 = 4u32;
11747}
11748#[derive(Clone)]
11749pub struct KhrShaderFloatControlsFn {}
11750unsafe impl Send for KhrShaderFloatControlsFn {}
11751unsafe impl Sync for KhrShaderFloatControlsFn {}
11752impl KhrShaderFloatControlsFn {
11753 pub fn load<F>(mut _f: F) -> Self
11754 where
11755 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11756 {
11757 Self {}
11758 }
11759}
11760#[doc = "Generated from 'VK_KHR_shader_float_controls'"]
11761impl ShaderFloatControlsIndependence {
11762 pub const TYPE_32_ONLY_KHR: Self = Self::TYPE_32_ONLY;
11763 pub const ALL_KHR: Self = Self::ALL;
11764 pub const NONE_KHR: Self = Self::NONE;
11765}
11766#[doc = "Generated from 'VK_KHR_shader_float_controls'"]
11767impl StructureType {
11768 pub const PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: Self =
11769 Self::PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
11770}
11771impl NvShaderSubgroupPartitionedFn {
11772 pub const fn name() -> &'static ::std::ffi::CStr {
11773 unsafe {
11774 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_subgroup_partitioned\0")
11775 }
11776 }
11777 pub const SPEC_VERSION: u32 = 1u32;
11778}
11779#[derive(Clone)]
11780pub struct NvShaderSubgroupPartitionedFn {}
11781unsafe impl Send for NvShaderSubgroupPartitionedFn {}
11782unsafe impl Sync for NvShaderSubgroupPartitionedFn {}
11783impl NvShaderSubgroupPartitionedFn {
11784 pub fn load<F>(mut _f: F) -> Self
11785 where
11786 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11787 {
11788 Self {}
11789 }
11790}
11791#[doc = "Generated from 'VK_NV_shader_subgroup_partitioned'"]
11792impl SubgroupFeatureFlags {
11793 pub const PARTITIONED_NV: Self = Self(0b1_0000_0000);
11794}
11795impl KhrDepthStencilResolveFn {
11796 pub const fn name() -> &'static ::std::ffi::CStr {
11797 unsafe {
11798 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_depth_stencil_resolve\0")
11799 }
11800 }
11801 pub const SPEC_VERSION: u32 = 1u32;
11802}
11803#[derive(Clone)]
11804pub struct KhrDepthStencilResolveFn {}
11805unsafe impl Send for KhrDepthStencilResolveFn {}
11806unsafe impl Sync for KhrDepthStencilResolveFn {}
11807impl KhrDepthStencilResolveFn {
11808 pub fn load<F>(mut _f: F) -> Self
11809 where
11810 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11811 {
11812 Self {}
11813 }
11814}
11815#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
11816impl ResolveModeFlags {
11817 pub const NONE_KHR: Self = Self::NONE;
11818 pub const SAMPLE_ZERO_KHR: Self = Self::SAMPLE_ZERO;
11819 pub const AVERAGE_KHR: Self = Self::AVERAGE;
11820 pub const MIN_KHR: Self = Self::MIN;
11821 pub const MAX_KHR: Self = Self::MAX;
11822}
11823#[doc = "Generated from 'VK_KHR_depth_stencil_resolve'"]
11824impl StructureType {
11825 pub const PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: Self =
11826 Self::PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
11827 pub const SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: Self =
11828 Self::SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
11829}
11830impl KhrSwapchainMutableFormatFn {
11831 pub const fn name() -> &'static ::std::ffi::CStr {
11832 unsafe {
11833 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_swapchain_mutable_format\0")
11834 }
11835 }
11836 pub const SPEC_VERSION: u32 = 1u32;
11837}
11838#[derive(Clone)]
11839pub struct KhrSwapchainMutableFormatFn {}
11840unsafe impl Send for KhrSwapchainMutableFormatFn {}
11841unsafe impl Sync for KhrSwapchainMutableFormatFn {}
11842impl KhrSwapchainMutableFormatFn {
11843 pub fn load<F>(mut _f: F) -> Self
11844 where
11845 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11846 {
11847 Self {}
11848 }
11849}
11850#[doc = "Generated from 'VK_KHR_swapchain_mutable_format'"]
11851impl SwapchainCreateFlagsKHR {
11852 pub const MUTABLE_FORMAT: Self = Self(0b100);
11853}
11854impl NvComputeShaderDerivativesFn {
11855 pub const fn name() -> &'static ::std::ffi::CStr {
11856 unsafe {
11857 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_compute_shader_derivatives\0")
11858 }
11859 }
11860 pub const SPEC_VERSION: u32 = 1u32;
11861}
11862#[derive(Clone)]
11863pub struct NvComputeShaderDerivativesFn {}
11864unsafe impl Send for NvComputeShaderDerivativesFn {}
11865unsafe impl Sync for NvComputeShaderDerivativesFn {}
11866impl NvComputeShaderDerivativesFn {
11867 pub fn load<F>(mut _f: F) -> Self
11868 where
11869 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11870 {
11871 Self {}
11872 }
11873}
11874#[doc = "Generated from 'VK_NV_compute_shader_derivatives'"]
11875impl StructureType {
11876 pub const PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: Self = Self(1_000_201_000);
11877}
11878impl NvMeshShaderFn {
11879 pub const fn name() -> &'static ::std::ffi::CStr {
11880 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_mesh_shader\0") }
11881 }
11882 pub const SPEC_VERSION: u32 = 1u32;
11883}
11884#[allow(non_camel_case_types)]
11885pub type PFN_vkCmdDrawMeshTasksNV =
11886 unsafe extern "system" fn(command_buffer: CommandBuffer, task_count: u32, first_task: u32);
11887#[allow(non_camel_case_types)]
11888pub type PFN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn(
11889 command_buffer: CommandBuffer,
11890 buffer: Buffer,
11891 offset: DeviceSize,
11892 draw_count: u32,
11893 stride: u32,
11894);
11895#[allow(non_camel_case_types)]
11896pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn(
11897 command_buffer: CommandBuffer,
11898 buffer: Buffer,
11899 offset: DeviceSize,
11900 count_buffer: Buffer,
11901 count_buffer_offset: DeviceSize,
11902 max_draw_count: u32,
11903 stride: u32,
11904);
11905#[derive(Clone)]
11906pub struct NvMeshShaderFn {
11907 pub cmd_draw_mesh_tasks_nv: PFN_vkCmdDrawMeshTasksNV,
11908 pub cmd_draw_mesh_tasks_indirect_nv: PFN_vkCmdDrawMeshTasksIndirectNV,
11909 pub cmd_draw_mesh_tasks_indirect_count_nv: PFN_vkCmdDrawMeshTasksIndirectCountNV,
11910}
11911unsafe impl Send for NvMeshShaderFn {}
11912unsafe impl Sync for NvMeshShaderFn {}
11913impl NvMeshShaderFn {
11914 pub fn load<F>(mut _f: F) -> Self
11915 where
11916 F: FnMut(&::std::ffi::CStr) -> *const c_void,
11917 {
11918 Self {
11919 cmd_draw_mesh_tasks_nv: unsafe {
11920 unsafe extern "system" fn cmd_draw_mesh_tasks_nv(
11921 _command_buffer: CommandBuffer,
11922 _task_count: u32,
11923 _first_task: u32,
11924 ) {
11925 panic!(concat!(
11926 "Unable to load ",
11927 stringify!(cmd_draw_mesh_tasks_nv)
11928 ))
11929 }
11930 let cname =
11931 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMeshTasksNV\0");
11932 let val = _f(cname);
11933 if val.is_null() {
11934 cmd_draw_mesh_tasks_nv
11935 } else {
11936 ::std::mem::transmute(val)
11937 }
11938 },
11939 cmd_draw_mesh_tasks_indirect_nv: unsafe {
11940 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_nv(
11941 _command_buffer: CommandBuffer,
11942 _buffer: Buffer,
11943 _offset: DeviceSize,
11944 _draw_count: u32,
11945 _stride: u32,
11946 ) {
11947 panic!(concat!(
11948 "Unable to load ",
11949 stringify!(cmd_draw_mesh_tasks_indirect_nv)
11950 ))
11951 }
11952 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11953 b"vkCmdDrawMeshTasksIndirectNV\0",
11954 );
11955 let val = _f(cname);
11956 if val.is_null() {
11957 cmd_draw_mesh_tasks_indirect_nv
11958 } else {
11959 ::std::mem::transmute(val)
11960 }
11961 },
11962 cmd_draw_mesh_tasks_indirect_count_nv: unsafe {
11963 unsafe extern "system" fn cmd_draw_mesh_tasks_indirect_count_nv(
11964 _command_buffer: CommandBuffer,
11965 _buffer: Buffer,
11966 _offset: DeviceSize,
11967 _count_buffer: Buffer,
11968 _count_buffer_offset: DeviceSize,
11969 _max_draw_count: u32,
11970 _stride: u32,
11971 ) {
11972 panic!(concat!(
11973 "Unable to load ",
11974 stringify!(cmd_draw_mesh_tasks_indirect_count_nv)
11975 ))
11976 }
11977 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
11978 b"vkCmdDrawMeshTasksIndirectCountNV\0",
11979 );
11980 let val = _f(cname);
11981 if val.is_null() {
11982 cmd_draw_mesh_tasks_indirect_count_nv
11983 } else {
11984 ::std::mem::transmute(val)
11985 }
11986 },
11987 }
11988 }
11989}
11990#[doc = "Generated from 'VK_NV_mesh_shader'"]
11991impl PipelineStageFlags {
11992 pub const TASK_SHADER_NV: Self = Self(0b1000_0000_0000_0000_0000);
11993 pub const MESH_SHADER_NV: Self = Self(0b1_0000_0000_0000_0000_0000);
11994}
11995#[doc = "Generated from 'VK_NV_mesh_shader'"]
11996impl ShaderStageFlags {
11997 pub const TASK_NV: Self = Self(0b100_0000);
11998 pub const MESH_NV: Self = Self(0b1000_0000);
11999}
12000#[doc = "Generated from 'VK_NV_mesh_shader'"]
12001impl StructureType {
12002 pub const PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: Self = Self(1_000_202_000);
12003 pub const PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: Self = Self(1_000_202_001);
12004}
12005impl NvFragmentShaderBarycentricFn {
12006 pub const fn name() -> &'static ::std::ffi::CStr {
12007 unsafe {
12008 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shader_barycentric\0")
12009 }
12010 }
12011 pub const SPEC_VERSION: u32 = 1u32;
12012}
12013#[derive(Clone)]
12014pub struct NvFragmentShaderBarycentricFn {}
12015unsafe impl Send for NvFragmentShaderBarycentricFn {}
12016unsafe impl Sync for NvFragmentShaderBarycentricFn {}
12017impl NvFragmentShaderBarycentricFn {
12018 pub fn load<F>(mut _f: F) -> Self
12019 where
12020 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12021 {
12022 Self {}
12023 }
12024}
12025#[doc = "Generated from 'VK_NV_fragment_shader_barycentric'"]
12026impl StructureType {
12027 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: Self = Self(1_000_203_000);
12028}
12029impl NvShaderImageFootprintFn {
12030 pub const fn name() -> &'static ::std::ffi::CStr {
12031 unsafe {
12032 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_shader_image_footprint\0")
12033 }
12034 }
12035 pub const SPEC_VERSION: u32 = 2u32;
12036}
12037#[derive(Clone)]
12038pub struct NvShaderImageFootprintFn {}
12039unsafe impl Send for NvShaderImageFootprintFn {}
12040unsafe impl Sync for NvShaderImageFootprintFn {}
12041impl NvShaderImageFootprintFn {
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_image_footprint'"]
12050impl StructureType {
12051 pub const PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: Self = Self(1_000_204_000);
12052}
12053impl NvScissorExclusiveFn {
12054 pub const fn name() -> &'static ::std::ffi::CStr {
12055 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_scissor_exclusive\0") }
12056 }
12057 pub const SPEC_VERSION: u32 = 1u32;
12058}
12059#[allow(non_camel_case_types)]
12060pub type PFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(
12061 command_buffer: CommandBuffer,
12062 first_exclusive_scissor: u32,
12063 exclusive_scissor_count: u32,
12064 p_exclusive_scissors: *const Rect2D,
12065);
12066#[derive(Clone)]
12067pub struct NvScissorExclusiveFn {
12068 pub cmd_set_exclusive_scissor_nv: PFN_vkCmdSetExclusiveScissorNV,
12069}
12070unsafe impl Send for NvScissorExclusiveFn {}
12071unsafe impl Sync for NvScissorExclusiveFn {}
12072impl NvScissorExclusiveFn {
12073 pub fn load<F>(mut _f: F) -> Self
12074 where
12075 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12076 {
12077 Self {
12078 cmd_set_exclusive_scissor_nv: unsafe {
12079 unsafe extern "system" fn cmd_set_exclusive_scissor_nv(
12080 _command_buffer: CommandBuffer,
12081 _first_exclusive_scissor: u32,
12082 _exclusive_scissor_count: u32,
12083 _p_exclusive_scissors: *const Rect2D,
12084 ) {
12085 panic!(concat!(
12086 "Unable to load ",
12087 stringify!(cmd_set_exclusive_scissor_nv)
12088 ))
12089 }
12090 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12091 b"vkCmdSetExclusiveScissorNV\0",
12092 );
12093 let val = _f(cname);
12094 if val.is_null() {
12095 cmd_set_exclusive_scissor_nv
12096 } else {
12097 ::std::mem::transmute(val)
12098 }
12099 },
12100 }
12101 }
12102}
12103#[doc = "Generated from 'VK_NV_scissor_exclusive'"]
12104impl DynamicState {
12105 pub const EXCLUSIVE_SCISSOR_NV: Self = Self(1_000_205_001);
12106}
12107#[doc = "Generated from 'VK_NV_scissor_exclusive'"]
12108impl StructureType {
12109 pub const PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: Self = Self(1_000_205_000);
12110 pub const PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: Self = Self(1_000_205_002);
12111}
12112impl NvDeviceDiagnosticCheckpointsFn {
12113 pub const fn name() -> &'static ::std::ffi::CStr {
12114 unsafe {
12115 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12116 b"VK_NV_device_diagnostic_checkpoints\0",
12117 )
12118 }
12119 }
12120 pub const SPEC_VERSION: u32 = 2u32;
12121}
12122#[allow(non_camel_case_types)]
12123pub type PFN_vkCmdSetCheckpointNV =
12124 unsafe extern "system" fn(command_buffer: CommandBuffer, p_checkpoint_marker: *const c_void);
12125#[allow(non_camel_case_types)]
12126pub type PFN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn(
12127 queue: Queue,
12128 p_checkpoint_data_count: *mut u32,
12129 p_checkpoint_data: *mut CheckpointDataNV,
12130);
12131#[derive(Clone)]
12132pub struct NvDeviceDiagnosticCheckpointsFn {
12133 pub cmd_set_checkpoint_nv: PFN_vkCmdSetCheckpointNV,
12134 pub get_queue_checkpoint_data_nv: PFN_vkGetQueueCheckpointDataNV,
12135}
12136unsafe impl Send for NvDeviceDiagnosticCheckpointsFn {}
12137unsafe impl Sync for NvDeviceDiagnosticCheckpointsFn {}
12138impl NvDeviceDiagnosticCheckpointsFn {
12139 pub fn load<F>(mut _f: F) -> Self
12140 where
12141 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12142 {
12143 Self {
12144 cmd_set_checkpoint_nv: unsafe {
12145 unsafe extern "system" fn cmd_set_checkpoint_nv(
12146 _command_buffer: CommandBuffer,
12147 _p_checkpoint_marker: *const c_void,
12148 ) {
12149 panic!(concat!(
12150 "Unable to load ",
12151 stringify!(cmd_set_checkpoint_nv)
12152 ))
12153 }
12154 let cname =
12155 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCheckpointNV\0");
12156 let val = _f(cname);
12157 if val.is_null() {
12158 cmd_set_checkpoint_nv
12159 } else {
12160 ::std::mem::transmute(val)
12161 }
12162 },
12163 get_queue_checkpoint_data_nv: unsafe {
12164 unsafe extern "system" fn get_queue_checkpoint_data_nv(
12165 _queue: Queue,
12166 _p_checkpoint_data_count: *mut u32,
12167 _p_checkpoint_data: *mut CheckpointDataNV,
12168 ) {
12169 panic!(concat!(
12170 "Unable to load ",
12171 stringify!(get_queue_checkpoint_data_nv)
12172 ))
12173 }
12174 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12175 b"vkGetQueueCheckpointDataNV\0",
12176 );
12177 let val = _f(cname);
12178 if val.is_null() {
12179 get_queue_checkpoint_data_nv
12180 } else {
12181 ::std::mem::transmute(val)
12182 }
12183 },
12184 }
12185 }
12186}
12187#[doc = "Generated from 'VK_NV_device_diagnostic_checkpoints'"]
12188impl StructureType {
12189 pub const CHECKPOINT_DATA_NV: Self = Self(1_000_206_000);
12190 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: Self = Self(1_000_206_001);
12191}
12192impl KhrTimelineSemaphoreFn {
12193 pub const fn name() -> &'static ::std::ffi::CStr {
12194 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_timeline_semaphore\0") }
12195 }
12196 pub const SPEC_VERSION: u32 = 2u32;
12197}
12198#[allow(non_camel_case_types)]
12199pub type PFN_vkGetSemaphoreCounterValue =
12200 unsafe extern "system" fn(device: Device, semaphore: Semaphore, p_value: *mut u64) -> Result;
12201#[allow(non_camel_case_types)]
12202pub type PFN_vkWaitSemaphores = unsafe extern "system" fn(
12203 device: Device,
12204 p_wait_info: *const SemaphoreWaitInfo,
12205 timeout: u64,
12206) -> Result;
12207#[allow(non_camel_case_types)]
12208pub type PFN_vkSignalSemaphore =
12209 unsafe extern "system" fn(device: Device, p_signal_info: *const SemaphoreSignalInfo) -> Result;
12210#[derive(Clone)]
12211pub struct KhrTimelineSemaphoreFn {
12212 pub get_semaphore_counter_value_khr: PFN_vkGetSemaphoreCounterValue,
12213 pub wait_semaphores_khr: PFN_vkWaitSemaphores,
12214 pub signal_semaphore_khr: PFN_vkSignalSemaphore,
12215}
12216unsafe impl Send for KhrTimelineSemaphoreFn {}
12217unsafe impl Sync for KhrTimelineSemaphoreFn {}
12218impl KhrTimelineSemaphoreFn {
12219 pub fn load<F>(mut _f: F) -> Self
12220 where
12221 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12222 {
12223 Self {
12224 get_semaphore_counter_value_khr: unsafe {
12225 unsafe extern "system" fn get_semaphore_counter_value_khr(
12226 _device: Device,
12227 _semaphore: Semaphore,
12228 _p_value: *mut u64,
12229 ) -> Result {
12230 panic!(concat!(
12231 "Unable to load ",
12232 stringify!(get_semaphore_counter_value_khr)
12233 ))
12234 }
12235 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12236 b"vkGetSemaphoreCounterValueKHR\0",
12237 );
12238 let val = _f(cname);
12239 if val.is_null() {
12240 get_semaphore_counter_value_khr
12241 } else {
12242 ::std::mem::transmute(val)
12243 }
12244 },
12245 wait_semaphores_khr: unsafe {
12246 unsafe extern "system" fn wait_semaphores_khr(
12247 _device: Device,
12248 _p_wait_info: *const SemaphoreWaitInfo,
12249 _timeout: u64,
12250 ) -> Result {
12251 panic!(concat!("Unable to load ", stringify!(wait_semaphores_khr)))
12252 }
12253 let cname =
12254 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitSemaphoresKHR\0");
12255 let val = _f(cname);
12256 if val.is_null() {
12257 wait_semaphores_khr
12258 } else {
12259 ::std::mem::transmute(val)
12260 }
12261 },
12262 signal_semaphore_khr: unsafe {
12263 unsafe extern "system" fn signal_semaphore_khr(
12264 _device: Device,
12265 _p_signal_info: *const SemaphoreSignalInfo,
12266 ) -> Result {
12267 panic!(concat!("Unable to load ", stringify!(signal_semaphore_khr)))
12268 }
12269 let cname =
12270 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSignalSemaphoreKHR\0");
12271 let val = _f(cname);
12272 if val.is_null() {
12273 signal_semaphore_khr
12274 } else {
12275 ::std::mem::transmute(val)
12276 }
12277 },
12278 }
12279 }
12280}
12281#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
12282impl SemaphoreType {
12283 pub const BINARY_KHR: Self = Self::BINARY;
12284 pub const TIMELINE_KHR: Self = Self::TIMELINE;
12285}
12286#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
12287impl SemaphoreWaitFlags {
12288 pub const ANY_KHR: Self = Self::ANY;
12289}
12290#[doc = "Generated from 'VK_KHR_timeline_semaphore'"]
12291impl StructureType {
12292 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: Self =
12293 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
12294 pub const PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: Self =
12295 Self::PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
12296 pub const SEMAPHORE_TYPE_CREATE_INFO_KHR: Self = Self::SEMAPHORE_TYPE_CREATE_INFO;
12297 pub const TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::TIMELINE_SEMAPHORE_SUBMIT_INFO;
12298 pub const SEMAPHORE_WAIT_INFO_KHR: Self = Self::SEMAPHORE_WAIT_INFO;
12299 pub const SEMAPHORE_SIGNAL_INFO_KHR: Self = Self::SEMAPHORE_SIGNAL_INFO;
12300}
12301impl KhrExtension209Fn {
12302 pub const fn name() -> &'static ::std::ffi::CStr {
12303 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_209\0") }
12304 }
12305 pub const SPEC_VERSION: u32 = 0u32;
12306}
12307#[derive(Clone)]
12308pub struct KhrExtension209Fn {}
12309unsafe impl Send for KhrExtension209Fn {}
12310unsafe impl Sync for KhrExtension209Fn {}
12311impl KhrExtension209Fn {
12312 pub fn load<F>(mut _f: F) -> Self
12313 where
12314 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12315 {
12316 Self {}
12317 }
12318}
12319impl IntelShaderIntegerFunctions2Fn {
12320 pub const fn name() -> &'static ::std::ffi::CStr {
12321 unsafe {
12322 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_shader_integer_functions2\0")
12323 }
12324 }
12325 pub const SPEC_VERSION: u32 = 1u32;
12326}
12327#[derive(Clone)]
12328pub struct IntelShaderIntegerFunctions2Fn {}
12329unsafe impl Send for IntelShaderIntegerFunctions2Fn {}
12330unsafe impl Sync for IntelShaderIntegerFunctions2Fn {}
12331impl IntelShaderIntegerFunctions2Fn {
12332 pub fn load<F>(mut _f: F) -> Self
12333 where
12334 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12335 {
12336 Self {}
12337 }
12338}
12339#[doc = "Generated from 'VK_INTEL_shader_integer_functions2'"]
12340impl StructureType {
12341 pub const PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: Self = Self(1_000_209_000);
12342}
12343impl IntelPerformanceQueryFn {
12344 pub const fn name() -> &'static ::std::ffi::CStr {
12345 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_performance_query\0") }
12346 }
12347 pub const SPEC_VERSION: u32 = 2u32;
12348}
12349#[allow(non_camel_case_types)]
12350pub type PFN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn(
12351 device: Device,
12352 p_initialize_info: *const InitializePerformanceApiInfoINTEL,
12353) -> Result;
12354#[allow(non_camel_case_types)]
12355pub type PFN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: Device);
12356#[allow(non_camel_case_types)]
12357pub type PFN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn(
12358 command_buffer: CommandBuffer,
12359 p_marker_info: *const PerformanceMarkerInfoINTEL,
12360) -> Result;
12361#[allow(non_camel_case_types)]
12362pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn(
12363 command_buffer: CommandBuffer,
12364 p_marker_info: *const PerformanceStreamMarkerInfoINTEL,
12365) -> Result;
12366#[allow(non_camel_case_types)]
12367pub type PFN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn(
12368 command_buffer: CommandBuffer,
12369 p_override_info: *const PerformanceOverrideInfoINTEL,
12370) -> Result;
12371#[allow(non_camel_case_types)]
12372pub type PFN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn(
12373 device: Device,
12374 p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL,
12375 p_configuration: *mut PerformanceConfigurationINTEL,
12376) -> Result;
12377#[allow(non_camel_case_types)]
12378pub type PFN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn(
12379 device: Device,
12380 configuration: PerformanceConfigurationINTEL,
12381) -> Result;
12382#[allow(non_camel_case_types)]
12383pub type PFN_vkQueueSetPerformanceConfigurationINTEL =
12384 unsafe extern "system" fn(queue: Queue, configuration: PerformanceConfigurationINTEL) -> Result;
12385#[allow(non_camel_case_types)]
12386pub type PFN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn(
12387 device: Device,
12388 parameter: PerformanceParameterTypeINTEL,
12389 p_value: *mut PerformanceValueINTEL,
12390) -> Result;
12391#[derive(Clone)]
12392pub struct IntelPerformanceQueryFn {
12393 pub initialize_performance_api_intel: PFN_vkInitializePerformanceApiINTEL,
12394 pub uninitialize_performance_api_intel: PFN_vkUninitializePerformanceApiINTEL,
12395 pub cmd_set_performance_marker_intel: PFN_vkCmdSetPerformanceMarkerINTEL,
12396 pub cmd_set_performance_stream_marker_intel: PFN_vkCmdSetPerformanceStreamMarkerINTEL,
12397 pub cmd_set_performance_override_intel: PFN_vkCmdSetPerformanceOverrideINTEL,
12398 pub acquire_performance_configuration_intel: PFN_vkAcquirePerformanceConfigurationINTEL,
12399 pub release_performance_configuration_intel: PFN_vkReleasePerformanceConfigurationINTEL,
12400 pub queue_set_performance_configuration_intel: PFN_vkQueueSetPerformanceConfigurationINTEL,
12401 pub get_performance_parameter_intel: PFN_vkGetPerformanceParameterINTEL,
12402}
12403unsafe impl Send for IntelPerformanceQueryFn {}
12404unsafe impl Sync for IntelPerformanceQueryFn {}
12405impl IntelPerformanceQueryFn {
12406 pub fn load<F>(mut _f: F) -> Self
12407 where
12408 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12409 {
12410 Self {
12411 initialize_performance_api_intel: unsafe {
12412 unsafe extern "system" fn initialize_performance_api_intel(
12413 _device: Device,
12414 _p_initialize_info: *const InitializePerformanceApiInfoINTEL,
12415 ) -> Result {
12416 panic!(concat!(
12417 "Unable to load ",
12418 stringify!(initialize_performance_api_intel)
12419 ))
12420 }
12421 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12422 b"vkInitializePerformanceApiINTEL\0",
12423 );
12424 let val = _f(cname);
12425 if val.is_null() {
12426 initialize_performance_api_intel
12427 } else {
12428 ::std::mem::transmute(val)
12429 }
12430 },
12431 uninitialize_performance_api_intel: unsafe {
12432 unsafe extern "system" fn uninitialize_performance_api_intel(_device: Device) {
12433 panic!(concat!(
12434 "Unable to load ",
12435 stringify!(uninitialize_performance_api_intel)
12436 ))
12437 }
12438 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12439 b"vkUninitializePerformanceApiINTEL\0",
12440 );
12441 let val = _f(cname);
12442 if val.is_null() {
12443 uninitialize_performance_api_intel
12444 } else {
12445 ::std::mem::transmute(val)
12446 }
12447 },
12448 cmd_set_performance_marker_intel: unsafe {
12449 unsafe extern "system" fn cmd_set_performance_marker_intel(
12450 _command_buffer: CommandBuffer,
12451 _p_marker_info: *const PerformanceMarkerInfoINTEL,
12452 ) -> Result {
12453 panic!(concat!(
12454 "Unable to load ",
12455 stringify!(cmd_set_performance_marker_intel)
12456 ))
12457 }
12458 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12459 b"vkCmdSetPerformanceMarkerINTEL\0",
12460 );
12461 let val = _f(cname);
12462 if val.is_null() {
12463 cmd_set_performance_marker_intel
12464 } else {
12465 ::std::mem::transmute(val)
12466 }
12467 },
12468 cmd_set_performance_stream_marker_intel: unsafe {
12469 unsafe extern "system" fn cmd_set_performance_stream_marker_intel(
12470 _command_buffer: CommandBuffer,
12471 _p_marker_info: *const PerformanceStreamMarkerInfoINTEL,
12472 ) -> Result {
12473 panic!(concat!(
12474 "Unable to load ",
12475 stringify!(cmd_set_performance_stream_marker_intel)
12476 ))
12477 }
12478 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12479 b"vkCmdSetPerformanceStreamMarkerINTEL\0",
12480 );
12481 let val = _f(cname);
12482 if val.is_null() {
12483 cmd_set_performance_stream_marker_intel
12484 } else {
12485 ::std::mem::transmute(val)
12486 }
12487 },
12488 cmd_set_performance_override_intel: unsafe {
12489 unsafe extern "system" fn cmd_set_performance_override_intel(
12490 _command_buffer: CommandBuffer,
12491 _p_override_info: *const PerformanceOverrideInfoINTEL,
12492 ) -> Result {
12493 panic!(concat!(
12494 "Unable to load ",
12495 stringify!(cmd_set_performance_override_intel)
12496 ))
12497 }
12498 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12499 b"vkCmdSetPerformanceOverrideINTEL\0",
12500 );
12501 let val = _f(cname);
12502 if val.is_null() {
12503 cmd_set_performance_override_intel
12504 } else {
12505 ::std::mem::transmute(val)
12506 }
12507 },
12508 acquire_performance_configuration_intel: unsafe {
12509 unsafe extern "system" fn acquire_performance_configuration_intel(
12510 _device: Device,
12511 _p_acquire_info: *const PerformanceConfigurationAcquireInfoINTEL,
12512 _p_configuration: *mut PerformanceConfigurationINTEL,
12513 ) -> Result {
12514 panic!(concat!(
12515 "Unable to load ",
12516 stringify!(acquire_performance_configuration_intel)
12517 ))
12518 }
12519 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12520 b"vkAcquirePerformanceConfigurationINTEL\0",
12521 );
12522 let val = _f(cname);
12523 if val.is_null() {
12524 acquire_performance_configuration_intel
12525 } else {
12526 ::std::mem::transmute(val)
12527 }
12528 },
12529 release_performance_configuration_intel: unsafe {
12530 unsafe extern "system" fn release_performance_configuration_intel(
12531 _device: Device,
12532 _configuration: PerformanceConfigurationINTEL,
12533 ) -> Result {
12534 panic!(concat!(
12535 "Unable to load ",
12536 stringify!(release_performance_configuration_intel)
12537 ))
12538 }
12539 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12540 b"vkReleasePerformanceConfigurationINTEL\0",
12541 );
12542 let val = _f(cname);
12543 if val.is_null() {
12544 release_performance_configuration_intel
12545 } else {
12546 ::std::mem::transmute(val)
12547 }
12548 },
12549 queue_set_performance_configuration_intel: unsafe {
12550 unsafe extern "system" fn queue_set_performance_configuration_intel(
12551 _queue: Queue,
12552 _configuration: PerformanceConfigurationINTEL,
12553 ) -> Result {
12554 panic!(concat!(
12555 "Unable to load ",
12556 stringify!(queue_set_performance_configuration_intel)
12557 ))
12558 }
12559 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12560 b"vkQueueSetPerformanceConfigurationINTEL\0",
12561 );
12562 let val = _f(cname);
12563 if val.is_null() {
12564 queue_set_performance_configuration_intel
12565 } else {
12566 ::std::mem::transmute(val)
12567 }
12568 },
12569 get_performance_parameter_intel: unsafe {
12570 unsafe extern "system" fn get_performance_parameter_intel(
12571 _device: Device,
12572 _parameter: PerformanceParameterTypeINTEL,
12573 _p_value: *mut PerformanceValueINTEL,
12574 ) -> Result {
12575 panic!(concat!(
12576 "Unable to load ",
12577 stringify!(get_performance_parameter_intel)
12578 ))
12579 }
12580 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12581 b"vkGetPerformanceParameterINTEL\0",
12582 );
12583 let val = _f(cname);
12584 if val.is_null() {
12585 get_performance_parameter_intel
12586 } else {
12587 ::std::mem::transmute(val)
12588 }
12589 },
12590 }
12591 }
12592}
12593#[doc = "Generated from 'VK_INTEL_performance_query'"]
12594impl ObjectType {
12595 pub const PERFORMANCE_CONFIGURATION_INTEL: Self = Self(1_000_210_000);
12596}
12597#[doc = "Generated from 'VK_INTEL_performance_query'"]
12598impl QueryType {
12599 pub const PERFORMANCE_QUERY_INTEL: Self = Self(1_000_210_000);
12600}
12601#[doc = "Generated from 'VK_INTEL_performance_query'"]
12602impl StructureType {
12603 pub const QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: Self = Self(1_000_210_000);
12604 pub const INITIALIZE_PERFORMANCE_API_INFO_INTEL: Self = Self(1_000_210_001);
12605 pub const PERFORMANCE_MARKER_INFO_INTEL: Self = Self(1_000_210_002);
12606 pub const PERFORMANCE_STREAM_MARKER_INFO_INTEL: Self = Self(1_000_210_003);
12607 pub const PERFORMANCE_OVERRIDE_INFO_INTEL: Self = Self(1_000_210_004);
12608 pub const PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: Self = Self(1_000_210_005);
12609}
12610impl KhrVulkanMemoryModelFn {
12611 pub const fn name() -> &'static ::std::ffi::CStr {
12612 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_vulkan_memory_model\0") }
12613 }
12614 pub const SPEC_VERSION: u32 = 3u32;
12615}
12616#[derive(Clone)]
12617pub struct KhrVulkanMemoryModelFn {}
12618unsafe impl Send for KhrVulkanMemoryModelFn {}
12619unsafe impl Sync for KhrVulkanMemoryModelFn {}
12620impl KhrVulkanMemoryModelFn {
12621 pub fn load<F>(mut _f: F) -> Self
12622 where
12623 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12624 {
12625 Self {}
12626 }
12627}
12628#[doc = "Generated from 'VK_KHR_vulkan_memory_model'"]
12629impl StructureType {
12630 pub const PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: Self =
12631 Self::PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
12632}
12633impl ExtPciBusInfoFn {
12634 pub const fn name() -> &'static ::std::ffi::CStr {
12635 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_pci_bus_info\0") }
12636 }
12637 pub const SPEC_VERSION: u32 = 2u32;
12638}
12639#[derive(Clone)]
12640pub struct ExtPciBusInfoFn {}
12641unsafe impl Send for ExtPciBusInfoFn {}
12642unsafe impl Sync for ExtPciBusInfoFn {}
12643impl ExtPciBusInfoFn {
12644 pub fn load<F>(mut _f: F) -> Self
12645 where
12646 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12647 {
12648 Self {}
12649 }
12650}
12651#[doc = "Generated from 'VK_EXT_pci_bus_info'"]
12652impl StructureType {
12653 pub const PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: Self = Self(1_000_212_000);
12654}
12655impl AmdDisplayNativeHdrFn {
12656 pub const fn name() -> &'static ::std::ffi::CStr {
12657 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_display_native_hdr\0") }
12658 }
12659 pub const SPEC_VERSION: u32 = 1u32;
12660}
12661#[allow(non_camel_case_types)]
12662pub type PFN_vkSetLocalDimmingAMD = unsafe extern "system" fn(
12663 device: Device,
12664 swap_chain: SwapchainKHR,
12665 local_dimming_enable: Bool32,
12666);
12667#[derive(Clone)]
12668pub struct AmdDisplayNativeHdrFn {
12669 pub set_local_dimming_amd: PFN_vkSetLocalDimmingAMD,
12670}
12671unsafe impl Send for AmdDisplayNativeHdrFn {}
12672unsafe impl Sync for AmdDisplayNativeHdrFn {}
12673impl AmdDisplayNativeHdrFn {
12674 pub fn load<F>(mut _f: F) -> Self
12675 where
12676 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12677 {
12678 Self {
12679 set_local_dimming_amd: unsafe {
12680 unsafe extern "system" fn set_local_dimming_amd(
12681 _device: Device,
12682 _swap_chain: SwapchainKHR,
12683 _local_dimming_enable: Bool32,
12684 ) {
12685 panic!(concat!(
12686 "Unable to load ",
12687 stringify!(set_local_dimming_amd)
12688 ))
12689 }
12690 let cname =
12691 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetLocalDimmingAMD\0");
12692 let val = _f(cname);
12693 if val.is_null() {
12694 set_local_dimming_amd
12695 } else {
12696 ::std::mem::transmute(val)
12697 }
12698 },
12699 }
12700 }
12701}
12702#[doc = "Generated from 'VK_AMD_display_native_hdr'"]
12703impl ColorSpaceKHR {
12704 pub const DISPLAY_NATIVE_AMD: Self = Self(1_000_213_000);
12705}
12706#[doc = "Generated from 'VK_AMD_display_native_hdr'"]
12707impl StructureType {
12708 pub const DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: Self = Self(1_000_213_000);
12709 pub const SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: Self = Self(1_000_213_001);
12710}
12711impl FuchsiaImagepipeSurfaceFn {
12712 pub const fn name() -> &'static ::std::ffi::CStr {
12713 unsafe {
12714 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_imagepipe_surface\0")
12715 }
12716 }
12717 pub const SPEC_VERSION: u32 = 1u32;
12718}
12719#[allow(non_camel_case_types)]
12720pub type PFN_vkCreateImagePipeSurfaceFUCHSIA = unsafe extern "system" fn(
12721 instance: Instance,
12722 p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA,
12723 p_allocator: *const AllocationCallbacks,
12724 p_surface: *mut SurfaceKHR,
12725) -> Result;
12726#[derive(Clone)]
12727pub struct FuchsiaImagepipeSurfaceFn {
12728 pub create_image_pipe_surface_fuchsia: PFN_vkCreateImagePipeSurfaceFUCHSIA,
12729}
12730unsafe impl Send for FuchsiaImagepipeSurfaceFn {}
12731unsafe impl Sync for FuchsiaImagepipeSurfaceFn {}
12732impl FuchsiaImagepipeSurfaceFn {
12733 pub fn load<F>(mut _f: F) -> Self
12734 where
12735 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12736 {
12737 Self {
12738 create_image_pipe_surface_fuchsia: unsafe {
12739 unsafe extern "system" fn create_image_pipe_surface_fuchsia(
12740 _instance: Instance,
12741 _p_create_info: *const ImagePipeSurfaceCreateInfoFUCHSIA,
12742 _p_allocator: *const AllocationCallbacks,
12743 _p_surface: *mut SurfaceKHR,
12744 ) -> Result {
12745 panic!(concat!(
12746 "Unable to load ",
12747 stringify!(create_image_pipe_surface_fuchsia)
12748 ))
12749 }
12750 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
12751 b"vkCreateImagePipeSurfaceFUCHSIA\0",
12752 );
12753 let val = _f(cname);
12754 if val.is_null() {
12755 create_image_pipe_surface_fuchsia
12756 } else {
12757 ::std::mem::transmute(val)
12758 }
12759 },
12760 }
12761 }
12762}
12763#[doc = "Generated from 'VK_FUCHSIA_imagepipe_surface'"]
12764impl StructureType {
12765 pub const IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: Self = Self(1_000_214_000);
12766}
12767impl KhrShaderTerminateInvocationFn {
12768 pub const fn name() -> &'static ::std::ffi::CStr {
12769 unsafe {
12770 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_terminate_invocation\0")
12771 }
12772 }
12773 pub const SPEC_VERSION: u32 = 1u32;
12774}
12775#[derive(Clone)]
12776pub struct KhrShaderTerminateInvocationFn {}
12777unsafe impl Send for KhrShaderTerminateInvocationFn {}
12778unsafe impl Sync for KhrShaderTerminateInvocationFn {}
12779impl KhrShaderTerminateInvocationFn {
12780 pub fn load<F>(mut _f: F) -> Self
12781 where
12782 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12783 {
12784 Self {}
12785 }
12786}
12787#[doc = "Generated from 'VK_KHR_shader_terminate_invocation'"]
12788impl StructureType {
12789 pub const PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: Self =
12790 Self::PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
12791}
12792impl GoogleExtension217Fn {
12793 pub const fn name() -> &'static ::std::ffi::CStr {
12794 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_217\0") }
12795 }
12796 pub const SPEC_VERSION: u32 = 0u32;
12797}
12798#[derive(Clone)]
12799pub struct GoogleExtension217Fn {}
12800unsafe impl Send for GoogleExtension217Fn {}
12801unsafe impl Sync for GoogleExtension217Fn {}
12802impl GoogleExtension217Fn {
12803 pub fn load<F>(mut _f: F) -> Self
12804 where
12805 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12806 {
12807 Self {}
12808 }
12809}
12810impl ExtMetalSurfaceFn {
12811 pub const fn name() -> &'static ::std::ffi::CStr {
12812 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_metal_surface\0") }
12813 }
12814 pub const SPEC_VERSION: u32 = 1u32;
12815}
12816#[allow(non_camel_case_types)]
12817pub type PFN_vkCreateMetalSurfaceEXT = unsafe extern "system" fn(
12818 instance: Instance,
12819 p_create_info: *const MetalSurfaceCreateInfoEXT,
12820 p_allocator: *const AllocationCallbacks,
12821 p_surface: *mut SurfaceKHR,
12822) -> Result;
12823#[derive(Clone)]
12824pub struct ExtMetalSurfaceFn {
12825 pub create_metal_surface_ext: PFN_vkCreateMetalSurfaceEXT,
12826}
12827unsafe impl Send for ExtMetalSurfaceFn {}
12828unsafe impl Sync for ExtMetalSurfaceFn {}
12829impl ExtMetalSurfaceFn {
12830 pub fn load<F>(mut _f: F) -> Self
12831 where
12832 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12833 {
12834 Self {
12835 create_metal_surface_ext: unsafe {
12836 unsafe extern "system" fn create_metal_surface_ext(
12837 _instance: Instance,
12838 _p_create_info: *const MetalSurfaceCreateInfoEXT,
12839 _p_allocator: *const AllocationCallbacks,
12840 _p_surface: *mut SurfaceKHR,
12841 ) -> Result {
12842 panic!(concat!(
12843 "Unable to load ",
12844 stringify!(create_metal_surface_ext)
12845 ))
12846 }
12847 let cname =
12848 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateMetalSurfaceEXT\0");
12849 let val = _f(cname);
12850 if val.is_null() {
12851 create_metal_surface_ext
12852 } else {
12853 ::std::mem::transmute(val)
12854 }
12855 },
12856 }
12857 }
12858}
12859#[doc = "Generated from 'VK_EXT_metal_surface'"]
12860impl StructureType {
12861 pub const METAL_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_217_000);
12862}
12863impl ExtFragmentDensityMapFn {
12864 pub const fn name() -> &'static ::std::ffi::CStr {
12865 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map\0") }
12866 }
12867 pub const SPEC_VERSION: u32 = 2u32;
12868}
12869#[derive(Clone)]
12870pub struct ExtFragmentDensityMapFn {}
12871unsafe impl Send for ExtFragmentDensityMapFn {}
12872unsafe impl Sync for ExtFragmentDensityMapFn {}
12873impl ExtFragmentDensityMapFn {
12874 pub fn load<F>(mut _f: F) -> Self
12875 where
12876 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12877 {
12878 Self {}
12879 }
12880}
12881#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12882impl AccessFlags {
12883 pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
12884}
12885#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12886impl FormatFeatureFlags {
12887 pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
12888}
12889#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12890impl FormatFeatureFlags2 {
12891 pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
12892}
12893#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12894impl ImageCreateFlags {
12895 pub const SUBSAMPLED_EXT: Self = Self(0b100_0000_0000_0000);
12896}
12897#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12898impl ImageLayout {
12899 pub const FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: Self = Self(1_000_218_000);
12900}
12901#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12902impl ImageUsageFlags {
12903 pub const FRAGMENT_DENSITY_MAP_EXT: Self = Self(0b10_0000_0000);
12904}
12905#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12906impl ImageViewCreateFlags {
12907 pub const FRAGMENT_DENSITY_MAP_DYNAMIC_EXT: Self = Self(0b1);
12908}
12909#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12910impl PipelineStageFlags {
12911 pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
12912}
12913#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12914impl SamplerCreateFlags {
12915 pub const SUBSAMPLED_EXT: Self = Self(0b1);
12916 pub const SUBSAMPLED_COARSE_RECONSTRUCTION_EXT: Self = Self(0b10);
12917}
12918#[doc = "Generated from 'VK_EXT_fragment_density_map'"]
12919impl StructureType {
12920 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: Self = Self(1_000_218_000);
12921 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: Self = Self(1_000_218_001);
12922 pub const RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: Self = Self(1_000_218_002);
12923}
12924impl ExtExtension220Fn {
12925 pub const fn name() -> &'static ::std::ffi::CStr {
12926 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_220\0") }
12927 }
12928 pub const SPEC_VERSION: u32 = 0u32;
12929}
12930#[derive(Clone)]
12931pub struct ExtExtension220Fn {}
12932unsafe impl Send for ExtExtension220Fn {}
12933unsafe impl Sync for ExtExtension220Fn {}
12934impl ExtExtension220Fn {
12935 pub fn load<F>(mut _f: F) -> Self
12936 where
12937 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12938 {
12939 Self {}
12940 }
12941}
12942impl KhrExtension221Fn {
12943 pub const fn name() -> &'static ::std::ffi::CStr {
12944 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_221\0") }
12945 }
12946 pub const SPEC_VERSION: u32 = 0u32;
12947}
12948#[derive(Clone)]
12949pub struct KhrExtension221Fn {}
12950unsafe impl Send for KhrExtension221Fn {}
12951unsafe impl Sync for KhrExtension221Fn {}
12952impl KhrExtension221Fn {
12953 pub fn load<F>(mut _f: F) -> Self
12954 where
12955 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12956 {
12957 Self {}
12958 }
12959}
12960#[doc = "Generated from 'VK_KHR_extension_221'"]
12961impl RenderPassCreateFlags {
12962 pub const RESERVED_0_KHR: Self = Self(0b1);
12963}
12964impl ExtScalarBlockLayoutFn {
12965 pub const fn name() -> &'static ::std::ffi::CStr {
12966 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_scalar_block_layout\0") }
12967 }
12968 pub const SPEC_VERSION: u32 = 1u32;
12969}
12970#[derive(Clone)]
12971pub struct ExtScalarBlockLayoutFn {}
12972unsafe impl Send for ExtScalarBlockLayoutFn {}
12973unsafe impl Sync for ExtScalarBlockLayoutFn {}
12974impl ExtScalarBlockLayoutFn {
12975 pub fn load<F>(mut _f: F) -> Self
12976 where
12977 F: FnMut(&::std::ffi::CStr) -> *const c_void,
12978 {
12979 Self {}
12980 }
12981}
12982#[doc = "Generated from 'VK_EXT_scalar_block_layout'"]
12983impl StructureType {
12984 pub const PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: Self =
12985 Self::PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
12986}
12987impl ExtExtension223Fn {
12988 pub const fn name() -> &'static ::std::ffi::CStr {
12989 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_223\0") }
12990 }
12991 pub const SPEC_VERSION: u32 = 0u32;
12992}
12993#[derive(Clone)]
12994pub struct ExtExtension223Fn {}
12995unsafe impl Send for ExtExtension223Fn {}
12996unsafe impl Sync for ExtExtension223Fn {}
12997impl ExtExtension223Fn {
12998 pub fn load<F>(mut _f: F) -> Self
12999 where
13000 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13001 {
13002 Self {}
13003 }
13004}
13005impl GoogleHlslFunctionality1Fn {
13006 pub const fn name() -> &'static ::std::ffi::CStr {
13007 unsafe {
13008 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_hlsl_functionality1\0")
13009 }
13010 }
13011 pub const SPEC_VERSION: u32 = 1u32;
13012}
13013#[derive(Clone)]
13014pub struct GoogleHlslFunctionality1Fn {}
13015unsafe impl Send for GoogleHlslFunctionality1Fn {}
13016unsafe impl Sync for GoogleHlslFunctionality1Fn {}
13017impl GoogleHlslFunctionality1Fn {
13018 pub fn load<F>(mut _f: F) -> Self
13019 where
13020 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13021 {
13022 Self {}
13023 }
13024}
13025impl GoogleDecorateStringFn {
13026 pub const fn name() -> &'static ::std::ffi::CStr {
13027 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_decorate_string\0") }
13028 }
13029 pub const SPEC_VERSION: u32 = 1u32;
13030}
13031#[derive(Clone)]
13032pub struct GoogleDecorateStringFn {}
13033unsafe impl Send for GoogleDecorateStringFn {}
13034unsafe impl Sync for GoogleDecorateStringFn {}
13035impl GoogleDecorateStringFn {
13036 pub fn load<F>(mut _f: F) -> Self
13037 where
13038 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13039 {
13040 Self {}
13041 }
13042}
13043impl ExtSubgroupSizeControlFn {
13044 pub const fn name() -> &'static ::std::ffi::CStr {
13045 unsafe {
13046 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_subgroup_size_control\0")
13047 }
13048 }
13049 pub const SPEC_VERSION: u32 = 2u32;
13050}
13051#[derive(Clone)]
13052pub struct ExtSubgroupSizeControlFn {}
13053unsafe impl Send for ExtSubgroupSizeControlFn {}
13054unsafe impl Sync for ExtSubgroupSizeControlFn {}
13055impl ExtSubgroupSizeControlFn {
13056 pub fn load<F>(mut _f: F) -> Self
13057 where
13058 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13059 {
13060 Self {}
13061 }
13062}
13063#[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
13064impl PipelineShaderStageCreateFlags {
13065 pub const ALLOW_VARYING_SUBGROUP_SIZE_EXT: Self = Self::ALLOW_VARYING_SUBGROUP_SIZE;
13066 pub const REQUIRE_FULL_SUBGROUPS_EXT: Self = Self::REQUIRE_FULL_SUBGROUPS;
13067}
13068#[doc = "Generated from 'VK_EXT_subgroup_size_control'"]
13069impl StructureType {
13070 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: Self =
13071 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
13072 pub const PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: Self =
13073 Self::PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
13074 pub const PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: Self =
13075 Self::PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
13076}
13077impl KhrFragmentShadingRateFn {
13078 pub const fn name() -> &'static ::std::ffi::CStr {
13079 unsafe {
13080 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_fragment_shading_rate\0")
13081 }
13082 }
13083 pub const SPEC_VERSION: u32 = 2u32;
13084}
13085#[allow(non_camel_case_types)]
13086pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn(
13087 physical_device: PhysicalDevice,
13088 p_fragment_shading_rate_count: *mut u32,
13089 p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR,
13090) -> Result;
13091#[allow(non_camel_case_types)]
13092pub type PFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn(
13093 command_buffer: CommandBuffer,
13094 p_fragment_size: *const Extent2D,
13095 combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
13096);
13097#[derive(Clone)]
13098pub struct KhrFragmentShadingRateFn {
13099 pub get_physical_device_fragment_shading_rates_khr:
13100 PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR,
13101 pub cmd_set_fragment_shading_rate_khr: PFN_vkCmdSetFragmentShadingRateKHR,
13102}
13103unsafe impl Send for KhrFragmentShadingRateFn {}
13104unsafe impl Sync for KhrFragmentShadingRateFn {}
13105impl KhrFragmentShadingRateFn {
13106 pub fn load<F>(mut _f: F) -> Self
13107 where
13108 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13109 {
13110 Self {
13111 get_physical_device_fragment_shading_rates_khr: unsafe {
13112 unsafe extern "system" fn get_physical_device_fragment_shading_rates_khr(
13113 _physical_device: PhysicalDevice,
13114 _p_fragment_shading_rate_count: *mut u32,
13115 _p_fragment_shading_rates: *mut PhysicalDeviceFragmentShadingRateKHR,
13116 ) -> Result {
13117 panic!(concat!(
13118 "Unable to load ",
13119 stringify!(get_physical_device_fragment_shading_rates_khr)
13120 ))
13121 }
13122 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13123 b"vkGetPhysicalDeviceFragmentShadingRatesKHR\0",
13124 );
13125 let val = _f(cname);
13126 if val.is_null() {
13127 get_physical_device_fragment_shading_rates_khr
13128 } else {
13129 ::std::mem::transmute(val)
13130 }
13131 },
13132 cmd_set_fragment_shading_rate_khr: unsafe {
13133 unsafe extern "system" fn cmd_set_fragment_shading_rate_khr(
13134 _command_buffer: CommandBuffer,
13135 _p_fragment_size: *const Extent2D,
13136 _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
13137 ) {
13138 panic!(concat!(
13139 "Unable to load ",
13140 stringify!(cmd_set_fragment_shading_rate_khr)
13141 ))
13142 }
13143 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13144 b"vkCmdSetFragmentShadingRateKHR\0",
13145 );
13146 let val = _f(cname);
13147 if val.is_null() {
13148 cmd_set_fragment_shading_rate_khr
13149 } else {
13150 ::std::mem::transmute(val)
13151 }
13152 },
13153 }
13154 }
13155}
13156#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13157impl AccessFlags {
13158 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self =
13159 Self(0b1000_0000_0000_0000_0000_0000);
13160}
13161#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13162impl DynamicState {
13163 pub const FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_000);
13164}
13165#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13166impl FormatFeatureFlags {
13167 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
13168 Self(0b100_0000_0000_0000_0000_0000_0000_0000);
13169}
13170#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13171impl FormatFeatureFlags2 {
13172 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self =
13173 Self(0b100_0000_0000_0000_0000_0000_0000_0000);
13174}
13175#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13176impl ImageLayout {
13177 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: Self = Self(1_000_164_003);
13178}
13179#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13180impl ImageUsageFlags {
13181 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b1_0000_0000);
13182}
13183#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13184impl PipelineStageFlags {
13185 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
13186}
13187#[doc = "Generated from 'VK_KHR_fragment_shading_rate'"]
13188impl StructureType {
13189 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: Self = Self(1_000_226_000);
13190 pub const PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: Self = Self(1_000_226_001);
13191 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: Self = Self(1_000_226_002);
13192 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: Self = Self(1_000_226_003);
13193 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: Self = Self(1_000_226_004);
13194}
13195impl AmdShaderCoreProperties2Fn {
13196 pub const fn name() -> &'static ::std::ffi::CStr {
13197 unsafe {
13198 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_shader_core_properties2\0")
13199 }
13200 }
13201 pub const SPEC_VERSION: u32 = 1u32;
13202}
13203#[derive(Clone)]
13204pub struct AmdShaderCoreProperties2Fn {}
13205unsafe impl Send for AmdShaderCoreProperties2Fn {}
13206unsafe impl Sync for AmdShaderCoreProperties2Fn {}
13207impl AmdShaderCoreProperties2Fn {
13208 pub fn load<F>(mut _f: F) -> Self
13209 where
13210 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13211 {
13212 Self {}
13213 }
13214}
13215#[doc = "Generated from 'VK_AMD_shader_core_properties2'"]
13216impl StructureType {
13217 pub const PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: Self = Self(1_000_227_000);
13218}
13219impl AmdExtension229Fn {
13220 pub const fn name() -> &'static ::std::ffi::CStr {
13221 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_229\0") }
13222 }
13223 pub const SPEC_VERSION: u32 = 0u32;
13224}
13225#[derive(Clone)]
13226pub struct AmdExtension229Fn {}
13227unsafe impl Send for AmdExtension229Fn {}
13228unsafe impl Sync for AmdExtension229Fn {}
13229impl AmdExtension229Fn {
13230 pub fn load<F>(mut _f: F) -> Self
13231 where
13232 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13233 {
13234 Self {}
13235 }
13236}
13237impl AmdDeviceCoherentMemoryFn {
13238 pub const fn name() -> &'static ::std::ffi::CStr {
13239 unsafe {
13240 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_device_coherent_memory\0")
13241 }
13242 }
13243 pub const SPEC_VERSION: u32 = 1u32;
13244}
13245#[derive(Clone)]
13246pub struct AmdDeviceCoherentMemoryFn {}
13247unsafe impl Send for AmdDeviceCoherentMemoryFn {}
13248unsafe impl Sync for AmdDeviceCoherentMemoryFn {}
13249impl AmdDeviceCoherentMemoryFn {
13250 pub fn load<F>(mut _f: F) -> Self
13251 where
13252 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13253 {
13254 Self {}
13255 }
13256}
13257#[doc = "Generated from 'VK_AMD_device_coherent_memory'"]
13258impl MemoryPropertyFlags {
13259 pub const DEVICE_COHERENT_AMD: Self = Self(0b100_0000);
13260 pub const DEVICE_UNCACHED_AMD: Self = Self(0b1000_0000);
13261}
13262#[doc = "Generated from 'VK_AMD_device_coherent_memory'"]
13263impl StructureType {
13264 pub const PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: Self = Self(1_000_229_000);
13265}
13266impl AmdExtension231Fn {
13267 pub const fn name() -> &'static ::std::ffi::CStr {
13268 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_231\0") }
13269 }
13270 pub const SPEC_VERSION: u32 = 0u32;
13271}
13272#[derive(Clone)]
13273pub struct AmdExtension231Fn {}
13274unsafe impl Send for AmdExtension231Fn {}
13275unsafe impl Sync for AmdExtension231Fn {}
13276impl AmdExtension231Fn {
13277 pub fn load<F>(mut _f: F) -> Self
13278 where
13279 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13280 {
13281 Self {}
13282 }
13283}
13284impl AmdExtension232Fn {
13285 pub const fn name() -> &'static ::std::ffi::CStr {
13286 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_232\0") }
13287 }
13288 pub const SPEC_VERSION: u32 = 0u32;
13289}
13290#[derive(Clone)]
13291pub struct AmdExtension232Fn {}
13292unsafe impl Send for AmdExtension232Fn {}
13293unsafe impl Sync for AmdExtension232Fn {}
13294impl AmdExtension232Fn {
13295 pub fn load<F>(mut _f: F) -> Self
13296 where
13297 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13298 {
13299 Self {}
13300 }
13301}
13302impl AmdExtension233Fn {
13303 pub const fn name() -> &'static ::std::ffi::CStr {
13304 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_233\0") }
13305 }
13306 pub const SPEC_VERSION: u32 = 0u32;
13307}
13308#[derive(Clone)]
13309pub struct AmdExtension233Fn {}
13310unsafe impl Send for AmdExtension233Fn {}
13311unsafe impl Sync for AmdExtension233Fn {}
13312impl AmdExtension233Fn {
13313 pub fn load<F>(mut _f: F) -> Self
13314 where
13315 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13316 {
13317 Self {}
13318 }
13319}
13320impl AmdExtension234Fn {
13321 pub const fn name() -> &'static ::std::ffi::CStr {
13322 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_234\0") }
13323 }
13324 pub const SPEC_VERSION: u32 = 0u32;
13325}
13326#[derive(Clone)]
13327pub struct AmdExtension234Fn {}
13328unsafe impl Send for AmdExtension234Fn {}
13329unsafe impl Sync for AmdExtension234Fn {}
13330impl AmdExtension234Fn {
13331 pub fn load<F>(mut _f: F) -> Self
13332 where
13333 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13334 {
13335 Self {}
13336 }
13337}
13338impl ExtShaderImageAtomicInt64Fn {
13339 pub const fn name() -> &'static ::std::ffi::CStr {
13340 unsafe {
13341 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_image_atomic_int64\0")
13342 }
13343 }
13344 pub const SPEC_VERSION: u32 = 1u32;
13345}
13346#[derive(Clone)]
13347pub struct ExtShaderImageAtomicInt64Fn {}
13348unsafe impl Send for ExtShaderImageAtomicInt64Fn {}
13349unsafe impl Sync for ExtShaderImageAtomicInt64Fn {}
13350impl ExtShaderImageAtomicInt64Fn {
13351 pub fn load<F>(mut _f: F) -> Self
13352 where
13353 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13354 {
13355 Self {}
13356 }
13357}
13358#[doc = "Generated from 'VK_EXT_shader_image_atomic_int64'"]
13359impl StructureType {
13360 pub const PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: Self = Self(1_000_234_000);
13361}
13362impl AmdExtension236Fn {
13363 pub const fn name() -> &'static ::std::ffi::CStr {
13364 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_236\0") }
13365 }
13366 pub const SPEC_VERSION: u32 = 0u32;
13367}
13368#[derive(Clone)]
13369pub struct AmdExtension236Fn {}
13370unsafe impl Send for AmdExtension236Fn {}
13371unsafe impl Sync for AmdExtension236Fn {}
13372impl AmdExtension236Fn {
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}
13380impl KhrSpirv14Fn {
13381 pub const fn name() -> &'static ::std::ffi::CStr {
13382 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_spirv_1_4\0") }
13383 }
13384 pub const SPEC_VERSION: u32 = 1u32;
13385}
13386#[derive(Clone)]
13387pub struct KhrSpirv14Fn {}
13388unsafe impl Send for KhrSpirv14Fn {}
13389unsafe impl Sync for KhrSpirv14Fn {}
13390impl KhrSpirv14Fn {
13391 pub fn load<F>(mut _f: F) -> Self
13392 where
13393 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13394 {
13395 Self {}
13396 }
13397}
13398impl ExtMemoryBudgetFn {
13399 pub const fn name() -> &'static ::std::ffi::CStr {
13400 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_budget\0") }
13401 }
13402 pub const SPEC_VERSION: u32 = 1u32;
13403}
13404#[derive(Clone)]
13405pub struct ExtMemoryBudgetFn {}
13406unsafe impl Send for ExtMemoryBudgetFn {}
13407unsafe impl Sync for ExtMemoryBudgetFn {}
13408impl ExtMemoryBudgetFn {
13409 pub fn load<F>(mut _f: F) -> Self
13410 where
13411 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13412 {
13413 Self {}
13414 }
13415}
13416#[doc = "Generated from 'VK_EXT_memory_budget'"]
13417impl StructureType {
13418 pub const PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: Self = Self(1_000_237_000);
13419}
13420impl ExtMemoryPriorityFn {
13421 pub const fn name() -> &'static ::std::ffi::CStr {
13422 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_memory_priority\0") }
13423 }
13424 pub const SPEC_VERSION: u32 = 1u32;
13425}
13426#[derive(Clone)]
13427pub struct ExtMemoryPriorityFn {}
13428unsafe impl Send for ExtMemoryPriorityFn {}
13429unsafe impl Sync for ExtMemoryPriorityFn {}
13430impl ExtMemoryPriorityFn {
13431 pub fn load<F>(mut _f: F) -> Self
13432 where
13433 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13434 {
13435 Self {}
13436 }
13437}
13438#[doc = "Generated from 'VK_EXT_memory_priority'"]
13439impl StructureType {
13440 pub const PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: Self = Self(1_000_238_000);
13441 pub const MEMORY_PRIORITY_ALLOCATE_INFO_EXT: Self = Self(1_000_238_001);
13442}
13443impl KhrSurfaceProtectedCapabilitiesFn {
13444 pub const fn name() -> &'static ::std::ffi::CStr {
13445 unsafe {
13446 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13447 b"VK_KHR_surface_protected_capabilities\0",
13448 )
13449 }
13450 }
13451 pub const SPEC_VERSION: u32 = 1u32;
13452}
13453#[derive(Clone)]
13454pub struct KhrSurfaceProtectedCapabilitiesFn {}
13455unsafe impl Send for KhrSurfaceProtectedCapabilitiesFn {}
13456unsafe impl Sync for KhrSurfaceProtectedCapabilitiesFn {}
13457impl KhrSurfaceProtectedCapabilitiesFn {
13458 pub fn load<F>(mut _f: F) -> Self
13459 where
13460 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13461 {
13462 Self {}
13463 }
13464}
13465#[doc = "Generated from 'VK_KHR_surface_protected_capabilities'"]
13466impl StructureType {
13467 pub const SURFACE_PROTECTED_CAPABILITIES_KHR: Self = Self(1_000_239_000);
13468}
13469impl NvDedicatedAllocationImageAliasingFn {
13470 pub const fn name() -> &'static ::std::ffi::CStr {
13471 unsafe {
13472 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13473 b"VK_NV_dedicated_allocation_image_aliasing\0",
13474 )
13475 }
13476 }
13477 pub const SPEC_VERSION: u32 = 1u32;
13478}
13479#[derive(Clone)]
13480pub struct NvDedicatedAllocationImageAliasingFn {}
13481unsafe impl Send for NvDedicatedAllocationImageAliasingFn {}
13482unsafe impl Sync for NvDedicatedAllocationImageAliasingFn {}
13483impl NvDedicatedAllocationImageAliasingFn {
13484 pub fn load<F>(mut _f: F) -> Self
13485 where
13486 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13487 {
13488 Self {}
13489 }
13490}
13491#[doc = "Generated from 'VK_NV_dedicated_allocation_image_aliasing'"]
13492impl StructureType {
13493 pub const PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: Self =
13494 Self(1_000_240_000);
13495}
13496impl KhrSeparateDepthStencilLayoutsFn {
13497 pub const fn name() -> &'static ::std::ffi::CStr {
13498 unsafe {
13499 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13500 b"VK_KHR_separate_depth_stencil_layouts\0",
13501 )
13502 }
13503 }
13504 pub const SPEC_VERSION: u32 = 1u32;
13505}
13506#[derive(Clone)]
13507pub struct KhrSeparateDepthStencilLayoutsFn {}
13508unsafe impl Send for KhrSeparateDepthStencilLayoutsFn {}
13509unsafe impl Sync for KhrSeparateDepthStencilLayoutsFn {}
13510impl KhrSeparateDepthStencilLayoutsFn {
13511 pub fn load<F>(mut _f: F) -> Self
13512 where
13513 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13514 {
13515 Self {}
13516 }
13517}
13518#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
13519impl ImageLayout {
13520 pub const DEPTH_ATTACHMENT_OPTIMAL_KHR: Self = Self::DEPTH_ATTACHMENT_OPTIMAL;
13521 pub const DEPTH_READ_ONLY_OPTIMAL_KHR: Self = Self::DEPTH_READ_ONLY_OPTIMAL;
13522 pub const STENCIL_ATTACHMENT_OPTIMAL_KHR: Self = Self::STENCIL_ATTACHMENT_OPTIMAL;
13523 pub const STENCIL_READ_ONLY_OPTIMAL_KHR: Self = Self::STENCIL_READ_ONLY_OPTIMAL;
13524}
13525#[doc = "Generated from 'VK_KHR_separate_depth_stencil_layouts'"]
13526impl StructureType {
13527 pub const PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: Self =
13528 Self::PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
13529 pub const ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: Self =
13530 Self::ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
13531 pub const ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: Self =
13532 Self::ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
13533}
13534impl IntelExtension243Fn {
13535 pub const fn name() -> &'static ::std::ffi::CStr {
13536 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_243\0") }
13537 }
13538 pub const SPEC_VERSION: u32 = 0u32;
13539}
13540#[derive(Clone)]
13541pub struct IntelExtension243Fn {}
13542unsafe impl Send for IntelExtension243Fn {}
13543unsafe impl Sync for IntelExtension243Fn {}
13544impl IntelExtension243Fn {
13545 pub fn load<F>(mut _f: F) -> Self
13546 where
13547 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13548 {
13549 Self {}
13550 }
13551}
13552impl MesaExtension244Fn {
13553 pub const fn name() -> &'static ::std::ffi::CStr {
13554 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_244\0") }
13555 }
13556 pub const SPEC_VERSION: u32 = 0u32;
13557}
13558#[derive(Clone)]
13559pub struct MesaExtension244Fn {}
13560unsafe impl Send for MesaExtension244Fn {}
13561unsafe impl Sync for MesaExtension244Fn {}
13562impl MesaExtension244Fn {
13563 pub fn load<F>(mut _f: F) -> Self
13564 where
13565 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13566 {
13567 Self {}
13568 }
13569}
13570impl ExtBufferDeviceAddressFn {
13571 pub const fn name() -> &'static ::std::ffi::CStr {
13572 unsafe {
13573 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_buffer_device_address\0")
13574 }
13575 }
13576 pub const SPEC_VERSION: u32 = 2u32;
13577}
13578#[allow(non_camel_case_types)]
13579pub type PFN_vkGetBufferDeviceAddress = unsafe extern "system" fn(
13580 device: Device,
13581 p_info: *const BufferDeviceAddressInfo,
13582) -> DeviceAddress;
13583#[derive(Clone)]
13584pub struct ExtBufferDeviceAddressFn {
13585 pub get_buffer_device_address_ext: PFN_vkGetBufferDeviceAddress,
13586}
13587unsafe impl Send for ExtBufferDeviceAddressFn {}
13588unsafe impl Sync for ExtBufferDeviceAddressFn {}
13589impl ExtBufferDeviceAddressFn {
13590 pub fn load<F>(mut _f: F) -> Self
13591 where
13592 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13593 {
13594 Self {
13595 get_buffer_device_address_ext: unsafe {
13596 unsafe extern "system" fn get_buffer_device_address_ext(
13597 _device: Device,
13598 _p_info: *const BufferDeviceAddressInfo,
13599 ) -> DeviceAddress {
13600 panic!(concat!(
13601 "Unable to load ",
13602 stringify!(get_buffer_device_address_ext)
13603 ))
13604 }
13605 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13606 b"vkGetBufferDeviceAddressEXT\0",
13607 );
13608 let val = _f(cname);
13609 if val.is_null() {
13610 get_buffer_device_address_ext
13611 } else {
13612 ::std::mem::transmute(val)
13613 }
13614 },
13615 }
13616 }
13617}
13618#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13619impl BufferCreateFlags {
13620 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_EXT: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
13621}
13622#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13623impl BufferUsageFlags {
13624 pub const SHADER_DEVICE_ADDRESS_EXT: Self = Self::SHADER_DEVICE_ADDRESS;
13625}
13626#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13627impl Result {
13628 pub const ERROR_INVALID_DEVICE_ADDRESS_EXT: Self = Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
13629}
13630#[doc = "Generated from 'VK_EXT_buffer_device_address'"]
13631impl StructureType {
13632 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: Self = Self(1_000_244_000);
13633 pub const PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: Self =
13634 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
13635 pub const BUFFER_DEVICE_ADDRESS_INFO_EXT: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
13636 pub const BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: Self = Self(1_000_244_002);
13637}
13638impl ExtToolingInfoFn {
13639 pub const fn name() -> &'static ::std::ffi::CStr {
13640 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_tooling_info\0") }
13641 }
13642 pub const SPEC_VERSION: u32 = 1u32;
13643}
13644#[allow(non_camel_case_types)]
13645pub type PFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn(
13646 physical_device: PhysicalDevice,
13647 p_tool_count: *mut u32,
13648 p_tool_properties: *mut PhysicalDeviceToolProperties,
13649) -> Result;
13650#[derive(Clone)]
13651pub struct ExtToolingInfoFn {
13652 pub get_physical_device_tool_properties_ext: PFN_vkGetPhysicalDeviceToolProperties,
13653}
13654unsafe impl Send for ExtToolingInfoFn {}
13655unsafe impl Sync for ExtToolingInfoFn {}
13656impl ExtToolingInfoFn {
13657 pub fn load<F>(mut _f: F) -> Self
13658 where
13659 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13660 {
13661 Self {
13662 get_physical_device_tool_properties_ext: unsafe {
13663 unsafe extern "system" fn get_physical_device_tool_properties_ext(
13664 _physical_device: PhysicalDevice,
13665 _p_tool_count: *mut u32,
13666 _p_tool_properties: *mut PhysicalDeviceToolProperties,
13667 ) -> Result {
13668 panic!(concat!(
13669 "Unable to load ",
13670 stringify!(get_physical_device_tool_properties_ext)
13671 ))
13672 }
13673 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13674 b"vkGetPhysicalDeviceToolPropertiesEXT\0",
13675 );
13676 let val = _f(cname);
13677 if val.is_null() {
13678 get_physical_device_tool_properties_ext
13679 } else {
13680 ::std::mem::transmute(val)
13681 }
13682 },
13683 }
13684 }
13685}
13686#[doc = "Generated from 'VK_EXT_tooling_info'"]
13687impl StructureType {
13688 pub const PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: Self = Self::PHYSICAL_DEVICE_TOOL_PROPERTIES;
13689}
13690#[doc = "Generated from 'VK_EXT_tooling_info'"]
13691impl ToolPurposeFlags {
13692 pub const DEBUG_REPORTING_EXT: Self = Self(0b10_0000);
13693 pub const DEBUG_MARKERS_EXT: Self = Self(0b100_0000);
13694}
13695impl ExtSeparateStencilUsageFn {
13696 pub const fn name() -> &'static ::std::ffi::CStr {
13697 unsafe {
13698 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_separate_stencil_usage\0")
13699 }
13700 }
13701 pub const SPEC_VERSION: u32 = 1u32;
13702}
13703#[derive(Clone)]
13704pub struct ExtSeparateStencilUsageFn {}
13705unsafe impl Send for ExtSeparateStencilUsageFn {}
13706unsafe impl Sync for ExtSeparateStencilUsageFn {}
13707impl ExtSeparateStencilUsageFn {
13708 pub fn load<F>(mut _f: F) -> Self
13709 where
13710 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13711 {
13712 Self {}
13713 }
13714}
13715#[doc = "Generated from 'VK_EXT_separate_stencil_usage'"]
13716impl StructureType {
13717 pub const IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: Self = Self::IMAGE_STENCIL_USAGE_CREATE_INFO;
13718}
13719impl ExtValidationFeaturesFn {
13720 pub const fn name() -> &'static ::std::ffi::CStr {
13721 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_validation_features\0") }
13722 }
13723 pub const SPEC_VERSION: u32 = 5u32;
13724}
13725#[derive(Clone)]
13726pub struct ExtValidationFeaturesFn {}
13727unsafe impl Send for ExtValidationFeaturesFn {}
13728unsafe impl Sync for ExtValidationFeaturesFn {}
13729impl ExtValidationFeaturesFn {
13730 pub fn load<F>(mut _f: F) -> Self
13731 where
13732 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13733 {
13734 Self {}
13735 }
13736}
13737#[doc = "Generated from 'VK_EXT_validation_features'"]
13738impl StructureType {
13739 pub const VALIDATION_FEATURES_EXT: Self = Self(1_000_247_000);
13740}
13741impl KhrPresentWaitFn {
13742 pub const fn name() -> &'static ::std::ffi::CStr {
13743 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_wait\0") }
13744 }
13745 pub const SPEC_VERSION: u32 = 1u32;
13746}
13747#[allow(non_camel_case_types)]
13748pub type PFN_vkWaitForPresentKHR = unsafe extern "system" fn(
13749 device: Device,
13750 swapchain: SwapchainKHR,
13751 present_id: u64,
13752 timeout: u64,
13753) -> Result;
13754#[derive(Clone)]
13755pub struct KhrPresentWaitFn {
13756 pub wait_for_present_khr: PFN_vkWaitForPresentKHR,
13757}
13758unsafe impl Send for KhrPresentWaitFn {}
13759unsafe impl Sync for KhrPresentWaitFn {}
13760impl KhrPresentWaitFn {
13761 pub fn load<F>(mut _f: F) -> Self
13762 where
13763 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13764 {
13765 Self {
13766 wait_for_present_khr: unsafe {
13767 unsafe extern "system" fn wait_for_present_khr(
13768 _device: Device,
13769 _swapchain: SwapchainKHR,
13770 _present_id: u64,
13771 _timeout: u64,
13772 ) -> Result {
13773 panic!(concat!("Unable to load ", stringify!(wait_for_present_khr)))
13774 }
13775 let cname =
13776 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkWaitForPresentKHR\0");
13777 let val = _f(cname);
13778 if val.is_null() {
13779 wait_for_present_khr
13780 } else {
13781 ::std::mem::transmute(val)
13782 }
13783 },
13784 }
13785 }
13786}
13787#[doc = "Generated from 'VK_KHR_present_wait'"]
13788impl StructureType {
13789 pub const PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: Self = Self(1_000_248_000);
13790}
13791impl NvCooperativeMatrixFn {
13792 pub const fn name() -> &'static ::std::ffi::CStr {
13793 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_cooperative_matrix\0") }
13794 }
13795 pub const SPEC_VERSION: u32 = 1u32;
13796}
13797#[allow(non_camel_case_types)]
13798pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn(
13799 physical_device: PhysicalDevice,
13800 p_property_count: *mut u32,
13801 p_properties: *mut CooperativeMatrixPropertiesNV,
13802)
13803 -> Result;
13804#[derive(Clone)]
13805pub struct NvCooperativeMatrixFn {
13806 pub get_physical_device_cooperative_matrix_properties_nv:
13807 PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV,
13808}
13809unsafe impl Send for NvCooperativeMatrixFn {}
13810unsafe impl Sync for NvCooperativeMatrixFn {}
13811impl NvCooperativeMatrixFn {
13812 pub fn load<F>(mut _f: F) -> Self
13813 where
13814 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13815 {
13816 Self {
13817 get_physical_device_cooperative_matrix_properties_nv: unsafe {
13818 unsafe extern "system" fn get_physical_device_cooperative_matrix_properties_nv(
13819 _physical_device: PhysicalDevice,
13820 _p_property_count: *mut u32,
13821 _p_properties: *mut CooperativeMatrixPropertiesNV,
13822 ) -> Result {
13823 panic!(concat!(
13824 "Unable to load ",
13825 stringify!(get_physical_device_cooperative_matrix_properties_nv)
13826 ))
13827 }
13828 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13829 b"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV\0",
13830 );
13831 let val = _f(cname);
13832 if val.is_null() {
13833 get_physical_device_cooperative_matrix_properties_nv
13834 } else {
13835 ::std::mem::transmute(val)
13836 }
13837 },
13838 }
13839 }
13840}
13841#[doc = "Generated from 'VK_NV_cooperative_matrix'"]
13842impl StructureType {
13843 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: Self = Self(1_000_249_000);
13844 pub const COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_001);
13845 pub const PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: Self = Self(1_000_249_002);
13846}
13847impl NvCoverageReductionModeFn {
13848 pub const fn name() -> &'static ::std::ffi::CStr {
13849 unsafe {
13850 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_coverage_reduction_mode\0")
13851 }
13852 }
13853 pub const SPEC_VERSION: u32 = 1u32;
13854}
13855#[allow(non_camel_case_types)]
13856pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV =
13857 unsafe extern "system" fn(
13858 physical_device: PhysicalDevice,
13859 p_combination_count: *mut u32,
13860 p_combinations: *mut FramebufferMixedSamplesCombinationNV,
13861 ) -> Result;
13862#[derive(Clone)]
13863pub struct NvCoverageReductionModeFn {
13864 pub get_physical_device_supported_framebuffer_mixed_samples_combinations_nv:
13865 PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV,
13866}
13867unsafe impl Send for NvCoverageReductionModeFn {}
13868unsafe impl Sync for NvCoverageReductionModeFn {}
13869impl NvCoverageReductionModeFn {
13870 pub fn load<F>(mut _f: F) -> Self
13871 where
13872 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13873 {
13874 Self {
13875 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv: unsafe {
13876 unsafe extern "system" fn get_physical_device_supported_framebuffer_mixed_samples_combinations_nv(
13877 _physical_device: PhysicalDevice,
13878 _p_combination_count: *mut u32,
13879 _p_combinations: *mut FramebufferMixedSamplesCombinationNV,
13880 ) -> Result {
13881 panic!(concat!(
13882 "Unable to load ",
13883 stringify!(
13884 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv
13885 )
13886 ))
13887 }
13888 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13889 b"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV\0",
13890 );
13891 let val = _f(cname);
13892 if val.is_null() {
13893 get_physical_device_supported_framebuffer_mixed_samples_combinations_nv
13894 } else {
13895 ::std::mem::transmute(val)
13896 }
13897 },
13898 }
13899 }
13900}
13901#[doc = "Generated from 'VK_NV_coverage_reduction_mode'"]
13902impl StructureType {
13903 pub const PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: Self = Self(1_000_250_000);
13904 pub const PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: Self = Self(1_000_250_001);
13905 pub const FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: Self = Self(1_000_250_002);
13906}
13907impl ExtFragmentShaderInterlockFn {
13908 pub const fn name() -> &'static ::std::ffi::CStr {
13909 unsafe {
13910 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_shader_interlock\0")
13911 }
13912 }
13913 pub const SPEC_VERSION: u32 = 1u32;
13914}
13915#[derive(Clone)]
13916pub struct ExtFragmentShaderInterlockFn {}
13917unsafe impl Send for ExtFragmentShaderInterlockFn {}
13918unsafe impl Sync for ExtFragmentShaderInterlockFn {}
13919impl ExtFragmentShaderInterlockFn {
13920 pub fn load<F>(mut _f: F) -> Self
13921 where
13922 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13923 {
13924 Self {}
13925 }
13926}
13927#[doc = "Generated from 'VK_EXT_fragment_shader_interlock'"]
13928impl StructureType {
13929 pub const PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: Self = Self(1_000_251_000);
13930}
13931impl ExtYcbcrImageArraysFn {
13932 pub const fn name() -> &'static ::std::ffi::CStr {
13933 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_image_arrays\0") }
13934 }
13935 pub const SPEC_VERSION: u32 = 1u32;
13936}
13937#[derive(Clone)]
13938pub struct ExtYcbcrImageArraysFn {}
13939unsafe impl Send for ExtYcbcrImageArraysFn {}
13940unsafe impl Sync for ExtYcbcrImageArraysFn {}
13941impl ExtYcbcrImageArraysFn {
13942 pub fn load<F>(mut _f: F) -> Self
13943 where
13944 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13945 {
13946 Self {}
13947 }
13948}
13949#[doc = "Generated from 'VK_EXT_ycbcr_image_arrays'"]
13950impl StructureType {
13951 pub const PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: Self = Self(1_000_252_000);
13952}
13953impl KhrUniformBufferStandardLayoutFn {
13954 pub const fn name() -> &'static ::std::ffi::CStr {
13955 unsafe {
13956 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
13957 b"VK_KHR_uniform_buffer_standard_layout\0",
13958 )
13959 }
13960 }
13961 pub const SPEC_VERSION: u32 = 1u32;
13962}
13963#[derive(Clone)]
13964pub struct KhrUniformBufferStandardLayoutFn {}
13965unsafe impl Send for KhrUniformBufferStandardLayoutFn {}
13966unsafe impl Sync for KhrUniformBufferStandardLayoutFn {}
13967impl KhrUniformBufferStandardLayoutFn {
13968 pub fn load<F>(mut _f: F) -> Self
13969 where
13970 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13971 {
13972 Self {}
13973 }
13974}
13975#[doc = "Generated from 'VK_KHR_uniform_buffer_standard_layout'"]
13976impl StructureType {
13977 pub const PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: Self =
13978 Self::PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
13979}
13980impl ExtProvokingVertexFn {
13981 pub const fn name() -> &'static ::std::ffi::CStr {
13982 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_provoking_vertex\0") }
13983 }
13984 pub const SPEC_VERSION: u32 = 1u32;
13985}
13986#[derive(Clone)]
13987pub struct ExtProvokingVertexFn {}
13988unsafe impl Send for ExtProvokingVertexFn {}
13989unsafe impl Sync for ExtProvokingVertexFn {}
13990impl ExtProvokingVertexFn {
13991 pub fn load<F>(mut _f: F) -> Self
13992 where
13993 F: FnMut(&::std::ffi::CStr) -> *const c_void,
13994 {
13995 Self {}
13996 }
13997}
13998#[doc = "Generated from 'VK_EXT_provoking_vertex'"]
13999impl StructureType {
14000 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: Self = Self(1_000_254_000);
14001 pub const PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: Self =
14002 Self(1_000_254_001);
14003 pub const PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: Self = Self(1_000_254_002);
14004}
14005impl ExtFullScreenExclusiveFn {
14006 pub const fn name() -> &'static ::std::ffi::CStr {
14007 unsafe {
14008 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_full_screen_exclusive\0")
14009 }
14010 }
14011 pub const SPEC_VERSION: u32 = 4u32;
14012}
14013#[allow(non_camel_case_types)]
14014pub type PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT = unsafe extern "system" fn(
14015 physical_device: PhysicalDevice,
14016 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14017 p_present_mode_count: *mut u32,
14018 p_present_modes: *mut PresentModeKHR,
14019) -> Result;
14020#[allow(non_camel_case_types)]
14021pub type PFN_vkAcquireFullScreenExclusiveModeEXT =
14022 unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result;
14023#[allow(non_camel_case_types)]
14024pub type PFN_vkReleaseFullScreenExclusiveModeEXT =
14025 unsafe extern "system" fn(device: Device, swapchain: SwapchainKHR) -> Result;
14026#[allow(non_camel_case_types)]
14027pub type PFN_vkGetDeviceGroupSurfacePresentModes2EXT = unsafe extern "system" fn(
14028 device: Device,
14029 p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14030 p_modes: *mut DeviceGroupPresentModeFlagsKHR,
14031) -> Result;
14032#[derive(Clone)]
14033pub struct ExtFullScreenExclusiveFn {
14034 pub get_physical_device_surface_present_modes2_ext:
14035 PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT,
14036 pub acquire_full_screen_exclusive_mode_ext: PFN_vkAcquireFullScreenExclusiveModeEXT,
14037 pub release_full_screen_exclusive_mode_ext: PFN_vkReleaseFullScreenExclusiveModeEXT,
14038 pub get_device_group_surface_present_modes2_ext: PFN_vkGetDeviceGroupSurfacePresentModes2EXT,
14039}
14040unsafe impl Send for ExtFullScreenExclusiveFn {}
14041unsafe impl Sync for ExtFullScreenExclusiveFn {}
14042impl ExtFullScreenExclusiveFn {
14043 pub fn load<F>(mut _f: F) -> Self
14044 where
14045 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14046 {
14047 Self {
14048 get_physical_device_surface_present_modes2_ext: unsafe {
14049 unsafe extern "system" fn get_physical_device_surface_present_modes2_ext(
14050 _physical_device: PhysicalDevice,
14051 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14052 _p_present_mode_count: *mut u32,
14053 _p_present_modes: *mut PresentModeKHR,
14054 ) -> Result {
14055 panic!(concat!(
14056 "Unable to load ",
14057 stringify!(get_physical_device_surface_present_modes2_ext)
14058 ))
14059 }
14060 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14061 b"vkGetPhysicalDeviceSurfacePresentModes2EXT\0",
14062 );
14063 let val = _f(cname);
14064 if val.is_null() {
14065 get_physical_device_surface_present_modes2_ext
14066 } else {
14067 ::std::mem::transmute(val)
14068 }
14069 },
14070 acquire_full_screen_exclusive_mode_ext: unsafe {
14071 unsafe extern "system" fn acquire_full_screen_exclusive_mode_ext(
14072 _device: Device,
14073 _swapchain: SwapchainKHR,
14074 ) -> Result {
14075 panic!(concat!(
14076 "Unable to load ",
14077 stringify!(acquire_full_screen_exclusive_mode_ext)
14078 ))
14079 }
14080 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14081 b"vkAcquireFullScreenExclusiveModeEXT\0",
14082 );
14083 let val = _f(cname);
14084 if val.is_null() {
14085 acquire_full_screen_exclusive_mode_ext
14086 } else {
14087 ::std::mem::transmute(val)
14088 }
14089 },
14090 release_full_screen_exclusive_mode_ext: unsafe {
14091 unsafe extern "system" fn release_full_screen_exclusive_mode_ext(
14092 _device: Device,
14093 _swapchain: SwapchainKHR,
14094 ) -> Result {
14095 panic!(concat!(
14096 "Unable to load ",
14097 stringify!(release_full_screen_exclusive_mode_ext)
14098 ))
14099 }
14100 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14101 b"vkReleaseFullScreenExclusiveModeEXT\0",
14102 );
14103 let val = _f(cname);
14104 if val.is_null() {
14105 release_full_screen_exclusive_mode_ext
14106 } else {
14107 ::std::mem::transmute(val)
14108 }
14109 },
14110 get_device_group_surface_present_modes2_ext: unsafe {
14111 unsafe extern "system" fn get_device_group_surface_present_modes2_ext(
14112 _device: Device,
14113 _p_surface_info: *const PhysicalDeviceSurfaceInfo2KHR,
14114 _p_modes: *mut DeviceGroupPresentModeFlagsKHR,
14115 ) -> Result {
14116 panic!(concat!(
14117 "Unable to load ",
14118 stringify!(get_device_group_surface_present_modes2_ext)
14119 ))
14120 }
14121 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14122 b"vkGetDeviceGroupSurfacePresentModes2EXT\0",
14123 );
14124 let val = _f(cname);
14125 if val.is_null() {
14126 get_device_group_surface_present_modes2_ext
14127 } else {
14128 ::std::mem::transmute(val)
14129 }
14130 },
14131 }
14132 }
14133}
14134#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
14135impl Result {
14136 pub const ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: Self = Self(-1_000_255_000);
14137}
14138#[doc = "Generated from 'VK_EXT_full_screen_exclusive'"]
14139impl StructureType {
14140 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: Self = Self(1_000_255_000);
14141 pub const SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: Self = Self(1_000_255_002);
14142 pub const SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT: Self = Self(1_000_255_001);
14143}
14144impl ExtHeadlessSurfaceFn {
14145 pub const fn name() -> &'static ::std::ffi::CStr {
14146 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_headless_surface\0") }
14147 }
14148 pub const SPEC_VERSION: u32 = 1u32;
14149}
14150#[allow(non_camel_case_types)]
14151pub type PFN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn(
14152 instance: Instance,
14153 p_create_info: *const HeadlessSurfaceCreateInfoEXT,
14154 p_allocator: *const AllocationCallbacks,
14155 p_surface: *mut SurfaceKHR,
14156) -> Result;
14157#[derive(Clone)]
14158pub struct ExtHeadlessSurfaceFn {
14159 pub create_headless_surface_ext: PFN_vkCreateHeadlessSurfaceEXT,
14160}
14161unsafe impl Send for ExtHeadlessSurfaceFn {}
14162unsafe impl Sync for ExtHeadlessSurfaceFn {}
14163impl ExtHeadlessSurfaceFn {
14164 pub fn load<F>(mut _f: F) -> Self
14165 where
14166 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14167 {
14168 Self {
14169 create_headless_surface_ext: unsafe {
14170 unsafe extern "system" fn create_headless_surface_ext(
14171 _instance: Instance,
14172 _p_create_info: *const HeadlessSurfaceCreateInfoEXT,
14173 _p_allocator: *const AllocationCallbacks,
14174 _p_surface: *mut SurfaceKHR,
14175 ) -> Result {
14176 panic!(concat!(
14177 "Unable to load ",
14178 stringify!(create_headless_surface_ext)
14179 ))
14180 }
14181 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14182 b"vkCreateHeadlessSurfaceEXT\0",
14183 );
14184 let val = _f(cname);
14185 if val.is_null() {
14186 create_headless_surface_ext
14187 } else {
14188 ::std::mem::transmute(val)
14189 }
14190 },
14191 }
14192 }
14193}
14194#[doc = "Generated from 'VK_EXT_headless_surface'"]
14195impl StructureType {
14196 pub const HEADLESS_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_256_000);
14197}
14198impl KhrBufferDeviceAddressFn {
14199 pub const fn name() -> &'static ::std::ffi::CStr {
14200 unsafe {
14201 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_buffer_device_address\0")
14202 }
14203 }
14204 pub const SPEC_VERSION: u32 = 1u32;
14205}
14206#[allow(non_camel_case_types)]
14207pub type PFN_vkGetBufferOpaqueCaptureAddress =
14208 unsafe extern "system" fn(device: Device, p_info: *const BufferDeviceAddressInfo) -> u64;
14209#[allow(non_camel_case_types)]
14210pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn(
14211 device: Device,
14212 p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
14213) -> u64;
14214#[derive(Clone)]
14215pub struct KhrBufferDeviceAddressFn {
14216 pub get_buffer_device_address_khr: crate::vk::PFN_vkGetBufferDeviceAddress,
14217 pub get_buffer_opaque_capture_address_khr: PFN_vkGetBufferOpaqueCaptureAddress,
14218 pub get_device_memory_opaque_capture_address_khr: PFN_vkGetDeviceMemoryOpaqueCaptureAddress,
14219}
14220unsafe impl Send for KhrBufferDeviceAddressFn {}
14221unsafe impl Sync for KhrBufferDeviceAddressFn {}
14222impl KhrBufferDeviceAddressFn {
14223 pub fn load<F>(mut _f: F) -> Self
14224 where
14225 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14226 {
14227 Self {
14228 get_buffer_device_address_khr: unsafe {
14229 unsafe extern "system" fn get_buffer_device_address_khr(
14230 _device: Device,
14231 _p_info: *const BufferDeviceAddressInfo,
14232 ) -> DeviceAddress {
14233 panic!(concat!(
14234 "Unable to load ",
14235 stringify!(get_buffer_device_address_khr)
14236 ))
14237 }
14238 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14239 b"vkGetBufferDeviceAddressKHR\0",
14240 );
14241 let val = _f(cname);
14242 if val.is_null() {
14243 get_buffer_device_address_khr
14244 } else {
14245 ::std::mem::transmute(val)
14246 }
14247 },
14248 get_buffer_opaque_capture_address_khr: unsafe {
14249 unsafe extern "system" fn get_buffer_opaque_capture_address_khr(
14250 _device: Device,
14251 _p_info: *const BufferDeviceAddressInfo,
14252 ) -> u64 {
14253 panic!(concat!(
14254 "Unable to load ",
14255 stringify!(get_buffer_opaque_capture_address_khr)
14256 ))
14257 }
14258 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14259 b"vkGetBufferOpaqueCaptureAddressKHR\0",
14260 );
14261 let val = _f(cname);
14262 if val.is_null() {
14263 get_buffer_opaque_capture_address_khr
14264 } else {
14265 ::std::mem::transmute(val)
14266 }
14267 },
14268 get_device_memory_opaque_capture_address_khr: unsafe {
14269 unsafe extern "system" fn get_device_memory_opaque_capture_address_khr(
14270 _device: Device,
14271 _p_info: *const DeviceMemoryOpaqueCaptureAddressInfo,
14272 ) -> u64 {
14273 panic!(concat!(
14274 "Unable to load ",
14275 stringify!(get_device_memory_opaque_capture_address_khr)
14276 ))
14277 }
14278 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14279 b"vkGetDeviceMemoryOpaqueCaptureAddressKHR\0",
14280 );
14281 let val = _f(cname);
14282 if val.is_null() {
14283 get_device_memory_opaque_capture_address_khr
14284 } else {
14285 ::std::mem::transmute(val)
14286 }
14287 },
14288 }
14289 }
14290}
14291#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14292impl BufferCreateFlags {
14293 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
14294}
14295#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14296impl BufferUsageFlags {
14297 pub const SHADER_DEVICE_ADDRESS_KHR: Self = Self::SHADER_DEVICE_ADDRESS;
14298}
14299#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14300impl MemoryAllocateFlags {
14301 pub const DEVICE_ADDRESS_KHR: Self = Self::DEVICE_ADDRESS;
14302 pub const DEVICE_ADDRESS_CAPTURE_REPLAY_KHR: Self = Self::DEVICE_ADDRESS_CAPTURE_REPLAY;
14303}
14304#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14305impl Result {
14306 pub const ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: Self =
14307 Self::ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
14308}
14309#[doc = "Generated from 'VK_KHR_buffer_device_address'"]
14310impl StructureType {
14311 pub const PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: Self =
14312 Self::PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
14313 pub const BUFFER_DEVICE_ADDRESS_INFO_KHR: Self = Self::BUFFER_DEVICE_ADDRESS_INFO;
14314 pub const BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: Self =
14315 Self::BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
14316 pub const MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: Self =
14317 Self::MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
14318 pub const DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: Self =
14319 Self::DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
14320}
14321impl ExtExtension259Fn {
14322 pub const fn name() -> &'static ::std::ffi::CStr {
14323 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_259\0") }
14324 }
14325 pub const SPEC_VERSION: u32 = 0u32;
14326}
14327#[derive(Clone)]
14328pub struct ExtExtension259Fn {}
14329unsafe impl Send for ExtExtension259Fn {}
14330unsafe impl Sync for ExtExtension259Fn {}
14331impl ExtExtension259Fn {
14332 pub fn load<F>(mut _f: F) -> Self
14333 where
14334 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14335 {
14336 Self {}
14337 }
14338}
14339impl ExtLineRasterizationFn {
14340 pub const fn name() -> &'static ::std::ffi::CStr {
14341 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_line_rasterization\0") }
14342 }
14343 pub const SPEC_VERSION: u32 = 1u32;
14344}
14345#[allow(non_camel_case_types)]
14346pub type PFN_vkCmdSetLineStippleEXT = unsafe extern "system" fn(
14347 command_buffer: CommandBuffer,
14348 line_stipple_factor: u32,
14349 line_stipple_pattern: u16,
14350);
14351#[derive(Clone)]
14352pub struct ExtLineRasterizationFn {
14353 pub cmd_set_line_stipple_ext: PFN_vkCmdSetLineStippleEXT,
14354}
14355unsafe impl Send for ExtLineRasterizationFn {}
14356unsafe impl Sync for ExtLineRasterizationFn {}
14357impl ExtLineRasterizationFn {
14358 pub fn load<F>(mut _f: F) -> Self
14359 where
14360 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14361 {
14362 Self {
14363 cmd_set_line_stipple_ext: unsafe {
14364 unsafe extern "system" fn cmd_set_line_stipple_ext(
14365 _command_buffer: CommandBuffer,
14366 _line_stipple_factor: u32,
14367 _line_stipple_pattern: u16,
14368 ) {
14369 panic!(concat!(
14370 "Unable to load ",
14371 stringify!(cmd_set_line_stipple_ext)
14372 ))
14373 }
14374 let cname =
14375 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLineStippleEXT\0");
14376 let val = _f(cname);
14377 if val.is_null() {
14378 cmd_set_line_stipple_ext
14379 } else {
14380 ::std::mem::transmute(val)
14381 }
14382 },
14383 }
14384 }
14385}
14386#[doc = "Generated from 'VK_EXT_line_rasterization'"]
14387impl DynamicState {
14388 pub const LINE_STIPPLE_EXT: Self = Self(1_000_259_000);
14389}
14390#[doc = "Generated from 'VK_EXT_line_rasterization'"]
14391impl StructureType {
14392 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: Self = Self(1_000_259_000);
14393 pub const PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: Self = Self(1_000_259_001);
14394 pub const PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: Self = Self(1_000_259_002);
14395}
14396impl ExtShaderAtomicFloatFn {
14397 pub const fn name() -> &'static ::std::ffi::CStr {
14398 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float\0") }
14399 }
14400 pub const SPEC_VERSION: u32 = 1u32;
14401}
14402#[derive(Clone)]
14403pub struct ExtShaderAtomicFloatFn {}
14404unsafe impl Send for ExtShaderAtomicFloatFn {}
14405unsafe impl Sync for ExtShaderAtomicFloatFn {}
14406impl ExtShaderAtomicFloatFn {
14407 pub fn load<F>(mut _f: F) -> Self
14408 where
14409 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14410 {
14411 Self {}
14412 }
14413}
14414#[doc = "Generated from 'VK_EXT_shader_atomic_float'"]
14415impl StructureType {
14416 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: Self = Self(1_000_260_000);
14417}
14418impl ExtHostQueryResetFn {
14419 pub const fn name() -> &'static ::std::ffi::CStr {
14420 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_host_query_reset\0") }
14421 }
14422 pub const SPEC_VERSION: u32 = 1u32;
14423}
14424#[allow(non_camel_case_types)]
14425pub type PFN_vkResetQueryPool = unsafe extern "system" fn(
14426 device: Device,
14427 query_pool: QueryPool,
14428 first_query: u32,
14429 query_count: u32,
14430);
14431#[derive(Clone)]
14432pub struct ExtHostQueryResetFn {
14433 pub reset_query_pool_ext: PFN_vkResetQueryPool,
14434}
14435unsafe impl Send for ExtHostQueryResetFn {}
14436unsafe impl Sync for ExtHostQueryResetFn {}
14437impl ExtHostQueryResetFn {
14438 pub fn load<F>(mut _f: F) -> Self
14439 where
14440 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14441 {
14442 Self {
14443 reset_query_pool_ext: unsafe {
14444 unsafe extern "system" fn reset_query_pool_ext(
14445 _device: Device,
14446 _query_pool: QueryPool,
14447 _first_query: u32,
14448 _query_count: u32,
14449 ) {
14450 panic!(concat!("Unable to load ", stringify!(reset_query_pool_ext)))
14451 }
14452 let cname =
14453 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkResetQueryPoolEXT\0");
14454 let val = _f(cname);
14455 if val.is_null() {
14456 reset_query_pool_ext
14457 } else {
14458 ::std::mem::transmute(val)
14459 }
14460 },
14461 }
14462 }
14463}
14464#[doc = "Generated from 'VK_EXT_host_query_reset'"]
14465impl StructureType {
14466 pub const PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: Self =
14467 Self::PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
14468}
14469impl GgpExtension263Fn {
14470 pub const fn name() -> &'static ::std::ffi::CStr {
14471 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_263\0") }
14472 }
14473 pub const SPEC_VERSION: u32 = 0u32;
14474}
14475#[derive(Clone)]
14476pub struct GgpExtension263Fn {}
14477unsafe impl Send for GgpExtension263Fn {}
14478unsafe impl Sync for GgpExtension263Fn {}
14479impl GgpExtension263Fn {
14480 pub fn load<F>(mut _f: F) -> Self
14481 where
14482 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14483 {
14484 Self {}
14485 }
14486}
14487impl BrcmExtension264Fn {
14488 pub const fn name() -> &'static ::std::ffi::CStr {
14489 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_264\0") }
14490 }
14491 pub const SPEC_VERSION: u32 = 0u32;
14492}
14493#[derive(Clone)]
14494pub struct BrcmExtension264Fn {}
14495unsafe impl Send for BrcmExtension264Fn {}
14496unsafe impl Sync for BrcmExtension264Fn {}
14497impl BrcmExtension264Fn {
14498 pub fn load<F>(mut _f: F) -> Self
14499 where
14500 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14501 {
14502 Self {}
14503 }
14504}
14505impl BrcmExtension265Fn {
14506 pub const fn name() -> &'static ::std::ffi::CStr {
14507 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_BRCM_extension_265\0") }
14508 }
14509 pub const SPEC_VERSION: u32 = 0u32;
14510}
14511#[derive(Clone)]
14512pub struct BrcmExtension265Fn {}
14513unsafe impl Send for BrcmExtension265Fn {}
14514unsafe impl Sync for BrcmExtension265Fn {}
14515impl BrcmExtension265Fn {
14516 pub fn load<F>(mut _f: F) -> Self
14517 where
14518 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14519 {
14520 Self {}
14521 }
14522}
14523impl ExtIndexTypeUint8Fn {
14524 pub const fn name() -> &'static ::std::ffi::CStr {
14525 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_index_type_uint8\0") }
14526 }
14527 pub const SPEC_VERSION: u32 = 1u32;
14528}
14529#[derive(Clone)]
14530pub struct ExtIndexTypeUint8Fn {}
14531unsafe impl Send for ExtIndexTypeUint8Fn {}
14532unsafe impl Sync for ExtIndexTypeUint8Fn {}
14533impl ExtIndexTypeUint8Fn {
14534 pub fn load<F>(mut _f: F) -> Self
14535 where
14536 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14537 {
14538 Self {}
14539 }
14540}
14541#[doc = "Generated from 'VK_EXT_index_type_uint8'"]
14542impl IndexType {
14543 pub const UINT8_EXT: Self = Self(1_000_265_000);
14544}
14545#[doc = "Generated from 'VK_EXT_index_type_uint8'"]
14546impl StructureType {
14547 pub const PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: Self = Self(1_000_265_000);
14548}
14549impl ExtExtension267Fn {
14550 pub const fn name() -> &'static ::std::ffi::CStr {
14551 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_267\0") }
14552 }
14553 pub const SPEC_VERSION: u32 = 0u32;
14554}
14555#[derive(Clone)]
14556pub struct ExtExtension267Fn {}
14557unsafe impl Send for ExtExtension267Fn {}
14558unsafe impl Sync for ExtExtension267Fn {}
14559impl ExtExtension267Fn {
14560 pub fn load<F>(mut _f: F) -> Self
14561 where
14562 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14563 {
14564 Self {}
14565 }
14566}
14567impl ExtExtendedDynamicStateFn {
14568 pub const fn name() -> &'static ::std::ffi::CStr {
14569 unsafe {
14570 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state\0")
14571 }
14572 }
14573 pub const SPEC_VERSION: u32 = 1u32;
14574}
14575#[allow(non_camel_case_types)]
14576pub type PFN_vkCmdSetCullMode =
14577 unsafe extern "system" fn(command_buffer: CommandBuffer, cull_mode: CullModeFlags);
14578#[allow(non_camel_case_types)]
14579pub type PFN_vkCmdSetFrontFace =
14580 unsafe extern "system" fn(command_buffer: CommandBuffer, front_face: FrontFace);
14581#[allow(non_camel_case_types)]
14582pub type PFN_vkCmdSetPrimitiveTopology =
14583 unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_topology: PrimitiveTopology);
14584#[allow(non_camel_case_types)]
14585pub type PFN_vkCmdSetViewportWithCount = unsafe extern "system" fn(
14586 command_buffer: CommandBuffer,
14587 viewport_count: u32,
14588 p_viewports: *const Viewport,
14589);
14590#[allow(non_camel_case_types)]
14591pub type PFN_vkCmdSetScissorWithCount = unsafe extern "system" fn(
14592 command_buffer: CommandBuffer,
14593 scissor_count: u32,
14594 p_scissors: *const Rect2D,
14595);
14596#[allow(non_camel_case_types)]
14597pub type PFN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn(
14598 command_buffer: CommandBuffer,
14599 first_binding: u32,
14600 binding_count: u32,
14601 p_buffers: *const Buffer,
14602 p_offsets: *const DeviceSize,
14603 p_sizes: *const DeviceSize,
14604 p_strides: *const DeviceSize,
14605);
14606#[allow(non_camel_case_types)]
14607pub type PFN_vkCmdSetDepthTestEnable =
14608 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_test_enable: Bool32);
14609#[allow(non_camel_case_types)]
14610pub type PFN_vkCmdSetDepthWriteEnable =
14611 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_write_enable: Bool32);
14612#[allow(non_camel_case_types)]
14613pub type PFN_vkCmdSetDepthCompareOp =
14614 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_compare_op: CompareOp);
14615#[allow(non_camel_case_types)]
14616pub type PFN_vkCmdSetDepthBoundsTestEnable =
14617 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bounds_test_enable: Bool32);
14618#[allow(non_camel_case_types)]
14619pub type PFN_vkCmdSetStencilTestEnable =
14620 unsafe extern "system" fn(command_buffer: CommandBuffer, stencil_test_enable: Bool32);
14621#[allow(non_camel_case_types)]
14622pub type PFN_vkCmdSetStencilOp = unsafe extern "system" fn(
14623 command_buffer: CommandBuffer,
14624 face_mask: StencilFaceFlags,
14625 fail_op: StencilOp,
14626 pass_op: StencilOp,
14627 depth_fail_op: StencilOp,
14628 compare_op: CompareOp,
14629);
14630#[derive(Clone)]
14631pub struct ExtExtendedDynamicStateFn {
14632 pub cmd_set_cull_mode_ext: PFN_vkCmdSetCullMode,
14633 pub cmd_set_front_face_ext: PFN_vkCmdSetFrontFace,
14634 pub cmd_set_primitive_topology_ext: PFN_vkCmdSetPrimitiveTopology,
14635 pub cmd_set_viewport_with_count_ext: PFN_vkCmdSetViewportWithCount,
14636 pub cmd_set_scissor_with_count_ext: PFN_vkCmdSetScissorWithCount,
14637 pub cmd_bind_vertex_buffers2_ext: PFN_vkCmdBindVertexBuffers2,
14638 pub cmd_set_depth_test_enable_ext: PFN_vkCmdSetDepthTestEnable,
14639 pub cmd_set_depth_write_enable_ext: PFN_vkCmdSetDepthWriteEnable,
14640 pub cmd_set_depth_compare_op_ext: PFN_vkCmdSetDepthCompareOp,
14641 pub cmd_set_depth_bounds_test_enable_ext: PFN_vkCmdSetDepthBoundsTestEnable,
14642 pub cmd_set_stencil_test_enable_ext: PFN_vkCmdSetStencilTestEnable,
14643 pub cmd_set_stencil_op_ext: PFN_vkCmdSetStencilOp,
14644}
14645unsafe impl Send for ExtExtendedDynamicStateFn {}
14646unsafe impl Sync for ExtExtendedDynamicStateFn {}
14647impl ExtExtendedDynamicStateFn {
14648 pub fn load<F>(mut _f: F) -> Self
14649 where
14650 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14651 {
14652 Self {
14653 cmd_set_cull_mode_ext: unsafe {
14654 unsafe extern "system" fn cmd_set_cull_mode_ext(
14655 _command_buffer: CommandBuffer,
14656 _cull_mode: CullModeFlags,
14657 ) {
14658 panic!(concat!(
14659 "Unable to load ",
14660 stringify!(cmd_set_cull_mode_ext)
14661 ))
14662 }
14663 let cname =
14664 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetCullModeEXT\0");
14665 let val = _f(cname);
14666 if val.is_null() {
14667 cmd_set_cull_mode_ext
14668 } else {
14669 ::std::mem::transmute(val)
14670 }
14671 },
14672 cmd_set_front_face_ext: unsafe {
14673 unsafe extern "system" fn cmd_set_front_face_ext(
14674 _command_buffer: CommandBuffer,
14675 _front_face: FrontFace,
14676 ) {
14677 panic!(concat!(
14678 "Unable to load ",
14679 stringify!(cmd_set_front_face_ext)
14680 ))
14681 }
14682 let cname =
14683 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetFrontFaceEXT\0");
14684 let val = _f(cname);
14685 if val.is_null() {
14686 cmd_set_front_face_ext
14687 } else {
14688 ::std::mem::transmute(val)
14689 }
14690 },
14691 cmd_set_primitive_topology_ext: unsafe {
14692 unsafe extern "system" fn cmd_set_primitive_topology_ext(
14693 _command_buffer: CommandBuffer,
14694 _primitive_topology: PrimitiveTopology,
14695 ) {
14696 panic!(concat!(
14697 "Unable to load ",
14698 stringify!(cmd_set_primitive_topology_ext)
14699 ))
14700 }
14701 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14702 b"vkCmdSetPrimitiveTopologyEXT\0",
14703 );
14704 let val = _f(cname);
14705 if val.is_null() {
14706 cmd_set_primitive_topology_ext
14707 } else {
14708 ::std::mem::transmute(val)
14709 }
14710 },
14711 cmd_set_viewport_with_count_ext: unsafe {
14712 unsafe extern "system" fn cmd_set_viewport_with_count_ext(
14713 _command_buffer: CommandBuffer,
14714 _viewport_count: u32,
14715 _p_viewports: *const Viewport,
14716 ) {
14717 panic!(concat!(
14718 "Unable to load ",
14719 stringify!(cmd_set_viewport_with_count_ext)
14720 ))
14721 }
14722 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14723 b"vkCmdSetViewportWithCountEXT\0",
14724 );
14725 let val = _f(cname);
14726 if val.is_null() {
14727 cmd_set_viewport_with_count_ext
14728 } else {
14729 ::std::mem::transmute(val)
14730 }
14731 },
14732 cmd_set_scissor_with_count_ext: unsafe {
14733 unsafe extern "system" fn cmd_set_scissor_with_count_ext(
14734 _command_buffer: CommandBuffer,
14735 _scissor_count: u32,
14736 _p_scissors: *const Rect2D,
14737 ) {
14738 panic!(concat!(
14739 "Unable to load ",
14740 stringify!(cmd_set_scissor_with_count_ext)
14741 ))
14742 }
14743 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14744 b"vkCmdSetScissorWithCountEXT\0",
14745 );
14746 let val = _f(cname);
14747 if val.is_null() {
14748 cmd_set_scissor_with_count_ext
14749 } else {
14750 ::std::mem::transmute(val)
14751 }
14752 },
14753 cmd_bind_vertex_buffers2_ext: unsafe {
14754 unsafe extern "system" fn cmd_bind_vertex_buffers2_ext(
14755 _command_buffer: CommandBuffer,
14756 _first_binding: u32,
14757 _binding_count: u32,
14758 _p_buffers: *const Buffer,
14759 _p_offsets: *const DeviceSize,
14760 _p_sizes: *const DeviceSize,
14761 _p_strides: *const DeviceSize,
14762 ) {
14763 panic!(concat!(
14764 "Unable to load ",
14765 stringify!(cmd_bind_vertex_buffers2_ext)
14766 ))
14767 }
14768 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14769 b"vkCmdBindVertexBuffers2EXT\0",
14770 );
14771 let val = _f(cname);
14772 if val.is_null() {
14773 cmd_bind_vertex_buffers2_ext
14774 } else {
14775 ::std::mem::transmute(val)
14776 }
14777 },
14778 cmd_set_depth_test_enable_ext: unsafe {
14779 unsafe extern "system" fn cmd_set_depth_test_enable_ext(
14780 _command_buffer: CommandBuffer,
14781 _depth_test_enable: Bool32,
14782 ) {
14783 panic!(concat!(
14784 "Unable to load ",
14785 stringify!(cmd_set_depth_test_enable_ext)
14786 ))
14787 }
14788 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14789 b"vkCmdSetDepthTestEnableEXT\0",
14790 );
14791 let val = _f(cname);
14792 if val.is_null() {
14793 cmd_set_depth_test_enable_ext
14794 } else {
14795 ::std::mem::transmute(val)
14796 }
14797 },
14798 cmd_set_depth_write_enable_ext: unsafe {
14799 unsafe extern "system" fn cmd_set_depth_write_enable_ext(
14800 _command_buffer: CommandBuffer,
14801 _depth_write_enable: Bool32,
14802 ) {
14803 panic!(concat!(
14804 "Unable to load ",
14805 stringify!(cmd_set_depth_write_enable_ext)
14806 ))
14807 }
14808 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14809 b"vkCmdSetDepthWriteEnableEXT\0",
14810 );
14811 let val = _f(cname);
14812 if val.is_null() {
14813 cmd_set_depth_write_enable_ext
14814 } else {
14815 ::std::mem::transmute(val)
14816 }
14817 },
14818 cmd_set_depth_compare_op_ext: unsafe {
14819 unsafe extern "system" fn cmd_set_depth_compare_op_ext(
14820 _command_buffer: CommandBuffer,
14821 _depth_compare_op: CompareOp,
14822 ) {
14823 panic!(concat!(
14824 "Unable to load ",
14825 stringify!(cmd_set_depth_compare_op_ext)
14826 ))
14827 }
14828 let cname =
14829 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetDepthCompareOpEXT\0");
14830 let val = _f(cname);
14831 if val.is_null() {
14832 cmd_set_depth_compare_op_ext
14833 } else {
14834 ::std::mem::transmute(val)
14835 }
14836 },
14837 cmd_set_depth_bounds_test_enable_ext: unsafe {
14838 unsafe extern "system" fn cmd_set_depth_bounds_test_enable_ext(
14839 _command_buffer: CommandBuffer,
14840 _depth_bounds_test_enable: Bool32,
14841 ) {
14842 panic!(concat!(
14843 "Unable to load ",
14844 stringify!(cmd_set_depth_bounds_test_enable_ext)
14845 ))
14846 }
14847 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14848 b"vkCmdSetDepthBoundsTestEnableEXT\0",
14849 );
14850 let val = _f(cname);
14851 if val.is_null() {
14852 cmd_set_depth_bounds_test_enable_ext
14853 } else {
14854 ::std::mem::transmute(val)
14855 }
14856 },
14857 cmd_set_stencil_test_enable_ext: unsafe {
14858 unsafe extern "system" fn cmd_set_stencil_test_enable_ext(
14859 _command_buffer: CommandBuffer,
14860 _stencil_test_enable: Bool32,
14861 ) {
14862 panic!(concat!(
14863 "Unable to load ",
14864 stringify!(cmd_set_stencil_test_enable_ext)
14865 ))
14866 }
14867 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14868 b"vkCmdSetStencilTestEnableEXT\0",
14869 );
14870 let val = _f(cname);
14871 if val.is_null() {
14872 cmd_set_stencil_test_enable_ext
14873 } else {
14874 ::std::mem::transmute(val)
14875 }
14876 },
14877 cmd_set_stencil_op_ext: unsafe {
14878 unsafe extern "system" fn cmd_set_stencil_op_ext(
14879 _command_buffer: CommandBuffer,
14880 _face_mask: StencilFaceFlags,
14881 _fail_op: StencilOp,
14882 _pass_op: StencilOp,
14883 _depth_fail_op: StencilOp,
14884 _compare_op: CompareOp,
14885 ) {
14886 panic!(concat!(
14887 "Unable to load ",
14888 stringify!(cmd_set_stencil_op_ext)
14889 ))
14890 }
14891 let cname =
14892 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetStencilOpEXT\0");
14893 let val = _f(cname);
14894 if val.is_null() {
14895 cmd_set_stencil_op_ext
14896 } else {
14897 ::std::mem::transmute(val)
14898 }
14899 },
14900 }
14901 }
14902}
14903#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
14904impl DynamicState {
14905 pub const CULL_MODE_EXT: Self = Self::CULL_MODE;
14906 pub const FRONT_FACE_EXT: Self = Self::FRONT_FACE;
14907 pub const PRIMITIVE_TOPOLOGY_EXT: Self = Self::PRIMITIVE_TOPOLOGY;
14908 pub const VIEWPORT_WITH_COUNT_EXT: Self = Self::VIEWPORT_WITH_COUNT;
14909 pub const SCISSOR_WITH_COUNT_EXT: Self = Self::SCISSOR_WITH_COUNT;
14910 pub const VERTEX_INPUT_BINDING_STRIDE_EXT: Self = Self::VERTEX_INPUT_BINDING_STRIDE;
14911 pub const DEPTH_TEST_ENABLE_EXT: Self = Self::DEPTH_TEST_ENABLE;
14912 pub const DEPTH_WRITE_ENABLE_EXT: Self = Self::DEPTH_WRITE_ENABLE;
14913 pub const DEPTH_COMPARE_OP_EXT: Self = Self::DEPTH_COMPARE_OP;
14914 pub const DEPTH_BOUNDS_TEST_ENABLE_EXT: Self = Self::DEPTH_BOUNDS_TEST_ENABLE;
14915 pub const STENCIL_TEST_ENABLE_EXT: Self = Self::STENCIL_TEST_ENABLE;
14916 pub const STENCIL_OP_EXT: Self = Self::STENCIL_OP;
14917}
14918#[doc = "Generated from 'VK_EXT_extended_dynamic_state'"]
14919impl StructureType {
14920 #[doc = "Not promoted to 1.3"]
14921 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_267_000);
14922}
14923impl KhrDeferredHostOperationsFn {
14924 pub const fn name() -> &'static ::std::ffi::CStr {
14925 unsafe {
14926 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_deferred_host_operations\0")
14927 }
14928 }
14929 pub const SPEC_VERSION: u32 = 4u32;
14930}
14931#[allow(non_camel_case_types)]
14932pub type PFN_vkCreateDeferredOperationKHR = unsafe extern "system" fn(
14933 device: Device,
14934 p_allocator: *const AllocationCallbacks,
14935 p_deferred_operation: *mut DeferredOperationKHR,
14936) -> Result;
14937#[allow(non_camel_case_types)]
14938pub type PFN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn(
14939 device: Device,
14940 operation: DeferredOperationKHR,
14941 p_allocator: *const AllocationCallbacks,
14942);
14943#[allow(non_camel_case_types)]
14944pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR =
14945 unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> u32;
14946#[allow(non_camel_case_types)]
14947pub type PFN_vkGetDeferredOperationResultKHR =
14948 unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result;
14949#[allow(non_camel_case_types)]
14950pub type PFN_vkDeferredOperationJoinKHR =
14951 unsafe extern "system" fn(device: Device, operation: DeferredOperationKHR) -> Result;
14952#[derive(Clone)]
14953pub struct KhrDeferredHostOperationsFn {
14954 pub create_deferred_operation_khr: PFN_vkCreateDeferredOperationKHR,
14955 pub destroy_deferred_operation_khr: PFN_vkDestroyDeferredOperationKHR,
14956 pub get_deferred_operation_max_concurrency_khr: PFN_vkGetDeferredOperationMaxConcurrencyKHR,
14957 pub get_deferred_operation_result_khr: PFN_vkGetDeferredOperationResultKHR,
14958 pub deferred_operation_join_khr: PFN_vkDeferredOperationJoinKHR,
14959}
14960unsafe impl Send for KhrDeferredHostOperationsFn {}
14961unsafe impl Sync for KhrDeferredHostOperationsFn {}
14962impl KhrDeferredHostOperationsFn {
14963 pub fn load<F>(mut _f: F) -> Self
14964 where
14965 F: FnMut(&::std::ffi::CStr) -> *const c_void,
14966 {
14967 Self {
14968 create_deferred_operation_khr: unsafe {
14969 unsafe extern "system" fn create_deferred_operation_khr(
14970 _device: Device,
14971 _p_allocator: *const AllocationCallbacks,
14972 _p_deferred_operation: *mut DeferredOperationKHR,
14973 ) -> Result {
14974 panic!(concat!(
14975 "Unable to load ",
14976 stringify!(create_deferred_operation_khr)
14977 ))
14978 }
14979 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
14980 b"vkCreateDeferredOperationKHR\0",
14981 );
14982 let val = _f(cname);
14983 if val.is_null() {
14984 create_deferred_operation_khr
14985 } else {
14986 ::std::mem::transmute(val)
14987 }
14988 },
14989 destroy_deferred_operation_khr: unsafe {
14990 unsafe extern "system" fn destroy_deferred_operation_khr(
14991 _device: Device,
14992 _operation: DeferredOperationKHR,
14993 _p_allocator: *const AllocationCallbacks,
14994 ) {
14995 panic!(concat!(
14996 "Unable to load ",
14997 stringify!(destroy_deferred_operation_khr)
14998 ))
14999 }
15000 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15001 b"vkDestroyDeferredOperationKHR\0",
15002 );
15003 let val = _f(cname);
15004 if val.is_null() {
15005 destroy_deferred_operation_khr
15006 } else {
15007 ::std::mem::transmute(val)
15008 }
15009 },
15010 get_deferred_operation_max_concurrency_khr: unsafe {
15011 unsafe extern "system" fn get_deferred_operation_max_concurrency_khr(
15012 _device: Device,
15013 _operation: DeferredOperationKHR,
15014 ) -> u32 {
15015 panic!(concat!(
15016 "Unable to load ",
15017 stringify!(get_deferred_operation_max_concurrency_khr)
15018 ))
15019 }
15020 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15021 b"vkGetDeferredOperationMaxConcurrencyKHR\0",
15022 );
15023 let val = _f(cname);
15024 if val.is_null() {
15025 get_deferred_operation_max_concurrency_khr
15026 } else {
15027 ::std::mem::transmute(val)
15028 }
15029 },
15030 get_deferred_operation_result_khr: unsafe {
15031 unsafe extern "system" fn get_deferred_operation_result_khr(
15032 _device: Device,
15033 _operation: DeferredOperationKHR,
15034 ) -> Result {
15035 panic!(concat!(
15036 "Unable to load ",
15037 stringify!(get_deferred_operation_result_khr)
15038 ))
15039 }
15040 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15041 b"vkGetDeferredOperationResultKHR\0",
15042 );
15043 let val = _f(cname);
15044 if val.is_null() {
15045 get_deferred_operation_result_khr
15046 } else {
15047 ::std::mem::transmute(val)
15048 }
15049 },
15050 deferred_operation_join_khr: unsafe {
15051 unsafe extern "system" fn deferred_operation_join_khr(
15052 _device: Device,
15053 _operation: DeferredOperationKHR,
15054 ) -> Result {
15055 panic!(concat!(
15056 "Unable to load ",
15057 stringify!(deferred_operation_join_khr)
15058 ))
15059 }
15060 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15061 b"vkDeferredOperationJoinKHR\0",
15062 );
15063 let val = _f(cname);
15064 if val.is_null() {
15065 deferred_operation_join_khr
15066 } else {
15067 ::std::mem::transmute(val)
15068 }
15069 },
15070 }
15071 }
15072}
15073#[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
15074impl ObjectType {
15075 pub const DEFERRED_OPERATION_KHR: Self = Self(1_000_268_000);
15076}
15077#[doc = "Generated from 'VK_KHR_deferred_host_operations'"]
15078impl Result {
15079 pub const THREAD_IDLE_KHR: Self = Self(1_000_268_000);
15080 pub const THREAD_DONE_KHR: Self = Self(1_000_268_001);
15081 pub const OPERATION_DEFERRED_KHR: Self = Self(1_000_268_002);
15082 pub const OPERATION_NOT_DEFERRED_KHR: Self = Self(1_000_268_003);
15083}
15084impl KhrPipelineExecutablePropertiesFn {
15085 pub const fn name() -> &'static ::std::ffi::CStr {
15086 unsafe {
15087 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15088 b"VK_KHR_pipeline_executable_properties\0",
15089 )
15090 }
15091 }
15092 pub const SPEC_VERSION: u32 = 1u32;
15093}
15094#[allow(non_camel_case_types)]
15095pub type PFN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn(
15096 device: Device,
15097 p_pipeline_info: *const PipelineInfoKHR,
15098 p_executable_count: *mut u32,
15099 p_properties: *mut PipelineExecutablePropertiesKHR,
15100) -> Result;
15101#[allow(non_camel_case_types)]
15102pub type PFN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn(
15103 device: Device,
15104 p_executable_info: *const PipelineExecutableInfoKHR,
15105 p_statistic_count: *mut u32,
15106 p_statistics: *mut PipelineExecutableStatisticKHR,
15107) -> Result;
15108#[allow(non_camel_case_types)]
15109pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR =
15110 unsafe extern "system" fn(
15111 device: Device,
15112 p_executable_info: *const PipelineExecutableInfoKHR,
15113 p_internal_representation_count: *mut u32,
15114 p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR,
15115 ) -> Result;
15116#[derive(Clone)]
15117pub struct KhrPipelineExecutablePropertiesFn {
15118 pub get_pipeline_executable_properties_khr: PFN_vkGetPipelineExecutablePropertiesKHR,
15119 pub get_pipeline_executable_statistics_khr: PFN_vkGetPipelineExecutableStatisticsKHR,
15120 pub get_pipeline_executable_internal_representations_khr:
15121 PFN_vkGetPipelineExecutableInternalRepresentationsKHR,
15122}
15123unsafe impl Send for KhrPipelineExecutablePropertiesFn {}
15124unsafe impl Sync for KhrPipelineExecutablePropertiesFn {}
15125impl KhrPipelineExecutablePropertiesFn {
15126 pub fn load<F>(mut _f: F) -> Self
15127 where
15128 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15129 {
15130 Self {
15131 get_pipeline_executable_properties_khr: unsafe {
15132 unsafe extern "system" fn get_pipeline_executable_properties_khr(
15133 _device: Device,
15134 _p_pipeline_info: *const PipelineInfoKHR,
15135 _p_executable_count: *mut u32,
15136 _p_properties: *mut PipelineExecutablePropertiesKHR,
15137 ) -> Result {
15138 panic!(concat!(
15139 "Unable to load ",
15140 stringify!(get_pipeline_executable_properties_khr)
15141 ))
15142 }
15143 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15144 b"vkGetPipelineExecutablePropertiesKHR\0",
15145 );
15146 let val = _f(cname);
15147 if val.is_null() {
15148 get_pipeline_executable_properties_khr
15149 } else {
15150 ::std::mem::transmute(val)
15151 }
15152 },
15153 get_pipeline_executable_statistics_khr: unsafe {
15154 unsafe extern "system" fn get_pipeline_executable_statistics_khr(
15155 _device: Device,
15156 _p_executable_info: *const PipelineExecutableInfoKHR,
15157 _p_statistic_count: *mut u32,
15158 _p_statistics: *mut PipelineExecutableStatisticKHR,
15159 ) -> Result {
15160 panic!(concat!(
15161 "Unable to load ",
15162 stringify!(get_pipeline_executable_statistics_khr)
15163 ))
15164 }
15165 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15166 b"vkGetPipelineExecutableStatisticsKHR\0",
15167 );
15168 let val = _f(cname);
15169 if val.is_null() {
15170 get_pipeline_executable_statistics_khr
15171 } else {
15172 ::std::mem::transmute(val)
15173 }
15174 },
15175 get_pipeline_executable_internal_representations_khr: unsafe {
15176 unsafe extern "system" fn get_pipeline_executable_internal_representations_khr(
15177 _device: Device,
15178 _p_executable_info: *const PipelineExecutableInfoKHR,
15179 _p_internal_representation_count: *mut u32,
15180 _p_internal_representations: *mut PipelineExecutableInternalRepresentationKHR,
15181 ) -> Result {
15182 panic!(concat!(
15183 "Unable to load ",
15184 stringify!(get_pipeline_executable_internal_representations_khr)
15185 ))
15186 }
15187 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15188 b"vkGetPipelineExecutableInternalRepresentationsKHR\0",
15189 );
15190 let val = _f(cname);
15191 if val.is_null() {
15192 get_pipeline_executable_internal_representations_khr
15193 } else {
15194 ::std::mem::transmute(val)
15195 }
15196 },
15197 }
15198 }
15199}
15200#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
15201impl PipelineCreateFlags {
15202 pub const CAPTURE_STATISTICS_KHR: Self = Self(0b100_0000);
15203 pub const CAPTURE_INTERNAL_REPRESENTATIONS_KHR: Self = Self(0b1000_0000);
15204}
15205#[doc = "Generated from 'VK_KHR_pipeline_executable_properties'"]
15206impl StructureType {
15207 pub const PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: Self =
15208 Self(1_000_269_000);
15209 pub const PIPELINE_INFO_KHR: Self = Self(1_000_269_001);
15210 pub const PIPELINE_EXECUTABLE_PROPERTIES_KHR: Self = Self(1_000_269_002);
15211 pub const PIPELINE_EXECUTABLE_INFO_KHR: Self = Self(1_000_269_003);
15212 pub const PIPELINE_EXECUTABLE_STATISTIC_KHR: Self = Self(1_000_269_004);
15213 pub const PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: Self = Self(1_000_269_005);
15214}
15215impl IntelExtension271Fn {
15216 pub const fn name() -> &'static ::std::ffi::CStr {
15217 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_271\0") }
15218 }
15219 pub const SPEC_VERSION: u32 = 0u32;
15220}
15221#[derive(Clone)]
15222pub struct IntelExtension271Fn {}
15223unsafe impl Send for IntelExtension271Fn {}
15224unsafe impl Sync for IntelExtension271Fn {}
15225impl IntelExtension271Fn {
15226 pub fn load<F>(mut _f: F) -> Self
15227 where
15228 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15229 {
15230 Self {}
15231 }
15232}
15233#[doc = "Generated from 'VK_INTEL_extension_271'"]
15234impl ImageUsageFlags {
15235 pub const RESERVED_22_EXT: Self = Self(0b100_0000_0000_0000_0000_0000);
15236}
15237impl IntelExtension272Fn {
15238 pub const fn name() -> &'static ::std::ffi::CStr {
15239 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_272\0") }
15240 }
15241 pub const SPEC_VERSION: u32 = 0u32;
15242}
15243#[derive(Clone)]
15244pub struct IntelExtension272Fn {}
15245unsafe impl Send for IntelExtension272Fn {}
15246unsafe impl Sync for IntelExtension272Fn {}
15247impl IntelExtension272Fn {
15248 pub fn load<F>(mut _f: F) -> Self
15249 where
15250 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15251 {
15252 Self {}
15253 }
15254}
15255impl IntelExtension273Fn {
15256 pub const fn name() -> &'static ::std::ffi::CStr {
15257 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_INTEL_extension_273\0") }
15258 }
15259 pub const SPEC_VERSION: u32 = 0u32;
15260}
15261#[derive(Clone)]
15262pub struct IntelExtension273Fn {}
15263unsafe impl Send for IntelExtension273Fn {}
15264unsafe impl Sync for IntelExtension273Fn {}
15265impl IntelExtension273Fn {
15266 pub fn load<F>(mut _f: F) -> Self
15267 where
15268 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15269 {
15270 Self {}
15271 }
15272}
15273impl ExtShaderAtomicFloat2Fn {
15274 pub const fn name() -> &'static ::std::ffi::CStr {
15275 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_shader_atomic_float2\0") }
15276 }
15277 pub const SPEC_VERSION: u32 = 1u32;
15278}
15279#[derive(Clone)]
15280pub struct ExtShaderAtomicFloat2Fn {}
15281unsafe impl Send for ExtShaderAtomicFloat2Fn {}
15282unsafe impl Sync for ExtShaderAtomicFloat2Fn {}
15283impl ExtShaderAtomicFloat2Fn {
15284 pub fn load<F>(mut _f: F) -> Self
15285 where
15286 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15287 {
15288 Self {}
15289 }
15290}
15291#[doc = "Generated from 'VK_EXT_shader_atomic_float2'"]
15292impl StructureType {
15293 pub const PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: Self = Self(1_000_273_000);
15294}
15295impl KhrExtension275Fn {
15296 pub const fn name() -> &'static ::std::ffi::CStr {
15297 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_275\0") }
15298 }
15299 pub const SPEC_VERSION: u32 = 0u32;
15300}
15301#[derive(Clone)]
15302pub struct KhrExtension275Fn {}
15303unsafe impl Send for KhrExtension275Fn {}
15304unsafe impl Sync for KhrExtension275Fn {}
15305impl KhrExtension275Fn {
15306 pub fn load<F>(mut _f: F) -> Self
15307 where
15308 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15309 {
15310 Self {}
15311 }
15312}
15313impl KhrExtension276Fn {
15314 pub const fn name() -> &'static ::std::ffi::CStr {
15315 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_276\0") }
15316 }
15317 pub const SPEC_VERSION: u32 = 0u32;
15318}
15319#[derive(Clone)]
15320pub struct KhrExtension276Fn {}
15321unsafe impl Send for KhrExtension276Fn {}
15322unsafe impl Sync for KhrExtension276Fn {}
15323impl KhrExtension276Fn {
15324 pub fn load<F>(mut _f: F) -> Self
15325 where
15326 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15327 {
15328 Self {}
15329 }
15330}
15331impl ExtShaderDemoteToHelperInvocationFn {
15332 pub const fn name() -> &'static ::std::ffi::CStr {
15333 unsafe {
15334 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15335 b"VK_EXT_shader_demote_to_helper_invocation\0",
15336 )
15337 }
15338 }
15339 pub const SPEC_VERSION: u32 = 1u32;
15340}
15341#[derive(Clone)]
15342pub struct ExtShaderDemoteToHelperInvocationFn {}
15343unsafe impl Send for ExtShaderDemoteToHelperInvocationFn {}
15344unsafe impl Sync for ExtShaderDemoteToHelperInvocationFn {}
15345impl ExtShaderDemoteToHelperInvocationFn {
15346 pub fn load<F>(mut _f: F) -> Self
15347 where
15348 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15349 {
15350 Self {}
15351 }
15352}
15353#[doc = "Generated from 'VK_EXT_shader_demote_to_helper_invocation'"]
15354impl StructureType {
15355 pub const PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: Self =
15356 Self::PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
15357}
15358impl NvDeviceGeneratedCommandsFn {
15359 pub const fn name() -> &'static ::std::ffi::CStr {
15360 unsafe {
15361 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_generated_commands\0")
15362 }
15363 }
15364 pub const SPEC_VERSION: u32 = 3u32;
15365}
15366#[allow(non_camel_case_types)]
15367pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn(
15368 device: Device,
15369 p_info: *const GeneratedCommandsMemoryRequirementsInfoNV,
15370 p_memory_requirements: *mut MemoryRequirements2,
15371);
15372#[allow(non_camel_case_types)]
15373pub type PFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn(
15374 command_buffer: CommandBuffer,
15375 p_generated_commands_info: *const GeneratedCommandsInfoNV,
15376);
15377#[allow(non_camel_case_types)]
15378pub type PFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn(
15379 command_buffer: CommandBuffer,
15380 is_preprocessed: Bool32,
15381 p_generated_commands_info: *const GeneratedCommandsInfoNV,
15382);
15383#[allow(non_camel_case_types)]
15384pub type PFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn(
15385 command_buffer: CommandBuffer,
15386 pipeline_bind_point: PipelineBindPoint,
15387 pipeline: Pipeline,
15388 group_index: u32,
15389);
15390#[allow(non_camel_case_types)]
15391pub type PFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn(
15392 device: Device,
15393 p_create_info: *const IndirectCommandsLayoutCreateInfoNV,
15394 p_allocator: *const AllocationCallbacks,
15395 p_indirect_commands_layout: *mut IndirectCommandsLayoutNV,
15396) -> Result;
15397#[allow(non_camel_case_types)]
15398pub type PFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn(
15399 device: Device,
15400 indirect_commands_layout: IndirectCommandsLayoutNV,
15401 p_allocator: *const AllocationCallbacks,
15402);
15403#[derive(Clone)]
15404pub struct NvDeviceGeneratedCommandsFn {
15405 pub get_generated_commands_memory_requirements_nv:
15406 PFN_vkGetGeneratedCommandsMemoryRequirementsNV,
15407 pub cmd_preprocess_generated_commands_nv: PFN_vkCmdPreprocessGeneratedCommandsNV,
15408 pub cmd_execute_generated_commands_nv: PFN_vkCmdExecuteGeneratedCommandsNV,
15409 pub cmd_bind_pipeline_shader_group_nv: PFN_vkCmdBindPipelineShaderGroupNV,
15410 pub create_indirect_commands_layout_nv: PFN_vkCreateIndirectCommandsLayoutNV,
15411 pub destroy_indirect_commands_layout_nv: PFN_vkDestroyIndirectCommandsLayoutNV,
15412}
15413unsafe impl Send for NvDeviceGeneratedCommandsFn {}
15414unsafe impl Sync for NvDeviceGeneratedCommandsFn {}
15415impl NvDeviceGeneratedCommandsFn {
15416 pub fn load<F>(mut _f: F) -> Self
15417 where
15418 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15419 {
15420 Self {
15421 get_generated_commands_memory_requirements_nv: unsafe {
15422 unsafe extern "system" fn get_generated_commands_memory_requirements_nv(
15423 _device: Device,
15424 _p_info: *const GeneratedCommandsMemoryRequirementsInfoNV,
15425 _p_memory_requirements: *mut MemoryRequirements2,
15426 ) {
15427 panic!(concat!(
15428 "Unable to load ",
15429 stringify!(get_generated_commands_memory_requirements_nv)
15430 ))
15431 }
15432 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15433 b"vkGetGeneratedCommandsMemoryRequirementsNV\0",
15434 );
15435 let val = _f(cname);
15436 if val.is_null() {
15437 get_generated_commands_memory_requirements_nv
15438 } else {
15439 ::std::mem::transmute(val)
15440 }
15441 },
15442 cmd_preprocess_generated_commands_nv: unsafe {
15443 unsafe extern "system" fn cmd_preprocess_generated_commands_nv(
15444 _command_buffer: CommandBuffer,
15445 _p_generated_commands_info: *const GeneratedCommandsInfoNV,
15446 ) {
15447 panic!(concat!(
15448 "Unable to load ",
15449 stringify!(cmd_preprocess_generated_commands_nv)
15450 ))
15451 }
15452 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15453 b"vkCmdPreprocessGeneratedCommandsNV\0",
15454 );
15455 let val = _f(cname);
15456 if val.is_null() {
15457 cmd_preprocess_generated_commands_nv
15458 } else {
15459 ::std::mem::transmute(val)
15460 }
15461 },
15462 cmd_execute_generated_commands_nv: unsafe {
15463 unsafe extern "system" fn cmd_execute_generated_commands_nv(
15464 _command_buffer: CommandBuffer,
15465 _is_preprocessed: Bool32,
15466 _p_generated_commands_info: *const GeneratedCommandsInfoNV,
15467 ) {
15468 panic!(concat!(
15469 "Unable to load ",
15470 stringify!(cmd_execute_generated_commands_nv)
15471 ))
15472 }
15473 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15474 b"vkCmdExecuteGeneratedCommandsNV\0",
15475 );
15476 let val = _f(cname);
15477 if val.is_null() {
15478 cmd_execute_generated_commands_nv
15479 } else {
15480 ::std::mem::transmute(val)
15481 }
15482 },
15483 cmd_bind_pipeline_shader_group_nv: unsafe {
15484 unsafe extern "system" fn cmd_bind_pipeline_shader_group_nv(
15485 _command_buffer: CommandBuffer,
15486 _pipeline_bind_point: PipelineBindPoint,
15487 _pipeline: Pipeline,
15488 _group_index: u32,
15489 ) {
15490 panic!(concat!(
15491 "Unable to load ",
15492 stringify!(cmd_bind_pipeline_shader_group_nv)
15493 ))
15494 }
15495 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15496 b"vkCmdBindPipelineShaderGroupNV\0",
15497 );
15498 let val = _f(cname);
15499 if val.is_null() {
15500 cmd_bind_pipeline_shader_group_nv
15501 } else {
15502 ::std::mem::transmute(val)
15503 }
15504 },
15505 create_indirect_commands_layout_nv: unsafe {
15506 unsafe extern "system" fn create_indirect_commands_layout_nv(
15507 _device: Device,
15508 _p_create_info: *const IndirectCommandsLayoutCreateInfoNV,
15509 _p_allocator: *const AllocationCallbacks,
15510 _p_indirect_commands_layout: *mut IndirectCommandsLayoutNV,
15511 ) -> Result {
15512 panic!(concat!(
15513 "Unable to load ",
15514 stringify!(create_indirect_commands_layout_nv)
15515 ))
15516 }
15517 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15518 b"vkCreateIndirectCommandsLayoutNV\0",
15519 );
15520 let val = _f(cname);
15521 if val.is_null() {
15522 create_indirect_commands_layout_nv
15523 } else {
15524 ::std::mem::transmute(val)
15525 }
15526 },
15527 destroy_indirect_commands_layout_nv: unsafe {
15528 unsafe extern "system" fn destroy_indirect_commands_layout_nv(
15529 _device: Device,
15530 _indirect_commands_layout: IndirectCommandsLayoutNV,
15531 _p_allocator: *const AllocationCallbacks,
15532 ) {
15533 panic!(concat!(
15534 "Unable to load ",
15535 stringify!(destroy_indirect_commands_layout_nv)
15536 ))
15537 }
15538 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
15539 b"vkDestroyIndirectCommandsLayoutNV\0",
15540 );
15541 let val = _f(cname);
15542 if val.is_null() {
15543 destroy_indirect_commands_layout_nv
15544 } else {
15545 ::std::mem::transmute(val)
15546 }
15547 },
15548 }
15549 }
15550}
15551#[doc = "Generated from 'VK_NV_device_generated_commands'"]
15552impl AccessFlags {
15553 pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000);
15554 pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000);
15555}
15556#[doc = "Generated from 'VK_NV_device_generated_commands'"]
15557impl ObjectType {
15558 pub const INDIRECT_COMMANDS_LAYOUT_NV: Self = Self(1_000_277_000);
15559}
15560#[doc = "Generated from 'VK_NV_device_generated_commands'"]
15561impl PipelineCreateFlags {
15562 pub const INDIRECT_BINDABLE_NV: Self = Self(0b100_0000_0000_0000_0000);
15563}
15564#[doc = "Generated from 'VK_NV_device_generated_commands'"]
15565impl PipelineStageFlags {
15566 pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
15567}
15568#[doc = "Generated from 'VK_NV_device_generated_commands'"]
15569impl StructureType {
15570 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: Self = Self(1_000_277_000);
15571 pub const GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: Self = Self(1_000_277_001);
15572 pub const GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: Self = Self(1_000_277_002);
15573 pub const INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: Self = Self(1_000_277_003);
15574 pub const INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: Self = Self(1_000_277_004);
15575 pub const GENERATED_COMMANDS_INFO_NV: Self = Self(1_000_277_005);
15576 pub const GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: Self = Self(1_000_277_006);
15577 pub const PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: Self = Self(1_000_277_007);
15578}
15579impl NvInheritedViewportScissorFn {
15580 pub const fn name() -> &'static ::std::ffi::CStr {
15581 unsafe {
15582 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_inherited_viewport_scissor\0")
15583 }
15584 }
15585 pub const SPEC_VERSION: u32 = 1u32;
15586}
15587#[derive(Clone)]
15588pub struct NvInheritedViewportScissorFn {}
15589unsafe impl Send for NvInheritedViewportScissorFn {}
15590unsafe impl Sync for NvInheritedViewportScissorFn {}
15591impl NvInheritedViewportScissorFn {
15592 pub fn load<F>(mut _f: F) -> Self
15593 where
15594 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15595 {
15596 Self {}
15597 }
15598}
15599#[doc = "Generated from 'VK_NV_inherited_viewport_scissor'"]
15600impl StructureType {
15601 pub const PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: Self = Self(1_000_278_000);
15602 pub const COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: Self = Self(1_000_278_001);
15603}
15604impl KhrExtension280Fn {
15605 pub const fn name() -> &'static ::std::ffi::CStr {
15606 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_280\0") }
15607 }
15608 pub const SPEC_VERSION: u32 = 0u32;
15609}
15610#[derive(Clone)]
15611pub struct KhrExtension280Fn {}
15612unsafe impl Send for KhrExtension280Fn {}
15613unsafe impl Sync for KhrExtension280Fn {}
15614impl KhrExtension280Fn {
15615 pub fn load<F>(mut _f: F) -> Self
15616 where
15617 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15618 {
15619 Self {}
15620 }
15621}
15622impl KhrShaderIntegerDotProductFn {
15623 pub const fn name() -> &'static ::std::ffi::CStr {
15624 unsafe {
15625 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_integer_dot_product\0")
15626 }
15627 }
15628 pub const SPEC_VERSION: u32 = 1u32;
15629}
15630#[derive(Clone)]
15631pub struct KhrShaderIntegerDotProductFn {}
15632unsafe impl Send for KhrShaderIntegerDotProductFn {}
15633unsafe impl Sync for KhrShaderIntegerDotProductFn {}
15634impl KhrShaderIntegerDotProductFn {
15635 pub fn load<F>(mut _f: F) -> Self
15636 where
15637 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15638 {
15639 Self {}
15640 }
15641}
15642#[doc = "Generated from 'VK_KHR_shader_integer_dot_product'"]
15643impl StructureType {
15644 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: Self =
15645 Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
15646 pub const PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: Self =
15647 Self::PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
15648}
15649impl ExtTexelBufferAlignmentFn {
15650 pub const fn name() -> &'static ::std::ffi::CStr {
15651 unsafe {
15652 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_texel_buffer_alignment\0")
15653 }
15654 }
15655 pub const SPEC_VERSION: u32 = 1u32;
15656}
15657#[derive(Clone)]
15658pub struct ExtTexelBufferAlignmentFn {}
15659unsafe impl Send for ExtTexelBufferAlignmentFn {}
15660unsafe impl Sync for ExtTexelBufferAlignmentFn {}
15661impl ExtTexelBufferAlignmentFn {
15662 pub fn load<F>(mut _f: F) -> Self
15663 where
15664 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15665 {
15666 Self {}
15667 }
15668}
15669#[doc = "Generated from 'VK_EXT_texel_buffer_alignment'"]
15670impl StructureType {
15671 #[doc = "Not promoted to 1.3"]
15672 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: Self = Self(1_000_281_000);
15673 pub const PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: Self =
15674 Self::PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
15675}
15676impl QcomRenderPassTransformFn {
15677 pub const fn name() -> &'static ::std::ffi::CStr {
15678 unsafe {
15679 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_transform\0")
15680 }
15681 }
15682 pub const SPEC_VERSION: u32 = 2u32;
15683}
15684#[derive(Clone)]
15685pub struct QcomRenderPassTransformFn {}
15686unsafe impl Send for QcomRenderPassTransformFn {}
15687unsafe impl Sync for QcomRenderPassTransformFn {}
15688impl QcomRenderPassTransformFn {
15689 pub fn load<F>(mut _f: F) -> Self
15690 where
15691 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15692 {
15693 Self {}
15694 }
15695}
15696#[doc = "Generated from 'VK_QCOM_render_pass_transform'"]
15697impl RenderPassCreateFlags {
15698 pub const TRANSFORM_QCOM: Self = Self(0b10);
15699}
15700#[doc = "Generated from 'VK_QCOM_render_pass_transform'"]
15701impl StructureType {
15702 pub const COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: Self =
15703 Self(1_000_282_000);
15704 pub const RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: Self = Self(1_000_282_001);
15705}
15706impl ExtExtension284Fn {
15707 pub const fn name() -> &'static ::std::ffi::CStr {
15708 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_284\0") }
15709 }
15710 pub const SPEC_VERSION: u32 = 0u32;
15711}
15712#[derive(Clone)]
15713pub struct ExtExtension284Fn {}
15714unsafe impl Send for ExtExtension284Fn {}
15715unsafe impl Sync for ExtExtension284Fn {}
15716impl ExtExtension284Fn {
15717 pub fn load<F>(mut _f: F) -> Self
15718 where
15719 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15720 {
15721 Self {}
15722 }
15723}
15724impl ExtDeviceMemoryReportFn {
15725 pub const fn name() -> &'static ::std::ffi::CStr {
15726 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_device_memory_report\0") }
15727 }
15728 pub const SPEC_VERSION: u32 = 2u32;
15729}
15730#[derive(Clone)]
15731pub struct ExtDeviceMemoryReportFn {}
15732unsafe impl Send for ExtDeviceMemoryReportFn {}
15733unsafe impl Sync for ExtDeviceMemoryReportFn {}
15734impl ExtDeviceMemoryReportFn {
15735 pub fn load<F>(mut _f: F) -> Self
15736 where
15737 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15738 {
15739 Self {}
15740 }
15741}
15742#[doc = "Generated from 'VK_EXT_device_memory_report'"]
15743impl StructureType {
15744 pub const PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: Self = Self(1_000_284_000);
15745 pub const DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: Self = Self(1_000_284_001);
15746 pub const DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: Self = Self(1_000_284_002);
15747}
15748impl ExtAcquireDrmDisplayFn {
15749 pub const fn name() -> &'static ::std::ffi::CStr {
15750 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_acquire_drm_display\0") }
15751 }
15752 pub const SPEC_VERSION: u32 = 1u32;
15753}
15754#[allow(non_camel_case_types)]
15755pub type PFN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn(
15756 physical_device: PhysicalDevice,
15757 drm_fd: i32,
15758 display: DisplayKHR,
15759) -> Result;
15760#[allow(non_camel_case_types)]
15761pub type PFN_vkGetDrmDisplayEXT = unsafe extern "system" fn(
15762 physical_device: PhysicalDevice,
15763 drm_fd: i32,
15764 connector_id: u32,
15765 display: *mut DisplayKHR,
15766) -> Result;
15767#[derive(Clone)]
15768pub struct ExtAcquireDrmDisplayFn {
15769 pub acquire_drm_display_ext: PFN_vkAcquireDrmDisplayEXT,
15770 pub get_drm_display_ext: PFN_vkGetDrmDisplayEXT,
15771}
15772unsafe impl Send for ExtAcquireDrmDisplayFn {}
15773unsafe impl Sync for ExtAcquireDrmDisplayFn {}
15774impl ExtAcquireDrmDisplayFn {
15775 pub fn load<F>(mut _f: F) -> Self
15776 where
15777 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15778 {
15779 Self {
15780 acquire_drm_display_ext: unsafe {
15781 unsafe extern "system" fn acquire_drm_display_ext(
15782 _physical_device: PhysicalDevice,
15783 _drm_fd: i32,
15784 _display: DisplayKHR,
15785 ) -> Result {
15786 panic!(concat!(
15787 "Unable to load ",
15788 stringify!(acquire_drm_display_ext)
15789 ))
15790 }
15791 let cname =
15792 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireDrmDisplayEXT\0");
15793 let val = _f(cname);
15794 if val.is_null() {
15795 acquire_drm_display_ext
15796 } else {
15797 ::std::mem::transmute(val)
15798 }
15799 },
15800 get_drm_display_ext: unsafe {
15801 unsafe extern "system" fn get_drm_display_ext(
15802 _physical_device: PhysicalDevice,
15803 _drm_fd: i32,
15804 _connector_id: u32,
15805 _display: *mut DisplayKHR,
15806 ) -> Result {
15807 panic!(concat!("Unable to load ", stringify!(get_drm_display_ext)))
15808 }
15809 let cname =
15810 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetDrmDisplayEXT\0");
15811 let val = _f(cname);
15812 if val.is_null() {
15813 get_drm_display_ext
15814 } else {
15815 ::std::mem::transmute(val)
15816 }
15817 },
15818 }
15819 }
15820}
15821impl ExtRobustness2Fn {
15822 pub const fn name() -> &'static ::std::ffi::CStr {
15823 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_robustness2\0") }
15824 }
15825 pub const SPEC_VERSION: u32 = 1u32;
15826}
15827#[derive(Clone)]
15828pub struct ExtRobustness2Fn {}
15829unsafe impl Send for ExtRobustness2Fn {}
15830unsafe impl Sync for ExtRobustness2Fn {}
15831impl ExtRobustness2Fn {
15832 pub fn load<F>(mut _f: F) -> Self
15833 where
15834 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15835 {
15836 Self {}
15837 }
15838}
15839#[doc = "Generated from 'VK_EXT_robustness2'"]
15840impl StructureType {
15841 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: Self = Self(1_000_286_000);
15842 pub const PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: Self = Self(1_000_286_001);
15843}
15844impl ExtCustomBorderColorFn {
15845 pub const fn name() -> &'static ::std::ffi::CStr {
15846 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_custom_border_color\0") }
15847 }
15848 pub const SPEC_VERSION: u32 = 12u32;
15849}
15850#[derive(Clone)]
15851pub struct ExtCustomBorderColorFn {}
15852unsafe impl Send for ExtCustomBorderColorFn {}
15853unsafe impl Sync for ExtCustomBorderColorFn {}
15854impl ExtCustomBorderColorFn {
15855 pub fn load<F>(mut _f: F) -> Self
15856 where
15857 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15858 {
15859 Self {}
15860 }
15861}
15862#[doc = "Generated from 'VK_EXT_custom_border_color'"]
15863impl BorderColor {
15864 pub const FLOAT_CUSTOM_EXT: Self = Self(1_000_287_003);
15865 pub const INT_CUSTOM_EXT: Self = Self(1_000_287_004);
15866}
15867#[doc = "Generated from 'VK_EXT_custom_border_color'"]
15868impl StructureType {
15869 pub const SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: Self = Self(1_000_287_000);
15870 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: Self = Self(1_000_287_001);
15871 pub const PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: Self = Self(1_000_287_002);
15872}
15873impl ExtExtension289Fn {
15874 pub const fn name() -> &'static ::std::ffi::CStr {
15875 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_289\0") }
15876 }
15877 pub const SPEC_VERSION: u32 = 0u32;
15878}
15879#[derive(Clone)]
15880pub struct ExtExtension289Fn {}
15881unsafe impl Send for ExtExtension289Fn {}
15882unsafe impl Sync for ExtExtension289Fn {}
15883impl ExtExtension289Fn {
15884 pub fn load<F>(mut _f: F) -> Self
15885 where
15886 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15887 {
15888 Self {}
15889 }
15890}
15891#[doc = "Generated from 'VK_EXT_extension_289'"]
15892impl Format {
15893 pub const ASTC_3X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_000);
15894 pub const ASTC_3X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_001);
15895 pub const ASTC_3X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_002);
15896 pub const ASTC_4X3X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_003);
15897 pub const ASTC_4X3X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_004);
15898 pub const ASTC_4X3X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_005);
15899 pub const ASTC_4X4X3_UNORM_BLOCK_EXT: Self = Self(1_000_288_006);
15900 pub const ASTC_4X4X3_SRGB_BLOCK_EXT: Self = Self(1_000_288_007);
15901 pub const ASTC_4X4X3_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_008);
15902 pub const ASTC_4X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_009);
15903 pub const ASTC_4X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_010);
15904 pub const ASTC_4X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_011);
15905 pub const ASTC_5X4X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_012);
15906 pub const ASTC_5X4X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_013);
15907 pub const ASTC_5X4X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_014);
15908 pub const ASTC_5X5X4_UNORM_BLOCK_EXT: Self = Self(1_000_288_015);
15909 pub const ASTC_5X5X4_SRGB_BLOCK_EXT: Self = Self(1_000_288_016);
15910 pub const ASTC_5X5X4_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_017);
15911 pub const ASTC_5X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_018);
15912 pub const ASTC_5X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_019);
15913 pub const ASTC_5X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_020);
15914 pub const ASTC_6X5X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_021);
15915 pub const ASTC_6X5X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_022);
15916 pub const ASTC_6X5X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_023);
15917 pub const ASTC_6X6X5_UNORM_BLOCK_EXT: Self = Self(1_000_288_024);
15918 pub const ASTC_6X6X5_SRGB_BLOCK_EXT: Self = Self(1_000_288_025);
15919 pub const ASTC_6X6X5_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_026);
15920 pub const ASTC_6X6X6_UNORM_BLOCK_EXT: Self = Self(1_000_288_027);
15921 pub const ASTC_6X6X6_SRGB_BLOCK_EXT: Self = Self(1_000_288_028);
15922 pub const ASTC_6X6X6_SFLOAT_BLOCK_EXT: Self = Self(1_000_288_029);
15923}
15924impl GoogleUserTypeFn {
15925 pub const fn name() -> &'static ::std::ffi::CStr {
15926 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_user_type\0") }
15927 }
15928 pub const SPEC_VERSION: u32 = 1u32;
15929}
15930#[derive(Clone)]
15931pub struct GoogleUserTypeFn {}
15932unsafe impl Send for GoogleUserTypeFn {}
15933unsafe impl Sync for GoogleUserTypeFn {}
15934impl GoogleUserTypeFn {
15935 pub fn load<F>(mut _f: F) -> Self
15936 where
15937 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15938 {
15939 Self {}
15940 }
15941}
15942impl KhrPipelineLibraryFn {
15943 pub const fn name() -> &'static ::std::ffi::CStr {
15944 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_pipeline_library\0") }
15945 }
15946 pub const SPEC_VERSION: u32 = 1u32;
15947}
15948#[derive(Clone)]
15949pub struct KhrPipelineLibraryFn {}
15950unsafe impl Send for KhrPipelineLibraryFn {}
15951unsafe impl Sync for KhrPipelineLibraryFn {}
15952impl KhrPipelineLibraryFn {
15953 pub fn load<F>(mut _f: F) -> Self
15954 where
15955 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15956 {
15957 Self {}
15958 }
15959}
15960#[doc = "Generated from 'VK_KHR_pipeline_library'"]
15961impl PipelineCreateFlags {
15962 pub const LIBRARY_KHR: Self = Self(0b1000_0000_0000);
15963}
15964#[doc = "Generated from 'VK_KHR_pipeline_library'"]
15965impl StructureType {
15966 pub const PIPELINE_LIBRARY_CREATE_INFO_KHR: Self = Self(1_000_290_000);
15967}
15968impl NvExtension292Fn {
15969 pub const fn name() -> &'static ::std::ffi::CStr {
15970 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_292\0") }
15971 }
15972 pub const SPEC_VERSION: u32 = 0u32;
15973}
15974#[derive(Clone)]
15975pub struct NvExtension292Fn {}
15976unsafe impl Send for NvExtension292Fn {}
15977unsafe impl Sync for NvExtension292Fn {}
15978impl NvExtension292Fn {
15979 pub fn load<F>(mut _f: F) -> Self
15980 where
15981 F: FnMut(&::std::ffi::CStr) -> *const c_void,
15982 {
15983 Self {}
15984 }
15985}
15986impl NvExtension293Fn {
15987 pub const fn name() -> &'static ::std::ffi::CStr {
15988 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_293\0") }
15989 }
15990 pub const SPEC_VERSION: u32 = 0u32;
15991}
15992#[derive(Clone)]
15993pub struct NvExtension293Fn {}
15994unsafe impl Send for NvExtension293Fn {}
15995unsafe impl Sync for NvExtension293Fn {}
15996impl NvExtension293Fn {
15997 pub fn load<F>(mut _f: F) -> Self
15998 where
15999 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16000 {
16001 Self {}
16002 }
16003}
16004impl KhrShaderNonSemanticInfoFn {
16005 pub const fn name() -> &'static ::std::ffi::CStr {
16006 unsafe {
16007 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_shader_non_semantic_info\0")
16008 }
16009 }
16010 pub const SPEC_VERSION: u32 = 1u32;
16011}
16012#[derive(Clone)]
16013pub struct KhrShaderNonSemanticInfoFn {}
16014unsafe impl Send for KhrShaderNonSemanticInfoFn {}
16015unsafe impl Sync for KhrShaderNonSemanticInfoFn {}
16016impl KhrShaderNonSemanticInfoFn {
16017 pub fn load<F>(mut _f: F) -> Self
16018 where
16019 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16020 {
16021 Self {}
16022 }
16023}
16024impl KhrPresentIdFn {
16025 pub const fn name() -> &'static ::std::ffi::CStr {
16026 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_present_id\0") }
16027 }
16028 pub const SPEC_VERSION: u32 = 1u32;
16029}
16030#[derive(Clone)]
16031pub struct KhrPresentIdFn {}
16032unsafe impl Send for KhrPresentIdFn {}
16033unsafe impl Sync for KhrPresentIdFn {}
16034impl KhrPresentIdFn {
16035 pub fn load<F>(mut _f: F) -> Self
16036 where
16037 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16038 {
16039 Self {}
16040 }
16041}
16042#[doc = "Generated from 'VK_KHR_present_id'"]
16043impl StructureType {
16044 pub const PRESENT_ID_KHR: Self = Self(1_000_294_000);
16045 pub const PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: Self = Self(1_000_294_001);
16046}
16047impl ExtPrivateDataFn {
16048 pub const fn name() -> &'static ::std::ffi::CStr {
16049 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_private_data\0") }
16050 }
16051 pub const SPEC_VERSION: u32 = 1u32;
16052}
16053#[allow(non_camel_case_types)]
16054pub type PFN_vkCreatePrivateDataSlot = unsafe extern "system" fn(
16055 device: Device,
16056 p_create_info: *const PrivateDataSlotCreateInfo,
16057 p_allocator: *const AllocationCallbacks,
16058 p_private_data_slot: *mut PrivateDataSlot,
16059) -> Result;
16060#[allow(non_camel_case_types)]
16061pub type PFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn(
16062 device: Device,
16063 private_data_slot: PrivateDataSlot,
16064 p_allocator: *const AllocationCallbacks,
16065);
16066#[allow(non_camel_case_types)]
16067pub type PFN_vkSetPrivateData = unsafe extern "system" fn(
16068 device: Device,
16069 object_type: ObjectType,
16070 object_handle: u64,
16071 private_data_slot: PrivateDataSlot,
16072 data: u64,
16073) -> Result;
16074#[allow(non_camel_case_types)]
16075pub type PFN_vkGetPrivateData = unsafe extern "system" fn(
16076 device: Device,
16077 object_type: ObjectType,
16078 object_handle: u64,
16079 private_data_slot: PrivateDataSlot,
16080 p_data: *mut u64,
16081);
16082#[derive(Clone)]
16083pub struct ExtPrivateDataFn {
16084 pub create_private_data_slot_ext: PFN_vkCreatePrivateDataSlot,
16085 pub destroy_private_data_slot_ext: PFN_vkDestroyPrivateDataSlot,
16086 pub set_private_data_ext: PFN_vkSetPrivateData,
16087 pub get_private_data_ext: PFN_vkGetPrivateData,
16088}
16089unsafe impl Send for ExtPrivateDataFn {}
16090unsafe impl Sync for ExtPrivateDataFn {}
16091impl ExtPrivateDataFn {
16092 pub fn load<F>(mut _f: F) -> Self
16093 where
16094 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16095 {
16096 Self {
16097 create_private_data_slot_ext: unsafe {
16098 unsafe extern "system" fn create_private_data_slot_ext(
16099 _device: Device,
16100 _p_create_info: *const PrivateDataSlotCreateInfo,
16101 _p_allocator: *const AllocationCallbacks,
16102 _p_private_data_slot: *mut PrivateDataSlot,
16103 ) -> Result {
16104 panic!(concat!(
16105 "Unable to load ",
16106 stringify!(create_private_data_slot_ext)
16107 ))
16108 }
16109 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16110 b"vkCreatePrivateDataSlotEXT\0",
16111 );
16112 let val = _f(cname);
16113 if val.is_null() {
16114 create_private_data_slot_ext
16115 } else {
16116 ::std::mem::transmute(val)
16117 }
16118 },
16119 destroy_private_data_slot_ext: unsafe {
16120 unsafe extern "system" fn destroy_private_data_slot_ext(
16121 _device: Device,
16122 _private_data_slot: PrivateDataSlot,
16123 _p_allocator: *const AllocationCallbacks,
16124 ) {
16125 panic!(concat!(
16126 "Unable to load ",
16127 stringify!(destroy_private_data_slot_ext)
16128 ))
16129 }
16130 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16131 b"vkDestroyPrivateDataSlotEXT\0",
16132 );
16133 let val = _f(cname);
16134 if val.is_null() {
16135 destroy_private_data_slot_ext
16136 } else {
16137 ::std::mem::transmute(val)
16138 }
16139 },
16140 set_private_data_ext: unsafe {
16141 unsafe extern "system" fn set_private_data_ext(
16142 _device: Device,
16143 _object_type: ObjectType,
16144 _object_handle: u64,
16145 _private_data_slot: PrivateDataSlot,
16146 _data: u64,
16147 ) -> Result {
16148 panic!(concat!("Unable to load ", stringify!(set_private_data_ext)))
16149 }
16150 let cname =
16151 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkSetPrivateDataEXT\0");
16152 let val = _f(cname);
16153 if val.is_null() {
16154 set_private_data_ext
16155 } else {
16156 ::std::mem::transmute(val)
16157 }
16158 },
16159 get_private_data_ext: unsafe {
16160 unsafe extern "system" fn get_private_data_ext(
16161 _device: Device,
16162 _object_type: ObjectType,
16163 _object_handle: u64,
16164 _private_data_slot: PrivateDataSlot,
16165 _p_data: *mut u64,
16166 ) {
16167 panic!(concat!("Unable to load ", stringify!(get_private_data_ext)))
16168 }
16169 let cname =
16170 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetPrivateDataEXT\0");
16171 let val = _f(cname);
16172 if val.is_null() {
16173 get_private_data_ext
16174 } else {
16175 ::std::mem::transmute(val)
16176 }
16177 },
16178 }
16179 }
16180}
16181#[doc = "Generated from 'VK_EXT_private_data'"]
16182impl ObjectType {
16183 pub const PRIVATE_DATA_SLOT_EXT: Self = Self::PRIVATE_DATA_SLOT;
16184}
16185#[doc = "Generated from 'VK_EXT_private_data'"]
16186impl StructureType {
16187 pub const PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: Self =
16188 Self::PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
16189 pub const DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: Self = Self::DEVICE_PRIVATE_DATA_CREATE_INFO;
16190 pub const PRIVATE_DATA_SLOT_CREATE_INFO_EXT: Self = Self::PRIVATE_DATA_SLOT_CREATE_INFO;
16191}
16192impl KhrExtension297Fn {
16193 pub const fn name() -> &'static ::std::ffi::CStr {
16194 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_297\0") }
16195 }
16196 pub const SPEC_VERSION: u32 = 0u32;
16197}
16198#[derive(Clone)]
16199pub struct KhrExtension297Fn {}
16200unsafe impl Send for KhrExtension297Fn {}
16201unsafe impl Sync for KhrExtension297Fn {}
16202impl KhrExtension297Fn {
16203 pub fn load<F>(mut _f: F) -> Self
16204 where
16205 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16206 {
16207 Self {}
16208 }
16209}
16210#[doc = "Generated from 'VK_KHR_extension_297'"]
16211impl PipelineShaderStageCreateFlags {
16212 pub const RESERVED_3_KHR: Self = Self(0b1000);
16213}
16214impl ExtPipelineCreationCacheControlFn {
16215 pub const fn name() -> &'static ::std::ffi::CStr {
16216 unsafe {
16217 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16218 b"VK_EXT_pipeline_creation_cache_control\0",
16219 )
16220 }
16221 }
16222 pub const SPEC_VERSION: u32 = 3u32;
16223}
16224#[derive(Clone)]
16225pub struct ExtPipelineCreationCacheControlFn {}
16226unsafe impl Send for ExtPipelineCreationCacheControlFn {}
16227unsafe impl Sync for ExtPipelineCreationCacheControlFn {}
16228impl ExtPipelineCreationCacheControlFn {
16229 pub fn load<F>(mut _f: F) -> Self
16230 where
16231 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16232 {
16233 Self {}
16234 }
16235}
16236#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16237impl PipelineCacheCreateFlags {
16238 pub const EXTERNALLY_SYNCHRONIZED_EXT: Self = Self::EXTERNALLY_SYNCHRONIZED;
16239}
16240#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16241impl PipelineCreateFlags {
16242 pub const FAIL_ON_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::FAIL_ON_PIPELINE_COMPILE_REQUIRED;
16243 pub const EARLY_RETURN_ON_FAILURE_EXT: Self = Self::EARLY_RETURN_ON_FAILURE;
16244}
16245#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16246impl Result {
16247 pub const PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED;
16248 pub const ERROR_PIPELINE_COMPILE_REQUIRED_EXT: Self = Self::PIPELINE_COMPILE_REQUIRED;
16249}
16250#[doc = "Generated from 'VK_EXT_pipeline_creation_cache_control'"]
16251impl StructureType {
16252 pub const PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: Self =
16253 Self::PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
16254}
16255impl KhrExtension299Fn {
16256 pub const fn name() -> &'static ::std::ffi::CStr {
16257 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_299\0") }
16258 }
16259 pub const SPEC_VERSION: u32 = 0u32;
16260}
16261#[derive(Clone)]
16262pub struct KhrExtension299Fn {}
16263unsafe impl Send for KhrExtension299Fn {}
16264unsafe impl Sync for KhrExtension299Fn {}
16265impl KhrExtension299Fn {
16266 pub fn load<F>(mut _f: F) -> Self
16267 where
16268 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16269 {
16270 Self {}
16271 }
16272}
16273#[doc = "Generated from 'VK_KHR_extension_299'"]
16274impl MemoryHeapFlags {
16275 pub const RESERVED_2_KHR: Self = Self(0b100);
16276}
16277#[doc = "Generated from 'VK_KHR_extension_299'"]
16278impl PipelineCacheCreateFlags {
16279 pub const RESERVED_1_KHR: Self = Self::RESERVED_1_EXT;
16280 pub const RESERVED_2_KHR: Self = Self(0b100);
16281}
16282impl KhrVideoEncodeQueueFn {
16283 pub const fn name() -> &'static ::std::ffi::CStr {
16284 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_video_encode_queue\0") }
16285 }
16286 pub const SPEC_VERSION: u32 = 4u32;
16287}
16288#[allow(non_camel_case_types)]
16289pub type PFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(
16290 command_buffer: CommandBuffer,
16291 p_encode_info: *const VideoEncodeInfoKHR,
16292);
16293#[derive(Clone)]
16294pub struct KhrVideoEncodeQueueFn {
16295 pub cmd_encode_video_khr: PFN_vkCmdEncodeVideoKHR,
16296}
16297unsafe impl Send for KhrVideoEncodeQueueFn {}
16298unsafe impl Sync for KhrVideoEncodeQueueFn {}
16299impl KhrVideoEncodeQueueFn {
16300 pub fn load<F>(mut _f: F) -> Self
16301 where
16302 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16303 {
16304 Self {
16305 cmd_encode_video_khr: unsafe {
16306 unsafe extern "system" fn cmd_encode_video_khr(
16307 _command_buffer: CommandBuffer,
16308 _p_encode_info: *const VideoEncodeInfoKHR,
16309 ) {
16310 panic!(concat!("Unable to load ", stringify!(cmd_encode_video_khr)))
16311 }
16312 let cname =
16313 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdEncodeVideoKHR\0");
16314 let val = _f(cname);
16315 if val.is_null() {
16316 cmd_encode_video_khr
16317 } else {
16318 ::std::mem::transmute(val)
16319 }
16320 },
16321 }
16322 }
16323}
16324#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16325impl AccessFlags2 {
16326 pub const VIDEO_ENCODE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
16327 pub const VIDEO_ENCODE_WRITE_KHR: Self =
16328 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
16329}
16330#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16331impl BufferUsageFlags {
16332 pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b1000_0000_0000_0000);
16333 pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b1_0000_0000_0000_0000);
16334}
16335#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16336impl FormatFeatureFlags {
16337 pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
16338 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
16339}
16340#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16341impl FormatFeatureFlags2 {
16342 pub const VIDEO_ENCODE_INPUT_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
16343 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
16344}
16345#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16346impl ImageLayout {
16347 pub const VIDEO_ENCODE_DST_KHR: Self = Self(1_000_299_000);
16348 pub const VIDEO_ENCODE_SRC_KHR: Self = Self(1_000_299_001);
16349 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(1_000_299_002);
16350}
16351#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16352impl ImageUsageFlags {
16353 pub const VIDEO_ENCODE_DST_KHR: Self = Self(0b10_0000_0000_0000);
16354 pub const VIDEO_ENCODE_SRC_KHR: Self = Self(0b100_0000_0000_0000);
16355 pub const VIDEO_ENCODE_DPB_KHR: Self = Self(0b1000_0000_0000_0000);
16356}
16357#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16358impl PipelineStageFlags2 {
16359 pub const VIDEO_ENCODE_KHR: Self = Self(0b1000_0000_0000_0000_0000_0000_0000);
16360}
16361#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16362impl QueryType {
16363 pub const VIDEO_ENCODESTREAM_BUFFER_RANGE_KHR: Self = Self(1_000_299_000);
16364}
16365#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16366impl QueueFlags {
16367 pub const VIDEO_ENCODE_KHR: Self = Self(0b100_0000);
16368}
16369#[doc = "Generated from 'VK_KHR_video_encode_queue'"]
16370impl StructureType {
16371 pub const VIDEO_ENCODE_INFO_KHR: Self = Self(1_000_299_000);
16372 pub const VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: Self = Self(1_000_299_001);
16373 pub const VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: Self = Self(1_000_299_002);
16374 pub const VIDEO_ENCODE_CAPABILITIES_KHR: Self = Self(1_000_299_003);
16375}
16376impl NvDeviceDiagnosticsConfigFn {
16377 pub const fn name() -> &'static ::std::ffi::CStr {
16378 unsafe {
16379 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_device_diagnostics_config\0")
16380 }
16381 }
16382 pub const SPEC_VERSION: u32 = 1u32;
16383}
16384#[derive(Clone)]
16385pub struct NvDeviceDiagnosticsConfigFn {}
16386unsafe impl Send for NvDeviceDiagnosticsConfigFn {}
16387unsafe impl Sync for NvDeviceDiagnosticsConfigFn {}
16388impl NvDeviceDiagnosticsConfigFn {
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_NV_device_diagnostics_config'"]
16397impl StructureType {
16398 pub const PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: Self = Self(1_000_300_000);
16399 pub const DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: Self = Self(1_000_300_001);
16400}
16401impl QcomRenderPassStoreOpsFn {
16402 pub const fn name() -> &'static ::std::ffi::CStr {
16403 unsafe {
16404 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_render_pass_store_ops\0")
16405 }
16406 }
16407 pub const SPEC_VERSION: u32 = 2u32;
16408}
16409#[derive(Clone)]
16410pub struct QcomRenderPassStoreOpsFn {}
16411unsafe impl Send for QcomRenderPassStoreOpsFn {}
16412unsafe impl Sync for QcomRenderPassStoreOpsFn {}
16413impl QcomRenderPassStoreOpsFn {
16414 pub fn load<F>(mut _f: F) -> Self
16415 where
16416 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16417 {
16418 Self {}
16419 }
16420}
16421#[doc = "Generated from 'VK_QCOM_render_pass_store_ops'"]
16422impl AttachmentStoreOp {
16423 pub const NONE_QCOM: Self = Self::NONE;
16424}
16425impl QcomExtension303Fn {
16426 pub const fn name() -> &'static ::std::ffi::CStr {
16427 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_303\0") }
16428 }
16429 pub const SPEC_VERSION: u32 = 0u32;
16430}
16431#[derive(Clone)]
16432pub struct QcomExtension303Fn {}
16433unsafe impl Send for QcomExtension303Fn {}
16434unsafe impl Sync for QcomExtension303Fn {}
16435impl QcomExtension303Fn {
16436 pub fn load<F>(mut _f: F) -> Self
16437 where
16438 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16439 {
16440 Self {}
16441 }
16442}
16443impl QcomExtension304Fn {
16444 pub const fn name() -> &'static ::std::ffi::CStr {
16445 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_304\0") }
16446 }
16447 pub const SPEC_VERSION: u32 = 0u32;
16448}
16449#[derive(Clone)]
16450pub struct QcomExtension304Fn {}
16451unsafe impl Send for QcomExtension304Fn {}
16452unsafe impl Sync for QcomExtension304Fn {}
16453impl QcomExtension304Fn {
16454 pub fn load<F>(mut _f: F) -> Self
16455 where
16456 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16457 {
16458 Self {}
16459 }
16460}
16461impl QcomExtension305Fn {
16462 pub const fn name() -> &'static ::std::ffi::CStr {
16463 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_305\0") }
16464 }
16465 pub const SPEC_VERSION: u32 = 0u32;
16466}
16467#[derive(Clone)]
16468pub struct QcomExtension305Fn {}
16469unsafe impl Send for QcomExtension305Fn {}
16470unsafe impl Sync for QcomExtension305Fn {}
16471impl QcomExtension305Fn {
16472 pub fn load<F>(mut _f: F) -> Self
16473 where
16474 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16475 {
16476 Self {}
16477 }
16478}
16479impl QcomExtension306Fn {
16480 pub const fn name() -> &'static ::std::ffi::CStr {
16481 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_306\0") }
16482 }
16483 pub const SPEC_VERSION: u32 = 0u32;
16484}
16485#[derive(Clone)]
16486pub struct QcomExtension306Fn {}
16487unsafe impl Send for QcomExtension306Fn {}
16488unsafe impl Sync for QcomExtension306Fn {}
16489impl QcomExtension306Fn {
16490 pub fn load<F>(mut _f: F) -> Self
16491 where
16492 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16493 {
16494 Self {}
16495 }
16496}
16497impl QcomExtension307Fn {
16498 pub const fn name() -> &'static ::std::ffi::CStr {
16499 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_307\0") }
16500 }
16501 pub const SPEC_VERSION: u32 = 0u32;
16502}
16503#[derive(Clone)]
16504pub struct QcomExtension307Fn {}
16505unsafe impl Send for QcomExtension307Fn {}
16506unsafe impl Sync for QcomExtension307Fn {}
16507impl QcomExtension307Fn {
16508 pub fn load<F>(mut _f: F) -> Self
16509 where
16510 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16511 {
16512 Self {}
16513 }
16514}
16515impl NvExtension308Fn {
16516 pub const fn name() -> &'static ::std::ffi::CStr {
16517 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_308\0") }
16518 }
16519 pub const SPEC_VERSION: u32 = 0u32;
16520}
16521#[derive(Clone)]
16522pub struct NvExtension308Fn {}
16523unsafe impl Send for NvExtension308Fn {}
16524unsafe impl Sync for NvExtension308Fn {}
16525impl NvExtension308Fn {
16526 pub fn load<F>(mut _f: F) -> Self
16527 where
16528 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16529 {
16530 Self {}
16531 }
16532}
16533impl KhrExtension309Fn {
16534 pub const fn name() -> &'static ::std::ffi::CStr {
16535 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_309\0") }
16536 }
16537 pub const SPEC_VERSION: u32 = 0u32;
16538}
16539#[derive(Clone)]
16540pub struct KhrExtension309Fn {}
16541unsafe impl Send for KhrExtension309Fn {}
16542unsafe impl Sync for KhrExtension309Fn {}
16543impl KhrExtension309Fn {
16544 pub fn load<F>(mut _f: F) -> Self
16545 where
16546 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16547 {
16548 Self {}
16549 }
16550}
16551impl QcomExtension310Fn {
16552 pub const fn name() -> &'static ::std::ffi::CStr {
16553 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_310\0") }
16554 }
16555 pub const SPEC_VERSION: u32 = 0u32;
16556}
16557#[derive(Clone)]
16558pub struct QcomExtension310Fn {}
16559unsafe impl Send for QcomExtension310Fn {}
16560unsafe impl Sync for QcomExtension310Fn {}
16561impl QcomExtension310Fn {
16562 pub fn load<F>(mut _f: F) -> Self
16563 where
16564 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16565 {
16566 Self {}
16567 }
16568}
16569#[doc = "Generated from 'VK_QCOM_extension_310'"]
16570impl StructureType {
16571 pub const RESERVED_QCOM: Self = Self(1_000_309_000);
16572}
16573impl NvExtension311Fn {
16574 pub const fn name() -> &'static ::std::ffi::CStr {
16575 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_311\0") }
16576 }
16577 pub const SPEC_VERSION: u32 = 0u32;
16578}
16579#[derive(Clone)]
16580pub struct NvExtension311Fn {}
16581unsafe impl Send for NvExtension311Fn {}
16582unsafe impl Sync for NvExtension311Fn {}
16583impl NvExtension311Fn {
16584 pub fn load<F>(mut _f: F) -> Self
16585 where
16586 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16587 {
16588 Self {}
16589 }
16590}
16591impl ExtExtension312Fn {
16592 pub const fn name() -> &'static ::std::ffi::CStr {
16593 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_312\0") }
16594 }
16595 pub const SPEC_VERSION: u32 = 0u32;
16596}
16597#[derive(Clone)]
16598pub struct ExtExtension312Fn {}
16599unsafe impl Send for ExtExtension312Fn {}
16600unsafe impl Sync for ExtExtension312Fn {}
16601impl ExtExtension312Fn {
16602 pub fn load<F>(mut _f: F) -> Self
16603 where
16604 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16605 {
16606 Self {}
16607 }
16608}
16609impl ExtExtension313Fn {
16610 pub const fn name() -> &'static ::std::ffi::CStr {
16611 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_313\0") }
16612 }
16613 pub const SPEC_VERSION: u32 = 0u32;
16614}
16615#[derive(Clone)]
16616pub struct ExtExtension313Fn {}
16617unsafe impl Send for ExtExtension313Fn {}
16618unsafe impl Sync for ExtExtension313Fn {}
16619impl ExtExtension313Fn {
16620 pub fn load<F>(mut _f: F) -> Self
16621 where
16622 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16623 {
16624 Self {}
16625 }
16626}
16627impl AmdExtension314Fn {
16628 pub const fn name() -> &'static ::std::ffi::CStr {
16629 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_314\0") }
16630 }
16631 pub const SPEC_VERSION: u32 = 0u32;
16632}
16633#[derive(Clone)]
16634pub struct AmdExtension314Fn {}
16635unsafe impl Send for AmdExtension314Fn {}
16636unsafe impl Sync for AmdExtension314Fn {}
16637impl AmdExtension314Fn {
16638 pub fn load<F>(mut _f: F) -> Self
16639 where
16640 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16641 {
16642 Self {}
16643 }
16644}
16645impl KhrSynchronization2Fn {
16646 pub const fn name() -> &'static ::std::ffi::CStr {
16647 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_synchronization2\0") }
16648 }
16649 pub const SPEC_VERSION: u32 = 1u32;
16650}
16651#[allow(non_camel_case_types)]
16652pub type PFN_vkCmdSetEvent2 = unsafe extern "system" fn(
16653 command_buffer: CommandBuffer,
16654 event: Event,
16655 p_dependency_info: *const DependencyInfo,
16656);
16657#[allow(non_camel_case_types)]
16658pub type PFN_vkCmdResetEvent2 = unsafe extern "system" fn(
16659 command_buffer: CommandBuffer,
16660 event: Event,
16661 stage_mask: PipelineStageFlags2,
16662);
16663#[allow(non_camel_case_types)]
16664pub type PFN_vkCmdWaitEvents2 = unsafe extern "system" fn(
16665 command_buffer: CommandBuffer,
16666 event_count: u32,
16667 p_events: *const Event,
16668 p_dependency_infos: *const DependencyInfo,
16669);
16670#[allow(non_camel_case_types)]
16671pub type PFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn(
16672 command_buffer: CommandBuffer,
16673 p_dependency_info: *const DependencyInfo,
16674);
16675#[allow(non_camel_case_types)]
16676pub type PFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn(
16677 command_buffer: CommandBuffer,
16678 stage: PipelineStageFlags2,
16679 query_pool: QueryPool,
16680 query: u32,
16681);
16682#[allow(non_camel_case_types)]
16683pub type PFN_vkQueueSubmit2 = unsafe extern "system" fn(
16684 queue: Queue,
16685 submit_count: u32,
16686 p_submits: *const SubmitInfo2,
16687 fence: Fence,
16688) -> Result;
16689#[allow(non_camel_case_types)]
16690pub type PFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn(
16691 command_buffer: CommandBuffer,
16692 stage: PipelineStageFlags2,
16693 dst_buffer: Buffer,
16694 dst_offset: DeviceSize,
16695 marker: u32,
16696);
16697#[allow(non_camel_case_types)]
16698pub type PFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn(
16699 queue: Queue,
16700 p_checkpoint_data_count: *mut u32,
16701 p_checkpoint_data: *mut CheckpointData2NV,
16702);
16703#[derive(Clone)]
16704pub struct KhrSynchronization2Fn {
16705 pub cmd_set_event2_khr: PFN_vkCmdSetEvent2,
16706 pub cmd_reset_event2_khr: PFN_vkCmdResetEvent2,
16707 pub cmd_wait_events2_khr: PFN_vkCmdWaitEvents2,
16708 pub cmd_pipeline_barrier2_khr: PFN_vkCmdPipelineBarrier2,
16709 pub cmd_write_timestamp2_khr: PFN_vkCmdWriteTimestamp2,
16710 pub queue_submit2_khr: PFN_vkQueueSubmit2,
16711 pub cmd_write_buffer_marker2_amd: PFN_vkCmdWriteBufferMarker2AMD,
16712 pub get_queue_checkpoint_data2_nv: PFN_vkGetQueueCheckpointData2NV,
16713}
16714unsafe impl Send for KhrSynchronization2Fn {}
16715unsafe impl Sync for KhrSynchronization2Fn {}
16716impl KhrSynchronization2Fn {
16717 pub fn load<F>(mut _f: F) -> Self
16718 where
16719 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16720 {
16721 Self {
16722 cmd_set_event2_khr: unsafe {
16723 unsafe extern "system" fn cmd_set_event2_khr(
16724 _command_buffer: CommandBuffer,
16725 _event: Event,
16726 _p_dependency_info: *const DependencyInfo,
16727 ) {
16728 panic!(concat!("Unable to load ", stringify!(cmd_set_event2_khr)))
16729 }
16730 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetEvent2KHR\0");
16731 let val = _f(cname);
16732 if val.is_null() {
16733 cmd_set_event2_khr
16734 } else {
16735 ::std::mem::transmute(val)
16736 }
16737 },
16738 cmd_reset_event2_khr: unsafe {
16739 unsafe extern "system" fn cmd_reset_event2_khr(
16740 _command_buffer: CommandBuffer,
16741 _event: Event,
16742 _stage_mask: PipelineStageFlags2,
16743 ) {
16744 panic!(concat!("Unable to load ", stringify!(cmd_reset_event2_khr)))
16745 }
16746 let cname =
16747 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResetEvent2KHR\0");
16748 let val = _f(cname);
16749 if val.is_null() {
16750 cmd_reset_event2_khr
16751 } else {
16752 ::std::mem::transmute(val)
16753 }
16754 },
16755 cmd_wait_events2_khr: unsafe {
16756 unsafe extern "system" fn cmd_wait_events2_khr(
16757 _command_buffer: CommandBuffer,
16758 _event_count: u32,
16759 _p_events: *const Event,
16760 _p_dependency_infos: *const DependencyInfo,
16761 ) {
16762 panic!(concat!("Unable to load ", stringify!(cmd_wait_events2_khr)))
16763 }
16764 let cname =
16765 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWaitEvents2KHR\0");
16766 let val = _f(cname);
16767 if val.is_null() {
16768 cmd_wait_events2_khr
16769 } else {
16770 ::std::mem::transmute(val)
16771 }
16772 },
16773 cmd_pipeline_barrier2_khr: unsafe {
16774 unsafe extern "system" fn cmd_pipeline_barrier2_khr(
16775 _command_buffer: CommandBuffer,
16776 _p_dependency_info: *const DependencyInfo,
16777 ) {
16778 panic!(concat!(
16779 "Unable to load ",
16780 stringify!(cmd_pipeline_barrier2_khr)
16781 ))
16782 }
16783 let cname =
16784 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdPipelineBarrier2KHR\0");
16785 let val = _f(cname);
16786 if val.is_null() {
16787 cmd_pipeline_barrier2_khr
16788 } else {
16789 ::std::mem::transmute(val)
16790 }
16791 },
16792 cmd_write_timestamp2_khr: unsafe {
16793 unsafe extern "system" fn cmd_write_timestamp2_khr(
16794 _command_buffer: CommandBuffer,
16795 _stage: PipelineStageFlags2,
16796 _query_pool: QueryPool,
16797 _query: u32,
16798 ) {
16799 panic!(concat!(
16800 "Unable to load ",
16801 stringify!(cmd_write_timestamp2_khr)
16802 ))
16803 }
16804 let cname =
16805 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdWriteTimestamp2KHR\0");
16806 let val = _f(cname);
16807 if val.is_null() {
16808 cmd_write_timestamp2_khr
16809 } else {
16810 ::std::mem::transmute(val)
16811 }
16812 },
16813 queue_submit2_khr: unsafe {
16814 unsafe extern "system" fn queue_submit2_khr(
16815 _queue: Queue,
16816 _submit_count: u32,
16817 _p_submits: *const SubmitInfo2,
16818 _fence: Fence,
16819 ) -> Result {
16820 panic!(concat!("Unable to load ", stringify!(queue_submit2_khr)))
16821 }
16822 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkQueueSubmit2KHR\0");
16823 let val = _f(cname);
16824 if val.is_null() {
16825 queue_submit2_khr
16826 } else {
16827 ::std::mem::transmute(val)
16828 }
16829 },
16830 cmd_write_buffer_marker2_amd: unsafe {
16831 unsafe extern "system" fn cmd_write_buffer_marker2_amd(
16832 _command_buffer: CommandBuffer,
16833 _stage: PipelineStageFlags2,
16834 _dst_buffer: Buffer,
16835 _dst_offset: DeviceSize,
16836 _marker: u32,
16837 ) {
16838 panic!(concat!(
16839 "Unable to load ",
16840 stringify!(cmd_write_buffer_marker2_amd)
16841 ))
16842 }
16843 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16844 b"vkCmdWriteBufferMarker2AMD\0",
16845 );
16846 let val = _f(cname);
16847 if val.is_null() {
16848 cmd_write_buffer_marker2_amd
16849 } else {
16850 ::std::mem::transmute(val)
16851 }
16852 },
16853 get_queue_checkpoint_data2_nv: unsafe {
16854 unsafe extern "system" fn get_queue_checkpoint_data2_nv(
16855 _queue: Queue,
16856 _p_checkpoint_data_count: *mut u32,
16857 _p_checkpoint_data: *mut CheckpointData2NV,
16858 ) {
16859 panic!(concat!(
16860 "Unable to load ",
16861 stringify!(get_queue_checkpoint_data2_nv)
16862 ))
16863 }
16864 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
16865 b"vkGetQueueCheckpointData2NV\0",
16866 );
16867 let val = _f(cname);
16868 if val.is_null() {
16869 get_queue_checkpoint_data2_nv
16870 } else {
16871 ::std::mem::transmute(val)
16872 }
16873 },
16874 }
16875 }
16876}
16877#[doc = "Generated from 'VK_KHR_synchronization2'"]
16878impl AccessFlags {
16879 pub const NONE_KHR: Self = Self::NONE;
16880}
16881#[doc = "Generated from 'VK_KHR_synchronization2'"]
16882impl AccessFlags2 {
16883 pub const TRANSFORM_FEEDBACK_WRITE_EXT: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
16884 pub const TRANSFORM_FEEDBACK_COUNTER_READ_EXT: Self = Self(0b100_0000_0000_0000_0000_0000_0000);
16885 pub const TRANSFORM_FEEDBACK_COUNTER_WRITE_EXT: Self =
16886 Self(0b1000_0000_0000_0000_0000_0000_0000);
16887 #[doc = "read access flag for reading conditional rendering predicate"]
16888 pub const CONDITIONAL_RENDERING_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000);
16889 pub const COMMAND_PREPROCESS_READ_NV: Self = Self(0b10_0000_0000_0000_0000);
16890 pub const COMMAND_PREPROCESS_WRITE_NV: Self = Self(0b100_0000_0000_0000_0000);
16891 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR: Self =
16892 Self(0b1000_0000_0000_0000_0000_0000);
16893 pub const SHADING_RATE_IMAGE_READ_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_READ_KHR;
16894 pub const ACCELERATION_STRUCTURE_READ_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
16895 pub const ACCELERATION_STRUCTURE_WRITE_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
16896 pub const ACCELERATION_STRUCTURE_READ_NV: Self = Self::ACCELERATION_STRUCTURE_READ_KHR;
16897 pub const ACCELERATION_STRUCTURE_WRITE_NV: Self = Self::ACCELERATION_STRUCTURE_WRITE_KHR;
16898 pub const FRAGMENT_DENSITY_MAP_READ_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
16899 pub const COLOR_ATTACHMENT_READ_NONCOHERENT_EXT: Self = Self(0b1000_0000_0000_0000_0000);
16900}
16901#[doc = "Generated from 'VK_KHR_synchronization2'"]
16902impl EventCreateFlags {
16903 pub const DEVICE_ONLY_KHR: Self = Self::DEVICE_ONLY;
16904}
16905#[doc = "Generated from 'VK_KHR_synchronization2'"]
16906impl ImageLayout {
16907 pub const READ_ONLY_OPTIMAL_KHR: Self = Self::READ_ONLY_OPTIMAL;
16908 pub const ATTACHMENT_OPTIMAL_KHR: Self = Self::ATTACHMENT_OPTIMAL;
16909}
16910#[doc = "Generated from 'VK_KHR_synchronization2'"]
16911impl PipelineStageFlags {
16912 pub const NONE_KHR: Self = Self::NONE;
16913}
16914#[doc = "Generated from 'VK_KHR_synchronization2'"]
16915impl PipelineStageFlags2 {
16916 pub const TRANSFORM_FEEDBACK_EXT: Self = Self(0b1_0000_0000_0000_0000_0000_0000);
16917 #[doc = "A pipeline stage for conditional rendering predicate fetch"]
16918 pub const CONDITIONAL_RENDERING_EXT: Self = Self(0b100_0000_0000_0000_0000);
16919 pub const COMMAND_PREPROCESS_NV: Self = Self(0b10_0000_0000_0000_0000);
16920 pub const FRAGMENT_SHADING_RATE_ATTACHMENT_KHR: Self = Self(0b100_0000_0000_0000_0000_0000);
16921 pub const SHADING_RATE_IMAGE_NV: Self = Self::FRAGMENT_SHADING_RATE_ATTACHMENT_KHR;
16922 pub const ACCELERATION_STRUCTURE_BUILD_KHR: Self = Self(0b10_0000_0000_0000_0000_0000_0000);
16923 pub const RAY_TRACING_SHADER_KHR: Self = Self(0b10_0000_0000_0000_0000_0000);
16924 pub const RAY_TRACING_SHADER_NV: Self = Self::RAY_TRACING_SHADER_KHR;
16925 pub const ACCELERATION_STRUCTURE_BUILD_NV: Self = Self::ACCELERATION_STRUCTURE_BUILD_KHR;
16926 pub const FRAGMENT_DENSITY_PROCESS_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000);
16927 pub const TASK_SHADER_NV: Self = Self(0b1000_0000_0000_0000_0000);
16928 pub const MESH_SHADER_NV: Self = Self(0b1_0000_0000_0000_0000_0000);
16929}
16930#[doc = "Generated from 'VK_KHR_synchronization2'"]
16931impl StructureType {
16932 pub const MEMORY_BARRIER_2_KHR: Self = Self::MEMORY_BARRIER_2;
16933 pub const BUFFER_MEMORY_BARRIER_2_KHR: Self = Self::BUFFER_MEMORY_BARRIER_2;
16934 pub const IMAGE_MEMORY_BARRIER_2_KHR: Self = Self::IMAGE_MEMORY_BARRIER_2;
16935 pub const DEPENDENCY_INFO_KHR: Self = Self::DEPENDENCY_INFO;
16936 pub const SUBMIT_INFO_2_KHR: Self = Self::SUBMIT_INFO_2;
16937 pub const SEMAPHORE_SUBMIT_INFO_KHR: Self = Self::SEMAPHORE_SUBMIT_INFO;
16938 pub const COMMAND_BUFFER_SUBMIT_INFO_KHR: Self = Self::COMMAND_BUFFER_SUBMIT_INFO;
16939 pub const PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: Self =
16940 Self::PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
16941 pub const QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: Self = Self(1_000_314_008);
16942 pub const CHECKPOINT_DATA_2_NV: Self = Self(1_000_314_009);
16943}
16944impl AmdExtension316Fn {
16945 pub const fn name() -> &'static ::std::ffi::CStr {
16946 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_316\0") }
16947 }
16948 pub const SPEC_VERSION: u32 = 0u32;
16949}
16950#[derive(Clone)]
16951pub struct AmdExtension316Fn {}
16952unsafe impl Send for AmdExtension316Fn {}
16953unsafe impl Sync for AmdExtension316Fn {}
16954impl AmdExtension316Fn {
16955 pub fn load<F>(mut _f: F) -> Self
16956 where
16957 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16958 {
16959 Self {}
16960 }
16961}
16962impl AmdExtension317Fn {
16963 pub const fn name() -> &'static ::std::ffi::CStr {
16964 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_317\0") }
16965 }
16966 pub const SPEC_VERSION: u32 = 0u32;
16967}
16968#[derive(Clone)]
16969pub struct AmdExtension317Fn {}
16970unsafe impl Send for AmdExtension317Fn {}
16971unsafe impl Sync for AmdExtension317Fn {}
16972impl AmdExtension317Fn {
16973 pub fn load<F>(mut _f: F) -> Self
16974 where
16975 F: FnMut(&::std::ffi::CStr) -> *const c_void,
16976 {
16977 Self {}
16978 }
16979}
16980#[doc = "Generated from 'VK_AMD_extension_317'"]
16981impl AccessFlags2 {
16982 pub const RESERVED_41_AMD: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
16983}
16984#[doc = "Generated from 'VK_AMD_extension_317'"]
16985impl BufferCreateFlags {
16986 pub const RESERVED_5_AMD: Self = Self(0b10_0000);
16987}
16988#[doc = "Generated from 'VK_AMD_extension_317'"]
16989impl BufferUsageFlags {
16990 pub const RESERVED_21_AMD: Self = Self(0b10_0000_0000_0000_0000_0000);
16991 pub const RESERVED_22_AMD: Self = Self(0b100_0000_0000_0000_0000_0000);
16992}
16993#[doc = "Generated from 'VK_AMD_extension_317'"]
16994impl DescriptorSetLayoutCreateFlags {
16995 pub const RESERVED_4_AMD: Self = Self(0b1_0000);
16996}
16997#[doc = "Generated from 'VK_AMD_extension_317'"]
16998impl ImageCreateFlags {
16999 pub const RESERVED_16_AMD: Self = Self(0b1_0000_0000_0000_0000);
17000}
17001#[doc = "Generated from 'VK_AMD_extension_317'"]
17002impl ImageViewCreateFlags {
17003 pub const RESERVED_2_AMD: Self = Self(0b100);
17004}
17005#[doc = "Generated from 'VK_AMD_extension_317'"]
17006impl SamplerCreateFlags {
17007 pub const RESERVED_3_AMD: Self = Self(0b1000);
17008}
17009impl AmdExtension318Fn {
17010 pub const fn name() -> &'static ::std::ffi::CStr {
17011 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_318\0") }
17012 }
17013 pub const SPEC_VERSION: u32 = 0u32;
17014}
17015#[derive(Clone)]
17016pub struct AmdExtension318Fn {}
17017unsafe impl Send for AmdExtension318Fn {}
17018unsafe impl Sync for AmdExtension318Fn {}
17019impl AmdExtension318Fn {
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 AmdExtension319Fn {
17028 pub const fn name() -> &'static ::std::ffi::CStr {
17029 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_319\0") }
17030 }
17031 pub const SPEC_VERSION: u32 = 0u32;
17032}
17033#[derive(Clone)]
17034pub struct AmdExtension319Fn {}
17035unsafe impl Send for AmdExtension319Fn {}
17036unsafe impl Sync for AmdExtension319Fn {}
17037impl AmdExtension319Fn {
17038 pub fn load<F>(mut _f: F) -> Self
17039 where
17040 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17041 {
17042 Self {}
17043 }
17044}
17045#[doc = "Generated from 'VK_AMD_extension_319'"]
17046impl DescriptorSetLayoutCreateFlags {
17047 pub const RESERVED_3_AMD: Self = Self(0b1000);
17048}
17049#[doc = "Generated from 'VK_AMD_extension_319'"]
17050impl PipelineLayoutCreateFlags {
17051 pub const RESERVED_0_AMD: Self = Self(0b1);
17052}
17053impl AmdExtension320Fn {
17054 pub const fn name() -> &'static ::std::ffi::CStr {
17055 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_320\0") }
17056 }
17057 pub const SPEC_VERSION: u32 = 0u32;
17058}
17059#[derive(Clone)]
17060pub struct AmdExtension320Fn {}
17061unsafe impl Send for AmdExtension320Fn {}
17062unsafe impl Sync for AmdExtension320Fn {}
17063impl AmdExtension320Fn {
17064 pub fn load<F>(mut _f: F) -> Self
17065 where
17066 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17067 {
17068 Self {}
17069 }
17070}
17071impl AmdExtension321Fn {
17072 pub const fn name() -> &'static ::std::ffi::CStr {
17073 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_321\0") }
17074 }
17075 pub const SPEC_VERSION: u32 = 0u32;
17076}
17077#[derive(Clone)]
17078pub struct AmdExtension321Fn {}
17079unsafe impl Send for AmdExtension321Fn {}
17080unsafe impl Sync for AmdExtension321Fn {}
17081impl AmdExtension321Fn {
17082 pub fn load<F>(mut _f: F) -> Self
17083 where
17084 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17085 {
17086 Self {}
17087 }
17088}
17089#[doc = "Generated from 'VK_AMD_extension_321'"]
17090impl PipelineCreateFlags {
17091 pub const RESERVED_23_AMD: Self = Self(0b1000_0000_0000_0000_0000_0000);
17092 pub const RESERVED_10_AMD: Self = Self(0b100_0000_0000);
17093}
17094#[doc = "Generated from 'VK_AMD_extension_321'"]
17095impl PipelineLayoutCreateFlags {
17096 pub const RESERVED_1_AMD: Self = Self(0b10);
17097}
17098impl AmdExtension322Fn {
17099 pub const fn name() -> &'static ::std::ffi::CStr {
17100 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_322\0") }
17101 }
17102 pub const SPEC_VERSION: u32 = 0u32;
17103}
17104#[derive(Clone)]
17105pub struct AmdExtension322Fn {}
17106unsafe impl Send for AmdExtension322Fn {}
17107unsafe impl Sync for AmdExtension322Fn {}
17108impl AmdExtension322Fn {
17109 pub fn load<F>(mut _f: F) -> Self
17110 where
17111 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17112 {
17113 Self {}
17114 }
17115}
17116impl AmdExtension323Fn {
17117 pub const fn name() -> &'static ::std::ffi::CStr {
17118 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_AMD_extension_323\0") }
17119 }
17120 pub const SPEC_VERSION: u32 = 0u32;
17121}
17122#[derive(Clone)]
17123pub struct AmdExtension323Fn {}
17124unsafe impl Send for AmdExtension323Fn {}
17125unsafe impl Sync for AmdExtension323Fn {}
17126impl AmdExtension323Fn {
17127 pub fn load<F>(mut _f: F) -> Self
17128 where
17129 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17130 {
17131 Self {}
17132 }
17133}
17134impl KhrShaderSubgroupUniformControlFlowFn {
17135 pub const fn name() -> &'static ::std::ffi::CStr {
17136 unsafe {
17137 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17138 b"VK_KHR_shader_subgroup_uniform_control_flow\0",
17139 )
17140 }
17141 }
17142 pub const SPEC_VERSION: u32 = 1u32;
17143}
17144#[derive(Clone)]
17145pub struct KhrShaderSubgroupUniformControlFlowFn {}
17146unsafe impl Send for KhrShaderSubgroupUniformControlFlowFn {}
17147unsafe impl Sync for KhrShaderSubgroupUniformControlFlowFn {}
17148impl KhrShaderSubgroupUniformControlFlowFn {
17149 pub fn load<F>(mut _f: F) -> Self
17150 where
17151 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17152 {
17153 Self {}
17154 }
17155}
17156#[doc = "Generated from 'VK_KHR_shader_subgroup_uniform_control_flow'"]
17157impl StructureType {
17158 pub const PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: Self =
17159 Self(1_000_323_000);
17160}
17161impl KhrExtension325Fn {
17162 pub const fn name() -> &'static ::std::ffi::CStr {
17163 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_325\0") }
17164 }
17165 pub const SPEC_VERSION: u32 = 0u32;
17166}
17167#[derive(Clone)]
17168pub struct KhrExtension325Fn {}
17169unsafe impl Send for KhrExtension325Fn {}
17170unsafe impl Sync for KhrExtension325Fn {}
17171impl KhrExtension325Fn {
17172 pub fn load<F>(mut _f: F) -> Self
17173 where
17174 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17175 {
17176 Self {}
17177 }
17178}
17179impl KhrZeroInitializeWorkgroupMemoryFn {
17180 pub const fn name() -> &'static ::std::ffi::CStr {
17181 unsafe {
17182 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17183 b"VK_KHR_zero_initialize_workgroup_memory\0",
17184 )
17185 }
17186 }
17187 pub const SPEC_VERSION: u32 = 1u32;
17188}
17189#[derive(Clone)]
17190pub struct KhrZeroInitializeWorkgroupMemoryFn {}
17191unsafe impl Send for KhrZeroInitializeWorkgroupMemoryFn {}
17192unsafe impl Sync for KhrZeroInitializeWorkgroupMemoryFn {}
17193impl KhrZeroInitializeWorkgroupMemoryFn {
17194 pub fn load<F>(mut _f: F) -> Self
17195 where
17196 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17197 {
17198 Self {}
17199 }
17200}
17201#[doc = "Generated from 'VK_KHR_zero_initialize_workgroup_memory'"]
17202impl StructureType {
17203 pub const PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: Self =
17204 Self::PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
17205}
17206impl NvFragmentShadingRateEnumsFn {
17207 pub const fn name() -> &'static ::std::ffi::CStr {
17208 unsafe {
17209 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_fragment_shading_rate_enums\0")
17210 }
17211 }
17212 pub const SPEC_VERSION: u32 = 1u32;
17213}
17214#[allow(non_camel_case_types)]
17215pub type PFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn(
17216 command_buffer: CommandBuffer,
17217 shading_rate: FragmentShadingRateNV,
17218 combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
17219);
17220#[derive(Clone)]
17221pub struct NvFragmentShadingRateEnumsFn {
17222 pub cmd_set_fragment_shading_rate_enum_nv: PFN_vkCmdSetFragmentShadingRateEnumNV,
17223}
17224unsafe impl Send for NvFragmentShadingRateEnumsFn {}
17225unsafe impl Sync for NvFragmentShadingRateEnumsFn {}
17226impl NvFragmentShadingRateEnumsFn {
17227 pub fn load<F>(mut _f: F) -> Self
17228 where
17229 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17230 {
17231 Self {
17232 cmd_set_fragment_shading_rate_enum_nv: unsafe {
17233 unsafe extern "system" fn cmd_set_fragment_shading_rate_enum_nv(
17234 _command_buffer: CommandBuffer,
17235 _shading_rate: FragmentShadingRateNV,
17236 _combiner_ops: *const [FragmentShadingRateCombinerOpKHR; 2],
17237 ) {
17238 panic!(concat!(
17239 "Unable to load ",
17240 stringify!(cmd_set_fragment_shading_rate_enum_nv)
17241 ))
17242 }
17243 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17244 b"vkCmdSetFragmentShadingRateEnumNV\0",
17245 );
17246 let val = _f(cname);
17247 if val.is_null() {
17248 cmd_set_fragment_shading_rate_enum_nv
17249 } else {
17250 ::std::mem::transmute(val)
17251 }
17252 },
17253 }
17254 }
17255}
17256#[doc = "Generated from 'VK_NV_fragment_shading_rate_enums'"]
17257impl StructureType {
17258 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: Self = Self(1_000_326_000);
17259 pub const PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: Self = Self(1_000_326_001);
17260 pub const PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: Self = Self(1_000_326_002);
17261}
17262impl NvRayTracingMotionBlurFn {
17263 pub const fn name() -> &'static ::std::ffi::CStr {
17264 unsafe {
17265 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_ray_tracing_motion_blur\0")
17266 }
17267 }
17268 pub const SPEC_VERSION: u32 = 1u32;
17269}
17270#[derive(Clone)]
17271pub struct NvRayTracingMotionBlurFn {}
17272unsafe impl Send for NvRayTracingMotionBlurFn {}
17273unsafe impl Sync for NvRayTracingMotionBlurFn {}
17274impl NvRayTracingMotionBlurFn {
17275 pub fn load<F>(mut _f: F) -> Self
17276 where
17277 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17278 {
17279 Self {}
17280 }
17281}
17282#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
17283impl AccelerationStructureCreateFlagsKHR {
17284 pub const MOTION_NV: Self = Self(0b100);
17285}
17286#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
17287impl BuildAccelerationStructureFlagsKHR {
17288 pub const MOTION_NV: Self = Self(0b10_0000);
17289}
17290#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
17291impl PipelineCreateFlags {
17292 pub const RAY_TRACING_ALLOW_MOTION_NV: Self = Self(0b1_0000_0000_0000_0000_0000);
17293}
17294#[doc = "Generated from 'VK_NV_ray_tracing_motion_blur'"]
17295impl StructureType {
17296 pub const ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: Self = Self(1_000_327_000);
17297 pub const PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: Self = Self(1_000_327_001);
17298 pub const ACCELERATION_STRUCTURE_MOTION_INFO_NV: Self = Self(1_000_327_002);
17299}
17300impl NvExtension329Fn {
17301 pub const fn name() -> &'static ::std::ffi::CStr {
17302 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_329\0") }
17303 }
17304 pub const SPEC_VERSION: u32 = 0u32;
17305}
17306#[derive(Clone)]
17307pub struct NvExtension329Fn {}
17308unsafe impl Send for NvExtension329Fn {}
17309unsafe impl Sync for NvExtension329Fn {}
17310impl NvExtension329Fn {
17311 pub fn load<F>(mut _f: F) -> Self
17312 where
17313 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17314 {
17315 Self {}
17316 }
17317}
17318impl NvExtension330Fn {
17319 pub const fn name() -> &'static ::std::ffi::CStr {
17320 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_330\0") }
17321 }
17322 pub const SPEC_VERSION: u32 = 0u32;
17323}
17324#[derive(Clone)]
17325pub struct NvExtension330Fn {}
17326unsafe impl Send for NvExtension330Fn {}
17327unsafe impl Sync for NvExtension330Fn {}
17328impl NvExtension330Fn {
17329 pub fn load<F>(mut _f: F) -> Self
17330 where
17331 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17332 {
17333 Self {}
17334 }
17335}
17336impl ExtYcbcr2plane444FormatsFn {
17337 pub const fn name() -> &'static ::std::ffi::CStr {
17338 unsafe {
17339 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_ycbcr_2plane_444_formats\0")
17340 }
17341 }
17342 pub const SPEC_VERSION: u32 = 1u32;
17343}
17344#[derive(Clone)]
17345pub struct ExtYcbcr2plane444FormatsFn {}
17346unsafe impl Send for ExtYcbcr2plane444FormatsFn {}
17347unsafe impl Sync for ExtYcbcr2plane444FormatsFn {}
17348impl ExtYcbcr2plane444FormatsFn {
17349 pub fn load<F>(mut _f: F) -> Self
17350 where
17351 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17352 {
17353 Self {}
17354 }
17355}
17356#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
17357impl Format {
17358 pub const G8_B8R8_2PLANE_444_UNORM_EXT: Self = Self::G8_B8R8_2PLANE_444_UNORM;
17359 pub const G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: Self =
17360 Self::G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16;
17361 pub const G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: Self =
17362 Self::G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16;
17363 pub const G16_B16R16_2PLANE_444_UNORM_EXT: Self = Self::G16_B16R16_2PLANE_444_UNORM;
17364}
17365#[doc = "Generated from 'VK_EXT_ycbcr_2plane_444_formats'"]
17366impl StructureType {
17367 pub const PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: Self = Self(1_000_330_000);
17368}
17369impl NvExtension332Fn {
17370 pub const fn name() -> &'static ::std::ffi::CStr {
17371 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_332\0") }
17372 }
17373 pub const SPEC_VERSION: u32 = 0u32;
17374}
17375#[derive(Clone)]
17376pub struct NvExtension332Fn {}
17377unsafe impl Send for NvExtension332Fn {}
17378unsafe impl Sync for NvExtension332Fn {}
17379impl NvExtension332Fn {
17380 pub fn load<F>(mut _f: F) -> Self
17381 where
17382 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17383 {
17384 Self {}
17385 }
17386}
17387impl ExtFragmentDensityMap2Fn {
17388 pub const fn name() -> &'static ::std::ffi::CStr {
17389 unsafe {
17390 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_fragment_density_map2\0")
17391 }
17392 }
17393 pub const SPEC_VERSION: u32 = 1u32;
17394}
17395#[derive(Clone)]
17396pub struct ExtFragmentDensityMap2Fn {}
17397unsafe impl Send for ExtFragmentDensityMap2Fn {}
17398unsafe impl Sync for ExtFragmentDensityMap2Fn {}
17399impl ExtFragmentDensityMap2Fn {
17400 pub fn load<F>(mut _f: F) -> Self
17401 where
17402 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17403 {
17404 Self {}
17405 }
17406}
17407#[doc = "Generated from 'VK_EXT_fragment_density_map2'"]
17408impl ImageViewCreateFlags {
17409 pub const FRAGMENT_DENSITY_MAP_DEFERRED_EXT: Self = Self(0b10);
17410}
17411#[doc = "Generated from 'VK_EXT_fragment_density_map2'"]
17412impl StructureType {
17413 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: Self = Self(1_000_332_000);
17414 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: Self = Self(1_000_332_001);
17415}
17416impl QcomRotatedCopyCommandsFn {
17417 pub const fn name() -> &'static ::std::ffi::CStr {
17418 unsafe {
17419 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_rotated_copy_commands\0")
17420 }
17421 }
17422 pub const SPEC_VERSION: u32 = 1u32;
17423}
17424#[derive(Clone)]
17425pub struct QcomRotatedCopyCommandsFn {}
17426unsafe impl Send for QcomRotatedCopyCommandsFn {}
17427unsafe impl Sync for QcomRotatedCopyCommandsFn {}
17428impl QcomRotatedCopyCommandsFn {
17429 pub fn load<F>(mut _f: F) -> Self
17430 where
17431 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17432 {
17433 Self {}
17434 }
17435}
17436#[doc = "Generated from 'VK_QCOM_rotated_copy_commands'"]
17437impl StructureType {
17438 pub const COPY_COMMAND_TRANSFORM_INFO_QCOM: Self = Self(1_000_333_000);
17439}
17440impl KhrExtension335Fn {
17441 pub const fn name() -> &'static ::std::ffi::CStr {
17442 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_335\0") }
17443 }
17444 pub const SPEC_VERSION: u32 = 0u32;
17445}
17446#[derive(Clone)]
17447pub struct KhrExtension335Fn {}
17448unsafe impl Send for KhrExtension335Fn {}
17449unsafe impl Sync for KhrExtension335Fn {}
17450impl KhrExtension335Fn {
17451 pub fn load<F>(mut _f: F) -> Self
17452 where
17453 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17454 {
17455 Self {}
17456 }
17457}
17458impl ExtImageRobustnessFn {
17459 pub const fn name() -> &'static ::std::ffi::CStr {
17460 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_robustness\0") }
17461 }
17462 pub const SPEC_VERSION: u32 = 1u32;
17463}
17464#[derive(Clone)]
17465pub struct ExtImageRobustnessFn {}
17466unsafe impl Send for ExtImageRobustnessFn {}
17467unsafe impl Sync for ExtImageRobustnessFn {}
17468impl ExtImageRobustnessFn {
17469 pub fn load<F>(mut _f: F) -> Self
17470 where
17471 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17472 {
17473 Self {}
17474 }
17475}
17476#[doc = "Generated from 'VK_EXT_image_robustness'"]
17477impl StructureType {
17478 pub const PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: Self =
17479 Self::PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
17480}
17481impl KhrWorkgroupMemoryExplicitLayoutFn {
17482 pub const fn name() -> &'static ::std::ffi::CStr {
17483 unsafe {
17484 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17485 b"VK_KHR_workgroup_memory_explicit_layout\0",
17486 )
17487 }
17488 }
17489 pub const SPEC_VERSION: u32 = 1u32;
17490}
17491#[derive(Clone)]
17492pub struct KhrWorkgroupMemoryExplicitLayoutFn {}
17493unsafe impl Send for KhrWorkgroupMemoryExplicitLayoutFn {}
17494unsafe impl Sync for KhrWorkgroupMemoryExplicitLayoutFn {}
17495impl KhrWorkgroupMemoryExplicitLayoutFn {
17496 pub fn load<F>(mut _f: F) -> Self
17497 where
17498 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17499 {
17500 Self {}
17501 }
17502}
17503#[doc = "Generated from 'VK_KHR_workgroup_memory_explicit_layout'"]
17504impl StructureType {
17505 pub const PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: Self =
17506 Self(1_000_336_000);
17507}
17508impl KhrCopyCommands2Fn {
17509 pub const fn name() -> &'static ::std::ffi::CStr {
17510 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_copy_commands2\0") }
17511 }
17512 pub const SPEC_VERSION: u32 = 1u32;
17513}
17514#[allow(non_camel_case_types)]
17515pub type PFN_vkCmdCopyBuffer2 = unsafe extern "system" fn(
17516 command_buffer: CommandBuffer,
17517 p_copy_buffer_info: *const CopyBufferInfo2,
17518);
17519#[allow(non_camel_case_types)]
17520pub type PFN_vkCmdCopyImage2 = unsafe extern "system" fn(
17521 command_buffer: CommandBuffer,
17522 p_copy_image_info: *const CopyImageInfo2,
17523);
17524#[allow(non_camel_case_types)]
17525pub type PFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn(
17526 command_buffer: CommandBuffer,
17527 p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
17528);
17529#[allow(non_camel_case_types)]
17530pub type PFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn(
17531 command_buffer: CommandBuffer,
17532 p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
17533);
17534#[allow(non_camel_case_types)]
17535pub type PFN_vkCmdBlitImage2 = unsafe extern "system" fn(
17536 command_buffer: CommandBuffer,
17537 p_blit_image_info: *const BlitImageInfo2,
17538);
17539#[allow(non_camel_case_types)]
17540pub type PFN_vkCmdResolveImage2 = unsafe extern "system" fn(
17541 command_buffer: CommandBuffer,
17542 p_resolve_image_info: *const ResolveImageInfo2,
17543);
17544#[derive(Clone)]
17545pub struct KhrCopyCommands2Fn {
17546 pub cmd_copy_buffer2_khr: PFN_vkCmdCopyBuffer2,
17547 pub cmd_copy_image2_khr: PFN_vkCmdCopyImage2,
17548 pub cmd_copy_buffer_to_image2_khr: PFN_vkCmdCopyBufferToImage2,
17549 pub cmd_copy_image_to_buffer2_khr: PFN_vkCmdCopyImageToBuffer2,
17550 pub cmd_blit_image2_khr: PFN_vkCmdBlitImage2,
17551 pub cmd_resolve_image2_khr: PFN_vkCmdResolveImage2,
17552}
17553unsafe impl Send for KhrCopyCommands2Fn {}
17554unsafe impl Sync for KhrCopyCommands2Fn {}
17555impl KhrCopyCommands2Fn {
17556 pub fn load<F>(mut _f: F) -> Self
17557 where
17558 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17559 {
17560 Self {
17561 cmd_copy_buffer2_khr: unsafe {
17562 unsafe extern "system" fn cmd_copy_buffer2_khr(
17563 _command_buffer: CommandBuffer,
17564 _p_copy_buffer_info: *const CopyBufferInfo2,
17565 ) {
17566 panic!(concat!("Unable to load ", stringify!(cmd_copy_buffer2_khr)))
17567 }
17568 let cname =
17569 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyBuffer2KHR\0");
17570 let val = _f(cname);
17571 if val.is_null() {
17572 cmd_copy_buffer2_khr
17573 } else {
17574 ::std::mem::transmute(val)
17575 }
17576 },
17577 cmd_copy_image2_khr: unsafe {
17578 unsafe extern "system" fn cmd_copy_image2_khr(
17579 _command_buffer: CommandBuffer,
17580 _p_copy_image_info: *const CopyImageInfo2,
17581 ) {
17582 panic!(concat!("Unable to load ", stringify!(cmd_copy_image2_khr)))
17583 }
17584 let cname =
17585 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdCopyImage2KHR\0");
17586 let val = _f(cname);
17587 if val.is_null() {
17588 cmd_copy_image2_khr
17589 } else {
17590 ::std::mem::transmute(val)
17591 }
17592 },
17593 cmd_copy_buffer_to_image2_khr: unsafe {
17594 unsafe extern "system" fn cmd_copy_buffer_to_image2_khr(
17595 _command_buffer: CommandBuffer,
17596 _p_copy_buffer_to_image_info: *const CopyBufferToImageInfo2,
17597 ) {
17598 panic!(concat!(
17599 "Unable to load ",
17600 stringify!(cmd_copy_buffer_to_image2_khr)
17601 ))
17602 }
17603 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17604 b"vkCmdCopyBufferToImage2KHR\0",
17605 );
17606 let val = _f(cname);
17607 if val.is_null() {
17608 cmd_copy_buffer_to_image2_khr
17609 } else {
17610 ::std::mem::transmute(val)
17611 }
17612 },
17613 cmd_copy_image_to_buffer2_khr: unsafe {
17614 unsafe extern "system" fn cmd_copy_image_to_buffer2_khr(
17615 _command_buffer: CommandBuffer,
17616 _p_copy_image_to_buffer_info: *const CopyImageToBufferInfo2,
17617 ) {
17618 panic!(concat!(
17619 "Unable to load ",
17620 stringify!(cmd_copy_image_to_buffer2_khr)
17621 ))
17622 }
17623 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17624 b"vkCmdCopyImageToBuffer2KHR\0",
17625 );
17626 let val = _f(cname);
17627 if val.is_null() {
17628 cmd_copy_image_to_buffer2_khr
17629 } else {
17630 ::std::mem::transmute(val)
17631 }
17632 },
17633 cmd_blit_image2_khr: unsafe {
17634 unsafe extern "system" fn cmd_blit_image2_khr(
17635 _command_buffer: CommandBuffer,
17636 _p_blit_image_info: *const BlitImageInfo2,
17637 ) {
17638 panic!(concat!("Unable to load ", stringify!(cmd_blit_image2_khr)))
17639 }
17640 let cname =
17641 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdBlitImage2KHR\0");
17642 let val = _f(cname);
17643 if val.is_null() {
17644 cmd_blit_image2_khr
17645 } else {
17646 ::std::mem::transmute(val)
17647 }
17648 },
17649 cmd_resolve_image2_khr: unsafe {
17650 unsafe extern "system" fn cmd_resolve_image2_khr(
17651 _command_buffer: CommandBuffer,
17652 _p_resolve_image_info: *const ResolveImageInfo2,
17653 ) {
17654 panic!(concat!(
17655 "Unable to load ",
17656 stringify!(cmd_resolve_image2_khr)
17657 ))
17658 }
17659 let cname =
17660 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdResolveImage2KHR\0");
17661 let val = _f(cname);
17662 if val.is_null() {
17663 cmd_resolve_image2_khr
17664 } else {
17665 ::std::mem::transmute(val)
17666 }
17667 },
17668 }
17669 }
17670}
17671#[doc = "Generated from 'VK_KHR_copy_commands2'"]
17672impl StructureType {
17673 pub const COPY_BUFFER_INFO_2_KHR: Self = Self::COPY_BUFFER_INFO_2;
17674 pub const COPY_IMAGE_INFO_2_KHR: Self = Self::COPY_IMAGE_INFO_2;
17675 pub const COPY_BUFFER_TO_IMAGE_INFO_2_KHR: Self = Self::COPY_BUFFER_TO_IMAGE_INFO_2;
17676 pub const COPY_IMAGE_TO_BUFFER_INFO_2_KHR: Self = Self::COPY_IMAGE_TO_BUFFER_INFO_2;
17677 pub const BLIT_IMAGE_INFO_2_KHR: Self = Self::BLIT_IMAGE_INFO_2;
17678 pub const RESOLVE_IMAGE_INFO_2_KHR: Self = Self::RESOLVE_IMAGE_INFO_2;
17679 pub const BUFFER_COPY_2_KHR: Self = Self::BUFFER_COPY_2;
17680 pub const IMAGE_COPY_2_KHR: Self = Self::IMAGE_COPY_2;
17681 pub const IMAGE_BLIT_2_KHR: Self = Self::IMAGE_BLIT_2;
17682 pub const BUFFER_IMAGE_COPY_2_KHR: Self = Self::BUFFER_IMAGE_COPY_2;
17683 pub const IMAGE_RESOLVE_2_KHR: Self = Self::IMAGE_RESOLVE_2;
17684}
17685impl ArmExtension339Fn {
17686 pub const fn name() -> &'static ::std::ffi::CStr {
17687 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_339\0") }
17688 }
17689 pub const SPEC_VERSION: u32 = 0u32;
17690}
17691#[derive(Clone)]
17692pub struct ArmExtension339Fn {}
17693unsafe impl Send for ArmExtension339Fn {}
17694unsafe impl Sync for ArmExtension339Fn {}
17695impl ArmExtension339Fn {
17696 pub fn load<F>(mut _f: F) -> Self
17697 where
17698 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17699 {
17700 Self {}
17701 }
17702}
17703impl ExtExtension340Fn {
17704 pub const fn name() -> &'static ::std::ffi::CStr {
17705 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_340\0") }
17706 }
17707 pub const SPEC_VERSION: u32 = 0u32;
17708}
17709#[derive(Clone)]
17710pub struct ExtExtension340Fn {}
17711unsafe impl Send for ExtExtension340Fn {}
17712unsafe impl Sync for ExtExtension340Fn {}
17713impl ExtExtension340Fn {
17714 pub fn load<F>(mut _f: F) -> Self
17715 where
17716 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17717 {
17718 Self {}
17719 }
17720}
17721#[doc = "Generated from 'VK_EXT_extension_340'"]
17722impl ImageUsageFlags {
17723 pub const RESERVED_19_EXT: Self = Self(0b1000_0000_0000_0000_0000);
17724}
17725impl Ext4444FormatsFn {
17726 pub const fn name() -> &'static ::std::ffi::CStr {
17727 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_4444_formats\0") }
17728 }
17729 pub const SPEC_VERSION: u32 = 1u32;
17730}
17731#[derive(Clone)]
17732pub struct Ext4444FormatsFn {}
17733unsafe impl Send for Ext4444FormatsFn {}
17734unsafe impl Sync for Ext4444FormatsFn {}
17735impl Ext4444FormatsFn {
17736 pub fn load<F>(mut _f: F) -> Self
17737 where
17738 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17739 {
17740 Self {}
17741 }
17742}
17743#[doc = "Generated from 'VK_EXT_4444_formats'"]
17744impl Format {
17745 pub const A4R4G4B4_UNORM_PACK16_EXT: Self = Self::A4R4G4B4_UNORM_PACK16;
17746 pub const A4B4G4R4_UNORM_PACK16_EXT: Self = Self::A4B4G4R4_UNORM_PACK16;
17747}
17748#[doc = "Generated from 'VK_EXT_4444_formats'"]
17749impl StructureType {
17750 pub const PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: Self = Self(1_000_340_000);
17751}
17752impl ExtExtension342Fn {
17753 pub const fn name() -> &'static ::std::ffi::CStr {
17754 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_342\0") }
17755 }
17756 pub const SPEC_VERSION: u32 = 0u32;
17757}
17758#[derive(Clone)]
17759pub struct ExtExtension342Fn {}
17760unsafe impl Send for ExtExtension342Fn {}
17761unsafe impl Sync for ExtExtension342Fn {}
17762impl ExtExtension342Fn {
17763 pub fn load<F>(mut _f: F) -> Self
17764 where
17765 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17766 {
17767 Self {}
17768 }
17769}
17770impl ArmRasterizationOrderAttachmentAccessFn {
17771 pub const fn name() -> &'static ::std::ffi::CStr {
17772 unsafe {
17773 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17774 b"VK_ARM_rasterization_order_attachment_access\0",
17775 )
17776 }
17777 }
17778 pub const SPEC_VERSION: u32 = 1u32;
17779}
17780#[derive(Clone)]
17781pub struct ArmRasterizationOrderAttachmentAccessFn {}
17782unsafe impl Send for ArmRasterizationOrderAttachmentAccessFn {}
17783unsafe impl Sync for ArmRasterizationOrderAttachmentAccessFn {}
17784impl ArmRasterizationOrderAttachmentAccessFn {
17785 pub fn load<F>(mut _f: F) -> Self
17786 where
17787 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17788 {
17789 Self {}
17790 }
17791}
17792#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
17793impl PipelineColorBlendStateCreateFlags {
17794 pub const RASTERIZATION_ORDER_ATTACHMENT_ACCESS_ARM: Self = Self(0b1);
17795}
17796#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
17797impl PipelineDepthStencilStateCreateFlags {
17798 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = Self(0b1);
17799 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = Self(0b10);
17800}
17801#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
17802impl StructureType {
17803 pub const PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: Self =
17804 Self(1_000_342_000);
17805}
17806#[doc = "Generated from 'VK_ARM_rasterization_order_attachment_access'"]
17807impl SubpassDescriptionFlags {
17808 pub const RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_ARM: Self = Self(0b1_0000);
17809 pub const RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_ARM: Self = Self(0b10_0000);
17810 pub const RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_ARM: Self = Self(0b100_0000);
17811}
17812impl ArmExtension344Fn {
17813 pub const fn name() -> &'static ::std::ffi::CStr {
17814 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_344\0") }
17815 }
17816 pub const SPEC_VERSION: u32 = 0u32;
17817}
17818#[derive(Clone)]
17819pub struct ArmExtension344Fn {}
17820unsafe impl Send for ArmExtension344Fn {}
17821unsafe impl Sync for ArmExtension344Fn {}
17822impl ArmExtension344Fn {
17823 pub fn load<F>(mut _f: F) -> Self
17824 where
17825 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17826 {
17827 Self {}
17828 }
17829}
17830impl ExtRgba10x6FormatsFn {
17831 pub const fn name() -> &'static ::std::ffi::CStr {
17832 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_rgba10x6_formats\0") }
17833 }
17834 pub const SPEC_VERSION: u32 = 1u32;
17835}
17836#[derive(Clone)]
17837pub struct ExtRgba10x6FormatsFn {}
17838unsafe impl Send for ExtRgba10x6FormatsFn {}
17839unsafe impl Sync for ExtRgba10x6FormatsFn {}
17840impl ExtRgba10x6FormatsFn {
17841 pub fn load<F>(mut _f: F) -> Self
17842 where
17843 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17844 {
17845 Self {}
17846 }
17847}
17848#[doc = "Generated from 'VK_EXT_rgba10x6_formats'"]
17849impl StructureType {
17850 pub const PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: Self = Self(1_000_344_000);
17851}
17852impl NvAcquireWinrtDisplayFn {
17853 pub const fn name() -> &'static ::std::ffi::CStr {
17854 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_acquire_winrt_display\0") }
17855 }
17856 pub const SPEC_VERSION: u32 = 1u32;
17857}
17858#[allow(non_camel_case_types)]
17859pub type PFN_vkAcquireWinrtDisplayNV =
17860 unsafe extern "system" fn(physical_device: PhysicalDevice, display: DisplayKHR) -> Result;
17861#[allow(non_camel_case_types)]
17862pub type PFN_vkGetWinrtDisplayNV = unsafe extern "system" fn(
17863 physical_device: PhysicalDevice,
17864 device_relative_id: u32,
17865 p_display: *mut DisplayKHR,
17866) -> Result;
17867#[derive(Clone)]
17868pub struct NvAcquireWinrtDisplayFn {
17869 pub acquire_winrt_display_nv: PFN_vkAcquireWinrtDisplayNV,
17870 pub get_winrt_display_nv: PFN_vkGetWinrtDisplayNV,
17871}
17872unsafe impl Send for NvAcquireWinrtDisplayFn {}
17873unsafe impl Sync for NvAcquireWinrtDisplayFn {}
17874impl NvAcquireWinrtDisplayFn {
17875 pub fn load<F>(mut _f: F) -> Self
17876 where
17877 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17878 {
17879 Self {
17880 acquire_winrt_display_nv: unsafe {
17881 unsafe extern "system" fn acquire_winrt_display_nv(
17882 _physical_device: PhysicalDevice,
17883 _display: DisplayKHR,
17884 ) -> Result {
17885 panic!(concat!(
17886 "Unable to load ",
17887 stringify!(acquire_winrt_display_nv)
17888 ))
17889 }
17890 let cname =
17891 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkAcquireWinrtDisplayNV\0");
17892 let val = _f(cname);
17893 if val.is_null() {
17894 acquire_winrt_display_nv
17895 } else {
17896 ::std::mem::transmute(val)
17897 }
17898 },
17899 get_winrt_display_nv: unsafe {
17900 unsafe extern "system" fn get_winrt_display_nv(
17901 _physical_device: PhysicalDevice,
17902 _device_relative_id: u32,
17903 _p_display: *mut DisplayKHR,
17904 ) -> Result {
17905 panic!(concat!("Unable to load ", stringify!(get_winrt_display_nv)))
17906 }
17907 let cname =
17908 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkGetWinrtDisplayNV\0");
17909 let val = _f(cname);
17910 if val.is_null() {
17911 get_winrt_display_nv
17912 } else {
17913 ::std::mem::transmute(val)
17914 }
17915 },
17916 }
17917 }
17918}
17919impl ExtDirectfbSurfaceFn {
17920 pub const fn name() -> &'static ::std::ffi::CStr {
17921 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_directfb_surface\0") }
17922 }
17923 pub const SPEC_VERSION: u32 = 1u32;
17924}
17925#[allow(non_camel_case_types)]
17926pub type PFN_vkCreateDirectFBSurfaceEXT = unsafe extern "system" fn(
17927 instance: Instance,
17928 p_create_info: *const DirectFBSurfaceCreateInfoEXT,
17929 p_allocator: *const AllocationCallbacks,
17930 p_surface: *mut SurfaceKHR,
17931) -> Result;
17932#[allow(non_camel_case_types)]
17933pub type PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT =
17934 unsafe extern "system" fn(
17935 physical_device: PhysicalDevice,
17936 queue_family_index: u32,
17937 dfb: *mut IDirectFB,
17938 ) -> Bool32;
17939#[derive(Clone)]
17940pub struct ExtDirectfbSurfaceFn {
17941 pub create_direct_fb_surface_ext: PFN_vkCreateDirectFBSurfaceEXT,
17942 pub get_physical_device_direct_fb_presentation_support_ext:
17943 PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT,
17944}
17945unsafe impl Send for ExtDirectfbSurfaceFn {}
17946unsafe impl Sync for ExtDirectfbSurfaceFn {}
17947impl ExtDirectfbSurfaceFn {
17948 pub fn load<F>(mut _f: F) -> Self
17949 where
17950 F: FnMut(&::std::ffi::CStr) -> *const c_void,
17951 {
17952 Self {
17953 create_direct_fb_surface_ext: unsafe {
17954 unsafe extern "system" fn create_direct_fb_surface_ext(
17955 _instance: Instance,
17956 _p_create_info: *const DirectFBSurfaceCreateInfoEXT,
17957 _p_allocator: *const AllocationCallbacks,
17958 _p_surface: *mut SurfaceKHR,
17959 ) -> Result {
17960 panic!(concat!(
17961 "Unable to load ",
17962 stringify!(create_direct_fb_surface_ext)
17963 ))
17964 }
17965 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17966 b"vkCreateDirectFBSurfaceEXT\0",
17967 );
17968 let val = _f(cname);
17969 if val.is_null() {
17970 create_direct_fb_surface_ext
17971 } else {
17972 ::std::mem::transmute(val)
17973 }
17974 },
17975 get_physical_device_direct_fb_presentation_support_ext: unsafe {
17976 unsafe extern "system" fn get_physical_device_direct_fb_presentation_support_ext(
17977 _physical_device: PhysicalDevice,
17978 _queue_family_index: u32,
17979 _dfb: *mut IDirectFB,
17980 ) -> Bool32 {
17981 panic!(concat!(
17982 "Unable to load ",
17983 stringify!(get_physical_device_direct_fb_presentation_support_ext)
17984 ))
17985 }
17986 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
17987 b"vkGetPhysicalDeviceDirectFBPresentationSupportEXT\0",
17988 );
17989 let val = _f(cname);
17990 if val.is_null() {
17991 get_physical_device_direct_fb_presentation_support_ext
17992 } else {
17993 ::std::mem::transmute(val)
17994 }
17995 },
17996 }
17997 }
17998}
17999#[doc = "Generated from 'VK_EXT_directfb_surface'"]
18000impl StructureType {
18001 pub const DIRECTFB_SURFACE_CREATE_INFO_EXT: Self = Self(1_000_346_000);
18002}
18003impl KhrExtension350Fn {
18004 pub const fn name() -> &'static ::std::ffi::CStr {
18005 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_350\0") }
18006 }
18007 pub const SPEC_VERSION: u32 = 0u32;
18008}
18009#[derive(Clone)]
18010pub struct KhrExtension350Fn {}
18011unsafe impl Send for KhrExtension350Fn {}
18012unsafe impl Sync for KhrExtension350Fn {}
18013impl KhrExtension350Fn {
18014 pub fn load<F>(mut _f: F) -> Self
18015 where
18016 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18017 {
18018 Self {}
18019 }
18020}
18021impl NvExtension351Fn {
18022 pub const fn name() -> &'static ::std::ffi::CStr {
18023 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_351\0") }
18024 }
18025 pub const SPEC_VERSION: u32 = 0u32;
18026}
18027#[derive(Clone)]
18028pub struct NvExtension351Fn {}
18029unsafe impl Send for NvExtension351Fn {}
18030unsafe impl Sync for NvExtension351Fn {}
18031impl NvExtension351Fn {
18032 pub fn load<F>(mut _f: F) -> Self
18033 where
18034 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18035 {
18036 Self {}
18037 }
18038}
18039impl ValveMutableDescriptorTypeFn {
18040 pub const fn name() -> &'static ::std::ffi::CStr {
18041 unsafe {
18042 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_VALVE_mutable_descriptor_type\0")
18043 }
18044 }
18045 pub const SPEC_VERSION: u32 = 1u32;
18046}
18047#[derive(Clone)]
18048pub struct ValveMutableDescriptorTypeFn {}
18049unsafe impl Send for ValveMutableDescriptorTypeFn {}
18050unsafe impl Sync for ValveMutableDescriptorTypeFn {}
18051impl ValveMutableDescriptorTypeFn {
18052 pub fn load<F>(mut _f: F) -> Self
18053 where
18054 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18055 {
18056 Self {}
18057 }
18058}
18059#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
18060impl DescriptorPoolCreateFlags {
18061 pub const HOST_ONLY_VALVE: Self = Self(0b100);
18062}
18063#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
18064impl DescriptorSetLayoutCreateFlags {
18065 pub const HOST_ONLY_POOL_VALVE: Self = Self(0b100);
18066}
18067#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
18068impl DescriptorType {
18069 pub const MUTABLE_VALVE: Self = Self(1_000_351_000);
18070}
18071#[doc = "Generated from 'VK_VALVE_mutable_descriptor_type'"]
18072impl StructureType {
18073 pub const PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: Self = Self(1_000_351_000);
18074 pub const MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: Self = Self(1_000_351_002);
18075}
18076impl ExtVertexInputDynamicStateFn {
18077 pub const fn name() -> &'static ::std::ffi::CStr {
18078 unsafe {
18079 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_vertex_input_dynamic_state\0")
18080 }
18081 }
18082 pub const SPEC_VERSION: u32 = 2u32;
18083}
18084#[allow(non_camel_case_types)]
18085pub type PFN_vkCmdSetVertexInputEXT = unsafe extern "system" fn(
18086 command_buffer: CommandBuffer,
18087 vertex_binding_description_count: u32,
18088 p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT,
18089 vertex_attribute_description_count: u32,
18090 p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT,
18091);
18092#[derive(Clone)]
18093pub struct ExtVertexInputDynamicStateFn {
18094 pub cmd_set_vertex_input_ext: PFN_vkCmdSetVertexInputEXT,
18095}
18096unsafe impl Send for ExtVertexInputDynamicStateFn {}
18097unsafe impl Sync for ExtVertexInputDynamicStateFn {}
18098impl ExtVertexInputDynamicStateFn {
18099 pub fn load<F>(mut _f: F) -> Self
18100 where
18101 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18102 {
18103 Self {
18104 cmd_set_vertex_input_ext: unsafe {
18105 unsafe extern "system" fn cmd_set_vertex_input_ext(
18106 _command_buffer: CommandBuffer,
18107 _vertex_binding_description_count: u32,
18108 _p_vertex_binding_descriptions: *const VertexInputBindingDescription2EXT,
18109 _vertex_attribute_description_count: u32,
18110 _p_vertex_attribute_descriptions: *const VertexInputAttributeDescription2EXT,
18111 ) {
18112 panic!(concat!(
18113 "Unable to load ",
18114 stringify!(cmd_set_vertex_input_ext)
18115 ))
18116 }
18117 let cname =
18118 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetVertexInputEXT\0");
18119 let val = _f(cname);
18120 if val.is_null() {
18121 cmd_set_vertex_input_ext
18122 } else {
18123 ::std::mem::transmute(val)
18124 }
18125 },
18126 }
18127 }
18128}
18129#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
18130impl DynamicState {
18131 pub const VERTEX_INPUT_EXT: Self = Self(1_000_352_000);
18132}
18133#[doc = "Generated from 'VK_EXT_vertex_input_dynamic_state'"]
18134impl StructureType {
18135 pub const PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: Self = Self(1_000_352_000);
18136 pub const VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: Self = Self(1_000_352_001);
18137 pub const VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: Self = Self(1_000_352_002);
18138}
18139impl ExtPhysicalDeviceDrmFn {
18140 pub const fn name() -> &'static ::std::ffi::CStr {
18141 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_physical_device_drm\0") }
18142 }
18143 pub const SPEC_VERSION: u32 = 1u32;
18144}
18145#[derive(Clone)]
18146pub struct ExtPhysicalDeviceDrmFn {}
18147unsafe impl Send for ExtPhysicalDeviceDrmFn {}
18148unsafe impl Sync for ExtPhysicalDeviceDrmFn {}
18149impl ExtPhysicalDeviceDrmFn {
18150 pub fn load<F>(mut _f: F) -> Self
18151 where
18152 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18153 {
18154 Self {}
18155 }
18156}
18157#[doc = "Generated from 'VK_EXT_physical_device_drm'"]
18158impl StructureType {
18159 pub const PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: Self = Self(1_000_353_000);
18160}
18161impl ExtExtension355Fn {
18162 pub const fn name() -> &'static ::std::ffi::CStr {
18163 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_355\0") }
18164 }
18165 pub const SPEC_VERSION: u32 = 0u32;
18166}
18167#[derive(Clone)]
18168pub struct ExtExtension355Fn {}
18169unsafe impl Send for ExtExtension355Fn {}
18170unsafe impl Sync for ExtExtension355Fn {}
18171impl ExtExtension355Fn {
18172 pub fn load<F>(mut _f: F) -> Self
18173 where
18174 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18175 {
18176 Self {}
18177 }
18178}
18179impl ExtDepthClipControlFn {
18180 pub const fn name() -> &'static ::std::ffi::CStr {
18181 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_depth_clip_control\0") }
18182 }
18183 pub const SPEC_VERSION: u32 = 1u32;
18184}
18185#[derive(Clone)]
18186pub struct ExtDepthClipControlFn {}
18187unsafe impl Send for ExtDepthClipControlFn {}
18188unsafe impl Sync for ExtDepthClipControlFn {}
18189impl ExtDepthClipControlFn {
18190 pub fn load<F>(mut _f: F) -> Self
18191 where
18192 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18193 {
18194 Self {}
18195 }
18196}
18197#[doc = "Generated from 'VK_EXT_depth_clip_control'"]
18198impl StructureType {
18199 pub const PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: Self = Self(1_000_355_000);
18200 pub const PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: Self = Self(1_000_355_001);
18201}
18202impl ExtPrimitiveTopologyListRestartFn {
18203 pub const fn name() -> &'static ::std::ffi::CStr {
18204 unsafe {
18205 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18206 b"VK_EXT_primitive_topology_list_restart\0",
18207 )
18208 }
18209 }
18210 pub const SPEC_VERSION: u32 = 1u32;
18211}
18212#[derive(Clone)]
18213pub struct ExtPrimitiveTopologyListRestartFn {}
18214unsafe impl Send for ExtPrimitiveTopologyListRestartFn {}
18215unsafe impl Sync for ExtPrimitiveTopologyListRestartFn {}
18216impl ExtPrimitiveTopologyListRestartFn {
18217 pub fn load<F>(mut _f: F) -> Self
18218 where
18219 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18220 {
18221 Self {}
18222 }
18223}
18224#[doc = "Generated from 'VK_EXT_primitive_topology_list_restart'"]
18225impl StructureType {
18226 pub const PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: Self =
18227 Self(1_000_356_000);
18228}
18229impl KhrExtension358Fn {
18230 pub const fn name() -> &'static ::std::ffi::CStr {
18231 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_358\0") }
18232 }
18233 pub const SPEC_VERSION: u32 = 0u32;
18234}
18235#[derive(Clone)]
18236pub struct KhrExtension358Fn {}
18237unsafe impl Send for KhrExtension358Fn {}
18238unsafe impl Sync for KhrExtension358Fn {}
18239impl KhrExtension358Fn {
18240 pub fn load<F>(mut _f: F) -> Self
18241 where
18242 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18243 {
18244 Self {}
18245 }
18246}
18247impl ExtExtension359Fn {
18248 pub const fn name() -> &'static ::std::ffi::CStr {
18249 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_359\0") }
18250 }
18251 pub const SPEC_VERSION: u32 = 0u32;
18252}
18253#[derive(Clone)]
18254pub struct ExtExtension359Fn {}
18255unsafe impl Send for ExtExtension359Fn {}
18256unsafe impl Sync for ExtExtension359Fn {}
18257impl ExtExtension359Fn {
18258 pub fn load<F>(mut _f: F) -> Self
18259 where
18260 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18261 {
18262 Self {}
18263 }
18264}
18265impl ExtExtension360Fn {
18266 pub const fn name() -> &'static ::std::ffi::CStr {
18267 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_360\0") }
18268 }
18269 pub const SPEC_VERSION: u32 = 0u32;
18270}
18271#[derive(Clone)]
18272pub struct ExtExtension360Fn {}
18273unsafe impl Send for ExtExtension360Fn {}
18274unsafe impl Sync for ExtExtension360Fn {}
18275impl ExtExtension360Fn {
18276 pub fn load<F>(mut _f: F) -> Self
18277 where
18278 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18279 {
18280 Self {}
18281 }
18282}
18283impl KhrFormatFeatureFlags2Fn {
18284 pub const fn name() -> &'static ::std::ffi::CStr {
18285 unsafe {
18286 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_format_feature_flags2\0")
18287 }
18288 }
18289 pub const SPEC_VERSION: u32 = 1u32;
18290}
18291#[derive(Clone)]
18292pub struct KhrFormatFeatureFlags2Fn {}
18293unsafe impl Send for KhrFormatFeatureFlags2Fn {}
18294unsafe impl Sync for KhrFormatFeatureFlags2Fn {}
18295impl KhrFormatFeatureFlags2Fn {
18296 pub fn load<F>(mut _f: F) -> Self
18297 where
18298 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18299 {
18300 Self {}
18301 }
18302}
18303#[doc = "Generated from 'VK_KHR_format_feature_flags2'"]
18304impl StructureType {
18305 pub const FORMAT_PROPERTIES_3_KHR: Self = Self::FORMAT_PROPERTIES_3;
18306}
18307impl ExtExtension362Fn {
18308 pub const fn name() -> &'static ::std::ffi::CStr {
18309 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_362\0") }
18310 }
18311 pub const SPEC_VERSION: u32 = 0u32;
18312}
18313#[derive(Clone)]
18314pub struct ExtExtension362Fn {}
18315unsafe impl Send for ExtExtension362Fn {}
18316unsafe impl Sync for ExtExtension362Fn {}
18317impl ExtExtension362Fn {
18318 pub fn load<F>(mut _f: F) -> Self
18319 where
18320 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18321 {
18322 Self {}
18323 }
18324}
18325impl ExtExtension363Fn {
18326 pub const fn name() -> &'static ::std::ffi::CStr {
18327 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_363\0") }
18328 }
18329 pub const SPEC_VERSION: u32 = 0u32;
18330}
18331#[derive(Clone)]
18332pub struct ExtExtension363Fn {}
18333unsafe impl Send for ExtExtension363Fn {}
18334unsafe impl Sync for ExtExtension363Fn {}
18335impl ExtExtension363Fn {
18336 pub fn load<F>(mut _f: F) -> Self
18337 where
18338 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18339 {
18340 Self {}
18341 }
18342}
18343impl FuchsiaExtension364Fn {
18344 pub const fn name() -> &'static ::std::ffi::CStr {
18345 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_364\0") }
18346 }
18347 pub const SPEC_VERSION: u32 = 0u32;
18348}
18349#[derive(Clone)]
18350pub struct FuchsiaExtension364Fn {}
18351unsafe impl Send for FuchsiaExtension364Fn {}
18352unsafe impl Sync for FuchsiaExtension364Fn {}
18353impl FuchsiaExtension364Fn {
18354 pub fn load<F>(mut _f: F) -> Self
18355 where
18356 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18357 {
18358 Self {}
18359 }
18360}
18361impl FuchsiaExternalMemoryFn {
18362 pub const fn name() -> &'static ::std::ffi::CStr {
18363 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_memory\0") }
18364 }
18365 pub const SPEC_VERSION: u32 = 1u32;
18366}
18367#[allow(non_camel_case_types)]
18368pub type PFN_vkGetMemoryZirconHandleFUCHSIA = unsafe extern "system" fn(
18369 device: Device,
18370 p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA,
18371 p_zircon_handle: *mut zx_handle_t,
18372) -> Result;
18373#[allow(non_camel_case_types)]
18374pub type PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA = unsafe extern "system" fn(
18375 device: Device,
18376 handle_type: ExternalMemoryHandleTypeFlags,
18377 zircon_handle: zx_handle_t,
18378 p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA,
18379) -> Result;
18380#[derive(Clone)]
18381pub struct FuchsiaExternalMemoryFn {
18382 pub get_memory_zircon_handle_fuchsia: PFN_vkGetMemoryZirconHandleFUCHSIA,
18383 pub get_memory_zircon_handle_properties_fuchsia: PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA,
18384}
18385unsafe impl Send for FuchsiaExternalMemoryFn {}
18386unsafe impl Sync for FuchsiaExternalMemoryFn {}
18387impl FuchsiaExternalMemoryFn {
18388 pub fn load<F>(mut _f: F) -> Self
18389 where
18390 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18391 {
18392 Self {
18393 get_memory_zircon_handle_fuchsia: unsafe {
18394 unsafe extern "system" fn get_memory_zircon_handle_fuchsia(
18395 _device: Device,
18396 _p_get_zircon_handle_info: *const MemoryGetZirconHandleInfoFUCHSIA,
18397 _p_zircon_handle: *mut zx_handle_t,
18398 ) -> Result {
18399 panic!(concat!(
18400 "Unable to load ",
18401 stringify!(get_memory_zircon_handle_fuchsia)
18402 ))
18403 }
18404 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18405 b"vkGetMemoryZirconHandleFUCHSIA\0",
18406 );
18407 let val = _f(cname);
18408 if val.is_null() {
18409 get_memory_zircon_handle_fuchsia
18410 } else {
18411 ::std::mem::transmute(val)
18412 }
18413 },
18414 get_memory_zircon_handle_properties_fuchsia: unsafe {
18415 unsafe extern "system" fn get_memory_zircon_handle_properties_fuchsia(
18416 _device: Device,
18417 _handle_type: ExternalMemoryHandleTypeFlags,
18418 _zircon_handle: zx_handle_t,
18419 _p_memory_zircon_handle_properties: *mut MemoryZirconHandlePropertiesFUCHSIA,
18420 ) -> Result {
18421 panic!(concat!(
18422 "Unable to load ",
18423 stringify!(get_memory_zircon_handle_properties_fuchsia)
18424 ))
18425 }
18426 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18427 b"vkGetMemoryZirconHandlePropertiesFUCHSIA\0",
18428 );
18429 let val = _f(cname);
18430 if val.is_null() {
18431 get_memory_zircon_handle_properties_fuchsia
18432 } else {
18433 ::std::mem::transmute(val)
18434 }
18435 },
18436 }
18437 }
18438}
18439#[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
18440impl ExternalMemoryHandleTypeFlags {
18441 pub const ZIRCON_VMO_FUCHSIA: Self = Self(0b1000_0000_0000);
18442}
18443#[doc = "Generated from 'VK_FUCHSIA_external_memory'"]
18444impl StructureType {
18445 pub const IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_000);
18446 pub const MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: Self = Self(1_000_364_001);
18447 pub const MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_364_002);
18448}
18449impl FuchsiaExternalSemaphoreFn {
18450 pub const fn name() -> &'static ::std::ffi::CStr {
18451 unsafe {
18452 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_external_semaphore\0")
18453 }
18454 }
18455 pub const SPEC_VERSION: u32 = 1u32;
18456}
18457#[allow(non_camel_case_types)]
18458pub type PFN_vkImportSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn(
18459 device: Device,
18460 p_import_semaphore_zircon_handle_info: *const ImportSemaphoreZirconHandleInfoFUCHSIA,
18461) -> Result;
18462#[allow(non_camel_case_types)]
18463pub type PFN_vkGetSemaphoreZirconHandleFUCHSIA = unsafe extern "system" fn(
18464 device: Device,
18465 p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA,
18466 p_zircon_handle: *mut zx_handle_t,
18467) -> Result;
18468#[derive(Clone)]
18469pub struct FuchsiaExternalSemaphoreFn {
18470 pub import_semaphore_zircon_handle_fuchsia: PFN_vkImportSemaphoreZirconHandleFUCHSIA,
18471 pub get_semaphore_zircon_handle_fuchsia: PFN_vkGetSemaphoreZirconHandleFUCHSIA,
18472}
18473unsafe impl Send for FuchsiaExternalSemaphoreFn {}
18474unsafe impl Sync for FuchsiaExternalSemaphoreFn {}
18475impl FuchsiaExternalSemaphoreFn {
18476 pub fn load<F>(mut _f: F) -> Self
18477 where
18478 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18479 {
18480 Self {
18481 import_semaphore_zircon_handle_fuchsia: unsafe {
18482 unsafe extern "system" fn import_semaphore_zircon_handle_fuchsia(
18483 _device: Device,
18484 _p_import_semaphore_zircon_handle_info : * const ImportSemaphoreZirconHandleInfoFUCHSIA,
18485 ) -> Result {
18486 panic!(concat!(
18487 "Unable to load ",
18488 stringify!(import_semaphore_zircon_handle_fuchsia)
18489 ))
18490 }
18491 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18492 b"vkImportSemaphoreZirconHandleFUCHSIA\0",
18493 );
18494 let val = _f(cname);
18495 if val.is_null() {
18496 import_semaphore_zircon_handle_fuchsia
18497 } else {
18498 ::std::mem::transmute(val)
18499 }
18500 },
18501 get_semaphore_zircon_handle_fuchsia: unsafe {
18502 unsafe extern "system" fn get_semaphore_zircon_handle_fuchsia(
18503 _device: Device,
18504 _p_get_zircon_handle_info: *const SemaphoreGetZirconHandleInfoFUCHSIA,
18505 _p_zircon_handle: *mut zx_handle_t,
18506 ) -> Result {
18507 panic!(concat!(
18508 "Unable to load ",
18509 stringify!(get_semaphore_zircon_handle_fuchsia)
18510 ))
18511 }
18512 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18513 b"vkGetSemaphoreZirconHandleFUCHSIA\0",
18514 );
18515 let val = _f(cname);
18516 if val.is_null() {
18517 get_semaphore_zircon_handle_fuchsia
18518 } else {
18519 ::std::mem::transmute(val)
18520 }
18521 },
18522 }
18523 }
18524}
18525#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"]
18526impl ExternalSemaphoreHandleTypeFlags {
18527 pub const ZIRCON_EVENT_FUCHSIA: Self = Self(0b1000_0000);
18528}
18529#[doc = "Generated from 'VK_FUCHSIA_external_semaphore'"]
18530impl StructureType {
18531 pub const IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_000);
18532 pub const SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: Self = Self(1_000_365_001);
18533}
18534impl FuchsiaBufferCollectionFn {
18535 pub const fn name() -> &'static ::std::ffi::CStr {
18536 unsafe {
18537 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_buffer_collection\0")
18538 }
18539 }
18540 pub const SPEC_VERSION: u32 = 2u32;
18541}
18542#[allow(non_camel_case_types)]
18543pub type PFN_vkCreateBufferCollectionFUCHSIA = unsafe extern "system" fn(
18544 device: Device,
18545 p_create_info: *const BufferCollectionCreateInfoFUCHSIA,
18546 p_allocator: *const AllocationCallbacks,
18547 p_collection: *mut BufferCollectionFUCHSIA,
18548) -> Result;
18549#[allow(non_camel_case_types)]
18550pub type PFN_vkSetBufferCollectionImageConstraintsFUCHSIA = unsafe extern "system" fn(
18551 device: Device,
18552 collection: BufferCollectionFUCHSIA,
18553 p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA,
18554) -> Result;
18555#[allow(non_camel_case_types)]
18556pub type PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA = unsafe extern "system" fn(
18557 device: Device,
18558 collection: BufferCollectionFUCHSIA,
18559 p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA,
18560) -> Result;
18561#[allow(non_camel_case_types)]
18562pub type PFN_vkDestroyBufferCollectionFUCHSIA = unsafe extern "system" fn(
18563 device: Device,
18564 collection: BufferCollectionFUCHSIA,
18565 p_allocator: *const AllocationCallbacks,
18566);
18567#[allow(non_camel_case_types)]
18568pub type PFN_vkGetBufferCollectionPropertiesFUCHSIA = unsafe extern "system" fn(
18569 device: Device,
18570 collection: BufferCollectionFUCHSIA,
18571 p_properties: *mut BufferCollectionPropertiesFUCHSIA,
18572) -> Result;
18573#[derive(Clone)]
18574pub struct FuchsiaBufferCollectionFn {
18575 pub create_buffer_collection_fuchsia: PFN_vkCreateBufferCollectionFUCHSIA,
18576 pub set_buffer_collection_image_constraints_fuchsia:
18577 PFN_vkSetBufferCollectionImageConstraintsFUCHSIA,
18578 pub set_buffer_collection_buffer_constraints_fuchsia:
18579 PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA,
18580 pub destroy_buffer_collection_fuchsia: PFN_vkDestroyBufferCollectionFUCHSIA,
18581 pub get_buffer_collection_properties_fuchsia: PFN_vkGetBufferCollectionPropertiesFUCHSIA,
18582}
18583unsafe impl Send for FuchsiaBufferCollectionFn {}
18584unsafe impl Sync for FuchsiaBufferCollectionFn {}
18585impl FuchsiaBufferCollectionFn {
18586 pub fn load<F>(mut _f: F) -> Self
18587 where
18588 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18589 {
18590 Self {
18591 create_buffer_collection_fuchsia: unsafe {
18592 unsafe extern "system" fn create_buffer_collection_fuchsia(
18593 _device: Device,
18594 _p_create_info: *const BufferCollectionCreateInfoFUCHSIA,
18595 _p_allocator: *const AllocationCallbacks,
18596 _p_collection: *mut BufferCollectionFUCHSIA,
18597 ) -> Result {
18598 panic!(concat!(
18599 "Unable to load ",
18600 stringify!(create_buffer_collection_fuchsia)
18601 ))
18602 }
18603 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18604 b"vkCreateBufferCollectionFUCHSIA\0",
18605 );
18606 let val = _f(cname);
18607 if val.is_null() {
18608 create_buffer_collection_fuchsia
18609 } else {
18610 ::std::mem::transmute(val)
18611 }
18612 },
18613 set_buffer_collection_image_constraints_fuchsia: unsafe {
18614 unsafe extern "system" fn set_buffer_collection_image_constraints_fuchsia(
18615 _device: Device,
18616 _collection: BufferCollectionFUCHSIA,
18617 _p_image_constraints_info: *const ImageConstraintsInfoFUCHSIA,
18618 ) -> Result {
18619 panic!(concat!(
18620 "Unable to load ",
18621 stringify!(set_buffer_collection_image_constraints_fuchsia)
18622 ))
18623 }
18624 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18625 b"vkSetBufferCollectionImageConstraintsFUCHSIA\0",
18626 );
18627 let val = _f(cname);
18628 if val.is_null() {
18629 set_buffer_collection_image_constraints_fuchsia
18630 } else {
18631 ::std::mem::transmute(val)
18632 }
18633 },
18634 set_buffer_collection_buffer_constraints_fuchsia: unsafe {
18635 unsafe extern "system" fn set_buffer_collection_buffer_constraints_fuchsia(
18636 _device: Device,
18637 _collection: BufferCollectionFUCHSIA,
18638 _p_buffer_constraints_info: *const BufferConstraintsInfoFUCHSIA,
18639 ) -> Result {
18640 panic!(concat!(
18641 "Unable to load ",
18642 stringify!(set_buffer_collection_buffer_constraints_fuchsia)
18643 ))
18644 }
18645 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18646 b"vkSetBufferCollectionBufferConstraintsFUCHSIA\0",
18647 );
18648 let val = _f(cname);
18649 if val.is_null() {
18650 set_buffer_collection_buffer_constraints_fuchsia
18651 } else {
18652 ::std::mem::transmute(val)
18653 }
18654 },
18655 destroy_buffer_collection_fuchsia: unsafe {
18656 unsafe extern "system" fn destroy_buffer_collection_fuchsia(
18657 _device: Device,
18658 _collection: BufferCollectionFUCHSIA,
18659 _p_allocator: *const AllocationCallbacks,
18660 ) {
18661 panic!(concat!(
18662 "Unable to load ",
18663 stringify!(destroy_buffer_collection_fuchsia)
18664 ))
18665 }
18666 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18667 b"vkDestroyBufferCollectionFUCHSIA\0",
18668 );
18669 let val = _f(cname);
18670 if val.is_null() {
18671 destroy_buffer_collection_fuchsia
18672 } else {
18673 ::std::mem::transmute(val)
18674 }
18675 },
18676 get_buffer_collection_properties_fuchsia: unsafe {
18677 unsafe extern "system" fn get_buffer_collection_properties_fuchsia(
18678 _device: Device,
18679 _collection: BufferCollectionFUCHSIA,
18680 _p_properties: *mut BufferCollectionPropertiesFUCHSIA,
18681 ) -> Result {
18682 panic!(concat!(
18683 "Unable to load ",
18684 stringify!(get_buffer_collection_properties_fuchsia)
18685 ))
18686 }
18687 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18688 b"vkGetBufferCollectionPropertiesFUCHSIA\0",
18689 );
18690 let val = _f(cname);
18691 if val.is_null() {
18692 get_buffer_collection_properties_fuchsia
18693 } else {
18694 ::std::mem::transmute(val)
18695 }
18696 },
18697 }
18698 }
18699}
18700#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
18701impl DebugReportObjectTypeEXT {
18702 pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000);
18703}
18704#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
18705impl ObjectType {
18706 #[doc = "VkBufferCollectionFUCHSIA"]
18707 pub const BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_000);
18708}
18709#[doc = "Generated from 'VK_FUCHSIA_buffer_collection'"]
18710impl StructureType {
18711 pub const BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_000);
18712 pub const IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: Self = Self(1_000_366_001);
18713 pub const BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_002);
18714 pub const BUFFER_COLLECTION_PROPERTIES_FUCHSIA: Self = Self(1_000_366_003);
18715 pub const BUFFER_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_004);
18716 pub const BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: Self = Self(1_000_366_005);
18717 pub const IMAGE_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_006);
18718 pub const IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_007);
18719 pub const SYSMEM_COLOR_SPACE_FUCHSIA: Self = Self(1_000_366_008);
18720 pub const BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: Self = Self(1_000_366_009);
18721}
18722impl FuchsiaExtension368Fn {
18723 pub const fn name() -> &'static ::std::ffi::CStr {
18724 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FUCHSIA_extension_368\0") }
18725 }
18726 pub const SPEC_VERSION: u32 = 0u32;
18727}
18728#[derive(Clone)]
18729pub struct FuchsiaExtension368Fn {}
18730unsafe impl Send for FuchsiaExtension368Fn {}
18731unsafe impl Sync for FuchsiaExtension368Fn {}
18732impl FuchsiaExtension368Fn {
18733 pub fn load<F>(mut _f: F) -> Self
18734 where
18735 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18736 {
18737 Self {}
18738 }
18739}
18740impl QcomExtension369Fn {
18741 pub const fn name() -> &'static ::std::ffi::CStr {
18742 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_369\0") }
18743 }
18744 pub const SPEC_VERSION: u32 = 0u32;
18745}
18746#[derive(Clone)]
18747pub struct QcomExtension369Fn {}
18748unsafe impl Send for QcomExtension369Fn {}
18749unsafe impl Sync for QcomExtension369Fn {}
18750impl QcomExtension369Fn {
18751 pub fn load<F>(mut _f: F) -> Self
18752 where
18753 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18754 {
18755 Self {}
18756 }
18757}
18758#[doc = "Generated from 'VK_QCOM_extension_369'"]
18759impl DescriptorBindingFlags {
18760 pub const RESERVED_4_QCOM: Self = Self(0b1_0000);
18761}
18762impl HuaweiSubpassShadingFn {
18763 pub const fn name() -> &'static ::std::ffi::CStr {
18764 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_subpass_shading\0") }
18765 }
18766 pub const SPEC_VERSION: u32 = 2u32;
18767}
18768#[allow(non_camel_case_types)]
18769pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn(
18770 device: Device,
18771 renderpass: RenderPass,
18772 p_max_workgroup_size: *mut Extent2D,
18773) -> Result;
18774#[allow(non_camel_case_types)]
18775pub type PFN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(command_buffer: CommandBuffer);
18776#[derive(Clone)]
18777pub struct HuaweiSubpassShadingFn {
18778 pub get_device_subpass_shading_max_workgroup_size_huawei:
18779 PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI,
18780 pub cmd_subpass_shading_huawei: PFN_vkCmdSubpassShadingHUAWEI,
18781}
18782unsafe impl Send for HuaweiSubpassShadingFn {}
18783unsafe impl Sync for HuaweiSubpassShadingFn {}
18784impl HuaweiSubpassShadingFn {
18785 pub fn load<F>(mut _f: F) -> Self
18786 where
18787 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18788 {
18789 Self {
18790 get_device_subpass_shading_max_workgroup_size_huawei: unsafe {
18791 unsafe extern "system" fn get_device_subpass_shading_max_workgroup_size_huawei(
18792 _device: Device,
18793 _renderpass: RenderPass,
18794 _p_max_workgroup_size: *mut Extent2D,
18795 ) -> Result {
18796 panic!(concat!(
18797 "Unable to load ",
18798 stringify!(get_device_subpass_shading_max_workgroup_size_huawei)
18799 ))
18800 }
18801 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18802 b"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI\0",
18803 );
18804 let val = _f(cname);
18805 if val.is_null() {
18806 get_device_subpass_shading_max_workgroup_size_huawei
18807 } else {
18808 ::std::mem::transmute(val)
18809 }
18810 },
18811 cmd_subpass_shading_huawei: unsafe {
18812 unsafe extern "system" fn cmd_subpass_shading_huawei(
18813 _command_buffer: CommandBuffer,
18814 ) {
18815 panic!(concat!(
18816 "Unable to load ",
18817 stringify!(cmd_subpass_shading_huawei)
18818 ))
18819 }
18820 let cname =
18821 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSubpassShadingHUAWEI\0");
18822 let val = _f(cname);
18823 if val.is_null() {
18824 cmd_subpass_shading_huawei
18825 } else {
18826 ::std::mem::transmute(val)
18827 }
18828 },
18829 }
18830 }
18831}
18832#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
18833impl PipelineBindPoint {
18834 pub const SUBPASS_SHADING_HUAWEI: Self = Self(1_000_369_003);
18835}
18836#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
18837impl PipelineStageFlags2 {
18838 pub const SUBPASS_SHADING_HUAWEI: Self =
18839 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
18840}
18841#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
18842impl ShaderStageFlags {
18843 pub const SUBPASS_SHADING_HUAWEI: Self = Self(0b100_0000_0000_0000);
18844}
18845#[doc = "Generated from 'VK_HUAWEI_subpass_shading'"]
18846impl StructureType {
18847 pub const SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: Self = Self(1_000_369_000);
18848 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: Self = Self(1_000_369_001);
18849 pub const PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: Self = Self(1_000_369_002);
18850}
18851impl HuaweiInvocationMaskFn {
18852 pub const fn name() -> &'static ::std::ffi::CStr {
18853 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_invocation_mask\0") }
18854 }
18855 pub const SPEC_VERSION: u32 = 1u32;
18856}
18857#[allow(non_camel_case_types)]
18858pub type PFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(
18859 command_buffer: CommandBuffer,
18860 image_view: ImageView,
18861 image_layout: ImageLayout,
18862);
18863#[derive(Clone)]
18864pub struct HuaweiInvocationMaskFn {
18865 pub cmd_bind_invocation_mask_huawei: PFN_vkCmdBindInvocationMaskHUAWEI,
18866}
18867unsafe impl Send for HuaweiInvocationMaskFn {}
18868unsafe impl Sync for HuaweiInvocationMaskFn {}
18869impl HuaweiInvocationMaskFn {
18870 pub fn load<F>(mut _f: F) -> Self
18871 where
18872 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18873 {
18874 Self {
18875 cmd_bind_invocation_mask_huawei: unsafe {
18876 unsafe extern "system" fn cmd_bind_invocation_mask_huawei(
18877 _command_buffer: CommandBuffer,
18878 _image_view: ImageView,
18879 _image_layout: ImageLayout,
18880 ) {
18881 panic!(concat!(
18882 "Unable to load ",
18883 stringify!(cmd_bind_invocation_mask_huawei)
18884 ))
18885 }
18886 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18887 b"vkCmdBindInvocationMaskHUAWEI\0",
18888 );
18889 let val = _f(cname);
18890 if val.is_null() {
18891 cmd_bind_invocation_mask_huawei
18892 } else {
18893 ::std::mem::transmute(val)
18894 }
18895 },
18896 }
18897 }
18898}
18899#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
18900impl AccessFlags2 {
18901 pub const INVOCATION_MASK_READ_HUAWEI: Self =
18902 Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
18903}
18904#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
18905impl ImageUsageFlags {
18906 pub const INVOCATION_MASK_HUAWEI: Self = Self(0b100_0000_0000_0000_0000);
18907}
18908#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
18909impl PipelineStageFlags2 {
18910 pub const INVOCATION_MASK_HUAWEI: Self =
18911 Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
18912}
18913#[doc = "Generated from 'VK_HUAWEI_invocation_mask'"]
18914impl StructureType {
18915 pub const PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: Self = Self(1_000_370_000);
18916}
18917impl NvExternalMemoryRdmaFn {
18918 pub const fn name() -> &'static ::std::ffi::CStr {
18919 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_external_memory_rdma\0") }
18920 }
18921 pub const SPEC_VERSION: u32 = 1u32;
18922}
18923#[allow(non_camel_case_types)]
18924pub type PFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(
18925 device: Device,
18926 p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
18927 p_address: *mut RemoteAddressNV,
18928) -> Result;
18929#[derive(Clone)]
18930pub struct NvExternalMemoryRdmaFn {
18931 pub get_memory_remote_address_nv: PFN_vkGetMemoryRemoteAddressNV,
18932}
18933unsafe impl Send for NvExternalMemoryRdmaFn {}
18934unsafe impl Sync for NvExternalMemoryRdmaFn {}
18935impl NvExternalMemoryRdmaFn {
18936 pub fn load<F>(mut _f: F) -> Self
18937 where
18938 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18939 {
18940 Self {
18941 get_memory_remote_address_nv: unsafe {
18942 unsafe extern "system" fn get_memory_remote_address_nv(
18943 _device: Device,
18944 _p_memory_get_remote_address_info: *const MemoryGetRemoteAddressInfoNV,
18945 _p_address: *mut RemoteAddressNV,
18946 ) -> Result {
18947 panic!(concat!(
18948 "Unable to load ",
18949 stringify!(get_memory_remote_address_nv)
18950 ))
18951 }
18952 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
18953 b"vkGetMemoryRemoteAddressNV\0",
18954 );
18955 let val = _f(cname);
18956 if val.is_null() {
18957 get_memory_remote_address_nv
18958 } else {
18959 ::std::mem::transmute(val)
18960 }
18961 },
18962 }
18963 }
18964}
18965#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
18966impl ExternalMemoryHandleTypeFlags {
18967 pub const RDMA_ADDRESS_NV: Self = Self(0b1_0000_0000_0000);
18968}
18969#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
18970impl MemoryPropertyFlags {
18971 pub const RDMA_CAPABLE_NV: Self = Self(0b1_0000_0000);
18972}
18973#[doc = "Generated from 'VK_NV_external_memory_rdma'"]
18974impl StructureType {
18975 pub const MEMORY_GET_REMOTE_ADDRESS_INFO_NV: Self = Self(1_000_371_000);
18976 pub const PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: Self = Self(1_000_371_001);
18977}
18978impl NvExtension373Fn {
18979 pub const fn name() -> &'static ::std::ffi::CStr {
18980 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_373\0") }
18981 }
18982 pub const SPEC_VERSION: u32 = 0u32;
18983}
18984#[derive(Clone)]
18985pub struct NvExtension373Fn {}
18986unsafe impl Send for NvExtension373Fn {}
18987unsafe impl Sync for NvExtension373Fn {}
18988impl NvExtension373Fn {
18989 pub fn load<F>(mut _f: F) -> Self
18990 where
18991 F: FnMut(&::std::ffi::CStr) -> *const c_void,
18992 {
18993 Self {}
18994 }
18995}
18996impl NvExtension374Fn {
18997 pub const fn name() -> &'static ::std::ffi::CStr {
18998 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_374\0") }
18999 }
19000 pub const SPEC_VERSION: u32 = 0u32;
19001}
19002#[derive(Clone)]
19003pub struct NvExtension374Fn {}
19004unsafe impl Send for NvExtension374Fn {}
19005unsafe impl Sync for NvExtension374Fn {}
19006impl NvExtension374Fn {
19007 pub fn load<F>(mut _f: F) -> Self
19008 where
19009 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19010 {
19011 Self {}
19012 }
19013}
19014#[doc = "Generated from 'VK_NV_extension_374'"]
19015impl ExternalFenceHandleTypeFlags {
19016 pub const RESERVED_4_NV: Self = Self(0b1_0000);
19017 pub const RESERVED_5_NV: Self = Self(0b10_0000);
19018}
19019#[doc = "Generated from 'VK_NV_extension_374'"]
19020impl ExternalSemaphoreHandleTypeFlags {
19021 pub const RESERVED_5_NV: Self = Self(0b10_0000);
19022 pub const RESERVED_6_NV: Self = Self(0b100_0000);
19023}
19024impl NvExtension375Fn {
19025 pub const fn name() -> &'static ::std::ffi::CStr {
19026 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_375\0") }
19027 }
19028 pub const SPEC_VERSION: u32 = 0u32;
19029}
19030#[derive(Clone)]
19031pub struct NvExtension375Fn {}
19032unsafe impl Send for NvExtension375Fn {}
19033unsafe impl Sync for NvExtension375Fn {}
19034impl NvExtension375Fn {
19035 pub fn load<F>(mut _f: F) -> Self
19036 where
19037 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19038 {
19039 Self {}
19040 }
19041}
19042#[doc = "Generated from 'VK_NV_extension_375'"]
19043impl ExternalMemoryHandleTypeFlags {
19044 pub const RESERVED_13_NV: Self = Self(0b10_0000_0000_0000);
19045}
19046impl ExtExtension376Fn {
19047 pub const fn name() -> &'static ::std::ffi::CStr {
19048 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_376\0") }
19049 }
19050 pub const SPEC_VERSION: u32 = 0u32;
19051}
19052#[derive(Clone)]
19053pub struct ExtExtension376Fn {}
19054unsafe impl Send for ExtExtension376Fn {}
19055unsafe impl Sync for ExtExtension376Fn {}
19056impl ExtExtension376Fn {
19057 pub fn load<F>(mut _f: F) -> Self
19058 where
19059 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19060 {
19061 Self {}
19062 }
19063}
19064impl ExtExtension377Fn {
19065 pub const fn name() -> &'static ::std::ffi::CStr {
19066 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_377\0") }
19067 }
19068 pub const SPEC_VERSION: u32 = 0u32;
19069}
19070#[derive(Clone)]
19071pub struct ExtExtension377Fn {}
19072unsafe impl Send for ExtExtension377Fn {}
19073unsafe impl Sync for ExtExtension377Fn {}
19074impl ExtExtension377Fn {
19075 pub fn load<F>(mut _f: F) -> Self
19076 where
19077 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19078 {
19079 Self {}
19080 }
19081}
19082#[doc = "Generated from 'VK_EXT_extension_377'"]
19083impl ImageCreateFlags {
19084 pub const RESERVED_18_EXT: Self = Self(0b100_0000_0000_0000_0000);
19085}
19086impl ExtExtendedDynamicState2Fn {
19087 pub const fn name() -> &'static ::std::ffi::CStr {
19088 unsafe {
19089 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extended_dynamic_state2\0")
19090 }
19091 }
19092 pub const SPEC_VERSION: u32 = 1u32;
19093}
19094#[allow(non_camel_case_types)]
19095pub type PFN_vkCmdSetPatchControlPointsEXT =
19096 unsafe extern "system" fn(command_buffer: CommandBuffer, patch_control_points: u32);
19097#[allow(non_camel_case_types)]
19098pub type PFN_vkCmdSetRasterizerDiscardEnable =
19099 unsafe extern "system" fn(command_buffer: CommandBuffer, rasterizer_discard_enable: Bool32);
19100#[allow(non_camel_case_types)]
19101pub type PFN_vkCmdSetDepthBiasEnable =
19102 unsafe extern "system" fn(command_buffer: CommandBuffer, depth_bias_enable: Bool32);
19103#[allow(non_camel_case_types)]
19104pub type PFN_vkCmdSetLogicOpEXT =
19105 unsafe extern "system" fn(command_buffer: CommandBuffer, logic_op: LogicOp);
19106#[allow(non_camel_case_types)]
19107pub type PFN_vkCmdSetPrimitiveRestartEnable =
19108 unsafe extern "system" fn(command_buffer: CommandBuffer, primitive_restart_enable: Bool32);
19109#[derive(Clone)]
19110pub struct ExtExtendedDynamicState2Fn {
19111 pub cmd_set_patch_control_points_ext: PFN_vkCmdSetPatchControlPointsEXT,
19112 pub cmd_set_rasterizer_discard_enable_ext: PFN_vkCmdSetRasterizerDiscardEnable,
19113 pub cmd_set_depth_bias_enable_ext: PFN_vkCmdSetDepthBiasEnable,
19114 pub cmd_set_logic_op_ext: PFN_vkCmdSetLogicOpEXT,
19115 pub cmd_set_primitive_restart_enable_ext: PFN_vkCmdSetPrimitiveRestartEnable,
19116}
19117unsafe impl Send for ExtExtendedDynamicState2Fn {}
19118unsafe impl Sync for ExtExtendedDynamicState2Fn {}
19119impl ExtExtendedDynamicState2Fn {
19120 pub fn load<F>(mut _f: F) -> Self
19121 where
19122 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19123 {
19124 Self {
19125 cmd_set_patch_control_points_ext: unsafe {
19126 unsafe extern "system" fn cmd_set_patch_control_points_ext(
19127 _command_buffer: CommandBuffer,
19128 _patch_control_points: u32,
19129 ) {
19130 panic!(concat!(
19131 "Unable to load ",
19132 stringify!(cmd_set_patch_control_points_ext)
19133 ))
19134 }
19135 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19136 b"vkCmdSetPatchControlPointsEXT\0",
19137 );
19138 let val = _f(cname);
19139 if val.is_null() {
19140 cmd_set_patch_control_points_ext
19141 } else {
19142 ::std::mem::transmute(val)
19143 }
19144 },
19145 cmd_set_rasterizer_discard_enable_ext: unsafe {
19146 unsafe extern "system" fn cmd_set_rasterizer_discard_enable_ext(
19147 _command_buffer: CommandBuffer,
19148 _rasterizer_discard_enable: Bool32,
19149 ) {
19150 panic!(concat!(
19151 "Unable to load ",
19152 stringify!(cmd_set_rasterizer_discard_enable_ext)
19153 ))
19154 }
19155 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19156 b"vkCmdSetRasterizerDiscardEnableEXT\0",
19157 );
19158 let val = _f(cname);
19159 if val.is_null() {
19160 cmd_set_rasterizer_discard_enable_ext
19161 } else {
19162 ::std::mem::transmute(val)
19163 }
19164 },
19165 cmd_set_depth_bias_enable_ext: unsafe {
19166 unsafe extern "system" fn cmd_set_depth_bias_enable_ext(
19167 _command_buffer: CommandBuffer,
19168 _depth_bias_enable: Bool32,
19169 ) {
19170 panic!(concat!(
19171 "Unable to load ",
19172 stringify!(cmd_set_depth_bias_enable_ext)
19173 ))
19174 }
19175 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19176 b"vkCmdSetDepthBiasEnableEXT\0",
19177 );
19178 let val = _f(cname);
19179 if val.is_null() {
19180 cmd_set_depth_bias_enable_ext
19181 } else {
19182 ::std::mem::transmute(val)
19183 }
19184 },
19185 cmd_set_logic_op_ext: unsafe {
19186 unsafe extern "system" fn cmd_set_logic_op_ext(
19187 _command_buffer: CommandBuffer,
19188 _logic_op: LogicOp,
19189 ) {
19190 panic!(concat!("Unable to load ", stringify!(cmd_set_logic_op_ext)))
19191 }
19192 let cname =
19193 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdSetLogicOpEXT\0");
19194 let val = _f(cname);
19195 if val.is_null() {
19196 cmd_set_logic_op_ext
19197 } else {
19198 ::std::mem::transmute(val)
19199 }
19200 },
19201 cmd_set_primitive_restart_enable_ext: unsafe {
19202 unsafe extern "system" fn cmd_set_primitive_restart_enable_ext(
19203 _command_buffer: CommandBuffer,
19204 _primitive_restart_enable: Bool32,
19205 ) {
19206 panic!(concat!(
19207 "Unable to load ",
19208 stringify!(cmd_set_primitive_restart_enable_ext)
19209 ))
19210 }
19211 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19212 b"vkCmdSetPrimitiveRestartEnableEXT\0",
19213 );
19214 let val = _f(cname);
19215 if val.is_null() {
19216 cmd_set_primitive_restart_enable_ext
19217 } else {
19218 ::std::mem::transmute(val)
19219 }
19220 },
19221 }
19222 }
19223}
19224#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
19225impl DynamicState {
19226 #[doc = "Not promoted to 1.3"]
19227 pub const PATCH_CONTROL_POINTS_EXT: Self = Self(1_000_377_000);
19228 pub const RASTERIZER_DISCARD_ENABLE_EXT: Self = Self::RASTERIZER_DISCARD_ENABLE;
19229 pub const DEPTH_BIAS_ENABLE_EXT: Self = Self::DEPTH_BIAS_ENABLE;
19230 #[doc = "Not promoted to 1.3"]
19231 pub const LOGIC_OP_EXT: Self = Self(1_000_377_003);
19232 pub const PRIMITIVE_RESTART_ENABLE_EXT: Self = Self::PRIMITIVE_RESTART_ENABLE;
19233}
19234#[doc = "Generated from 'VK_EXT_extended_dynamic_state2'"]
19235impl StructureType {
19236 #[doc = "Not promoted to 1.3"]
19237 pub const PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: Self = Self(1_000_377_000);
19238}
19239impl QnxScreenSurfaceFn {
19240 pub const fn name() -> &'static ::std::ffi::CStr {
19241 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QNX_screen_surface\0") }
19242 }
19243 pub const SPEC_VERSION: u32 = 1u32;
19244}
19245#[allow(non_camel_case_types)]
19246pub type PFN_vkCreateScreenSurfaceQNX = unsafe extern "system" fn(
19247 instance: Instance,
19248 p_create_info: *const ScreenSurfaceCreateInfoQNX,
19249 p_allocator: *const AllocationCallbacks,
19250 p_surface: *mut SurfaceKHR,
19251) -> Result;
19252#[allow(non_camel_case_types)]
19253pub type PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX = unsafe extern "system" fn(
19254 physical_device: PhysicalDevice,
19255 queue_family_index: u32,
19256 window: *mut _screen_window,
19257) -> Bool32;
19258#[derive(Clone)]
19259pub struct QnxScreenSurfaceFn {
19260 pub create_screen_surface_qnx: PFN_vkCreateScreenSurfaceQNX,
19261 pub get_physical_device_screen_presentation_support_qnx:
19262 PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX,
19263}
19264unsafe impl Send for QnxScreenSurfaceFn {}
19265unsafe impl Sync for QnxScreenSurfaceFn {}
19266impl QnxScreenSurfaceFn {
19267 pub fn load<F>(mut _f: F) -> Self
19268 where
19269 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19270 {
19271 Self {
19272 create_screen_surface_qnx: unsafe {
19273 unsafe extern "system" fn create_screen_surface_qnx(
19274 _instance: Instance,
19275 _p_create_info: *const ScreenSurfaceCreateInfoQNX,
19276 _p_allocator: *const AllocationCallbacks,
19277 _p_surface: *mut SurfaceKHR,
19278 ) -> Result {
19279 panic!(concat!(
19280 "Unable to load ",
19281 stringify!(create_screen_surface_qnx)
19282 ))
19283 }
19284 let cname =
19285 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCreateScreenSurfaceQNX\0");
19286 let val = _f(cname);
19287 if val.is_null() {
19288 create_screen_surface_qnx
19289 } else {
19290 ::std::mem::transmute(val)
19291 }
19292 },
19293 get_physical_device_screen_presentation_support_qnx: unsafe {
19294 unsafe extern "system" fn get_physical_device_screen_presentation_support_qnx(
19295 _physical_device: PhysicalDevice,
19296 _queue_family_index: u32,
19297 _window: *mut _screen_window,
19298 ) -> Bool32 {
19299 panic!(concat!(
19300 "Unable to load ",
19301 stringify!(get_physical_device_screen_presentation_support_qnx)
19302 ))
19303 }
19304 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19305 b"vkGetPhysicalDeviceScreenPresentationSupportQNX\0",
19306 );
19307 let val = _f(cname);
19308 if val.is_null() {
19309 get_physical_device_screen_presentation_support_qnx
19310 } else {
19311 ::std::mem::transmute(val)
19312 }
19313 },
19314 }
19315 }
19316}
19317#[doc = "Generated from 'VK_QNX_screen_surface'"]
19318impl StructureType {
19319 pub const SCREEN_SURFACE_CREATE_INFO_QNX: Self = Self(1_000_378_000);
19320}
19321impl KhrExtension380Fn {
19322 pub const fn name() -> &'static ::std::ffi::CStr {
19323 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_380\0") }
19324 }
19325 pub const SPEC_VERSION: u32 = 0u32;
19326}
19327#[derive(Clone)]
19328pub struct KhrExtension380Fn {}
19329unsafe impl Send for KhrExtension380Fn {}
19330unsafe impl Sync for KhrExtension380Fn {}
19331impl KhrExtension380Fn {
19332 pub fn load<F>(mut _f: F) -> Self
19333 where
19334 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19335 {
19336 Self {}
19337 }
19338}
19339impl KhrExtension381Fn {
19340 pub const fn name() -> &'static ::std::ffi::CStr {
19341 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_381\0") }
19342 }
19343 pub const SPEC_VERSION: u32 = 0u32;
19344}
19345#[derive(Clone)]
19346pub struct KhrExtension381Fn {}
19347unsafe impl Send for KhrExtension381Fn {}
19348unsafe impl Sync for KhrExtension381Fn {}
19349impl KhrExtension381Fn {
19350 pub fn load<F>(mut _f: F) -> Self
19351 where
19352 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19353 {
19354 Self {}
19355 }
19356}
19357impl ExtColorWriteEnableFn {
19358 pub const fn name() -> &'static ::std::ffi::CStr {
19359 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_color_write_enable\0") }
19360 }
19361 pub const SPEC_VERSION: u32 = 1u32;
19362}
19363#[allow(non_camel_case_types)]
19364pub type PFN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn(
19365 command_buffer: CommandBuffer,
19366 attachment_count: u32,
19367 p_color_write_enables: *const Bool32,
19368);
19369#[derive(Clone)]
19370pub struct ExtColorWriteEnableFn {
19371 pub cmd_set_color_write_enable_ext: PFN_vkCmdSetColorWriteEnableEXT,
19372}
19373unsafe impl Send for ExtColorWriteEnableFn {}
19374unsafe impl Sync for ExtColorWriteEnableFn {}
19375impl ExtColorWriteEnableFn {
19376 pub fn load<F>(mut _f: F) -> Self
19377 where
19378 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19379 {
19380 Self {
19381 cmd_set_color_write_enable_ext: unsafe {
19382 unsafe extern "system" fn cmd_set_color_write_enable_ext(
19383 _command_buffer: CommandBuffer,
19384 _attachment_count: u32,
19385 _p_color_write_enables: *const Bool32,
19386 ) {
19387 panic!(concat!(
19388 "Unable to load ",
19389 stringify!(cmd_set_color_write_enable_ext)
19390 ))
19391 }
19392 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
19393 b"vkCmdSetColorWriteEnableEXT\0",
19394 );
19395 let val = _f(cname);
19396 if val.is_null() {
19397 cmd_set_color_write_enable_ext
19398 } else {
19399 ::std::mem::transmute(val)
19400 }
19401 },
19402 }
19403 }
19404}
19405#[doc = "Generated from 'VK_EXT_color_write_enable'"]
19406impl DynamicState {
19407 pub const COLOR_WRITE_ENABLE_EXT: Self = Self(1_000_381_000);
19408}
19409#[doc = "Generated from 'VK_EXT_color_write_enable'"]
19410impl StructureType {
19411 pub const PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: Self = Self(1_000_381_000);
19412 pub const PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: Self = Self(1_000_381_001);
19413}
19414impl ExtExtension383Fn {
19415 pub const fn name() -> &'static ::std::ffi::CStr {
19416 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_383\0") }
19417 }
19418 pub const SPEC_VERSION: u32 = 0u32;
19419}
19420#[derive(Clone)]
19421pub struct ExtExtension383Fn {}
19422unsafe impl Send for ExtExtension383Fn {}
19423unsafe impl Sync for ExtExtension383Fn {}
19424impl ExtExtension383Fn {
19425 pub fn load<F>(mut _f: F) -> Self
19426 where
19427 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19428 {
19429 Self {}
19430 }
19431}
19432impl ExtExtension384Fn {
19433 pub const fn name() -> &'static ::std::ffi::CStr {
19434 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_384\0") }
19435 }
19436 pub const SPEC_VERSION: u32 = 0u32;
19437}
19438#[derive(Clone)]
19439pub struct ExtExtension384Fn {}
19440unsafe impl Send for ExtExtension384Fn {}
19441unsafe impl Sync for ExtExtension384Fn {}
19442impl ExtExtension384Fn {
19443 pub fn load<F>(mut _f: F) -> Self
19444 where
19445 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19446 {
19447 Self {}
19448 }
19449}
19450impl MesaExtension385Fn {
19451 pub const fn name() -> &'static ::std::ffi::CStr {
19452 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_MESA_extension_385\0") }
19453 }
19454 pub const SPEC_VERSION: u32 = 0u32;
19455}
19456#[derive(Clone)]
19457pub struct MesaExtension385Fn {}
19458unsafe impl Send for MesaExtension385Fn {}
19459unsafe impl Sync for MesaExtension385Fn {}
19460impl MesaExtension385Fn {
19461 pub fn load<F>(mut _f: F) -> Self
19462 where
19463 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19464 {
19465 Self {}
19466 }
19467}
19468impl GoogleExtension386Fn {
19469 pub const fn name() -> &'static ::std::ffi::CStr {
19470 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_386\0") }
19471 }
19472 pub const SPEC_VERSION: u32 = 0u32;
19473}
19474#[derive(Clone)]
19475pub struct GoogleExtension386Fn {}
19476unsafe impl Send for GoogleExtension386Fn {}
19477unsafe impl Sync for GoogleExtension386Fn {}
19478impl GoogleExtension386Fn {
19479 pub fn load<F>(mut _f: F) -> Self
19480 where
19481 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19482 {
19483 Self {}
19484 }
19485}
19486impl KhrExtension387Fn {
19487 pub const fn name() -> &'static ::std::ffi::CStr {
19488 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_387\0") }
19489 }
19490 pub const SPEC_VERSION: u32 = 0u32;
19491}
19492#[derive(Clone)]
19493pub struct KhrExtension387Fn {}
19494unsafe impl Send for KhrExtension387Fn {}
19495unsafe impl Sync for KhrExtension387Fn {}
19496impl KhrExtension387Fn {
19497 pub fn load<F>(mut _f: F) -> Self
19498 where
19499 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19500 {
19501 Self {}
19502 }
19503}
19504#[doc = "Generated from 'VK_KHR_extension_387'"]
19505impl AccessFlags2 {
19506 pub const RESERVED_387_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
19507}
19508#[doc = "Generated from 'VK_KHR_extension_387'"]
19509impl PipelineStageFlags2 {
19510 pub const RESERVED_387_KHR: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000);
19511}
19512impl ExtExtension388Fn {
19513 pub const fn name() -> &'static ::std::ffi::CStr {
19514 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_388\0") }
19515 }
19516 pub const SPEC_VERSION: u32 = 0u32;
19517}
19518#[derive(Clone)]
19519pub struct ExtExtension388Fn {}
19520unsafe impl Send for ExtExtension388Fn {}
19521unsafe impl Sync for ExtExtension388Fn {}
19522impl ExtExtension388Fn {
19523 pub fn load<F>(mut _f: F) -> Self
19524 where
19525 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19526 {
19527 Self {}
19528 }
19529}
19530impl ExtGlobalPriorityQueryFn {
19531 pub const fn name() -> &'static ::std::ffi::CStr {
19532 unsafe {
19533 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_global_priority_query\0")
19534 }
19535 }
19536 pub const SPEC_VERSION: u32 = 1u32;
19537}
19538#[derive(Clone)]
19539pub struct ExtGlobalPriorityQueryFn {}
19540unsafe impl Send for ExtGlobalPriorityQueryFn {}
19541unsafe impl Sync for ExtGlobalPriorityQueryFn {}
19542impl ExtGlobalPriorityQueryFn {
19543 pub fn load<F>(mut _f: F) -> Self
19544 where
19545 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19546 {
19547 Self {}
19548 }
19549}
19550#[doc = "Generated from 'VK_EXT_global_priority_query'"]
19551impl StructureType {
19552 pub const PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: Self =
19553 Self::PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR;
19554 pub const QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: Self =
19555 Self::QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR;
19556}
19557impl ExtExtension390Fn {
19558 pub const fn name() -> &'static ::std::ffi::CStr {
19559 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_390\0") }
19560 }
19561 pub const SPEC_VERSION: u32 = 0u32;
19562}
19563#[derive(Clone)]
19564pub struct ExtExtension390Fn {}
19565unsafe impl Send for ExtExtension390Fn {}
19566unsafe impl Sync for ExtExtension390Fn {}
19567impl ExtExtension390Fn {
19568 pub fn load<F>(mut _f: F) -> Self
19569 where
19570 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19571 {
19572 Self {}
19573 }
19574}
19575impl ExtExtension391Fn {
19576 pub const fn name() -> &'static ::std::ffi::CStr {
19577 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_391\0") }
19578 }
19579 pub const SPEC_VERSION: u32 = 0u32;
19580}
19581#[derive(Clone)]
19582pub struct ExtExtension391Fn {}
19583unsafe impl Send for ExtExtension391Fn {}
19584unsafe impl Sync for ExtExtension391Fn {}
19585impl ExtExtension391Fn {
19586 pub fn load<F>(mut _f: F) -> Self
19587 where
19588 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19589 {
19590 Self {}
19591 }
19592}
19593impl ExtImageViewMinLodFn {
19594 pub const fn name() -> &'static ::std::ffi::CStr {
19595 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_image_view_min_lod\0") }
19596 }
19597 pub const SPEC_VERSION: u32 = 1u32;
19598}
19599#[derive(Clone)]
19600pub struct ExtImageViewMinLodFn {}
19601unsafe impl Send for ExtImageViewMinLodFn {}
19602unsafe impl Sync for ExtImageViewMinLodFn {}
19603impl ExtImageViewMinLodFn {
19604 pub fn load<F>(mut _f: F) -> Self
19605 where
19606 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19607 {
19608 Self {}
19609 }
19610}
19611#[doc = "Generated from 'VK_EXT_image_view_min_lod'"]
19612impl StructureType {
19613 pub const PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: Self = Self(1_000_391_000);
19614 pub const IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: Self = Self(1_000_391_001);
19615}
19616impl ExtMultiDrawFn {
19617 pub const fn name() -> &'static ::std::ffi::CStr {
19618 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_multi_draw\0") }
19619 }
19620 pub const SPEC_VERSION: u32 = 1u32;
19621}
19622#[allow(non_camel_case_types)]
19623pub type PFN_vkCmdDrawMultiEXT = unsafe extern "system" fn(
19624 command_buffer: CommandBuffer,
19625 draw_count: u32,
19626 p_vertex_info: *const MultiDrawInfoEXT,
19627 instance_count: u32,
19628 first_instance: u32,
19629 stride: u32,
19630);
19631#[allow(non_camel_case_types)]
19632pub type PFN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn(
19633 command_buffer: CommandBuffer,
19634 draw_count: u32,
19635 p_index_info: *const MultiDrawIndexedInfoEXT,
19636 instance_count: u32,
19637 first_instance: u32,
19638 stride: u32,
19639 p_vertex_offset: *const i32,
19640);
19641#[derive(Clone)]
19642pub struct ExtMultiDrawFn {
19643 pub cmd_draw_multi_ext: PFN_vkCmdDrawMultiEXT,
19644 pub cmd_draw_multi_indexed_ext: PFN_vkCmdDrawMultiIndexedEXT,
19645}
19646unsafe impl Send for ExtMultiDrawFn {}
19647unsafe impl Sync for ExtMultiDrawFn {}
19648impl ExtMultiDrawFn {
19649 pub fn load<F>(mut _f: F) -> Self
19650 where
19651 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19652 {
19653 Self {
19654 cmd_draw_multi_ext: unsafe {
19655 unsafe extern "system" fn cmd_draw_multi_ext(
19656 _command_buffer: CommandBuffer,
19657 _draw_count: u32,
19658 _p_vertex_info: *const MultiDrawInfoEXT,
19659 _instance_count: u32,
19660 _first_instance: u32,
19661 _stride: u32,
19662 ) {
19663 panic!(concat!("Unable to load ", stringify!(cmd_draw_multi_ext)))
19664 }
19665 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiEXT\0");
19666 let val = _f(cname);
19667 if val.is_null() {
19668 cmd_draw_multi_ext
19669 } else {
19670 ::std::mem::transmute(val)
19671 }
19672 },
19673 cmd_draw_multi_indexed_ext: unsafe {
19674 unsafe extern "system" fn cmd_draw_multi_indexed_ext(
19675 _command_buffer: CommandBuffer,
19676 _draw_count: u32,
19677 _p_index_info: *const MultiDrawIndexedInfoEXT,
19678 _instance_count: u32,
19679 _first_instance: u32,
19680 _stride: u32,
19681 _p_vertex_offset: *const i32,
19682 ) {
19683 panic!(concat!(
19684 "Unable to load ",
19685 stringify!(cmd_draw_multi_indexed_ext)
19686 ))
19687 }
19688 let cname =
19689 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"vkCmdDrawMultiIndexedEXT\0");
19690 let val = _f(cname);
19691 if val.is_null() {
19692 cmd_draw_multi_indexed_ext
19693 } else {
19694 ::std::mem::transmute(val)
19695 }
19696 },
19697 }
19698 }
19699}
19700#[doc = "Generated from 'VK_EXT_multi_draw'"]
19701impl StructureType {
19702 pub const PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: Self = Self(1_000_392_000);
19703 pub const PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: Self = Self(1_000_392_001);
19704}
19705impl ExtExtension394Fn {
19706 pub const fn name() -> &'static ::std::ffi::CStr {
19707 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_394\0") }
19708 }
19709 pub const SPEC_VERSION: u32 = 0u32;
19710}
19711#[derive(Clone)]
19712pub struct ExtExtension394Fn {}
19713unsafe impl Send for ExtExtension394Fn {}
19714unsafe impl Sync for ExtExtension394Fn {}
19715impl ExtExtension394Fn {
19716 pub fn load<F>(mut _f: F) -> Self
19717 where
19718 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19719 {
19720 Self {}
19721 }
19722}
19723#[doc = "Generated from 'VK_EXT_extension_394'"]
19724impl ImageCreateFlags {
19725 pub const RESERVED_394_EXT: Self = Self(0b10_0000_0000_0000_0000);
19726}
19727impl KhrPortabilityEnumerationFn {
19728 pub const fn name() -> &'static ::std::ffi::CStr {
19729 unsafe {
19730 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_portability_enumeration\0")
19731 }
19732 }
19733 pub const SPEC_VERSION: u32 = 1u32;
19734}
19735#[derive(Clone)]
19736pub struct KhrPortabilityEnumerationFn {}
19737unsafe impl Send for KhrPortabilityEnumerationFn {}
19738unsafe impl Sync for KhrPortabilityEnumerationFn {}
19739impl KhrPortabilityEnumerationFn {
19740 pub fn load<F>(mut _f: F) -> Self
19741 where
19742 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19743 {
19744 Self {}
19745 }
19746}
19747#[doc = "Generated from 'VK_KHR_portability_enumeration'"]
19748impl InstanceCreateFlags {
19749 pub const ENUMERATE_PORTABILITY_KHR: Self = Self(0b1);
19750}
19751impl KhrExtension396Fn {
19752 pub const fn name() -> &'static ::std::ffi::CStr {
19753 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_396\0") }
19754 }
19755 pub const SPEC_VERSION: u32 = 0u32;
19756}
19757#[derive(Clone)]
19758pub struct KhrExtension396Fn {}
19759unsafe impl Send for KhrExtension396Fn {}
19760unsafe impl Sync for KhrExtension396Fn {}
19761impl KhrExtension396Fn {
19762 pub fn load<F>(mut _f: F) -> Self
19763 where
19764 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19765 {
19766 Self {}
19767 }
19768}
19769impl NvExtension397Fn {
19770 pub const fn name() -> &'static ::std::ffi::CStr {
19771 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_397\0") }
19772 }
19773 pub const SPEC_VERSION: u32 = 0u32;
19774}
19775#[derive(Clone)]
19776pub struct NvExtension397Fn {}
19777unsafe impl Send for NvExtension397Fn {}
19778unsafe impl Sync for NvExtension397Fn {}
19779impl NvExtension397Fn {
19780 pub fn load<F>(mut _f: F) -> Self
19781 where
19782 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19783 {
19784 Self {}
19785 }
19786}
19787impl NvExtension398Fn {
19788 pub const fn name() -> &'static ::std::ffi::CStr {
19789 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_398\0") }
19790 }
19791 pub const SPEC_VERSION: u32 = 0u32;
19792}
19793#[derive(Clone)]
19794pub struct NvExtension398Fn {}
19795unsafe impl Send for NvExtension398Fn {}
19796unsafe impl Sync for NvExtension398Fn {}
19797impl NvExtension398Fn {
19798 pub fn load<F>(mut _f: F) -> Self
19799 where
19800 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19801 {
19802 Self {}
19803 }
19804}
19805impl JuiceExtension399Fn {
19806 pub const fn name() -> &'static ::std::ffi::CStr {
19807 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_399\0") }
19808 }
19809 pub const SPEC_VERSION: u32 = 0u32;
19810}
19811#[derive(Clone)]
19812pub struct JuiceExtension399Fn {}
19813unsafe impl Send for JuiceExtension399Fn {}
19814unsafe impl Sync for JuiceExtension399Fn {}
19815impl JuiceExtension399Fn {
19816 pub fn load<F>(mut _f: F) -> Self
19817 where
19818 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19819 {
19820 Self {}
19821 }
19822}
19823impl JuiceExtension400Fn {
19824 pub const fn name() -> &'static ::std::ffi::CStr {
19825 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_JUICE_extension_400\0") }
19826 }
19827 pub const SPEC_VERSION: u32 = 0u32;
19828}
19829#[derive(Clone)]
19830pub struct JuiceExtension400Fn {}
19831unsafe impl Send for JuiceExtension400Fn {}
19832unsafe impl Sync for JuiceExtension400Fn {}
19833impl JuiceExtension400Fn {
19834 pub fn load<F>(mut _f: F) -> Self
19835 where
19836 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19837 {
19838 Self {}
19839 }
19840}
19841impl ExtLoadStoreOpNoneFn {
19842 pub const fn name() -> &'static ::std::ffi::CStr {
19843 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_load_store_op_none\0") }
19844 }
19845 pub const SPEC_VERSION: u32 = 1u32;
19846}
19847#[derive(Clone)]
19848pub struct ExtLoadStoreOpNoneFn {}
19849unsafe impl Send for ExtLoadStoreOpNoneFn {}
19850unsafe impl Sync for ExtLoadStoreOpNoneFn {}
19851impl ExtLoadStoreOpNoneFn {
19852 pub fn load<F>(mut _f: F) -> Self
19853 where
19854 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19855 {
19856 Self {}
19857 }
19858}
19859#[doc = "Generated from 'VK_EXT_load_store_op_none'"]
19860impl AttachmentLoadOp {
19861 pub const NONE_EXT: Self = Self(1_000_400_000);
19862}
19863#[doc = "Generated from 'VK_EXT_load_store_op_none'"]
19864impl AttachmentStoreOp {
19865 pub const NONE_EXT: Self = Self::NONE;
19866}
19867impl FbExtension402Fn {
19868 pub const fn name() -> &'static ::std::ffi::CStr {
19869 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_402\0") }
19870 }
19871 pub const SPEC_VERSION: u32 = 0u32;
19872}
19873#[derive(Clone)]
19874pub struct FbExtension402Fn {}
19875unsafe impl Send for FbExtension402Fn {}
19876unsafe impl Sync for FbExtension402Fn {}
19877impl FbExtension402Fn {
19878 pub fn load<F>(mut _f: F) -> Self
19879 where
19880 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19881 {
19882 Self {}
19883 }
19884}
19885impl FbExtension403Fn {
19886 pub const fn name() -> &'static ::std::ffi::CStr {
19887 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_403\0") }
19888 }
19889 pub const SPEC_VERSION: u32 = 0u32;
19890}
19891#[derive(Clone)]
19892pub struct FbExtension403Fn {}
19893unsafe impl Send for FbExtension403Fn {}
19894unsafe impl Sync for FbExtension403Fn {}
19895impl FbExtension403Fn {
19896 pub fn load<F>(mut _f: F) -> Self
19897 where
19898 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19899 {
19900 Self {}
19901 }
19902}
19903impl FbExtension404Fn {
19904 pub const fn name() -> &'static ::std::ffi::CStr {
19905 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_FB_extension_404\0") }
19906 }
19907 pub const SPEC_VERSION: u32 = 0u32;
19908}
19909#[derive(Clone)]
19910pub struct FbExtension404Fn {}
19911unsafe impl Send for FbExtension404Fn {}
19912unsafe impl Sync for FbExtension404Fn {}
19913impl FbExtension404Fn {
19914 pub fn load<F>(mut _f: F) -> Self
19915 where
19916 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19917 {
19918 Self {}
19919 }
19920}
19921impl HuaweiExtension405Fn {
19922 pub const fn name() -> &'static ::std::ffi::CStr {
19923 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_405\0") }
19924 }
19925 pub const SPEC_VERSION: u32 = 0u32;
19926}
19927#[derive(Clone)]
19928pub struct HuaweiExtension405Fn {}
19929unsafe impl Send for HuaweiExtension405Fn {}
19930unsafe impl Sync for HuaweiExtension405Fn {}
19931impl HuaweiExtension405Fn {
19932 pub fn load<F>(mut _f: F) -> Self
19933 where
19934 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19935 {
19936 Self {}
19937 }
19938}
19939impl HuaweiExtension406Fn {
19940 pub const fn name() -> &'static ::std::ffi::CStr {
19941 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_406\0") }
19942 }
19943 pub const SPEC_VERSION: u32 = 0u32;
19944}
19945#[derive(Clone)]
19946pub struct HuaweiExtension406Fn {}
19947unsafe impl Send for HuaweiExtension406Fn {}
19948unsafe impl Sync for HuaweiExtension406Fn {}
19949impl HuaweiExtension406Fn {
19950 pub fn load<F>(mut _f: F) -> Self
19951 where
19952 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19953 {
19954 Self {}
19955 }
19956}
19957impl GgpExtension407Fn {
19958 pub const fn name() -> &'static ::std::ffi::CStr {
19959 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_407\0") }
19960 }
19961 pub const SPEC_VERSION: u32 = 0u32;
19962}
19963#[derive(Clone)]
19964pub struct GgpExtension407Fn {}
19965unsafe impl Send for GgpExtension407Fn {}
19966unsafe impl Sync for GgpExtension407Fn {}
19967impl GgpExtension407Fn {
19968 pub fn load<F>(mut _f: F) -> Self
19969 where
19970 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19971 {
19972 Self {}
19973 }
19974}
19975impl GgpExtension408Fn {
19976 pub const fn name() -> &'static ::std::ffi::CStr {
19977 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_408\0") }
19978 }
19979 pub const SPEC_VERSION: u32 = 0u32;
19980}
19981#[derive(Clone)]
19982pub struct GgpExtension408Fn {}
19983unsafe impl Send for GgpExtension408Fn {}
19984unsafe impl Sync for GgpExtension408Fn {}
19985impl GgpExtension408Fn {
19986 pub fn load<F>(mut _f: F) -> Self
19987 where
19988 F: FnMut(&::std::ffi::CStr) -> *const c_void,
19989 {
19990 Self {}
19991 }
19992}
19993impl GgpExtension409Fn {
19994 pub const fn name() -> &'static ::std::ffi::CStr {
19995 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_409\0") }
19996 }
19997 pub const SPEC_VERSION: u32 = 0u32;
19998}
19999#[derive(Clone)]
20000pub struct GgpExtension409Fn {}
20001unsafe impl Send for GgpExtension409Fn {}
20002unsafe impl Sync for GgpExtension409Fn {}
20003impl GgpExtension409Fn {
20004 pub fn load<F>(mut _f: F) -> Self
20005 where
20006 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20007 {
20008 Self {}
20009 }
20010}
20011impl GgpExtension410Fn {
20012 pub const fn name() -> &'static ::std::ffi::CStr {
20013 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_410\0") }
20014 }
20015 pub const SPEC_VERSION: u32 = 0u32;
20016}
20017#[derive(Clone)]
20018pub struct GgpExtension410Fn {}
20019unsafe impl Send for GgpExtension410Fn {}
20020unsafe impl Sync for GgpExtension410Fn {}
20021impl GgpExtension410Fn {
20022 pub fn load<F>(mut _f: F) -> Self
20023 where
20024 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20025 {
20026 Self {}
20027 }
20028}
20029impl GgpExtension411Fn {
20030 pub const fn name() -> &'static ::std::ffi::CStr {
20031 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GGP_extension_411\0") }
20032 }
20033 pub const SPEC_VERSION: u32 = 0u32;
20034}
20035#[derive(Clone)]
20036pub struct GgpExtension411Fn {}
20037unsafe impl Send for GgpExtension411Fn {}
20038unsafe impl Sync for GgpExtension411Fn {}
20039impl GgpExtension411Fn {
20040 pub fn load<F>(mut _f: F) -> Self
20041 where
20042 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20043 {
20044 Self {}
20045 }
20046}
20047impl ExtBorderColorSwizzleFn {
20048 pub const fn name() -> &'static ::std::ffi::CStr {
20049 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_border_color_swizzle\0") }
20050 }
20051 pub const SPEC_VERSION: u32 = 1u32;
20052}
20053#[derive(Clone)]
20054pub struct ExtBorderColorSwizzleFn {}
20055unsafe impl Send for ExtBorderColorSwizzleFn {}
20056unsafe impl Sync for ExtBorderColorSwizzleFn {}
20057impl ExtBorderColorSwizzleFn {
20058 pub fn load<F>(mut _f: F) -> Self
20059 where
20060 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20061 {
20062 Self {}
20063 }
20064}
20065#[doc = "Generated from 'VK_EXT_border_color_swizzle'"]
20066impl StructureType {
20067 pub const PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: Self = Self(1_000_411_000);
20068 pub const SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: Self = Self(1_000_411_001);
20069}
20070impl ExtPageableDeviceLocalMemoryFn {
20071 pub const fn name() -> &'static ::std::ffi::CStr {
20072 unsafe {
20073 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20074 b"VK_EXT_pageable_device_local_memory\0",
20075 )
20076 }
20077 }
20078 pub const SPEC_VERSION: u32 = 1u32;
20079}
20080#[allow(non_camel_case_types)]
20081pub type PFN_vkSetDeviceMemoryPriorityEXT =
20082 unsafe extern "system" fn(device: Device, memory: DeviceMemory, priority: f32);
20083#[derive(Clone)]
20084pub struct ExtPageableDeviceLocalMemoryFn {
20085 pub set_device_memory_priority_ext: PFN_vkSetDeviceMemoryPriorityEXT,
20086}
20087unsafe impl Send for ExtPageableDeviceLocalMemoryFn {}
20088unsafe impl Sync for ExtPageableDeviceLocalMemoryFn {}
20089impl ExtPageableDeviceLocalMemoryFn {
20090 pub fn load<F>(mut _f: F) -> Self
20091 where
20092 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20093 {
20094 Self {
20095 set_device_memory_priority_ext: unsafe {
20096 unsafe extern "system" fn set_device_memory_priority_ext(
20097 _device: Device,
20098 _memory: DeviceMemory,
20099 _priority: f32,
20100 ) {
20101 panic!(concat!(
20102 "Unable to load ",
20103 stringify!(set_device_memory_priority_ext)
20104 ))
20105 }
20106 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20107 b"vkSetDeviceMemoryPriorityEXT\0",
20108 );
20109 let val = _f(cname);
20110 if val.is_null() {
20111 set_device_memory_priority_ext
20112 } else {
20113 ::std::mem::transmute(val)
20114 }
20115 },
20116 }
20117 }
20118}
20119#[doc = "Generated from 'VK_EXT_pageable_device_local_memory'"]
20120impl StructureType {
20121 pub const PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: Self = Self(1_000_412_000);
20122}
20123impl KhrMaintenance4Fn {
20124 pub const fn name() -> &'static ::std::ffi::CStr {
20125 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_maintenance4\0") }
20126 }
20127 pub const SPEC_VERSION: u32 = 2u32;
20128}
20129#[allow(non_camel_case_types)]
20130pub type PFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn(
20131 device: Device,
20132 p_info: *const DeviceBufferMemoryRequirements,
20133 p_memory_requirements: *mut MemoryRequirements2,
20134);
20135#[allow(non_camel_case_types)]
20136pub type PFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn(
20137 device: Device,
20138 p_info: *const DeviceImageMemoryRequirements,
20139 p_memory_requirements: *mut MemoryRequirements2,
20140);
20141#[allow(non_camel_case_types)]
20142pub type PFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn(
20143 device: Device,
20144 p_info: *const DeviceImageMemoryRequirements,
20145 p_sparse_memory_requirement_count: *mut u32,
20146 p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
20147);
20148#[derive(Clone)]
20149pub struct KhrMaintenance4Fn {
20150 pub get_device_buffer_memory_requirements_khr: PFN_vkGetDeviceBufferMemoryRequirements,
20151 pub get_device_image_memory_requirements_khr: PFN_vkGetDeviceImageMemoryRequirements,
20152 pub get_device_image_sparse_memory_requirements_khr:
20153 PFN_vkGetDeviceImageSparseMemoryRequirements,
20154}
20155unsafe impl Send for KhrMaintenance4Fn {}
20156unsafe impl Sync for KhrMaintenance4Fn {}
20157impl KhrMaintenance4Fn {
20158 pub fn load<F>(mut _f: F) -> Self
20159 where
20160 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20161 {
20162 Self {
20163 get_device_buffer_memory_requirements_khr: unsafe {
20164 unsafe extern "system" fn get_device_buffer_memory_requirements_khr(
20165 _device: Device,
20166 _p_info: *const DeviceBufferMemoryRequirements,
20167 _p_memory_requirements: *mut MemoryRequirements2,
20168 ) {
20169 panic!(concat!(
20170 "Unable to load ",
20171 stringify!(get_device_buffer_memory_requirements_khr)
20172 ))
20173 }
20174 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20175 b"vkGetDeviceBufferMemoryRequirementsKHR\0",
20176 );
20177 let val = _f(cname);
20178 if val.is_null() {
20179 get_device_buffer_memory_requirements_khr
20180 } else {
20181 ::std::mem::transmute(val)
20182 }
20183 },
20184 get_device_image_memory_requirements_khr: unsafe {
20185 unsafe extern "system" fn get_device_image_memory_requirements_khr(
20186 _device: Device,
20187 _p_info: *const DeviceImageMemoryRequirements,
20188 _p_memory_requirements: *mut MemoryRequirements2,
20189 ) {
20190 panic!(concat!(
20191 "Unable to load ",
20192 stringify!(get_device_image_memory_requirements_khr)
20193 ))
20194 }
20195 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20196 b"vkGetDeviceImageMemoryRequirementsKHR\0",
20197 );
20198 let val = _f(cname);
20199 if val.is_null() {
20200 get_device_image_memory_requirements_khr
20201 } else {
20202 ::std::mem::transmute(val)
20203 }
20204 },
20205 get_device_image_sparse_memory_requirements_khr: unsafe {
20206 unsafe extern "system" fn get_device_image_sparse_memory_requirements_khr(
20207 _device: Device,
20208 _p_info: *const DeviceImageMemoryRequirements,
20209 _p_sparse_memory_requirement_count: *mut u32,
20210 _p_sparse_memory_requirements: *mut SparseImageMemoryRequirements2,
20211 ) {
20212 panic!(concat!(
20213 "Unable to load ",
20214 stringify!(get_device_image_sparse_memory_requirements_khr)
20215 ))
20216 }
20217 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20218 b"vkGetDeviceImageSparseMemoryRequirementsKHR\0",
20219 );
20220 let val = _f(cname);
20221 if val.is_null() {
20222 get_device_image_sparse_memory_requirements_khr
20223 } else {
20224 ::std::mem::transmute(val)
20225 }
20226 },
20227 }
20228 }
20229}
20230#[doc = "Generated from 'VK_KHR_maintenance4'"]
20231impl ImageAspectFlags {
20232 pub const NONE_KHR: Self = Self::NONE;
20233}
20234#[doc = "Generated from 'VK_KHR_maintenance4'"]
20235impl StructureType {
20236 pub const PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: Self =
20237 Self::PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
20238 pub const PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: Self =
20239 Self::PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
20240 pub const DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_BUFFER_MEMORY_REQUIREMENTS;
20241 pub const DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: Self = Self::DEVICE_IMAGE_MEMORY_REQUIREMENTS;
20242}
20243impl HuaweiExtension415Fn {
20244 pub const fn name() -> &'static ::std::ffi::CStr {
20245 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_HUAWEI_extension_415\0") }
20246 }
20247 pub const SPEC_VERSION: u32 = 0u32;
20248}
20249#[derive(Clone)]
20250pub struct HuaweiExtension415Fn {}
20251unsafe impl Send for HuaweiExtension415Fn {}
20252unsafe impl Sync for HuaweiExtension415Fn {}
20253impl HuaweiExtension415Fn {
20254 pub fn load<F>(mut _f: F) -> Self
20255 where
20256 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20257 {
20258 Self {}
20259 }
20260}
20261impl ArmExtension416Fn {
20262 pub const fn name() -> &'static ::std::ffi::CStr {
20263 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_416\0") }
20264 }
20265 pub const SPEC_VERSION: u32 = 0u32;
20266}
20267#[derive(Clone)]
20268pub struct ArmExtension416Fn {}
20269unsafe impl Send for ArmExtension416Fn {}
20270unsafe impl Sync for ArmExtension416Fn {}
20271impl ArmExtension416Fn {
20272 pub fn load<F>(mut _f: F) -> Self
20273 where
20274 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20275 {
20276 Self {}
20277 }
20278}
20279impl KhrExtension417Fn {
20280 pub const fn name() -> &'static ::std::ffi::CStr {
20281 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_417\0") }
20282 }
20283 pub const SPEC_VERSION: u32 = 0u32;
20284}
20285#[derive(Clone)]
20286pub struct KhrExtension417Fn {}
20287unsafe impl Send for KhrExtension417Fn {}
20288unsafe impl Sync for KhrExtension417Fn {}
20289impl KhrExtension417Fn {
20290 pub fn load<F>(mut _f: F) -> Self
20291 where
20292 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20293 {
20294 Self {}
20295 }
20296}
20297impl ArmExtension418Fn {
20298 pub const fn name() -> &'static ::std::ffi::CStr {
20299 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_418\0") }
20300 }
20301 pub const SPEC_VERSION: u32 = 0u32;
20302}
20303#[derive(Clone)]
20304pub struct ArmExtension418Fn {}
20305unsafe impl Send for ArmExtension418Fn {}
20306unsafe impl Sync for ArmExtension418Fn {}
20307impl ArmExtension418Fn {
20308 pub fn load<F>(mut _f: F) -> Self
20309 where
20310 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20311 {
20312 Self {}
20313 }
20314}
20315impl ExtExtension419Fn {
20316 pub const fn name() -> &'static ::std::ffi::CStr {
20317 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_419\0") }
20318 }
20319 pub const SPEC_VERSION: u32 = 0u32;
20320}
20321#[derive(Clone)]
20322pub struct ExtExtension419Fn {}
20323unsafe impl Send for ExtExtension419Fn {}
20324unsafe impl Sync for ExtExtension419Fn {}
20325impl ExtExtension419Fn {
20326 pub fn load<F>(mut _f: F) -> Self
20327 where
20328 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20329 {
20330 Self {}
20331 }
20332}
20333impl ExtExtension420Fn {
20334 pub const fn name() -> &'static ::std::ffi::CStr {
20335 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_420\0") }
20336 }
20337 pub const SPEC_VERSION: u32 = 0u32;
20338}
20339#[derive(Clone)]
20340pub struct ExtExtension420Fn {}
20341unsafe impl Send for ExtExtension420Fn {}
20342unsafe impl Sync for ExtExtension420Fn {}
20343impl ExtExtension420Fn {
20344 pub fn load<F>(mut _f: F) -> Self
20345 where
20346 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20347 {
20348 Self {}
20349 }
20350}
20351impl ValveDescriptorSetHostMappingFn {
20352 pub const fn name() -> &'static ::std::ffi::CStr {
20353 unsafe {
20354 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20355 b"VK_VALVE_descriptor_set_host_mapping\0",
20356 )
20357 }
20358 }
20359 pub const SPEC_VERSION: u32 = 1u32;
20360}
20361#[allow(non_camel_case_types)]
20362pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn(
20363 device: Device,
20364 p_binding_reference: *const DescriptorSetBindingReferenceVALVE,
20365 p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE,
20366);
20367#[allow(non_camel_case_types)]
20368pub type PFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn(
20369 device: Device,
20370 descriptor_set: DescriptorSet,
20371 pp_data: *mut *mut c_void,
20372);
20373#[derive(Clone)]
20374pub struct ValveDescriptorSetHostMappingFn {
20375 pub get_descriptor_set_layout_host_mapping_info_valve:
20376 PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE,
20377 pub get_descriptor_set_host_mapping_valve: PFN_vkGetDescriptorSetHostMappingVALVE,
20378}
20379unsafe impl Send for ValveDescriptorSetHostMappingFn {}
20380unsafe impl Sync for ValveDescriptorSetHostMappingFn {}
20381impl ValveDescriptorSetHostMappingFn {
20382 pub fn load<F>(mut _f: F) -> Self
20383 where
20384 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20385 {
20386 Self {
20387 get_descriptor_set_layout_host_mapping_info_valve: unsafe {
20388 unsafe extern "system" fn get_descriptor_set_layout_host_mapping_info_valve(
20389 _device: Device,
20390 _p_binding_reference: *const DescriptorSetBindingReferenceVALVE,
20391 _p_host_mapping: *mut DescriptorSetLayoutHostMappingInfoVALVE,
20392 ) {
20393 panic!(concat!(
20394 "Unable to load ",
20395 stringify!(get_descriptor_set_layout_host_mapping_info_valve)
20396 ))
20397 }
20398 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20399 b"vkGetDescriptorSetLayoutHostMappingInfoVALVE\0",
20400 );
20401 let val = _f(cname);
20402 if val.is_null() {
20403 get_descriptor_set_layout_host_mapping_info_valve
20404 } else {
20405 ::std::mem::transmute(val)
20406 }
20407 },
20408 get_descriptor_set_host_mapping_valve: unsafe {
20409 unsafe extern "system" fn get_descriptor_set_host_mapping_valve(
20410 _device: Device,
20411 _descriptor_set: DescriptorSet,
20412 _pp_data: *mut *mut c_void,
20413 ) {
20414 panic!(concat!(
20415 "Unable to load ",
20416 stringify!(get_descriptor_set_host_mapping_valve)
20417 ))
20418 }
20419 let cname = ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20420 b"vkGetDescriptorSetHostMappingVALVE\0",
20421 );
20422 let val = _f(cname);
20423 if val.is_null() {
20424 get_descriptor_set_host_mapping_valve
20425 } else {
20426 ::std::mem::transmute(val)
20427 }
20428 },
20429 }
20430 }
20431}
20432#[doc = "Generated from 'VK_VALVE_descriptor_set_host_mapping'"]
20433impl StructureType {
20434 pub const PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: Self =
20435 Self(1_000_420_000);
20436 pub const DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: Self = Self(1_000_420_001);
20437 pub const DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: Self = Self(1_000_420_002);
20438}
20439impl ExtExtension422Fn {
20440 pub const fn name() -> &'static ::std::ffi::CStr {
20441 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_422\0") }
20442 }
20443 pub const SPEC_VERSION: u32 = 0u32;
20444}
20445#[derive(Clone)]
20446pub struct ExtExtension422Fn {}
20447unsafe impl Send for ExtExtension422Fn {}
20448unsafe impl Sync for ExtExtension422Fn {}
20449impl ExtExtension422Fn {
20450 pub fn load<F>(mut _f: F) -> Self
20451 where
20452 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20453 {
20454 Self {}
20455 }
20456}
20457impl ExtDisableCubeMapWrapFn {
20458 pub const fn name() -> &'static ::std::ffi::CStr {
20459 unsafe {
20460 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_disable_cube_map_wrap\0")
20461 }
20462 }
20463 pub const SPEC_VERSION: u32 = 0u32;
20464}
20465#[derive(Clone)]
20466pub struct ExtDisableCubeMapWrapFn {}
20467unsafe impl Send for ExtDisableCubeMapWrapFn {}
20468unsafe impl Sync for ExtDisableCubeMapWrapFn {}
20469impl ExtDisableCubeMapWrapFn {
20470 pub fn load<F>(mut _f: F) -> Self
20471 where
20472 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20473 {
20474 Self {}
20475 }
20476}
20477#[doc = "Generated from 'VK_EXT_disable_cube_map_wrap'"]
20478impl SamplerCreateFlags {
20479 pub const RESERVED_2_EXT: Self = Self(0b100);
20480}
20481impl ArmExtension424Fn {
20482 pub const fn name() -> &'static ::std::ffi::CStr {
20483 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_424\0") }
20484 }
20485 pub const SPEC_VERSION: u32 = 0u32;
20486}
20487#[derive(Clone)]
20488pub struct ArmExtension424Fn {}
20489unsafe impl Send for ArmExtension424Fn {}
20490unsafe impl Sync for ArmExtension424Fn {}
20491impl ArmExtension424Fn {
20492 pub fn load<F>(mut _f: F) -> Self
20493 where
20494 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20495 {
20496 Self {}
20497 }
20498}
20499impl ArmExtension425Fn {
20500 pub const fn name() -> &'static ::std::ffi::CStr {
20501 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_425\0") }
20502 }
20503 pub const SPEC_VERSION: u32 = 0u32;
20504}
20505#[derive(Clone)]
20506pub struct ArmExtension425Fn {}
20507unsafe impl Send for ArmExtension425Fn {}
20508unsafe impl Sync for ArmExtension425Fn {}
20509impl ArmExtension425Fn {
20510 pub fn load<F>(mut _f: F) -> Self
20511 where
20512 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20513 {
20514 Self {}
20515 }
20516}
20517impl QcomFragmentDensityMapOffsetFn {
20518 pub const fn name() -> &'static ::std::ffi::CStr {
20519 unsafe {
20520 ::std::ffi::CStr::from_bytes_with_nul_unchecked(
20521 b"VK_QCOM_fragment_density_map_offset\0",
20522 )
20523 }
20524 }
20525 pub const SPEC_VERSION: u32 = 1u32;
20526}
20527#[derive(Clone)]
20528pub struct QcomFragmentDensityMapOffsetFn {}
20529unsafe impl Send for QcomFragmentDensityMapOffsetFn {}
20530unsafe impl Sync for QcomFragmentDensityMapOffsetFn {}
20531impl QcomFragmentDensityMapOffsetFn {
20532 pub fn load<F>(mut _f: F) -> Self
20533 where
20534 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20535 {
20536 Self {}
20537 }
20538}
20539#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"]
20540impl ImageCreateFlags {
20541 pub const FRAGMENT_DENSITY_MAP_OFFSET_QCOM: Self = Self(0b1000_0000_0000_0000);
20542}
20543#[doc = "Generated from 'VK_QCOM_fragment_density_map_offset'"]
20544impl StructureType {
20545 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: Self = Self(1_000_425_000);
20546 pub const PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: Self =
20547 Self(1_000_425_001);
20548 pub const SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: Self = Self(1_000_425_002);
20549}
20550impl NvExtension427Fn {
20551 pub const fn name() -> &'static ::std::ffi::CStr {
20552 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_427\0") }
20553 }
20554 pub const SPEC_VERSION: u32 = 0u32;
20555}
20556#[derive(Clone)]
20557pub struct NvExtension427Fn {}
20558unsafe impl Send for NvExtension427Fn {}
20559unsafe impl Sync for NvExtension427Fn {}
20560impl NvExtension427Fn {
20561 pub fn load<F>(mut _f: F) -> Self
20562 where
20563 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20564 {
20565 Self {}
20566 }
20567}
20568impl NvExtension428Fn {
20569 pub const fn name() -> &'static ::std::ffi::CStr {
20570 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_428\0") }
20571 }
20572 pub const SPEC_VERSION: u32 = 0u32;
20573}
20574#[derive(Clone)]
20575pub struct NvExtension428Fn {}
20576unsafe impl Send for NvExtension428Fn {}
20577unsafe impl Sync for NvExtension428Fn {}
20578impl NvExtension428Fn {
20579 pub fn load<F>(mut _f: F) -> Self
20580 where
20581 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20582 {
20583 Self {}
20584 }
20585}
20586impl NvExtension429Fn {
20587 pub const fn name() -> &'static ::std::ffi::CStr {
20588 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_429\0") }
20589 }
20590 pub const SPEC_VERSION: u32 = 0u32;
20591}
20592#[derive(Clone)]
20593pub struct NvExtension429Fn {}
20594unsafe impl Send for NvExtension429Fn {}
20595unsafe impl Sync for NvExtension429Fn {}
20596impl NvExtension429Fn {
20597 pub fn load<F>(mut _f: F) -> Self
20598 where
20599 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20600 {
20601 Self {}
20602 }
20603}
20604impl NvExtension430Fn {
20605 pub const fn name() -> &'static ::std::ffi::CStr {
20606 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_430\0") }
20607 }
20608 pub const SPEC_VERSION: u32 = 0u32;
20609}
20610#[derive(Clone)]
20611pub struct NvExtension430Fn {}
20612unsafe impl Send for NvExtension430Fn {}
20613unsafe impl Sync for NvExtension430Fn {}
20614impl NvExtension430Fn {
20615 pub fn load<F>(mut _f: F) -> Self
20616 where
20617 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20618 {
20619 Self {}
20620 }
20621}
20622impl NvLinearColorAttachmentFn {
20623 pub const fn name() -> &'static ::std::ffi::CStr {
20624 unsafe {
20625 ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_linear_color_attachment\0")
20626 }
20627 }
20628 pub const SPEC_VERSION: u32 = 1u32;
20629}
20630#[derive(Clone)]
20631pub struct NvLinearColorAttachmentFn {}
20632unsafe impl Send for NvLinearColorAttachmentFn {}
20633unsafe impl Sync for NvLinearColorAttachmentFn {}
20634impl NvLinearColorAttachmentFn {
20635 pub fn load<F>(mut _f: F) -> Self
20636 where
20637 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20638 {
20639 Self {}
20640 }
20641}
20642#[doc = "Generated from 'VK_NV_linear_color_attachment'"]
20643impl FormatFeatureFlags2 {
20644 #[doc = "Format support linear image as render target, it cannot be mixed with non linear attachment"]
20645 pub const LINEAR_COLOR_ATTACHMENT_NV: Self =
20646 Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000_0000);
20647}
20648#[doc = "Generated from 'VK_NV_linear_color_attachment'"]
20649impl StructureType {
20650 pub const PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: Self = Self(1_000_430_000);
20651}
20652impl NvExtension432Fn {
20653 pub const fn name() -> &'static ::std::ffi::CStr {
20654 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_432\0") }
20655 }
20656 pub const SPEC_VERSION: u32 = 0u32;
20657}
20658#[derive(Clone)]
20659pub struct NvExtension432Fn {}
20660unsafe impl Send for NvExtension432Fn {}
20661unsafe impl Sync for NvExtension432Fn {}
20662impl NvExtension432Fn {
20663 pub fn load<F>(mut _f: F) -> Self
20664 where
20665 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20666 {
20667 Self {}
20668 }
20669}
20670impl NvExtension433Fn {
20671 pub const fn name() -> &'static ::std::ffi::CStr {
20672 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_433\0") }
20673 }
20674 pub const SPEC_VERSION: u32 = 0u32;
20675}
20676#[derive(Clone)]
20677pub struct NvExtension433Fn {}
20678unsafe impl Send for NvExtension433Fn {}
20679unsafe impl Sync for NvExtension433Fn {}
20680impl NvExtension433Fn {
20681 pub fn load<F>(mut _f: F) -> Self
20682 where
20683 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20684 {
20685 Self {}
20686 }
20687}
20688impl GoogleSurfacelessQueryFn {
20689 pub const fn name() -> &'static ::std::ffi::CStr {
20690 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_surfaceless_query\0") }
20691 }
20692 pub const SPEC_VERSION: u32 = 1u32;
20693}
20694#[derive(Clone)]
20695pub struct GoogleSurfacelessQueryFn {}
20696unsafe impl Send for GoogleSurfacelessQueryFn {}
20697unsafe impl Sync for GoogleSurfacelessQueryFn {}
20698impl GoogleSurfacelessQueryFn {
20699 pub fn load<F>(mut _f: F) -> Self
20700 where
20701 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20702 {
20703 Self {}
20704 }
20705}
20706impl KhrExtension435Fn {
20707 pub const fn name() -> &'static ::std::ffi::CStr {
20708 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_KHR_extension_435\0") }
20709 }
20710 pub const SPEC_VERSION: u32 = 0u32;
20711}
20712#[derive(Clone)]
20713pub struct KhrExtension435Fn {}
20714unsafe impl Send for KhrExtension435Fn {}
20715unsafe impl Sync for KhrExtension435Fn {}
20716impl KhrExtension435Fn {
20717 pub fn load<F>(mut _f: F) -> Self
20718 where
20719 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20720 {
20721 Self {}
20722 }
20723}
20724impl NvExtension436Fn {
20725 pub const fn name() -> &'static ::std::ffi::CStr {
20726 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_436\0") }
20727 }
20728 pub const SPEC_VERSION: u32 = 0u32;
20729}
20730#[derive(Clone)]
20731pub struct NvExtension436Fn {}
20732unsafe impl Send for NvExtension436Fn {}
20733unsafe impl Sync for NvExtension436Fn {}
20734impl NvExtension436Fn {
20735 pub fn load<F>(mut _f: F) -> Self
20736 where
20737 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20738 {
20739 Self {}
20740 }
20741}
20742impl ExtExtension437Fn {
20743 pub const fn name() -> &'static ::std::ffi::CStr {
20744 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_437\0") }
20745 }
20746 pub const SPEC_VERSION: u32 = 0u32;
20747}
20748#[derive(Clone)]
20749pub struct ExtExtension437Fn {}
20750unsafe impl Send for ExtExtension437Fn {}
20751unsafe impl Sync for ExtExtension437Fn {}
20752impl ExtExtension437Fn {
20753 pub fn load<F>(mut _f: F) -> Self
20754 where
20755 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20756 {
20757 Self {}
20758 }
20759}
20760impl ExtExtension438Fn {
20761 pub const fn name() -> &'static ::std::ffi::CStr {
20762 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_438\0") }
20763 }
20764 pub const SPEC_VERSION: u32 = 0u32;
20765}
20766#[derive(Clone)]
20767pub struct ExtExtension438Fn {}
20768unsafe impl Send for ExtExtension438Fn {}
20769unsafe impl Sync for ExtExtension438Fn {}
20770impl ExtExtension438Fn {
20771 pub fn load<F>(mut _f: F) -> Self
20772 where
20773 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20774 {
20775 Self {}
20776 }
20777}
20778impl SecExtension439Fn {
20779 pub const fn name() -> &'static ::std::ffi::CStr {
20780 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_439\0") }
20781 }
20782 pub const SPEC_VERSION: u32 = 0u32;
20783}
20784#[derive(Clone)]
20785pub struct SecExtension439Fn {}
20786unsafe impl Send for SecExtension439Fn {}
20787unsafe impl Sync for SecExtension439Fn {}
20788impl SecExtension439Fn {
20789 pub fn load<F>(mut _f: F) -> Self
20790 where
20791 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20792 {
20793 Self {}
20794 }
20795}
20796impl QcomExtension440Fn {
20797 pub const fn name() -> &'static ::std::ffi::CStr {
20798 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_440\0") }
20799 }
20800 pub const SPEC_VERSION: u32 = 0u32;
20801}
20802#[derive(Clone)]
20803pub struct QcomExtension440Fn {}
20804unsafe impl Send for QcomExtension440Fn {}
20805unsafe impl Sync for QcomExtension440Fn {}
20806impl QcomExtension440Fn {
20807 pub fn load<F>(mut _f: F) -> Self
20808 where
20809 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20810 {
20811 Self {}
20812 }
20813}
20814#[doc = "Generated from 'VK_QCOM_extension_440'"]
20815impl DeviceQueueCreateFlags {
20816 pub const RESERVED_1_QCOM: Self = Self(0b10);
20817}
20818#[doc = "Generated from 'VK_QCOM_extension_440'"]
20819impl QueueFlags {
20820 pub const RESERVED_7_QCOM: Self = Self(0b1000_0000);
20821}
20822impl QcomExtension441Fn {
20823 pub const fn name() -> &'static ::std::ffi::CStr {
20824 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_QCOM_extension_441\0") }
20825 }
20826 pub const SPEC_VERSION: u32 = 0u32;
20827}
20828#[derive(Clone)]
20829pub struct QcomExtension441Fn {}
20830unsafe impl Send for QcomExtension441Fn {}
20831unsafe impl Sync for QcomExtension441Fn {}
20832impl QcomExtension441Fn {
20833 pub fn load<F>(mut _f: F) -> Self
20834 where
20835 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20836 {
20837 Self {}
20838 }
20839}
20840#[doc = "Generated from 'VK_QCOM_extension_441'"]
20841impl FormatFeatureFlags2 {
20842 pub const RESERVED_34_QCOM: Self = Self(0b100_0000_0000_0000_0000_0000_0000_0000_0000);
20843 pub const RESERVED_35_QCOM: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000);
20844 pub const RESERVED_36_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000_0000_0000_0000_0000);
20845 pub const RESERVED_37_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000_0000_0000_0000_0000);
20846}
20847#[doc = "Generated from 'VK_QCOM_extension_441'"]
20848impl ImageUsageFlags {
20849 pub const RESERVED_20_QCOM: Self = Self(0b1_0000_0000_0000_0000_0000);
20850 pub const RESERVED_21_QCOM: Self = Self(0b10_0000_0000_0000_0000_0000);
20851}
20852#[doc = "Generated from 'VK_QCOM_extension_441'"]
20853impl SamplerCreateFlags {
20854 pub const IMAGE_PROCESSING_QCOM: Self = Self(0b1_0000);
20855}
20856impl CoreaviExtension442Fn {
20857 pub const fn name() -> &'static ::std::ffi::CStr {
20858 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_442\0") }
20859 }
20860 pub const SPEC_VERSION: u32 = 0u32;
20861}
20862#[derive(Clone)]
20863pub struct CoreaviExtension442Fn {}
20864unsafe impl Send for CoreaviExtension442Fn {}
20865unsafe impl Sync for CoreaviExtension442Fn {}
20866impl CoreaviExtension442Fn {
20867 pub fn load<F>(mut _f: F) -> Self
20868 where
20869 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20870 {
20871 Self {}
20872 }
20873}
20874impl CoreaviExtension443Fn {
20875 pub const fn name() -> &'static ::std::ffi::CStr {
20876 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_443\0") }
20877 }
20878 pub const SPEC_VERSION: u32 = 0u32;
20879}
20880#[derive(Clone)]
20881pub struct CoreaviExtension443Fn {}
20882unsafe impl Send for CoreaviExtension443Fn {}
20883unsafe impl Sync for CoreaviExtension443Fn {}
20884impl CoreaviExtension443Fn {
20885 pub fn load<F>(mut _f: F) -> Self
20886 where
20887 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20888 {
20889 Self {}
20890 }
20891}
20892impl CoreaviExtension444Fn {
20893 pub const fn name() -> &'static ::std::ffi::CStr {
20894 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_444\0") }
20895 }
20896 pub const SPEC_VERSION: u32 = 0u32;
20897}
20898#[derive(Clone)]
20899pub struct CoreaviExtension444Fn {}
20900unsafe impl Send for CoreaviExtension444Fn {}
20901unsafe impl Sync for CoreaviExtension444Fn {}
20902impl CoreaviExtension444Fn {
20903 pub fn load<F>(mut _f: F) -> Self
20904 where
20905 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20906 {
20907 Self {}
20908 }
20909}
20910#[doc = "Generated from 'VK_COREAVI_extension_444'"]
20911impl CommandPoolResetFlags {
20912 pub const RESERVED_1_COREAVI: Self = Self(0b10);
20913}
20914impl CoreaviExtension445Fn {
20915 pub const fn name() -> &'static ::std::ffi::CStr {
20916 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_445\0") }
20917 }
20918 pub const SPEC_VERSION: u32 = 0u32;
20919}
20920#[derive(Clone)]
20921pub struct CoreaviExtension445Fn {}
20922unsafe impl Send for CoreaviExtension445Fn {}
20923unsafe impl Sync for CoreaviExtension445Fn {}
20924impl CoreaviExtension445Fn {
20925 pub fn load<F>(mut _f: F) -> Self
20926 where
20927 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20928 {
20929 Self {}
20930 }
20931}
20932impl CoreaviExtension446Fn {
20933 pub const fn name() -> &'static ::std::ffi::CStr {
20934 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_446\0") }
20935 }
20936 pub const SPEC_VERSION: u32 = 0u32;
20937}
20938#[derive(Clone)]
20939pub struct CoreaviExtension446Fn {}
20940unsafe impl Send for CoreaviExtension446Fn {}
20941unsafe impl Sync for CoreaviExtension446Fn {}
20942impl CoreaviExtension446Fn {
20943 pub fn load<F>(mut _f: F) -> Self
20944 where
20945 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20946 {
20947 Self {}
20948 }
20949}
20950impl CoreaviExtension447Fn {
20951 pub const fn name() -> &'static ::std::ffi::CStr {
20952 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_COREAVI_extension_447\0") }
20953 }
20954 pub const SPEC_VERSION: u32 = 0u32;
20955}
20956#[derive(Clone)]
20957pub struct CoreaviExtension447Fn {}
20958unsafe impl Send for CoreaviExtension447Fn {}
20959unsafe impl Sync for CoreaviExtension447Fn {}
20960impl CoreaviExtension447Fn {
20961 pub fn load<F>(mut _f: F) -> Self
20962 where
20963 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20964 {
20965 Self {}
20966 }
20967}
20968impl SecExtension448Fn {
20969 pub const fn name() -> &'static ::std::ffi::CStr {
20970 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_448\0") }
20971 }
20972 pub const SPEC_VERSION: u32 = 0u32;
20973}
20974#[derive(Clone)]
20975pub struct SecExtension448Fn {}
20976unsafe impl Send for SecExtension448Fn {}
20977unsafe impl Sync for SecExtension448Fn {}
20978impl SecExtension448Fn {
20979 pub fn load<F>(mut _f: F) -> Self
20980 where
20981 F: FnMut(&::std::ffi::CStr) -> *const c_void,
20982 {
20983 Self {}
20984 }
20985}
20986impl SecExtension449Fn {
20987 pub const fn name() -> &'static ::std::ffi::CStr {
20988 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_449\0") }
20989 }
20990 pub const SPEC_VERSION: u32 = 0u32;
20991}
20992#[derive(Clone)]
20993pub struct SecExtension449Fn {}
20994unsafe impl Send for SecExtension449Fn {}
20995unsafe impl Sync for SecExtension449Fn {}
20996impl SecExtension449Fn {
20997 pub fn load<F>(mut _f: F) -> Self
20998 where
20999 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21000 {
21001 Self {}
21002 }
21003}
21004impl SecExtension450Fn {
21005 pub const fn name() -> &'static ::std::ffi::CStr {
21006 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_450\0") }
21007 }
21008 pub const SPEC_VERSION: u32 = 0u32;
21009}
21010#[derive(Clone)]
21011pub struct SecExtension450Fn {}
21012unsafe impl Send for SecExtension450Fn {}
21013unsafe impl Sync for SecExtension450Fn {}
21014impl SecExtension450Fn {
21015 pub fn load<F>(mut _f: F) -> Self
21016 where
21017 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21018 {
21019 Self {}
21020 }
21021}
21022impl SecExtension451Fn {
21023 pub const fn name() -> &'static ::std::ffi::CStr {
21024 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_SEC_extension_451\0") }
21025 }
21026 pub const SPEC_VERSION: u32 = 0u32;
21027}
21028#[derive(Clone)]
21029pub struct SecExtension451Fn {}
21030unsafe impl Send for SecExtension451Fn {}
21031unsafe impl Sync for SecExtension451Fn {}
21032impl SecExtension451Fn {
21033 pub fn load<F>(mut _f: F) -> Self
21034 where
21035 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21036 {
21037 Self {}
21038 }
21039}
21040impl NvExtension452Fn {
21041 pub const fn name() -> &'static ::std::ffi::CStr {
21042 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_452\0") }
21043 }
21044 pub const SPEC_VERSION: u32 = 0u32;
21045}
21046#[derive(Clone)]
21047pub struct NvExtension452Fn {}
21048unsafe impl Send for NvExtension452Fn {}
21049unsafe impl Sync for NvExtension452Fn {}
21050impl NvExtension452Fn {
21051 pub fn load<F>(mut _f: F) -> Self
21052 where
21053 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21054 {
21055 Self {}
21056 }
21057}
21058impl ArmExtension453Fn {
21059 pub const fn name() -> &'static ::std::ffi::CStr {
21060 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_453\0") }
21061 }
21062 pub const SPEC_VERSION: u32 = 0u32;
21063}
21064#[derive(Clone)]
21065pub struct ArmExtension453Fn {}
21066unsafe impl Send for ArmExtension453Fn {}
21067unsafe impl Sync for ArmExtension453Fn {}
21068impl ArmExtension453Fn {
21069 pub fn load<F>(mut _f: F) -> Self
21070 where
21071 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21072 {
21073 Self {}
21074 }
21075}
21076impl GoogleExtension454Fn {
21077 pub const fn name() -> &'static ::std::ffi::CStr {
21078 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_454\0") }
21079 }
21080 pub const SPEC_VERSION: u32 = 0u32;
21081}
21082#[derive(Clone)]
21083pub struct GoogleExtension454Fn {}
21084unsafe impl Send for GoogleExtension454Fn {}
21085unsafe impl Sync for GoogleExtension454Fn {}
21086impl GoogleExtension454Fn {
21087 pub fn load<F>(mut _f: F) -> Self
21088 where
21089 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21090 {
21091 Self {}
21092 }
21093}
21094impl GoogleExtension455Fn {
21095 pub const fn name() -> &'static ::std::ffi::CStr {
21096 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_GOOGLE_extension_455\0") }
21097 }
21098 pub const SPEC_VERSION: u32 = 0u32;
21099}
21100#[derive(Clone)]
21101pub struct GoogleExtension455Fn {}
21102unsafe impl Send for GoogleExtension455Fn {}
21103unsafe impl Sync for GoogleExtension455Fn {}
21104impl GoogleExtension455Fn {
21105 pub fn load<F>(mut _f: F) -> Self
21106 where
21107 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21108 {
21109 Self {}
21110 }
21111}
21112impl NvExtension456Fn {
21113 pub const fn name() -> &'static ::std::ffi::CStr {
21114 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_NV_extension_456\0") }
21115 }
21116 pub const SPEC_VERSION: u32 = 0u32;
21117}
21118#[derive(Clone)]
21119pub struct NvExtension456Fn {}
21120unsafe impl Send for NvExtension456Fn {}
21121unsafe impl Sync for NvExtension456Fn {}
21122impl NvExtension456Fn {
21123 pub fn load<F>(mut _f: F) -> Self
21124 where
21125 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21126 {
21127 Self {}
21128 }
21129}
21130impl ExtExtension457Fn {
21131 pub const fn name() -> &'static ::std::ffi::CStr {
21132 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_457\0") }
21133 }
21134 pub const SPEC_VERSION: u32 = 0u32;
21135}
21136#[derive(Clone)]
21137pub struct ExtExtension457Fn {}
21138unsafe impl Send for ExtExtension457Fn {}
21139unsafe impl Sync for ExtExtension457Fn {}
21140impl ExtExtension457Fn {
21141 pub fn load<F>(mut _f: F) -> Self
21142 where
21143 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21144 {
21145 Self {}
21146 }
21147}
21148impl ExtExtension458Fn {
21149 pub const fn name() -> &'static ::std::ffi::CStr {
21150 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_458\0") }
21151 }
21152 pub const SPEC_VERSION: u32 = 0u32;
21153}
21154#[derive(Clone)]
21155pub struct ExtExtension458Fn {}
21156unsafe impl Send for ExtExtension458Fn {}
21157unsafe impl Sync for ExtExtension458Fn {}
21158impl ExtExtension458Fn {
21159 pub fn load<F>(mut _f: F) -> Self
21160 where
21161 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21162 {
21163 Self {}
21164 }
21165}
21166impl ArmExtension459Fn {
21167 pub const fn name() -> &'static ::std::ffi::CStr {
21168 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_ARM_extension_459\0") }
21169 }
21170 pub const SPEC_VERSION: u32 = 0u32;
21171}
21172#[derive(Clone)]
21173pub struct ArmExtension459Fn {}
21174unsafe impl Send for ArmExtension459Fn {}
21175unsafe impl Sync for ArmExtension459Fn {}
21176impl ArmExtension459Fn {
21177 pub fn load<F>(mut _f: F) -> Self
21178 where
21179 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21180 {
21181 Self {}
21182 }
21183}
21184impl ExtExtension460Fn {
21185 pub const fn name() -> &'static ::std::ffi::CStr {
21186 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_460\0") }
21187 }
21188 pub const SPEC_VERSION: u32 = 0u32;
21189}
21190#[derive(Clone)]
21191pub struct ExtExtension460Fn {}
21192unsafe impl Send for ExtExtension460Fn {}
21193unsafe impl Sync for ExtExtension460Fn {}
21194impl ExtExtension460Fn {
21195 pub fn load<F>(mut _f: F) -> Self
21196 where
21197 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21198 {
21199 Self {}
21200 }
21201}
21202impl ExtExtension461Fn {
21203 pub const fn name() -> &'static ::std::ffi::CStr {
21204 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_461\0") }
21205 }
21206 pub const SPEC_VERSION: u32 = 0u32;
21207}
21208#[derive(Clone)]
21209pub struct ExtExtension461Fn {}
21210unsafe impl Send for ExtExtension461Fn {}
21211unsafe impl Sync for ExtExtension461Fn {}
21212impl ExtExtension461Fn {
21213 pub fn load<F>(mut _f: F) -> Self
21214 where
21215 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21216 {
21217 Self {}
21218 }
21219}
21220#[doc = "Generated from 'VK_EXT_extension_461'"]
21221impl FormatFeatureFlags2 {
21222 pub const RESERVED_39_EXT: Self = Self(0b1000_0000_0000_0000_0000_0000_0000_0000_0000_0000);
21223}
21224impl ExtExtension462Fn {
21225 pub const fn name() -> &'static ::std::ffi::CStr {
21226 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_462\0") }
21227 }
21228 pub const SPEC_VERSION: u32 = 0u32;
21229}
21230#[derive(Clone)]
21231pub struct ExtExtension462Fn {}
21232unsafe impl Send for ExtExtension462Fn {}
21233unsafe impl Sync for ExtExtension462Fn {}
21234impl ExtExtension462Fn {
21235 pub fn load<F>(mut _f: F) -> Self
21236 where
21237 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21238 {
21239 Self {}
21240 }
21241}
21242impl ExtExtension463Fn {
21243 pub const fn name() -> &'static ::std::ffi::CStr {
21244 unsafe { ::std::ffi::CStr::from_bytes_with_nul_unchecked(b"VK_EXT_extension_463\0") }
21245 }
21246 pub const SPEC_VERSION: u32 = 0u32;
21247}
21248#[derive(Clone)]
21249pub struct ExtExtension463Fn {}
21250unsafe impl Send for ExtExtension463Fn {}
21251unsafe impl Sync for ExtExtension463Fn {}
21252impl ExtExtension463Fn {
21253 pub fn load<F>(mut _f: F) -> Self
21254 where
21255 F: FnMut(&::std::ffi::CStr) -> *const c_void,
21256 {
21257 Self {}
21258 }
21259}