Skip to main content

vulkan_headers/vulkan/
vulkan_core.rs

1use crate::prelude::*;
2
3#[doc(no_inline)]
4pub use crate::vk_video::vulkan_video_codec_av1std::*;
5
6#[doc(no_inline)]
7pub use crate::vk_video::vulkan_video_codec_av1std_decode::*;
8
9#[doc(no_inline)]
10pub use crate::vk_video::vulkan_video_codec_av1std_encode::*;
11
12#[doc(no_inline)]
13pub use crate::vk_video::vulkan_video_codec_h264std::*;
14
15#[doc(no_inline)]
16pub use crate::vk_video::vulkan_video_codec_h264std_decode::*;
17
18#[doc(no_inline)]
19pub use crate::vk_video::vulkan_video_codec_h264std_encode::*;
20
21#[doc(no_inline)]
22pub use crate::vk_video::vulkan_video_codec_h265std::*;
23
24#[doc(no_inline)]
25pub use crate::vk_video::vulkan_video_codec_h265std_decode::*;
26
27#[doc(no_inline)]
28pub use crate::vk_video::vulkan_video_codec_h265std_encode::*;
29
30#[doc(no_inline)]
31pub use crate::vk_video::vulkan_video_codec_vp9std::*;
32
33#[doc(no_inline)]
34pub use crate::vk_video::vulkan_video_codec_vp9std_decode::*;
35
36#[doc(no_inline)]
37pub use crate::vk_video::vulkan_video_codecs_common::*;
38
39#[derive(Clone, Copy)]
40#[repr(C)]
41pub struct VkAabbPositionsKHR {
42    pub minX: f32,
43    pub minY: f32,
44    pub minZ: f32,
45    pub maxX: f32,
46    pub maxY: f32,
47    pub maxZ: f32,
48}
49
50#[derive(Clone, Copy)]
51#[repr(C)]
52pub struct VkAccelerationStructureBuildGeometryInfoKHR {
53    pub sType: VkStructureType,
54    pub pNext: *const c_void,
55    pub typ: VkAccelerationStructureTypeKHR,
56    pub flags: VkBuildAccelerationStructureFlagsKHR,
57    pub mode: VkBuildAccelerationStructureModeKHR,
58    pub srcAccelerationStructure: VkAccelerationStructureKHR,
59    pub dstAccelerationStructure: VkAccelerationStructureKHR,
60    pub geometryCount: u32,
61    pub pGeometries: *const VkAccelerationStructureGeometryKHR,
62    pub ppGeometries: *const *const VkAccelerationStructureGeometryKHR,
63    pub scratchData: VkDeviceOrHostAddressKHR,
64}
65
66#[derive(Clone, Copy)]
67#[repr(C)]
68pub struct VkAccelerationStructureBuildRangeInfoKHR {
69    pub primitiveCount: u32,
70    pub primitiveOffset: u32,
71    pub firstVertex: u32,
72    pub transformOffset: u32,
73}
74
75#[derive(Clone, Copy)]
76#[repr(C)]
77pub struct VkAccelerationStructureBuildSizesInfoKHR {
78    pub sType: VkStructureType,
79    pub pNext: *mut c_void,
80    pub accelerationStructureSize: VkDeviceSize,
81    pub updateScratchSize: VkDeviceSize,
82    pub buildScratchSize: VkDeviceSize,
83}
84
85#[derive(Clone, Copy)]
86#[repr(C)]
87pub struct VkAccelerationStructureCaptureDescriptorDataInfoEXT {
88    pub sType: VkStructureType,
89    pub pNext: *const c_void,
90    pub accelerationStructure: VkAccelerationStructureKHR,
91    pub accelerationStructureNV: VkAccelerationStructureNV,
92}
93
94#[derive(Clone, Copy)]
95#[repr(C)]
96pub struct VkAccelerationStructureCreateInfoKHR {
97    pub sType: VkStructureType,
98    pub pNext: *const c_void,
99    pub createFlags: VkAccelerationStructureCreateFlagsKHR,
100    pub buffer: VkBuffer,
101    pub offset: VkDeviceSize,
102    pub size: VkDeviceSize,
103    pub typ: VkAccelerationStructureTypeKHR,
104    pub deviceAddress: VkDeviceAddress,
105}
106
107#[derive(Clone, Copy)]
108#[repr(C)]
109pub struct VkAccelerationStructureCreateInfoNV {
110    pub sType: VkStructureType,
111    pub pNext: *const c_void,
112    pub compactedSize: VkDeviceSize,
113    pub info: VkAccelerationStructureInfoNV,
114}
115
116#[derive(Clone, Copy)]
117#[repr(C)]
118pub struct VkAccelerationStructureDeviceAddressInfoKHR {
119    pub sType: VkStructureType,
120    pub pNext: *const c_void,
121    pub accelerationStructure: VkAccelerationStructureKHR,
122}
123
124#[derive(Clone, Copy)]
125#[repr(C)]
126pub struct VkAccelerationStructureGeometryAabbsDataKHR {
127    pub sType: VkStructureType,
128    pub pNext: *const c_void,
129    pub data: VkDeviceOrHostAddressConstKHR,
130    pub stride: VkDeviceSize,
131}
132
133#[derive(Clone, Copy)]
134#[repr(C)]
135pub struct VkAccelerationStructureGeometryInstancesDataKHR {
136    pub sType: VkStructureType,
137    pub pNext: *const c_void,
138    pub arrayOfPointers: VkBool32,
139    pub data: VkDeviceOrHostAddressConstKHR,
140}
141
142#[derive(Clone, Copy)]
143#[repr(C)]
144pub struct VkAccelerationStructureGeometryKHR {
145    pub sType: VkStructureType,
146    pub pNext: *const c_void,
147    pub geometryType: VkGeometryTypeKHR,
148    pub geometry: VkAccelerationStructureGeometryDataKHR,
149    pub flags: VkGeometryFlagsKHR,
150}
151
152#[derive(Clone, Copy)]
153#[repr(C)]
154pub struct VkAccelerationStructureGeometryLinearSweptSpheresDataNV {
155    pub sType: VkStructureType,
156    pub pNext: *const c_void,
157    pub vertexFormat: VkFormat,
158    pub vertexData: VkDeviceOrHostAddressConstKHR,
159    pub vertexStride: VkDeviceSize,
160    pub radiusFormat: VkFormat,
161    pub radiusData: VkDeviceOrHostAddressConstKHR,
162    pub radiusStride: VkDeviceSize,
163    pub indexType: VkIndexType,
164    pub indexData: VkDeviceOrHostAddressConstKHR,
165    pub indexStride: VkDeviceSize,
166    pub indexingMode: VkRayTracingLssIndexingModeNV,
167    pub endCapsMode: VkRayTracingLssPrimitiveEndCapsModeNV,
168}
169
170#[derive(Clone, Copy)]
171#[repr(C)]
172pub struct VkAccelerationStructureGeometryMotionTrianglesDataNV {
173    pub sType: VkStructureType,
174    pub pNext: *const c_void,
175    pub vertexData: VkDeviceOrHostAddressConstKHR,
176}
177
178#[derive(Clone, Copy)]
179#[repr(C)]
180pub struct VkAccelerationStructureGeometrySpheresDataNV {
181    pub sType: VkStructureType,
182    pub pNext: *const c_void,
183    pub vertexFormat: VkFormat,
184    pub vertexData: VkDeviceOrHostAddressConstKHR,
185    pub vertexStride: VkDeviceSize,
186    pub radiusFormat: VkFormat,
187    pub radiusData: VkDeviceOrHostAddressConstKHR,
188    pub radiusStride: VkDeviceSize,
189    pub indexType: VkIndexType,
190    pub indexData: VkDeviceOrHostAddressConstKHR,
191    pub indexStride: VkDeviceSize,
192}
193
194#[derive(Clone, Copy)]
195#[repr(C)]
196pub struct VkAccelerationStructureGeometryTrianglesDataKHR {
197    pub sType: VkStructureType,
198    pub pNext: *const c_void,
199    pub vertexFormat: VkFormat,
200    pub vertexData: VkDeviceOrHostAddressConstKHR,
201    pub vertexStride: VkDeviceSize,
202    pub maxVertex: u32,
203    pub indexType: VkIndexType,
204    pub indexData: VkDeviceOrHostAddressConstKHR,
205    pub transformData: VkDeviceOrHostAddressConstKHR,
206}
207
208#[derive(Clone, Copy)]
209#[repr(C)]
210pub struct VkAccelerationStructureInfoNV {
211    pub sType: VkStructureType,
212    pub pNext: *const c_void,
213    pub typ: VkAccelerationStructureTypeNV,
214    pub flags: VkBuildAccelerationStructureFlagsNV,
215    pub instanceCount: u32,
216    pub geometryCount: u32,
217    pub pGeometries: *const VkGeometryNV,
218}
219
220#[derive(Clone, Copy)]
221#[repr(C)]
222pub struct VkAccelerationStructureInstanceKHR {
223    pub transform: VkTransformMatrixKHR,
224    pub bitfields: [u32; 2],
225    pub accelerationStructureReference: u64,
226}
227
228#[repr(C)]
229pub struct VkAccelerationStructureKHR_T {
230    _data: (),
231    _marker: PhantomData<(*mut u8, PhantomPinned)>,
232}
233
234#[derive(Clone, Copy)]
235#[repr(C)]
236pub struct VkAccelerationStructureMatrixMotionInstanceNV {
237    pub transformT0: VkTransformMatrixKHR,
238    pub transformT1: VkTransformMatrixKHR,
239    pub bitfields: [u32; 2],
240    pub accelerationStructureReference: u64,
241}
242
243#[derive(Clone, Copy)]
244#[repr(C)]
245pub struct VkAccelerationStructureMemoryRequirementsInfoNV {
246    pub sType: VkStructureType,
247    pub pNext: *const c_void,
248    pub typ: VkAccelerationStructureMemoryRequirementsTypeNV,
249    pub accelerationStructure: VkAccelerationStructureNV,
250}
251
252#[derive(Clone, Copy)]
253#[repr(C)]
254pub struct VkAccelerationStructureMotionInfoNV {
255    pub sType: VkStructureType,
256    pub pNext: *const c_void,
257    pub maxInstances: u32,
258    pub flags: VkAccelerationStructureMotionInfoFlagsNV,
259}
260
261#[derive(Clone, Copy)]
262#[repr(C)]
263pub struct VkAccelerationStructureMotionInstanceNV {
264    pub typ: VkAccelerationStructureMotionInstanceTypeNV,
265    pub flags: VkAccelerationStructureMotionInstanceFlagsNV,
266    pub data: VkAccelerationStructureMotionInstanceDataNV,
267}
268
269#[repr(C)]
270pub struct VkAccelerationStructureNV_T {
271    _data: (),
272    _marker: PhantomData<(*mut u8, PhantomPinned)>,
273}
274
275#[derive(Clone, Copy)]
276#[repr(C)]
277pub struct VkAccelerationStructureSRTMotionInstanceNV {
278    pub transformT0: VkSRTDataNV,
279    pub transformT1: VkSRTDataNV,
280    pub bitfields: [u32; 2],
281    pub accelerationStructureReference: u64,
282}
283
284#[derive(Clone, Copy)]
285#[repr(C)]
286pub struct VkAccelerationStructureTrianglesOpacityMicromapEXT {
287    pub sType: VkStructureType,
288    pub pNext: *mut c_void,
289    pub indexType: VkIndexType,
290    pub indexBuffer: VkDeviceOrHostAddressConstKHR,
291    pub indexStride: VkDeviceSize,
292    pub baseTriangle: u32,
293    pub usageCountsCount: u32,
294    pub pUsageCounts: *const VkMicromapUsageEXT,
295    pub ppUsageCounts: *const *const VkMicromapUsageEXT,
296    pub micromap: VkMicromapEXT,
297}
298
299#[derive(Clone, Copy)]
300#[repr(C)]
301pub struct VkAccelerationStructureVersionInfoKHR {
302    pub sType: VkStructureType,
303    pub pNext: *const c_void,
304    pub pVersionData: *const u8,
305}
306
307#[derive(Clone, Copy)]
308#[repr(C)]
309pub struct VkAcquireNextImageInfoKHR {
310    pub sType: VkStructureType,
311    pub pNext: *const c_void,
312    pub swapchain: VkSwapchainKHR,
313    pub timeout: u64,
314    pub semaphore: VkSemaphore,
315    pub fence: VkFence,
316    pub deviceMask: u32,
317}
318
319#[derive(Clone, Copy)]
320#[repr(C)]
321pub struct VkAcquireProfilingLockInfoKHR {
322    pub sType: VkStructureType,
323    pub pNext: *const c_void,
324    pub flags: VkAcquireProfilingLockFlagsKHR,
325    pub timeout: u64,
326}
327
328#[derive(Clone, Copy)]
329#[repr(C)]
330pub struct VkAllocationCallbacks {
331    pub pUserData: *mut c_void,
332    pub pfnAllocation: PFN_vkAllocationFunction,
333    pub pfnReallocation: PFN_vkReallocationFunction,
334    pub pfnFree: PFN_vkFreeFunction,
335    pub pfnInternalAllocation: PFN_vkInternalAllocationNotification,
336    pub pfnInternalFree: PFN_vkInternalFreeNotification,
337}
338
339#[derive(Clone, Copy)]
340#[repr(C)]
341pub struct VkAmigoProfilingSubmitInfoSEC {
342    pub sType: VkStructureType,
343    pub pNext: *const c_void,
344    pub firstDrawTimestamp: u64,
345    pub swapBufferTimestamp: u64,
346}
347
348#[derive(Clone, Copy)]
349#[repr(C)]
350pub struct VkAntiLagDataAMD {
351    pub sType: VkStructureType,
352    pub pNext: *const c_void,
353    pub mode: VkAntiLagModeAMD,
354    pub maxFPS: u32,
355    pub pPresentationInfo: *const VkAntiLagPresentationInfoAMD,
356}
357
358#[derive(Clone, Copy)]
359#[repr(C)]
360pub struct VkAntiLagPresentationInfoAMD {
361    pub sType: VkStructureType,
362    pub pNext: *mut c_void,
363    pub stage: VkAntiLagStageAMD,
364    pub frameIndex: u64,
365}
366
367#[derive(Clone, Copy)]
368#[repr(C)]
369pub struct VkApplicationInfo {
370    pub sType: VkStructureType,
371    pub pNext: *const c_void,
372    pub pApplicationName: *const c_char,
373    pub applicationVersion: u32,
374    pub pEngineName: *const c_char,
375    pub engineVersion: u32,
376    pub apiVersion: u32,
377}
378
379#[derive(Clone, Copy)]
380#[repr(C)]
381pub struct VkAttachmentDescription {
382    pub flags: VkAttachmentDescriptionFlags,
383    pub format: VkFormat,
384    pub samples: VkSampleCountFlagBits,
385    pub loadOp: VkAttachmentLoadOp,
386    pub storeOp: VkAttachmentStoreOp,
387    pub stencilLoadOp: VkAttachmentLoadOp,
388    pub stencilStoreOp: VkAttachmentStoreOp,
389    pub initialLayout: VkImageLayout,
390    pub finalLayout: VkImageLayout,
391}
392
393#[derive(Clone, Copy)]
394#[repr(C)]
395pub struct VkAttachmentDescription2 {
396    pub sType: VkStructureType,
397    pub pNext: *const c_void,
398    pub flags: VkAttachmentDescriptionFlags,
399    pub format: VkFormat,
400    pub samples: VkSampleCountFlagBits,
401    pub loadOp: VkAttachmentLoadOp,
402    pub storeOp: VkAttachmentStoreOp,
403    pub stencilLoadOp: VkAttachmentLoadOp,
404    pub stencilStoreOp: VkAttachmentStoreOp,
405    pub initialLayout: VkImageLayout,
406    pub finalLayout: VkImageLayout,
407}
408
409#[derive(Clone, Copy)]
410#[repr(C)]
411pub struct VkAttachmentDescriptionStencilLayout {
412    pub sType: VkStructureType,
413    pub pNext: *mut c_void,
414    pub stencilInitialLayout: VkImageLayout,
415    pub stencilFinalLayout: VkImageLayout,
416}
417
418#[derive(Clone, Copy)]
419#[repr(C)]
420pub struct VkAttachmentFeedbackLoopInfoEXT {
421    pub sType: VkStructureType,
422    pub pNext: *const c_void,
423    pub feedbackLoopEnable: VkBool32,
424}
425
426#[derive(Clone, Copy)]
427#[repr(C)]
428pub struct VkAttachmentReference {
429    pub attachment: u32,
430    pub layout: VkImageLayout,
431}
432
433#[derive(Clone, Copy)]
434#[repr(C)]
435pub struct VkAttachmentReference2 {
436    pub sType: VkStructureType,
437    pub pNext: *const c_void,
438    pub attachment: u32,
439    pub layout: VkImageLayout,
440    pub aspectMask: VkImageAspectFlags,
441}
442
443#[derive(Clone, Copy)]
444#[repr(C)]
445pub struct VkAttachmentReferenceStencilLayout {
446    pub sType: VkStructureType,
447    pub pNext: *mut c_void,
448    pub stencilLayout: VkImageLayout,
449}
450
451#[derive(Clone, Copy)]
452#[repr(C)]
453pub struct VkAttachmentSampleCountInfoAMD {
454    pub sType: VkStructureType,
455    pub pNext: *const c_void,
456    pub colorAttachmentCount: u32,
457    pub pColorAttachmentSamples: *const VkSampleCountFlagBits,
458    pub depthStencilAttachmentSamples: VkSampleCountFlagBits,
459}
460
461#[derive(Clone, Copy)]
462#[repr(C)]
463pub struct VkAttachmentSampleLocationsEXT {
464    pub attachmentIndex: u32,
465    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
466}
467
468#[derive(Clone, Copy)]
469#[repr(C)]
470pub struct VkBaseInStructure {
471    pub sType: VkStructureType,
472    pub pNext: *const VkBaseInStructure,
473}
474
475#[derive(Clone, Copy)]
476#[repr(C)]
477pub struct VkBaseOutStructure {
478    pub sType: VkStructureType,
479    pub pNext: *mut VkBaseOutStructure,
480}
481
482#[derive(Clone, Copy)]
483#[repr(C)]
484pub struct VkBeginCustomResolveInfoEXT {
485    pub sType: VkStructureType,
486    pub pNext: *mut c_void,
487}
488
489#[derive(Clone, Copy)]
490#[repr(C)]
491pub struct VkBindAccelerationStructureMemoryInfoNV {
492    pub sType: VkStructureType,
493    pub pNext: *const c_void,
494    pub accelerationStructure: VkAccelerationStructureNV,
495    pub memory: VkDeviceMemory,
496    pub memoryOffset: VkDeviceSize,
497    pub deviceIndexCount: u32,
498    pub pDeviceIndices: *const u32,
499}
500
501#[derive(Clone, Copy)]
502#[repr(C)]
503pub struct VkBindBufferMemoryDeviceGroupInfo {
504    pub sType: VkStructureType,
505    pub pNext: *const c_void,
506    pub deviceIndexCount: u32,
507    pub pDeviceIndices: *const u32,
508}
509
510#[derive(Clone, Copy)]
511#[repr(C)]
512pub struct VkBindBufferMemoryInfo {
513    pub sType: VkStructureType,
514    pub pNext: *const c_void,
515    pub buffer: VkBuffer,
516    pub memory: VkDeviceMemory,
517    pub memoryOffset: VkDeviceSize,
518}
519
520#[derive(Clone, Copy)]
521#[repr(C)]
522pub struct VkBindDataGraphPipelineSessionMemoryInfoARM {
523    pub sType: VkStructureType,
524    pub pNext: *const c_void,
525    pub session: VkDataGraphPipelineSessionARM,
526    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
527    pub objectIndex: u32,
528    pub memory: VkDeviceMemory,
529    pub memoryOffset: VkDeviceSize,
530}
531
532#[derive(Clone, Copy)]
533#[repr(C)]
534pub struct VkBindDescriptorBufferEmbeddedSamplersInfoEXT {
535    pub sType: VkStructureType,
536    pub pNext: *const c_void,
537    pub stageFlags: VkShaderStageFlags,
538    pub layout: VkPipelineLayout,
539    pub set: u32,
540}
541
542#[derive(Clone, Copy)]
543#[repr(C)]
544pub struct VkBindDescriptorSetsInfo {
545    pub sType: VkStructureType,
546    pub pNext: *const c_void,
547    pub stageFlags: VkShaderStageFlags,
548    pub layout: VkPipelineLayout,
549    pub firstSet: u32,
550    pub descriptorSetCount: u32,
551    pub pDescriptorSets: *const VkDescriptorSet,
552    pub dynamicOffsetCount: u32,
553    pub pDynamicOffsets: *const u32,
554}
555
556#[derive(Clone, Copy)]
557#[repr(C)]
558pub struct VkBindHeapInfoEXT {
559    pub sType: VkStructureType,
560    pub pNext: *const c_void,
561    pub heapRange: VkDeviceAddressRangeEXT,
562    pub reservedRangeOffset: VkDeviceSize,
563    pub reservedRangeSize: VkDeviceSize,
564}
565
566#[derive(Clone, Copy)]
567#[repr(C)]
568pub struct VkBindImageMemoryDeviceGroupInfo {
569    pub sType: VkStructureType,
570    pub pNext: *const c_void,
571    pub deviceIndexCount: u32,
572    pub pDeviceIndices: *const u32,
573    pub splitInstanceBindRegionCount: u32,
574    pub pSplitInstanceBindRegions: *const VkRect2D,
575}
576
577#[derive(Clone, Copy)]
578#[repr(C)]
579pub struct VkBindImageMemoryInfo {
580    pub sType: VkStructureType,
581    pub pNext: *const c_void,
582    pub image: VkImage,
583    pub memory: VkDeviceMemory,
584    pub memoryOffset: VkDeviceSize,
585}
586
587#[derive(Clone, Copy)]
588#[repr(C)]
589pub struct VkBindImageMemorySwapchainInfoKHR {
590    pub sType: VkStructureType,
591    pub pNext: *const c_void,
592    pub swapchain: VkSwapchainKHR,
593    pub imageIndex: u32,
594}
595
596#[derive(Clone, Copy)]
597#[repr(C)]
598pub struct VkBindImagePlaneMemoryInfo {
599    pub sType: VkStructureType,
600    pub pNext: *const c_void,
601    pub planeAspect: VkImageAspectFlagBits,
602}
603
604#[derive(Clone, Copy)]
605#[repr(C)]
606pub struct VkBindIndexBufferIndirectCommandEXT {
607    pub bufferAddress: VkDeviceAddress,
608    pub size: u32,
609    pub indexType: VkIndexType,
610}
611
612#[derive(Clone, Copy)]
613#[repr(C)]
614pub struct VkBindIndexBufferIndirectCommandNV {
615    pub bufferAddress: VkDeviceAddress,
616    pub size: u32,
617    pub indexType: VkIndexType,
618}
619
620#[derive(Clone, Copy)]
621#[repr(C)]
622pub struct VkBindMemoryStatus {
623    pub sType: VkStructureType,
624    pub pNext: *const c_void,
625    pub pResult: *mut VkResult,
626}
627
628#[derive(Clone, Copy)]
629#[repr(C)]
630pub struct VkBindPipelineIndirectCommandNV {
631    pub pipelineAddress: VkDeviceAddress,
632}
633
634#[derive(Clone, Copy)]
635#[repr(C)]
636pub struct VkBindShaderGroupIndirectCommandNV {
637    pub groupIndex: u32,
638}
639
640#[derive(Clone, Copy)]
641#[repr(C)]
642pub struct VkBindSparseInfo {
643    pub sType: VkStructureType,
644    pub pNext: *const c_void,
645    pub waitSemaphoreCount: u32,
646    pub pWaitSemaphores: *const VkSemaphore,
647    pub bufferBindCount: u32,
648    pub pBufferBinds: *const VkSparseBufferMemoryBindInfo,
649    pub imageOpaqueBindCount: u32,
650    pub pImageOpaqueBinds: *const VkSparseImageOpaqueMemoryBindInfo,
651    pub imageBindCount: u32,
652    pub pImageBinds: *const VkSparseImageMemoryBindInfo,
653    pub signalSemaphoreCount: u32,
654    pub pSignalSemaphores: *const VkSemaphore,
655}
656
657#[derive(Clone, Copy)]
658#[repr(C)]
659pub struct VkBindTensorMemoryInfoARM {
660    pub sType: VkStructureType,
661    pub pNext: *const c_void,
662    pub tensor: VkTensorARM,
663    pub memory: VkDeviceMemory,
664    pub memoryOffset: VkDeviceSize,
665}
666
667#[derive(Clone, Copy)]
668#[repr(C)]
669pub struct VkBindVertexBufferIndirectCommandEXT {
670    pub bufferAddress: VkDeviceAddress,
671    pub size: u32,
672    pub stride: u32,
673}
674
675#[derive(Clone, Copy)]
676#[repr(C)]
677pub struct VkBindVertexBufferIndirectCommandNV {
678    pub bufferAddress: VkDeviceAddress,
679    pub size: u32,
680    pub stride: u32,
681}
682
683#[derive(Clone, Copy)]
684#[repr(C)]
685pub struct VkBindVideoSessionMemoryInfoKHR {
686    pub sType: VkStructureType,
687    pub pNext: *const c_void,
688    pub memoryBindIndex: u32,
689    pub memory: VkDeviceMemory,
690    pub memoryOffset: VkDeviceSize,
691    pub memorySize: VkDeviceSize,
692}
693
694#[derive(Clone, Copy)]
695#[repr(C)]
696pub struct VkBlitImageCubicWeightsInfoQCOM {
697    pub sType: VkStructureType,
698    pub pNext: *const c_void,
699    pub cubicWeights: VkCubicFilterWeightsQCOM,
700}
701
702#[derive(Clone, Copy)]
703#[repr(C)]
704pub struct VkBlitImageInfo2 {
705    pub sType: VkStructureType,
706    pub pNext: *const c_void,
707    pub srcImage: VkImage,
708    pub srcImageLayout: VkImageLayout,
709    pub dstImage: VkImage,
710    pub dstImageLayout: VkImageLayout,
711    pub regionCount: u32,
712    pub pRegions: *const VkImageBlit2,
713    pub filter: VkFilter,
714}
715
716#[derive(Clone, Copy)]
717#[repr(C)]
718pub struct VkBufferCaptureDescriptorDataInfoEXT {
719    pub sType: VkStructureType,
720    pub pNext: *const c_void,
721    pub buffer: VkBuffer,
722}
723
724#[derive(Clone, Copy)]
725#[repr(C)]
726pub struct VkBufferCopy {
727    pub srcOffset: VkDeviceSize,
728    pub dstOffset: VkDeviceSize,
729    pub size: VkDeviceSize,
730}
731
732#[derive(Clone, Copy)]
733#[repr(C)]
734pub struct VkBufferCopy2 {
735    pub sType: VkStructureType,
736    pub pNext: *const c_void,
737    pub srcOffset: VkDeviceSize,
738    pub dstOffset: VkDeviceSize,
739    pub size: VkDeviceSize,
740}
741
742#[derive(Clone, Copy)]
743#[repr(C)]
744pub struct VkBufferCreateInfo {
745    pub sType: VkStructureType,
746    pub pNext: *const c_void,
747    pub flags: VkBufferCreateFlags,
748    pub size: VkDeviceSize,
749    pub usage: VkBufferUsageFlags,
750    pub sharingMode: VkSharingMode,
751    pub queueFamilyIndexCount: u32,
752    pub pQueueFamilyIndices: *const u32,
753}
754
755#[derive(Clone, Copy)]
756#[repr(C)]
757pub struct VkBufferDeviceAddressCreateInfoEXT {
758    pub sType: VkStructureType,
759    pub pNext: *const c_void,
760    pub deviceAddress: VkDeviceAddress,
761}
762
763#[derive(Clone, Copy)]
764#[repr(C)]
765pub struct VkBufferDeviceAddressInfo {
766    pub sType: VkStructureType,
767    pub pNext: *const c_void,
768    pub buffer: VkBuffer,
769}
770
771#[derive(Clone, Copy)]
772#[repr(C)]
773pub struct VkBufferImageCopy {
774    pub bufferOffset: VkDeviceSize,
775    pub bufferRowLength: u32,
776    pub bufferImageHeight: u32,
777    pub imageSubresource: VkImageSubresourceLayers,
778    pub imageOffset: VkOffset3D,
779    pub imageExtent: VkExtent3D,
780}
781
782#[derive(Clone, Copy)]
783#[repr(C)]
784pub struct VkBufferImageCopy2 {
785    pub sType: VkStructureType,
786    pub pNext: *const c_void,
787    pub bufferOffset: VkDeviceSize,
788    pub bufferRowLength: u32,
789    pub bufferImageHeight: u32,
790    pub imageSubresource: VkImageSubresourceLayers,
791    pub imageOffset: VkOffset3D,
792    pub imageExtent: VkExtent3D,
793}
794
795#[derive(Clone, Copy)]
796#[repr(C)]
797pub struct VkBufferMemoryBarrier {
798    pub sType: VkStructureType,
799    pub pNext: *const c_void,
800    pub srcAccessMask: VkAccessFlags,
801    pub dstAccessMask: VkAccessFlags,
802    pub srcQueueFamilyIndex: u32,
803    pub dstQueueFamilyIndex: u32,
804    pub buffer: VkBuffer,
805    pub offset: VkDeviceSize,
806    pub size: VkDeviceSize,
807}
808
809#[derive(Clone, Copy)]
810#[repr(C)]
811pub struct VkBufferMemoryBarrier2 {
812    pub sType: VkStructureType,
813    pub pNext: *const c_void,
814    pub srcStageMask: VkPipelineStageFlags2,
815    pub srcAccessMask: VkAccessFlags2,
816    pub dstStageMask: VkPipelineStageFlags2,
817    pub dstAccessMask: VkAccessFlags2,
818    pub srcQueueFamilyIndex: u32,
819    pub dstQueueFamilyIndex: u32,
820    pub buffer: VkBuffer,
821    pub offset: VkDeviceSize,
822    pub size: VkDeviceSize,
823}
824
825#[derive(Clone, Copy)]
826#[repr(C)]
827pub struct VkBufferMemoryRequirementsInfo2 {
828    pub sType: VkStructureType,
829    pub pNext: *const c_void,
830    pub buffer: VkBuffer,
831}
832
833#[derive(Clone, Copy)]
834#[repr(C)]
835pub struct VkBufferOpaqueCaptureAddressCreateInfo {
836    pub sType: VkStructureType,
837    pub pNext: *const c_void,
838    pub opaqueCaptureAddress: u64,
839}
840
841#[derive(Clone, Copy)]
842#[repr(C)]
843pub struct VkBufferUsageFlags2CreateInfo {
844    pub sType: VkStructureType,
845    pub pNext: *const c_void,
846    pub usage: VkBufferUsageFlags2,
847}
848
849#[derive(Clone, Copy)]
850#[repr(C)]
851pub struct VkBufferViewCreateInfo {
852    pub sType: VkStructureType,
853    pub pNext: *const c_void,
854    pub flags: VkBufferViewCreateFlags,
855    pub buffer: VkBuffer,
856    pub format: VkFormat,
857    pub offset: VkDeviceSize,
858    pub range: VkDeviceSize,
859}
860
861#[repr(C)]
862pub struct VkBufferView_T {
863    _data: (),
864    _marker: PhantomData<(*mut u8, PhantomPinned)>,
865}
866
867#[repr(C)]
868pub struct VkBuffer_T {
869    _data: (),
870    _marker: PhantomData<(*mut u8, PhantomPinned)>,
871}
872
873#[derive(Clone, Copy)]
874#[repr(C)]
875pub struct VkBuildPartitionedAccelerationStructureIndirectCommandNV {
876    pub opType: VkPartitionedAccelerationStructureOpTypeNV,
877    pub argCount: u32,
878    pub argData: VkStridedDeviceAddressNV,
879}
880
881#[derive(Clone, Copy)]
882#[repr(C)]
883pub struct VkBuildPartitionedAccelerationStructureInfoNV {
884    pub sType: VkStructureType,
885    pub pNext: *mut c_void,
886    pub input: VkPartitionedAccelerationStructureInstancesInputNV,
887    pub srcAccelerationStructureData: VkDeviceAddress,
888    pub dstAccelerationStructureData: VkDeviceAddress,
889    pub scratchData: VkDeviceAddress,
890    pub srcInfos: VkDeviceAddress,
891    pub srcInfosCount: VkDeviceAddress,
892}
893
894#[derive(Clone, Copy)]
895#[repr(C)]
896pub struct VkCalibratedTimestampInfoKHR {
897    pub sType: VkStructureType,
898    pub pNext: *const c_void,
899    pub timeDomain: VkTimeDomainKHR,
900}
901
902#[derive(Clone, Copy)]
903#[repr(C)]
904pub struct VkCheckpointData2NV {
905    pub sType: VkStructureType,
906    pub pNext: *mut c_void,
907    pub stage: VkPipelineStageFlags2,
908    pub pCheckpointMarker: *mut c_void,
909}
910
911#[derive(Clone, Copy)]
912#[repr(C)]
913pub struct VkCheckpointDataNV {
914    pub sType: VkStructureType,
915    pub pNext: *mut c_void,
916    pub stage: VkPipelineStageFlagBits,
917    pub pCheckpointMarker: *mut c_void,
918}
919
920#[derive(Clone, Copy)]
921#[repr(C)]
922pub struct VkClearAttachment {
923    pub aspectMask: VkImageAspectFlags,
924    pub colorAttachment: u32,
925    pub clearValue: VkClearValue,
926}
927
928#[derive(Clone, Copy)]
929#[repr(C)]
930pub struct VkClearDepthStencilValue {
931    pub depth: f32,
932    pub stencil: u32,
933}
934
935#[derive(Clone, Copy)]
936#[repr(C)]
937pub struct VkClearRect {
938    pub rect: VkRect2D,
939    pub baseArrayLayer: u32,
940    pub layerCount: u32,
941}
942
943#[derive(Clone, Copy)]
944#[repr(C)]
945pub struct VkClusterAccelerationStructureBuildClustersBottomLevelInfoNV {
946    pub clusterReferencesCount: u32,
947    pub clusterReferencesStride: u32,
948    pub clusterReferences: VkDeviceAddress,
949}
950
951#[derive(Clone, Copy)]
952#[repr(C)]
953pub struct VkClusterAccelerationStructureBuildTriangleClusterInfoNV {
954    pub clusterID: u32,
955    pub clusterFlags: VkClusterAccelerationStructureClusterFlagsNV,
956    pub bitfields: u32,
957    pub baseGeometryIndexAndGeometryFlags: VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
958    pub indexBufferStride: u16,
959    pub vertexBufferStride: u16,
960    pub geometryIndexAndFlagsBufferStride: u16,
961    pub opacityMicromapIndexBufferStride: u16,
962    pub indexBuffer: VkDeviceAddress,
963    pub vertexBuffer: VkDeviceAddress,
964    pub geometryIndexAndFlagsBuffer: VkDeviceAddress,
965    pub opacityMicromapArray: VkDeviceAddress,
966    pub opacityMicromapIndexBuffer: VkDeviceAddress,
967}
968
969#[derive(Clone, Copy)]
970#[repr(C)]
971pub struct VkClusterAccelerationStructureBuildTriangleClusterTemplateInfoNV {
972    pub clusterID: u32,
973    pub clusterFlags: VkClusterAccelerationStructureClusterFlagsNV,
974    pub bitfields: u32,
975    pub baseGeometryIndexAndGeometryFlags: VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV,
976    pub indexBufferStride: u16,
977    pub vertexBufferStride: u16,
978    pub geometryIndexAndFlagsBufferStride: u16,
979    pub opacityMicromapIndexBufferStride: u16,
980    pub indexBuffer: VkDeviceAddress,
981    pub vertexBuffer: VkDeviceAddress,
982    pub geometryIndexAndFlagsBuffer: VkDeviceAddress,
983    pub opacityMicromapArray: VkDeviceAddress,
984    pub opacityMicromapIndexBuffer: VkDeviceAddress,
985    pub instantiationBoundingBoxLimit: VkDeviceAddress,
986}
987
988#[derive(Clone, Copy)]
989#[repr(C)]
990pub struct VkClusterAccelerationStructureClustersBottomLevelInputNV {
991    pub sType: VkStructureType,
992    pub pNext: *mut c_void,
993    pub maxTotalClusterCount: u32,
994    pub maxClusterCountPerAccelerationStructure: u32,
995}
996
997#[derive(Clone, Copy)]
998#[repr(C)]
999pub struct VkClusterAccelerationStructureCommandsInfoNV {
1000    pub sType: VkStructureType,
1001    pub pNext: *mut c_void,
1002    pub input: VkClusterAccelerationStructureInputInfoNV,
1003    pub dstImplicitData: VkDeviceAddress,
1004    pub scratchData: VkDeviceAddress,
1005    pub dstAddressesArray: VkStridedDeviceAddressRegionKHR,
1006    pub dstSizesArray: VkStridedDeviceAddressRegionKHR,
1007    pub srcInfosArray: VkStridedDeviceAddressRegionKHR,
1008    pub srcInfosCount: VkDeviceAddress,
1009    pub addressResolutionFlags: VkClusterAccelerationStructureAddressResolutionFlagsNV,
1010}
1011
1012#[derive(Clone, Copy)]
1013#[repr(C)]
1014pub struct VkClusterAccelerationStructureGeometryIndexAndGeometryFlagsNV {
1015    pub bitfields: u32,
1016}
1017
1018#[derive(Clone, Copy)]
1019#[repr(C)]
1020pub struct VkClusterAccelerationStructureGetTemplateIndicesInfoNV {
1021    pub clusterTemplateAddress: VkDeviceAddress,
1022}
1023
1024#[derive(Clone, Copy)]
1025#[repr(C)]
1026pub struct VkClusterAccelerationStructureInputInfoNV {
1027    pub sType: VkStructureType,
1028    pub pNext: *mut c_void,
1029    pub maxAccelerationStructureCount: u32,
1030    pub flags: VkBuildAccelerationStructureFlagsKHR,
1031    pub opType: VkClusterAccelerationStructureOpTypeNV,
1032    pub opMode: VkClusterAccelerationStructureOpModeNV,
1033    pub opInput: VkClusterAccelerationStructureOpInputNV,
1034}
1035
1036#[derive(Clone, Copy)]
1037#[repr(C)]
1038pub struct VkClusterAccelerationStructureInstantiateClusterInfoNV {
1039    pub clusterIdOffset: u32,
1040    pub bitfields: u32,
1041    pub clusterTemplateAddress: VkDeviceAddress,
1042    pub vertexBuffer: VkStridedDeviceAddressNV,
1043}
1044
1045#[derive(Clone, Copy)]
1046#[repr(C)]
1047pub struct VkClusterAccelerationStructureMoveObjectsInfoNV {
1048    pub srcAccelerationStructure: VkDeviceAddress,
1049}
1050
1051#[derive(Clone, Copy)]
1052#[repr(C)]
1053pub struct VkClusterAccelerationStructureMoveObjectsInputNV {
1054    pub sType: VkStructureType,
1055    pub pNext: *mut c_void,
1056    pub typ: VkClusterAccelerationStructureTypeNV,
1057    pub noMoveOverlap: VkBool32,
1058    pub maxMovedBytes: VkDeviceSize,
1059}
1060
1061#[derive(Clone, Copy)]
1062#[repr(C)]
1063pub struct VkClusterAccelerationStructureTriangleClusterInputNV {
1064    pub sType: VkStructureType,
1065    pub pNext: *mut c_void,
1066    pub vertexFormat: VkFormat,
1067    pub maxGeometryIndexValue: u32,
1068    pub maxClusterUniqueGeometryCount: u32,
1069    pub maxClusterTriangleCount: u32,
1070    pub maxClusterVertexCount: u32,
1071    pub maxTotalTriangleCount: u32,
1072    pub maxTotalVertexCount: u32,
1073    pub minPositionTruncateBitCount: u32,
1074}
1075
1076#[derive(Clone, Copy)]
1077#[repr(C)]
1078pub struct VkCoarseSampleLocationNV {
1079    pub pixelX: u32,
1080    pub pixelY: u32,
1081    pub sample: u32,
1082}
1083
1084#[derive(Clone, Copy)]
1085#[repr(C)]
1086pub struct VkCoarseSampleOrderCustomNV {
1087    pub shadingRate: VkShadingRatePaletteEntryNV,
1088    pub sampleCount: u32,
1089    pub sampleLocationCount: u32,
1090    pub pSampleLocations: *const VkCoarseSampleLocationNV,
1091}
1092
1093#[derive(Clone, Copy)]
1094#[repr(C)]
1095pub struct VkColorBlendAdvancedEXT {
1096    pub advancedBlendOp: VkBlendOp,
1097    pub srcPremultiplied: VkBool32,
1098    pub dstPremultiplied: VkBool32,
1099    pub blendOverlap: VkBlendOverlapEXT,
1100    pub clampResults: VkBool32,
1101}
1102
1103#[derive(Clone, Copy)]
1104#[repr(C)]
1105pub struct VkColorBlendEquationEXT {
1106    pub srcColorBlendFactor: VkBlendFactor,
1107    pub dstColorBlendFactor: VkBlendFactor,
1108    pub colorBlendOp: VkBlendOp,
1109    pub srcAlphaBlendFactor: VkBlendFactor,
1110    pub dstAlphaBlendFactor: VkBlendFactor,
1111    pub alphaBlendOp: VkBlendOp,
1112}
1113
1114#[derive(Clone, Copy)]
1115#[repr(C)]
1116pub struct VkCommandBufferAllocateInfo {
1117    pub sType: VkStructureType,
1118    pub pNext: *const c_void,
1119    pub commandPool: VkCommandPool,
1120    pub level: VkCommandBufferLevel,
1121    pub commandBufferCount: u32,
1122}
1123
1124#[derive(Clone, Copy)]
1125#[repr(C)]
1126pub struct VkCommandBufferBeginInfo {
1127    pub sType: VkStructureType,
1128    pub pNext: *const c_void,
1129    pub flags: VkCommandBufferUsageFlags,
1130    pub pInheritanceInfo: *const VkCommandBufferInheritanceInfo,
1131}
1132
1133#[derive(Clone, Copy)]
1134#[repr(C)]
1135pub struct VkCommandBufferInheritanceConditionalRenderingInfoEXT {
1136    pub sType: VkStructureType,
1137    pub pNext: *const c_void,
1138    pub conditionalRenderingEnable: VkBool32,
1139}
1140
1141#[derive(Clone, Copy)]
1142#[repr(C)]
1143pub struct VkCommandBufferInheritanceDescriptorHeapInfoEXT {
1144    pub sType: VkStructureType,
1145    pub pNext: *const c_void,
1146    pub pSamplerHeapBindInfo: *const VkBindHeapInfoEXT,
1147    pub pResourceHeapBindInfo: *const VkBindHeapInfoEXT,
1148}
1149
1150#[derive(Clone, Copy)]
1151#[repr(C)]
1152pub struct VkCommandBufferInheritanceInfo {
1153    pub sType: VkStructureType,
1154    pub pNext: *const c_void,
1155    pub renderPass: VkRenderPass,
1156    pub subpass: u32,
1157    pub framebuffer: VkFramebuffer,
1158    pub occlusionQueryEnable: VkBool32,
1159    pub queryFlags: VkQueryControlFlags,
1160    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
1161}
1162
1163#[derive(Clone, Copy)]
1164#[repr(C)]
1165pub struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM {
1166    pub sType: VkStructureType,
1167    pub pNext: *const c_void,
1168    pub transform: VkSurfaceTransformFlagBitsKHR,
1169    pub renderArea: VkRect2D,
1170}
1171
1172#[derive(Clone, Copy)]
1173#[repr(C)]
1174pub struct VkCommandBufferInheritanceRenderingInfo {
1175    pub sType: VkStructureType,
1176    pub pNext: *const c_void,
1177    pub flags: VkRenderingFlags,
1178    pub viewMask: u32,
1179    pub colorAttachmentCount: u32,
1180    pub pColorAttachmentFormats: *const VkFormat,
1181    pub depthAttachmentFormat: VkFormat,
1182    pub stencilAttachmentFormat: VkFormat,
1183    pub rasterizationSamples: VkSampleCountFlagBits,
1184}
1185
1186#[derive(Clone, Copy)]
1187#[repr(C)]
1188pub struct VkCommandBufferInheritanceViewportScissorInfoNV {
1189    pub sType: VkStructureType,
1190    pub pNext: *const c_void,
1191    pub viewportScissor2D: VkBool32,
1192    pub viewportDepthCount: u32,
1193    pub pViewportDepths: *const VkViewport,
1194}
1195
1196#[derive(Clone, Copy)]
1197#[repr(C)]
1198pub struct VkCommandBufferSubmitInfo {
1199    pub sType: VkStructureType,
1200    pub pNext: *const c_void,
1201    pub commandBuffer: VkCommandBuffer,
1202    pub deviceMask: u32,
1203}
1204
1205#[repr(C)]
1206pub struct VkCommandBuffer_T {
1207    _data: (),
1208    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1209}
1210
1211#[derive(Clone, Copy)]
1212#[repr(C)]
1213pub struct VkCommandPoolCreateInfo {
1214    pub sType: VkStructureType,
1215    pub pNext: *const c_void,
1216    pub flags: VkCommandPoolCreateFlags,
1217    pub queueFamilyIndex: u32,
1218}
1219
1220#[repr(C)]
1221pub struct VkCommandPool_T {
1222    _data: (),
1223    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1224}
1225
1226#[derive(Clone, Copy)]
1227#[repr(C)]
1228pub struct VkComponentMapping {
1229    pub r: VkComponentSwizzle,
1230    pub g: VkComponentSwizzle,
1231    pub b: VkComponentSwizzle,
1232    pub a: VkComponentSwizzle,
1233}
1234
1235#[derive(Clone, Copy)]
1236#[repr(C)]
1237pub struct VkComputeOccupancyPriorityParametersNV {
1238    pub sType: VkStructureType,
1239    pub pNext: *const c_void,
1240    pub occupancyPriority: f32,
1241    pub occupancyThrottling: f32,
1242}
1243
1244#[derive(Clone, Copy)]
1245#[repr(C)]
1246pub struct VkComputePipelineCreateInfo {
1247    pub sType: VkStructureType,
1248    pub pNext: *const c_void,
1249    pub flags: VkPipelineCreateFlags,
1250    pub stage: VkPipelineShaderStageCreateInfo,
1251    pub layout: VkPipelineLayout,
1252    pub basePipelineHandle: VkPipeline,
1253    pub basePipelineIndex: i32,
1254}
1255
1256#[derive(Clone, Copy)]
1257#[repr(C)]
1258pub struct VkComputePipelineIndirectBufferInfoNV {
1259    pub sType: VkStructureType,
1260    pub pNext: *const c_void,
1261    pub deviceAddress: VkDeviceAddress,
1262    pub size: VkDeviceSize,
1263    pub pipelineDeviceAddressCaptureReplay: VkDeviceAddress,
1264}
1265
1266#[derive(Clone, Copy)]
1267#[repr(C)]
1268pub struct VkConditionalRenderingBeginInfoEXT {
1269    pub sType: VkStructureType,
1270    pub pNext: *const c_void,
1271    pub buffer: VkBuffer,
1272    pub offset: VkDeviceSize,
1273    pub flags: VkConditionalRenderingFlagsEXT,
1274}
1275
1276#[derive(Clone, Copy)]
1277#[repr(C)]
1278pub struct VkConformanceVersion {
1279    pub major: u8,
1280    pub minor: u8,
1281    pub subminor: u8,
1282    pub patch: u8,
1283}
1284
1285#[derive(Clone, Copy)]
1286#[repr(C)]
1287pub struct VkConvertCooperativeVectorMatrixInfoNV {
1288    pub sType: VkStructureType,
1289    pub pNext: *const c_void,
1290    pub srcSize: usize,
1291    pub srcData: VkDeviceOrHostAddressConstKHR,
1292    pub pDstSize: *mut usize,
1293    pub dstData: VkDeviceOrHostAddressKHR,
1294    pub srcComponentType: VkComponentTypeKHR,
1295    pub dstComponentType: VkComponentTypeKHR,
1296    pub numRows: u32,
1297    pub numColumns: u32,
1298    pub srcLayout: VkCooperativeVectorMatrixLayoutNV,
1299    pub srcStride: usize,
1300    pub dstLayout: VkCooperativeVectorMatrixLayoutNV,
1301    pub dstStride: usize,
1302}
1303
1304#[derive(Clone, Copy)]
1305#[repr(C)]
1306pub struct VkCooperativeMatrixFlexibleDimensionsPropertiesNV {
1307    pub sType: VkStructureType,
1308    pub pNext: *mut c_void,
1309    pub MGranularity: u32,
1310    pub NGranularity: u32,
1311    pub KGranularity: u32,
1312    pub AType: VkComponentTypeKHR,
1313    pub BType: VkComponentTypeKHR,
1314    pub CType: VkComponentTypeKHR,
1315    pub ResultType: VkComponentTypeKHR,
1316    pub saturatingAccumulation: VkBool32,
1317    pub scope: VkScopeKHR,
1318    pub workgroupInvocations: u32,
1319}
1320
1321#[derive(Clone, Copy)]
1322#[repr(C)]
1323pub struct VkCooperativeMatrixPropertiesKHR {
1324    pub sType: VkStructureType,
1325    pub pNext: *mut c_void,
1326    pub MSize: u32,
1327    pub NSize: u32,
1328    pub KSize: u32,
1329    pub AType: VkComponentTypeKHR,
1330    pub BType: VkComponentTypeKHR,
1331    pub CType: VkComponentTypeKHR,
1332    pub ResultType: VkComponentTypeKHR,
1333    pub saturatingAccumulation: VkBool32,
1334    pub scope: VkScopeKHR,
1335}
1336
1337#[derive(Clone, Copy)]
1338#[repr(C)]
1339pub struct VkCooperativeMatrixPropertiesNV {
1340    pub sType: VkStructureType,
1341    pub pNext: *mut c_void,
1342    pub MSize: u32,
1343    pub NSize: u32,
1344    pub KSize: u32,
1345    pub AType: VkComponentTypeNV,
1346    pub BType: VkComponentTypeNV,
1347    pub CType: VkComponentTypeNV,
1348    pub DType: VkComponentTypeNV,
1349    pub scope: VkScopeNV,
1350}
1351
1352#[derive(Clone, Copy)]
1353#[repr(C)]
1354pub struct VkCooperativeVectorPropertiesNV {
1355    pub sType: VkStructureType,
1356    pub pNext: *mut c_void,
1357    pub inputType: VkComponentTypeKHR,
1358    pub inputInterpretation: VkComponentTypeKHR,
1359    pub matrixInterpretation: VkComponentTypeKHR,
1360    pub biasInterpretation: VkComponentTypeKHR,
1361    pub resultType: VkComponentTypeKHR,
1362    pub transpose: VkBool32,
1363}
1364
1365#[derive(Clone, Copy)]
1366#[repr(C)]
1367pub struct VkCopyAccelerationStructureInfoKHR {
1368    pub sType: VkStructureType,
1369    pub pNext: *const c_void,
1370    pub src: VkAccelerationStructureKHR,
1371    pub dst: VkAccelerationStructureKHR,
1372    pub mode: VkCopyAccelerationStructureModeKHR,
1373}
1374
1375#[derive(Clone, Copy)]
1376#[repr(C)]
1377pub struct VkCopyAccelerationStructureToMemoryInfoKHR {
1378    pub sType: VkStructureType,
1379    pub pNext: *const c_void,
1380    pub src: VkAccelerationStructureKHR,
1381    pub dst: VkDeviceOrHostAddressKHR,
1382    pub mode: VkCopyAccelerationStructureModeKHR,
1383}
1384
1385#[derive(Clone, Copy)]
1386#[repr(C)]
1387pub struct VkCopyBufferInfo2 {
1388    pub sType: VkStructureType,
1389    pub pNext: *const c_void,
1390    pub srcBuffer: VkBuffer,
1391    pub dstBuffer: VkBuffer,
1392    pub regionCount: u32,
1393    pub pRegions: *const VkBufferCopy2,
1394}
1395
1396#[derive(Clone, Copy)]
1397#[repr(C)]
1398pub struct VkCopyBufferToImageInfo2 {
1399    pub sType: VkStructureType,
1400    pub pNext: *const c_void,
1401    pub srcBuffer: VkBuffer,
1402    pub dstImage: VkImage,
1403    pub dstImageLayout: VkImageLayout,
1404    pub regionCount: u32,
1405    pub pRegions: *const VkBufferImageCopy2,
1406}
1407
1408#[derive(Clone, Copy)]
1409#[repr(C)]
1410pub struct VkCopyCommandTransformInfoQCOM {
1411    pub sType: VkStructureType,
1412    pub pNext: *const c_void,
1413    pub transform: VkSurfaceTransformFlagBitsKHR,
1414}
1415
1416#[derive(Clone, Copy)]
1417#[repr(C)]
1418pub struct VkCopyDescriptorSet {
1419    pub sType: VkStructureType,
1420    pub pNext: *const c_void,
1421    pub srcSet: VkDescriptorSet,
1422    pub srcBinding: u32,
1423    pub srcArrayElement: u32,
1424    pub dstSet: VkDescriptorSet,
1425    pub dstBinding: u32,
1426    pub dstArrayElement: u32,
1427    pub descriptorCount: u32,
1428}
1429
1430#[derive(Clone, Copy)]
1431#[repr(C)]
1432pub struct VkCopyImageInfo2 {
1433    pub sType: VkStructureType,
1434    pub pNext: *const c_void,
1435    pub srcImage: VkImage,
1436    pub srcImageLayout: VkImageLayout,
1437    pub dstImage: VkImage,
1438    pub dstImageLayout: VkImageLayout,
1439    pub regionCount: u32,
1440    pub pRegions: *const VkImageCopy2,
1441}
1442
1443#[derive(Clone, Copy)]
1444#[repr(C)]
1445pub struct VkCopyImageToBufferInfo2 {
1446    pub sType: VkStructureType,
1447    pub pNext: *const c_void,
1448    pub srcImage: VkImage,
1449    pub srcImageLayout: VkImageLayout,
1450    pub dstBuffer: VkBuffer,
1451    pub regionCount: u32,
1452    pub pRegions: *const VkBufferImageCopy2,
1453}
1454
1455#[derive(Clone, Copy)]
1456#[repr(C)]
1457pub struct VkCopyImageToImageInfo {
1458    pub sType: VkStructureType,
1459    pub pNext: *const c_void,
1460    pub flags: VkHostImageCopyFlags,
1461    pub srcImage: VkImage,
1462    pub srcImageLayout: VkImageLayout,
1463    pub dstImage: VkImage,
1464    pub dstImageLayout: VkImageLayout,
1465    pub regionCount: u32,
1466    pub pRegions: *const VkImageCopy2,
1467}
1468
1469#[derive(Clone, Copy)]
1470#[repr(C)]
1471pub struct VkCopyImageToMemoryInfo {
1472    pub sType: VkStructureType,
1473    pub pNext: *const c_void,
1474    pub flags: VkHostImageCopyFlags,
1475    pub srcImage: VkImage,
1476    pub srcImageLayout: VkImageLayout,
1477    pub regionCount: u32,
1478    pub pRegions: *const VkImageToMemoryCopy,
1479}
1480
1481#[derive(Clone, Copy)]
1482#[repr(C)]
1483pub struct VkCopyMemoryIndirectCommandKHR {
1484    pub srcAddress: VkDeviceAddress,
1485    pub dstAddress: VkDeviceAddress,
1486    pub size: VkDeviceSize,
1487}
1488
1489#[derive(Clone, Copy)]
1490#[repr(C)]
1491pub struct VkCopyMemoryIndirectInfoKHR {
1492    pub sType: VkStructureType,
1493    pub pNext: *const c_void,
1494    pub srcCopyFlags: VkAddressCopyFlagsKHR,
1495    pub dstCopyFlags: VkAddressCopyFlagsKHR,
1496    pub copyCount: u32,
1497    pub copyAddressRange: VkStridedDeviceAddressRangeKHR,
1498}
1499
1500#[derive(Clone, Copy)]
1501#[repr(C)]
1502pub struct VkCopyMemoryToAccelerationStructureInfoKHR {
1503    pub sType: VkStructureType,
1504    pub pNext: *const c_void,
1505    pub src: VkDeviceOrHostAddressConstKHR,
1506    pub dst: VkAccelerationStructureKHR,
1507    pub mode: VkCopyAccelerationStructureModeKHR,
1508}
1509
1510#[derive(Clone, Copy)]
1511#[repr(C)]
1512pub struct VkCopyMemoryToImageIndirectCommandKHR {
1513    pub srcAddress: VkDeviceAddress,
1514    pub bufferRowLength: u32,
1515    pub bufferImageHeight: u32,
1516    pub imageSubresource: VkImageSubresourceLayers,
1517    pub imageOffset: VkOffset3D,
1518    pub imageExtent: VkExtent3D,
1519}
1520
1521#[derive(Clone, Copy)]
1522#[repr(C)]
1523pub struct VkCopyMemoryToImageIndirectInfoKHR {
1524    pub sType: VkStructureType,
1525    pub pNext: *const c_void,
1526    pub srcCopyFlags: VkAddressCopyFlagsKHR,
1527    pub copyCount: u32,
1528    pub copyAddressRange: VkStridedDeviceAddressRangeKHR,
1529    pub dstImage: VkImage,
1530    pub dstImageLayout: VkImageLayout,
1531    pub pImageSubresources: *const VkImageSubresourceLayers,
1532}
1533
1534#[derive(Clone, Copy)]
1535#[repr(C)]
1536pub struct VkCopyMemoryToImageInfo {
1537    pub sType: VkStructureType,
1538    pub pNext: *const c_void,
1539    pub flags: VkHostImageCopyFlags,
1540    pub dstImage: VkImage,
1541    pub dstImageLayout: VkImageLayout,
1542    pub regionCount: u32,
1543    pub pRegions: *const VkMemoryToImageCopy,
1544}
1545
1546#[derive(Clone, Copy)]
1547#[repr(C)]
1548pub struct VkCopyMemoryToMicromapInfoEXT {
1549    pub sType: VkStructureType,
1550    pub pNext: *const c_void,
1551    pub src: VkDeviceOrHostAddressConstKHR,
1552    pub dst: VkMicromapEXT,
1553    pub mode: VkCopyMicromapModeEXT,
1554}
1555
1556#[derive(Clone, Copy)]
1557#[repr(C)]
1558pub struct VkCopyMicromapInfoEXT {
1559    pub sType: VkStructureType,
1560    pub pNext: *const c_void,
1561    pub src: VkMicromapEXT,
1562    pub dst: VkMicromapEXT,
1563    pub mode: VkCopyMicromapModeEXT,
1564}
1565
1566#[derive(Clone, Copy)]
1567#[repr(C)]
1568pub struct VkCopyMicromapToMemoryInfoEXT {
1569    pub sType: VkStructureType,
1570    pub pNext: *const c_void,
1571    pub src: VkMicromapEXT,
1572    pub dst: VkDeviceOrHostAddressKHR,
1573    pub mode: VkCopyMicromapModeEXT,
1574}
1575
1576#[derive(Clone, Copy)]
1577#[repr(C)]
1578pub struct VkCopyTensorInfoARM {
1579    pub sType: VkStructureType,
1580    pub pNext: *const c_void,
1581    pub srcTensor: VkTensorARM,
1582    pub dstTensor: VkTensorARM,
1583    pub regionCount: u32,
1584    pub pRegions: *const VkTensorCopyARM,
1585}
1586
1587#[derive(Clone, Copy)]
1588#[repr(C)]
1589pub struct VkCuFunctionCreateInfoNVX {
1590    pub sType: VkStructureType,
1591    pub pNext: *const c_void,
1592    pub module: VkCuModuleNVX,
1593    pub pName: *const c_char,
1594}
1595
1596#[repr(C)]
1597pub struct VkCuFunctionNVX_T {
1598    _data: (),
1599    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1600}
1601
1602#[derive(Clone, Copy)]
1603#[repr(C)]
1604pub struct VkCuLaunchInfoNVX {
1605    pub sType: VkStructureType,
1606    pub pNext: *const c_void,
1607    pub function: VkCuFunctionNVX,
1608    pub gridDimX: u32,
1609    pub gridDimY: u32,
1610    pub gridDimZ: u32,
1611    pub blockDimX: u32,
1612    pub blockDimY: u32,
1613    pub blockDimZ: u32,
1614    pub sharedMemBytes: u32,
1615    pub paramCount: usize,
1616    pub pParams: *const *const c_void,
1617    pub extraCount: usize,
1618    pub pExtras: *const *const c_void,
1619}
1620
1621#[derive(Clone, Copy)]
1622#[repr(C)]
1623pub struct VkCuModuleCreateInfoNVX {
1624    pub sType: VkStructureType,
1625    pub pNext: *const c_void,
1626    pub dataSize: usize,
1627    pub pData: *const c_void,
1628}
1629
1630#[repr(C)]
1631pub struct VkCuModuleNVX_T {
1632    _data: (),
1633    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1634}
1635
1636#[derive(Clone, Copy)]
1637#[repr(C)]
1638pub struct VkCuModuleTexturingModeCreateInfoNVX {
1639    pub sType: VkStructureType,
1640    pub pNext: *const c_void,
1641    pub use64bitTexturing: VkBool32,
1642}
1643
1644#[derive(Clone, Copy)]
1645#[repr(C)]
1646pub struct VkCustomResolveCreateInfoEXT {
1647    pub sType: VkStructureType,
1648    pub pNext: *const c_void,
1649    pub customResolve: VkBool32,
1650    pub colorAttachmentCount: u32,
1651    pub pColorAttachmentFormats: *const VkFormat,
1652    pub depthAttachmentFormat: VkFormat,
1653    pub stencilAttachmentFormat: VkFormat,
1654}
1655
1656#[derive(Clone, Copy)]
1657#[repr(C)]
1658pub struct VkDataGraphPipelineBuiltinModelCreateInfoQCOM {
1659    pub sType: VkStructureType,
1660    pub pNext: *const c_void,
1661    pub pOperation: *const VkPhysicalDeviceDataGraphOperationSupportARM,
1662}
1663
1664#[derive(Clone, Copy)]
1665#[repr(C)]
1666pub struct VkDataGraphPipelineCompilerControlCreateInfoARM {
1667    pub sType: VkStructureType,
1668    pub pNext: *const c_void,
1669    pub pVendorOptions: *const c_char,
1670}
1671
1672#[derive(Clone, Copy)]
1673#[repr(C)]
1674pub struct VkDataGraphPipelineConstantARM {
1675    pub sType: VkStructureType,
1676    pub pNext: *const c_void,
1677    pub id: u32,
1678    pub pConstantData: *const c_void,
1679}
1680
1681#[derive(Clone, Copy)]
1682#[repr(C)]
1683pub struct VkDataGraphPipelineConstantTensorSemiStructuredSparsityInfoARM {
1684    pub sType: VkStructureType,
1685    pub pNext: *const c_void,
1686    pub dimension: u32,
1687    pub zeroCount: u32,
1688    pub groupSize: u32,
1689}
1690
1691#[derive(Clone, Copy)]
1692#[repr(C)]
1693pub struct VkDataGraphPipelineCreateInfoARM {
1694    pub sType: VkStructureType,
1695    pub pNext: *const c_void,
1696    pub flags: VkPipelineCreateFlags2KHR,
1697    pub layout: VkPipelineLayout,
1698    pub resourceInfoCount: u32,
1699    pub pResourceInfos: *const VkDataGraphPipelineResourceInfoARM,
1700}
1701
1702#[derive(Clone, Copy)]
1703#[repr(C)]
1704pub struct VkDataGraphPipelineDispatchInfoARM {
1705    pub sType: VkStructureType,
1706    pub pNext: *mut c_void,
1707    pub flags: VkDataGraphPipelineDispatchFlagsARM,
1708}
1709
1710#[derive(Clone, Copy)]
1711#[repr(C)]
1712pub struct VkDataGraphPipelineIdentifierCreateInfoARM {
1713    pub sType: VkStructureType,
1714    pub pNext: *const c_void,
1715    pub identifierSize: u32,
1716    pub pIdentifier: *const u8,
1717}
1718
1719#[derive(Clone, Copy)]
1720#[repr(C)]
1721pub struct VkDataGraphPipelineInfoARM {
1722    pub sType: VkStructureType,
1723    pub pNext: *const c_void,
1724    pub dataGraphPipeline: VkPipeline,
1725}
1726
1727#[derive(Clone, Copy)]
1728#[repr(C)]
1729pub struct VkDataGraphPipelinePropertyQueryResultARM {
1730    pub sType: VkStructureType,
1731    pub pNext: *mut c_void,
1732    pub property: VkDataGraphPipelinePropertyARM,
1733    pub isText: VkBool32,
1734    pub dataSize: usize,
1735    pub pData: *mut c_void,
1736}
1737
1738#[derive(Clone, Copy)]
1739#[repr(C)]
1740pub struct VkDataGraphPipelineResourceInfoARM {
1741    pub sType: VkStructureType,
1742    pub pNext: *const c_void,
1743    pub descriptorSet: u32,
1744    pub binding: u32,
1745    pub arrayElement: u32,
1746}
1747
1748#[repr(C)]
1749pub struct VkDataGraphPipelineSessionARM_T {
1750    _data: (),
1751    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1752}
1753
1754#[derive(Clone, Copy)]
1755#[repr(C)]
1756pub struct VkDataGraphPipelineSessionBindPointRequirementARM {
1757    pub sType: VkStructureType,
1758    pub pNext: *mut c_void,
1759    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
1760    pub bindPointType: VkDataGraphPipelineSessionBindPointTypeARM,
1761    pub numObjects: u32,
1762}
1763
1764#[derive(Clone, Copy)]
1765#[repr(C)]
1766pub struct VkDataGraphPipelineSessionBindPointRequirementsInfoARM {
1767    pub sType: VkStructureType,
1768    pub pNext: *const c_void,
1769    pub session: VkDataGraphPipelineSessionARM,
1770}
1771
1772#[derive(Clone, Copy)]
1773#[repr(C)]
1774pub struct VkDataGraphPipelineSessionCreateInfoARM {
1775    pub sType: VkStructureType,
1776    pub pNext: *const c_void,
1777    pub flags: VkDataGraphPipelineSessionCreateFlagsARM,
1778    pub dataGraphPipeline: VkPipeline,
1779}
1780
1781#[derive(Clone, Copy)]
1782#[repr(C)]
1783pub struct VkDataGraphPipelineSessionMemoryRequirementsInfoARM {
1784    pub sType: VkStructureType,
1785    pub pNext: *const c_void,
1786    pub session: VkDataGraphPipelineSessionARM,
1787    pub bindPoint: VkDataGraphPipelineSessionBindPointARM,
1788    pub objectIndex: u32,
1789}
1790
1791#[derive(Clone, Copy)]
1792#[repr(C)]
1793pub struct VkDataGraphPipelineShaderModuleCreateInfoARM {
1794    pub sType: VkStructureType,
1795    pub pNext: *const c_void,
1796    pub module: VkShaderModule,
1797    pub pName: *const c_char,
1798    pub pSpecializationInfo: *const VkSpecializationInfo,
1799    pub constantCount: u32,
1800    pub pConstants: *const VkDataGraphPipelineConstantARM,
1801}
1802
1803#[derive(Clone, Copy)]
1804#[repr(C)]
1805pub struct VkDataGraphProcessingEngineCreateInfoARM {
1806    pub sType: VkStructureType,
1807    pub pNext: *const c_void,
1808    pub processingEngineCount: u32,
1809    pub pProcessingEngines: *mut VkPhysicalDeviceDataGraphProcessingEngineARM,
1810}
1811
1812#[derive(Clone, Copy)]
1813#[repr(C)]
1814pub struct VkDebugMarkerMarkerInfoEXT {
1815    pub sType: VkStructureType,
1816    pub pNext: *const c_void,
1817    pub pMarkerName: *const c_char,
1818    pub color: [f32; 4 as usize],
1819}
1820
1821#[derive(Clone, Copy)]
1822#[repr(C)]
1823pub struct VkDebugMarkerObjectNameInfoEXT {
1824    pub sType: VkStructureType,
1825    pub pNext: *const c_void,
1826    pub objectType: VkDebugReportObjectTypeEXT,
1827    pub object: u64,
1828    pub pObjectName: *const c_char,
1829}
1830
1831#[derive(Clone, Copy)]
1832#[repr(C)]
1833pub struct VkDebugMarkerObjectTagInfoEXT {
1834    pub sType: VkStructureType,
1835    pub pNext: *const c_void,
1836    pub objectType: VkDebugReportObjectTypeEXT,
1837    pub object: u64,
1838    pub tagName: u64,
1839    pub tagSize: usize,
1840    pub pTag: *const c_void,
1841}
1842
1843#[derive(Clone, Copy)]
1844#[repr(C)]
1845pub struct VkDebugReportCallbackCreateInfoEXT {
1846    pub sType: VkStructureType,
1847    pub pNext: *const c_void,
1848    pub flags: VkDebugReportFlagsEXT,
1849    pub pfnCallback: PFN_vkDebugReportCallbackEXT,
1850    pub pUserData: *mut c_void,
1851}
1852
1853#[repr(C)]
1854pub struct VkDebugReportCallbackEXT_T {
1855    _data: (),
1856    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1857}
1858
1859#[derive(Clone, Copy)]
1860#[repr(C)]
1861pub struct VkDebugUtilsLabelEXT {
1862    pub sType: VkStructureType,
1863    pub pNext: *const c_void,
1864    pub pLabelName: *const c_char,
1865    pub color: [f32; 4 as usize],
1866}
1867
1868#[derive(Clone, Copy)]
1869#[repr(C)]
1870pub struct VkDebugUtilsMessengerCallbackDataEXT {
1871    pub sType: VkStructureType,
1872    pub pNext: *const c_void,
1873    pub flags: VkDebugUtilsMessengerCallbackDataFlagsEXT,
1874    pub pMessageIdName: *const c_char,
1875    pub messageIdNumber: i32,
1876    pub pMessage: *const c_char,
1877    pub queueLabelCount: u32,
1878    pub pQueueLabels: *const VkDebugUtilsLabelEXT,
1879    pub cmdBufLabelCount: u32,
1880    pub pCmdBufLabels: *const VkDebugUtilsLabelEXT,
1881    pub objectCount: u32,
1882    pub pObjects: *const VkDebugUtilsObjectNameInfoEXT,
1883}
1884
1885#[derive(Clone, Copy)]
1886#[repr(C)]
1887pub struct VkDebugUtilsMessengerCreateInfoEXT {
1888    pub sType: VkStructureType,
1889    pub pNext: *const c_void,
1890    pub flags: VkDebugUtilsMessengerCreateFlagsEXT,
1891    pub messageSeverity: VkDebugUtilsMessageSeverityFlagsEXT,
1892    pub messageType: VkDebugUtilsMessageTypeFlagsEXT,
1893    pub pfnUserCallback: PFN_vkDebugUtilsMessengerCallbackEXT,
1894    pub pUserData: *mut c_void,
1895}
1896
1897#[repr(C)]
1898pub struct VkDebugUtilsMessengerEXT_T {
1899    _data: (),
1900    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1901}
1902
1903#[derive(Clone, Copy)]
1904#[repr(C)]
1905pub struct VkDebugUtilsObjectNameInfoEXT {
1906    pub sType: VkStructureType,
1907    pub pNext: *const c_void,
1908    pub objectType: VkObjectType,
1909    pub objectHandle: u64,
1910    pub pObjectName: *const c_char,
1911}
1912
1913#[derive(Clone, Copy)]
1914#[repr(C)]
1915pub struct VkDebugUtilsObjectTagInfoEXT {
1916    pub sType: VkStructureType,
1917    pub pNext: *const c_void,
1918    pub objectType: VkObjectType,
1919    pub objectHandle: u64,
1920    pub tagName: u64,
1921    pub tagSize: usize,
1922    pub pTag: *const c_void,
1923}
1924
1925#[derive(Clone, Copy)]
1926#[repr(C)]
1927pub struct VkDecompressMemoryInfoEXT {
1928    pub sType: VkStructureType,
1929    pub pNext: *const c_void,
1930    pub decompressionMethod: VkMemoryDecompressionMethodFlagsEXT,
1931    pub regionCount: u32,
1932    pub pRegions: *const VkDecompressMemoryRegionEXT,
1933}
1934
1935#[derive(Clone, Copy)]
1936#[repr(C)]
1937pub struct VkDecompressMemoryRegionEXT {
1938    pub srcAddress: VkDeviceAddress,
1939    pub dstAddress: VkDeviceAddress,
1940    pub compressedSize: VkDeviceSize,
1941    pub decompressedSize: VkDeviceSize,
1942}
1943
1944#[derive(Clone, Copy)]
1945#[repr(C)]
1946pub struct VkDecompressMemoryRegionNV {
1947    pub srcAddress: VkDeviceAddress,
1948    pub dstAddress: VkDeviceAddress,
1949    pub compressedSize: VkDeviceSize,
1950    pub decompressedSize: VkDeviceSize,
1951    pub decompressionMethod: VkMemoryDecompressionMethodFlagsNV,
1952}
1953
1954#[derive(Clone, Copy)]
1955#[repr(C)]
1956pub struct VkDedicatedAllocationBufferCreateInfoNV {
1957    pub sType: VkStructureType,
1958    pub pNext: *const c_void,
1959    pub dedicatedAllocation: VkBool32,
1960}
1961
1962#[derive(Clone, Copy)]
1963#[repr(C)]
1964pub struct VkDedicatedAllocationImageCreateInfoNV {
1965    pub sType: VkStructureType,
1966    pub pNext: *const c_void,
1967    pub dedicatedAllocation: VkBool32,
1968}
1969
1970#[derive(Clone, Copy)]
1971#[repr(C)]
1972pub struct VkDedicatedAllocationMemoryAllocateInfoNV {
1973    pub sType: VkStructureType,
1974    pub pNext: *const c_void,
1975    pub image: VkImage,
1976    pub buffer: VkBuffer,
1977}
1978
1979#[repr(C)]
1980pub struct VkDeferredOperationKHR_T {
1981    _data: (),
1982    _marker: PhantomData<(*mut u8, PhantomPinned)>,
1983}
1984
1985#[derive(Clone, Copy)]
1986#[repr(C)]
1987pub struct VkDependencyInfo {
1988    pub sType: VkStructureType,
1989    pub pNext: *const c_void,
1990    pub dependencyFlags: VkDependencyFlags,
1991    pub memoryBarrierCount: u32,
1992    pub pMemoryBarriers: *const VkMemoryBarrier2,
1993    pub bufferMemoryBarrierCount: u32,
1994    pub pBufferMemoryBarriers: *const VkBufferMemoryBarrier2,
1995    pub imageMemoryBarrierCount: u32,
1996    pub pImageMemoryBarriers: *const VkImageMemoryBarrier2,
1997}
1998
1999#[derive(Clone, Copy)]
2000#[repr(C)]
2001pub struct VkDepthBiasInfoEXT {
2002    pub sType: VkStructureType,
2003    pub pNext: *const c_void,
2004    pub depthBiasConstantFactor: f32,
2005    pub depthBiasClamp: f32,
2006    pub depthBiasSlopeFactor: f32,
2007}
2008
2009#[derive(Clone, Copy)]
2010#[repr(C)]
2011pub struct VkDepthBiasRepresentationInfoEXT {
2012    pub sType: VkStructureType,
2013    pub pNext: *const c_void,
2014    pub depthBiasRepresentation: VkDepthBiasRepresentationEXT,
2015    pub depthBiasExact: VkBool32,
2016}
2017
2018#[derive(Clone, Copy)]
2019#[repr(C)]
2020pub struct VkDepthClampRangeEXT {
2021    pub minDepthClamp: f32,
2022    pub maxDepthClamp: f32,
2023}
2024
2025#[derive(Clone, Copy)]
2026#[repr(C)]
2027pub struct VkDescriptorAddressInfoEXT {
2028    pub sType: VkStructureType,
2029    pub pNext: *mut c_void,
2030    pub address: VkDeviceAddress,
2031    pub range: VkDeviceSize,
2032    pub format: VkFormat,
2033}
2034
2035#[derive(Clone, Copy)]
2036#[repr(C)]
2037pub struct VkDescriptorBufferBindingInfoEXT {
2038    pub sType: VkStructureType,
2039    pub pNext: *const c_void,
2040    pub address: VkDeviceAddress,
2041    pub usage: VkBufferUsageFlags,
2042}
2043
2044#[derive(Clone, Copy)]
2045#[repr(C)]
2046pub struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT {
2047    pub sType: VkStructureType,
2048    pub pNext: *const c_void,
2049    pub buffer: VkBuffer,
2050}
2051
2052#[derive(Clone, Copy)]
2053#[repr(C)]
2054pub struct VkDescriptorBufferInfo {
2055    pub buffer: VkBuffer,
2056    pub offset: VkDeviceSize,
2057    pub range: VkDeviceSize,
2058}
2059
2060#[derive(Clone, Copy)]
2061#[repr(C)]
2062pub struct VkDescriptorGetInfoEXT {
2063    pub sType: VkStructureType,
2064    pub pNext: *const c_void,
2065    pub typ: VkDescriptorType,
2066    pub data: VkDescriptorDataEXT,
2067}
2068
2069#[derive(Clone, Copy)]
2070#[repr(C)]
2071pub struct VkDescriptorGetTensorInfoARM {
2072    pub sType: VkStructureType,
2073    pub pNext: *const c_void,
2074    pub tensorView: VkTensorViewARM,
2075}
2076
2077#[derive(Clone, Copy)]
2078#[repr(C)]
2079pub struct VkDescriptorImageInfo {
2080    pub sampler: VkSampler,
2081    pub imageView: VkImageView,
2082    pub imageLayout: VkImageLayout,
2083}
2084
2085#[derive(Clone, Copy)]
2086#[repr(C)]
2087pub struct VkDescriptorMappingSourceConstantOffsetEXT {
2088    pub heapOffset: u32,
2089    pub heapArrayStride: u32,
2090    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
2091    pub samplerHeapOffset: u32,
2092    pub samplerHeapArrayStride: u32,
2093}
2094
2095#[derive(Clone, Copy)]
2096#[repr(C)]
2097pub struct VkDescriptorMappingSourceHeapDataEXT {
2098    pub heapOffset: u32,
2099    pub pushOffset: u32,
2100}
2101
2102#[derive(Clone, Copy)]
2103#[repr(C)]
2104pub struct VkDescriptorMappingSourceIndirectAddressEXT {
2105    pub pushOffset: u32,
2106    pub addressOffset: u32,
2107}
2108
2109#[derive(Clone, Copy)]
2110#[repr(C)]
2111pub struct VkDescriptorMappingSourceIndirectIndexArrayEXT {
2112    pub heapOffset: u32,
2113    pub pushOffset: u32,
2114    pub addressOffset: u32,
2115    pub heapIndexStride: u32,
2116    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
2117    pub useCombinedImageSamplerIndex: VkBool32,
2118    pub samplerHeapOffset: u32,
2119    pub samplerPushOffset: u32,
2120    pub samplerAddressOffset: u32,
2121    pub samplerHeapIndexStride: u32,
2122}
2123
2124#[derive(Clone, Copy)]
2125#[repr(C)]
2126pub struct VkDescriptorMappingSourceIndirectIndexEXT {
2127    pub heapOffset: u32,
2128    pub pushOffset: u32,
2129    pub addressOffset: u32,
2130    pub heapIndexStride: u32,
2131    pub heapArrayStride: u32,
2132    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
2133    pub useCombinedImageSamplerIndex: VkBool32,
2134    pub samplerHeapOffset: u32,
2135    pub samplerPushOffset: u32,
2136    pub samplerAddressOffset: u32,
2137    pub samplerHeapIndexStride: u32,
2138    pub samplerHeapArrayStride: u32,
2139}
2140
2141#[derive(Clone, Copy)]
2142#[repr(C)]
2143pub struct VkDescriptorMappingSourcePushIndexEXT {
2144    pub heapOffset: u32,
2145    pub pushOffset: u32,
2146    pub heapIndexStride: u32,
2147    pub heapArrayStride: u32,
2148    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
2149    pub useCombinedImageSamplerIndex: VkBool32,
2150    pub samplerHeapOffset: u32,
2151    pub samplerPushOffset: u32,
2152    pub samplerHeapIndexStride: u32,
2153    pub samplerHeapArrayStride: u32,
2154}
2155
2156#[derive(Clone, Copy)]
2157#[repr(C)]
2158pub struct VkDescriptorMappingSourceShaderRecordIndexEXT {
2159    pub heapOffset: u32,
2160    pub shaderRecordOffset: u32,
2161    pub heapIndexStride: u32,
2162    pub heapArrayStride: u32,
2163    pub pEmbeddedSampler: *const VkSamplerCreateInfo,
2164    pub useCombinedImageSamplerIndex: VkBool32,
2165    pub samplerHeapOffset: u32,
2166    pub samplerShaderRecordOffset: u32,
2167    pub samplerHeapIndexStride: u32,
2168    pub samplerHeapArrayStride: u32,
2169}
2170
2171#[derive(Clone, Copy)]
2172#[repr(C)]
2173pub struct VkDescriptorPoolCreateInfo {
2174    pub sType: VkStructureType,
2175    pub pNext: *const c_void,
2176    pub flags: VkDescriptorPoolCreateFlags,
2177    pub maxSets: u32,
2178    pub poolSizeCount: u32,
2179    pub pPoolSizes: *const VkDescriptorPoolSize,
2180}
2181
2182#[derive(Clone, Copy)]
2183#[repr(C)]
2184pub struct VkDescriptorPoolInlineUniformBlockCreateInfo {
2185    pub sType: VkStructureType,
2186    pub pNext: *const c_void,
2187    pub maxInlineUniformBlockBindings: u32,
2188}
2189
2190#[derive(Clone, Copy)]
2191#[repr(C)]
2192pub struct VkDescriptorPoolSize {
2193    pub typ: VkDescriptorType,
2194    pub descriptorCount: u32,
2195}
2196
2197#[repr(C)]
2198pub struct VkDescriptorPool_T {
2199    _data: (),
2200    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2201}
2202
2203#[derive(Clone, Copy)]
2204#[repr(C)]
2205pub struct VkDescriptorSetAllocateInfo {
2206    pub sType: VkStructureType,
2207    pub pNext: *const c_void,
2208    pub descriptorPool: VkDescriptorPool,
2209    pub descriptorSetCount: u32,
2210    pub pSetLayouts: *const VkDescriptorSetLayout,
2211}
2212
2213#[derive(Clone, Copy)]
2214#[repr(C)]
2215pub struct VkDescriptorSetAndBindingMappingEXT {
2216    pub sType: VkStructureType,
2217    pub pNext: *const c_void,
2218    pub descriptorSet: u32,
2219    pub firstBinding: u32,
2220    pub bindingCount: u32,
2221    pub resourceMask: VkSpirvResourceTypeFlagsEXT,
2222    pub source: VkDescriptorMappingSourceEXT,
2223    pub sourceData: VkDescriptorMappingSourceDataEXT,
2224}
2225
2226#[derive(Clone, Copy)]
2227#[repr(C)]
2228pub struct VkDescriptorSetBindingReferenceVALVE {
2229    pub sType: VkStructureType,
2230    pub pNext: *const c_void,
2231    pub descriptorSetLayout: VkDescriptorSetLayout,
2232    pub binding: u32,
2233}
2234
2235#[derive(Clone, Copy)]
2236#[repr(C)]
2237pub struct VkDescriptorSetLayoutBinding {
2238    pub binding: u32,
2239    pub descriptorType: VkDescriptorType,
2240    pub descriptorCount: u32,
2241    pub stageFlags: VkShaderStageFlags,
2242    pub pImmutableSamplers: *const VkSampler,
2243}
2244
2245#[derive(Clone, Copy)]
2246#[repr(C)]
2247pub struct VkDescriptorSetLayoutBindingFlagsCreateInfo {
2248    pub sType: VkStructureType,
2249    pub pNext: *const c_void,
2250    pub bindingCount: u32,
2251    pub pBindingFlags: *const VkDescriptorBindingFlags,
2252}
2253
2254#[derive(Clone, Copy)]
2255#[repr(C)]
2256pub struct VkDescriptorSetLayoutCreateInfo {
2257    pub sType: VkStructureType,
2258    pub pNext: *const c_void,
2259    pub flags: VkDescriptorSetLayoutCreateFlags,
2260    pub bindingCount: u32,
2261    pub pBindings: *const VkDescriptorSetLayoutBinding,
2262}
2263
2264#[derive(Clone, Copy)]
2265#[repr(C)]
2266pub struct VkDescriptorSetLayoutHostMappingInfoVALVE {
2267    pub sType: VkStructureType,
2268    pub pNext: *mut c_void,
2269    pub descriptorOffset: usize,
2270    pub descriptorSize: u32,
2271}
2272
2273#[derive(Clone, Copy)]
2274#[repr(C)]
2275pub struct VkDescriptorSetLayoutSupport {
2276    pub sType: VkStructureType,
2277    pub pNext: *mut c_void,
2278    pub supported: VkBool32,
2279}
2280
2281#[repr(C)]
2282pub struct VkDescriptorSetLayout_T {
2283    _data: (),
2284    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2285}
2286
2287#[derive(Clone, Copy)]
2288#[repr(C)]
2289pub struct VkDescriptorSetVariableDescriptorCountAllocateInfo {
2290    pub sType: VkStructureType,
2291    pub pNext: *const c_void,
2292    pub descriptorSetCount: u32,
2293    pub pDescriptorCounts: *const u32,
2294}
2295
2296#[derive(Clone, Copy)]
2297#[repr(C)]
2298pub struct VkDescriptorSetVariableDescriptorCountLayoutSupport {
2299    pub sType: VkStructureType,
2300    pub pNext: *mut c_void,
2301    pub maxVariableDescriptorCount: u32,
2302}
2303
2304#[repr(C)]
2305pub struct VkDescriptorSet_T {
2306    _data: (),
2307    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2308}
2309
2310#[derive(Clone, Copy)]
2311#[repr(C)]
2312pub struct VkDescriptorUpdateTemplateCreateInfo {
2313    pub sType: VkStructureType,
2314    pub pNext: *const c_void,
2315    pub flags: VkDescriptorUpdateTemplateCreateFlags,
2316    pub descriptorUpdateEntryCount: u32,
2317    pub pDescriptorUpdateEntries: *const VkDescriptorUpdateTemplateEntry,
2318    pub templateType: VkDescriptorUpdateTemplateType,
2319    pub descriptorSetLayout: VkDescriptorSetLayout,
2320    pub pipelineBindPoint: VkPipelineBindPoint,
2321    pub pipelineLayout: VkPipelineLayout,
2322    pub set: u32,
2323}
2324
2325#[derive(Clone, Copy)]
2326#[repr(C)]
2327pub struct VkDescriptorUpdateTemplateEntry {
2328    pub dstBinding: u32,
2329    pub dstArrayElement: u32,
2330    pub descriptorCount: u32,
2331    pub descriptorType: VkDescriptorType,
2332    pub offset: usize,
2333    pub stride: usize,
2334}
2335
2336#[repr(C)]
2337pub struct VkDescriptorUpdateTemplate_T {
2338    _data: (),
2339    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2340}
2341
2342#[derive(Clone, Copy)]
2343#[repr(C)]
2344pub struct VkDeviceAddressBindingCallbackDataEXT {
2345    pub sType: VkStructureType,
2346    pub pNext: *mut c_void,
2347    pub flags: VkDeviceAddressBindingFlagsEXT,
2348    pub baseAddress: VkDeviceAddress,
2349    pub size: VkDeviceSize,
2350    pub bindingType: VkDeviceAddressBindingTypeEXT,
2351}
2352
2353#[derive(Clone, Copy)]
2354#[repr(C)]
2355pub struct VkDeviceAddressRangeEXT {
2356    pub address: VkDeviceAddress,
2357    pub size: VkDeviceSize,
2358}
2359
2360#[derive(Clone, Copy)]
2361#[repr(C)]
2362pub struct VkDeviceBufferMemoryRequirements {
2363    pub sType: VkStructureType,
2364    pub pNext: *const c_void,
2365    pub pCreateInfo: *const VkBufferCreateInfo,
2366}
2367
2368#[derive(Clone, Copy)]
2369#[repr(C)]
2370pub struct VkDeviceCreateInfo {
2371    pub sType: VkStructureType,
2372    pub pNext: *const c_void,
2373    pub flags: VkDeviceCreateFlags,
2374    pub queueCreateInfoCount: u32,
2375    pub pQueueCreateInfos: *const VkDeviceQueueCreateInfo,
2376    pub enabledLayerCount: u32,
2377    pub ppEnabledLayerNames: *const *const c_char,
2378    pub enabledExtensionCount: u32,
2379    pub ppEnabledExtensionNames: *const *const c_char,
2380    pub pEnabledFeatures: *const VkPhysicalDeviceFeatures,
2381}
2382
2383#[derive(Clone, Copy)]
2384#[repr(C)]
2385pub struct VkDeviceDeviceMemoryReportCreateInfoEXT {
2386    pub sType: VkStructureType,
2387    pub pNext: *const c_void,
2388    pub flags: VkDeviceMemoryReportFlagsEXT,
2389    pub pfnUserCallback: PFN_vkDeviceMemoryReportCallbackEXT,
2390    pub pUserData: *mut c_void,
2391}
2392
2393#[derive(Clone, Copy)]
2394#[repr(C)]
2395pub struct VkDeviceDiagnosticsConfigCreateInfoNV {
2396    pub sType: VkStructureType,
2397    pub pNext: *const c_void,
2398    pub flags: VkDeviceDiagnosticsConfigFlagsNV,
2399}
2400
2401#[derive(Clone, Copy)]
2402#[repr(C)]
2403pub struct VkDeviceEventInfoEXT {
2404    pub sType: VkStructureType,
2405    pub pNext: *const c_void,
2406    pub deviceEvent: VkDeviceEventTypeEXT,
2407}
2408
2409#[derive(Clone, Copy)]
2410#[repr(C)]
2411pub struct VkDeviceFaultAddressInfoEXT {
2412    pub addressType: VkDeviceFaultAddressTypeEXT,
2413    pub reportedAddress: VkDeviceAddress,
2414    pub addressPrecision: VkDeviceSize,
2415}
2416
2417#[derive(Clone, Copy)]
2418#[repr(C)]
2419pub struct VkDeviceFaultCountsEXT {
2420    pub sType: VkStructureType,
2421    pub pNext: *mut c_void,
2422    pub addressInfoCount: u32,
2423    pub vendorInfoCount: u32,
2424    pub vendorBinarySize: VkDeviceSize,
2425}
2426
2427#[derive(Clone, Copy)]
2428#[repr(C)]
2429pub struct VkDeviceFaultInfoEXT {
2430    pub sType: VkStructureType,
2431    pub pNext: *mut c_void,
2432    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
2433    pub pAddressInfos: *mut VkDeviceFaultAddressInfoEXT,
2434    pub pVendorInfos: *mut VkDeviceFaultVendorInfoEXT,
2435    pub pVendorBinaryData: *mut c_void,
2436}
2437
2438#[derive(Clone, Copy)]
2439#[repr(C)]
2440pub struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT {
2441    pub headerSize: u32,
2442    pub headerVersion: VkDeviceFaultVendorBinaryHeaderVersionEXT,
2443    pub vendorID: u32,
2444    pub deviceID: u32,
2445    pub driverVersion: u32,
2446    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
2447    pub applicationNameOffset: u32,
2448    pub applicationVersion: u32,
2449    pub engineNameOffset: u32,
2450    pub engineVersion: u32,
2451    pub apiVersion: u32,
2452}
2453
2454#[derive(Clone, Copy)]
2455#[repr(C)]
2456pub struct VkDeviceFaultVendorInfoEXT {
2457    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
2458    pub vendorFaultCode: u64,
2459    pub vendorFaultData: u64,
2460}
2461
2462#[derive(Clone, Copy)]
2463#[repr(C)]
2464pub struct VkDeviceGroupBindSparseInfo {
2465    pub sType: VkStructureType,
2466    pub pNext: *const c_void,
2467    pub resourceDeviceIndex: u32,
2468    pub memoryDeviceIndex: u32,
2469}
2470
2471#[derive(Clone, Copy)]
2472#[repr(C)]
2473pub struct VkDeviceGroupCommandBufferBeginInfo {
2474    pub sType: VkStructureType,
2475    pub pNext: *const c_void,
2476    pub deviceMask: u32,
2477}
2478
2479#[derive(Clone, Copy)]
2480#[repr(C)]
2481pub struct VkDeviceGroupDeviceCreateInfo {
2482    pub sType: VkStructureType,
2483    pub pNext: *const c_void,
2484    pub physicalDeviceCount: u32,
2485    pub pPhysicalDevices: *const VkPhysicalDevice,
2486}
2487
2488#[derive(Clone, Copy)]
2489#[repr(C)]
2490pub struct VkDeviceGroupPresentCapabilitiesKHR {
2491    pub sType: VkStructureType,
2492    pub pNext: *mut c_void,
2493    pub presentMask: [u32; VK_MAX_DEVICE_GROUP_SIZE as usize],
2494    pub modes: VkDeviceGroupPresentModeFlagsKHR,
2495}
2496
2497#[derive(Clone, Copy)]
2498#[repr(C)]
2499pub struct VkDeviceGroupPresentInfoKHR {
2500    pub sType: VkStructureType,
2501    pub pNext: *const c_void,
2502    pub swapchainCount: u32,
2503    pub pDeviceMasks: *const u32,
2504    pub mode: VkDeviceGroupPresentModeFlagBitsKHR,
2505}
2506
2507#[derive(Clone, Copy)]
2508#[repr(C)]
2509pub struct VkDeviceGroupRenderPassBeginInfo {
2510    pub sType: VkStructureType,
2511    pub pNext: *const c_void,
2512    pub deviceMask: u32,
2513    pub deviceRenderAreaCount: u32,
2514    pub pDeviceRenderAreas: *const VkRect2D,
2515}
2516
2517#[derive(Clone, Copy)]
2518#[repr(C)]
2519pub struct VkDeviceGroupSubmitInfo {
2520    pub sType: VkStructureType,
2521    pub pNext: *const c_void,
2522    pub waitSemaphoreCount: u32,
2523    pub pWaitSemaphoreDeviceIndices: *const u32,
2524    pub commandBufferCount: u32,
2525    pub pCommandBufferDeviceMasks: *const u32,
2526    pub signalSemaphoreCount: u32,
2527    pub pSignalSemaphoreDeviceIndices: *const u32,
2528}
2529
2530#[derive(Clone, Copy)]
2531#[repr(C)]
2532pub struct VkDeviceGroupSwapchainCreateInfoKHR {
2533    pub sType: VkStructureType,
2534    pub pNext: *const c_void,
2535    pub modes: VkDeviceGroupPresentModeFlagsKHR,
2536}
2537
2538#[derive(Clone, Copy)]
2539#[repr(C)]
2540pub struct VkDeviceImageMemoryRequirements {
2541    pub sType: VkStructureType,
2542    pub pNext: *const c_void,
2543    pub pCreateInfo: *const VkImageCreateInfo,
2544    pub planeAspect: VkImageAspectFlagBits,
2545}
2546
2547#[derive(Clone, Copy)]
2548#[repr(C)]
2549pub struct VkDeviceImageSubresourceInfo {
2550    pub sType: VkStructureType,
2551    pub pNext: *const c_void,
2552    pub pCreateInfo: *const VkImageCreateInfo,
2553    pub pSubresource: *const VkImageSubresource2,
2554}
2555
2556#[derive(Clone, Copy)]
2557#[repr(C)]
2558pub struct VkDeviceMemoryOpaqueCaptureAddressInfo {
2559    pub sType: VkStructureType,
2560    pub pNext: *const c_void,
2561    pub memory: VkDeviceMemory,
2562}
2563
2564#[derive(Clone, Copy)]
2565#[repr(C)]
2566pub struct VkDeviceMemoryOverallocationCreateInfoAMD {
2567    pub sType: VkStructureType,
2568    pub pNext: *const c_void,
2569    pub overallocationBehavior: VkMemoryOverallocationBehaviorAMD,
2570}
2571
2572#[derive(Clone, Copy)]
2573#[repr(C)]
2574pub struct VkDeviceMemoryReportCallbackDataEXT {
2575    pub sType: VkStructureType,
2576    pub pNext: *mut c_void,
2577    pub flags: VkDeviceMemoryReportFlagsEXT,
2578    pub typ: VkDeviceMemoryReportEventTypeEXT,
2579    pub memoryObjectId: u64,
2580    pub size: VkDeviceSize,
2581    pub objectType: VkObjectType,
2582    pub objectHandle: u64,
2583    pub heapIndex: u32,
2584}
2585
2586#[repr(C)]
2587pub struct VkDeviceMemory_T {
2588    _data: (),
2589    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2590}
2591
2592#[derive(Clone, Copy)]
2593#[repr(C)]
2594pub struct VkDevicePipelineBinaryInternalCacheControlKHR {
2595    pub sType: VkStructureType,
2596    pub pNext: *const c_void,
2597    pub disableInternalCache: VkBool32,
2598}
2599
2600#[derive(Clone, Copy)]
2601#[repr(C)]
2602pub struct VkDevicePrivateDataCreateInfo {
2603    pub sType: VkStructureType,
2604    pub pNext: *const c_void,
2605    pub privateDataSlotRequestCount: u32,
2606}
2607
2608#[derive(Clone, Copy)]
2609#[repr(C)]
2610pub struct VkDeviceQueueCreateInfo {
2611    pub sType: VkStructureType,
2612    pub pNext: *const c_void,
2613    pub flags: VkDeviceQueueCreateFlags,
2614    pub queueFamilyIndex: u32,
2615    pub queueCount: u32,
2616    pub pQueuePriorities: *const f32,
2617}
2618
2619#[derive(Clone, Copy)]
2620#[repr(C)]
2621pub struct VkDeviceQueueGlobalPriorityCreateInfo {
2622    pub sType: VkStructureType,
2623    pub pNext: *const c_void,
2624    pub globalPriority: VkQueueGlobalPriority,
2625}
2626
2627#[derive(Clone, Copy)]
2628#[repr(C)]
2629pub struct VkDeviceQueueInfo2 {
2630    pub sType: VkStructureType,
2631    pub pNext: *const c_void,
2632    pub flags: VkDeviceQueueCreateFlags,
2633    pub queueFamilyIndex: u32,
2634    pub queueIndex: u32,
2635}
2636
2637#[derive(Clone, Copy)]
2638#[repr(C)]
2639pub struct VkDeviceQueueShaderCoreControlCreateInfoARM {
2640    pub sType: VkStructureType,
2641    pub pNext: *mut c_void,
2642    pub shaderCoreCount: u32,
2643}
2644
2645#[derive(Clone, Copy)]
2646#[repr(C)]
2647pub struct VkDeviceTensorMemoryRequirementsARM {
2648    pub sType: VkStructureType,
2649    pub pNext: *const c_void,
2650    pub pCreateInfo: *const VkTensorCreateInfoARM,
2651}
2652
2653#[repr(C)]
2654pub struct VkDevice_T {
2655    _data: (),
2656    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2657}
2658
2659#[derive(Clone, Copy)]
2660#[repr(C)]
2661pub struct VkDirectDriverLoadingInfoLUNARG {
2662    pub sType: VkStructureType,
2663    pub pNext: *mut c_void,
2664    pub flags: VkDirectDriverLoadingFlagsLUNARG,
2665    pub pfnGetInstanceProcAddr: PFN_vkGetInstanceProcAddrLUNARG,
2666}
2667
2668#[derive(Clone, Copy)]
2669#[repr(C)]
2670pub struct VkDirectDriverLoadingListLUNARG {
2671    pub sType: VkStructureType,
2672    pub pNext: *const c_void,
2673    pub mode: VkDirectDriverLoadingModeLUNARG,
2674    pub driverCount: u32,
2675    pub pDrivers: *const VkDirectDriverLoadingInfoLUNARG,
2676}
2677
2678#[derive(Clone, Copy)]
2679#[repr(C)]
2680pub struct VkDispatchIndirectCommand {
2681    pub x: u32,
2682    pub y: u32,
2683    pub z: u32,
2684}
2685
2686#[derive(Clone, Copy)]
2687#[repr(C)]
2688pub struct VkDispatchTileInfoQCOM {
2689    pub sType: VkStructureType,
2690    pub pNext: *const c_void,
2691}
2692
2693#[derive(Clone, Copy)]
2694#[repr(C)]
2695pub struct VkDisplayEventInfoEXT {
2696    pub sType: VkStructureType,
2697    pub pNext: *const c_void,
2698    pub displayEvent: VkDisplayEventTypeEXT,
2699}
2700
2701#[repr(C)]
2702pub struct VkDisplayKHR_T {
2703    _data: (),
2704    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2705}
2706
2707#[derive(Clone, Copy)]
2708#[repr(C)]
2709pub struct VkDisplayModeCreateInfoKHR {
2710    pub sType: VkStructureType,
2711    pub pNext: *const c_void,
2712    pub flags: VkDisplayModeCreateFlagsKHR,
2713    pub parameters: VkDisplayModeParametersKHR,
2714}
2715
2716#[repr(C)]
2717pub struct VkDisplayModeKHR_T {
2718    _data: (),
2719    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2720}
2721
2722#[derive(Clone, Copy)]
2723#[repr(C)]
2724pub struct VkDisplayModeParametersKHR {
2725    pub visibleRegion: VkExtent2D,
2726    pub refreshRate: u32,
2727}
2728
2729#[derive(Clone, Copy)]
2730#[repr(C)]
2731pub struct VkDisplayModeProperties2KHR {
2732    pub sType: VkStructureType,
2733    pub pNext: *mut c_void,
2734    pub displayModeProperties: VkDisplayModePropertiesKHR,
2735}
2736
2737#[derive(Clone, Copy)]
2738#[repr(C)]
2739pub struct VkDisplayModePropertiesKHR {
2740    pub displayMode: VkDisplayModeKHR,
2741    pub parameters: VkDisplayModeParametersKHR,
2742}
2743
2744#[derive(Clone, Copy)]
2745#[repr(C)]
2746pub struct VkDisplayModeStereoPropertiesNV {
2747    pub sType: VkStructureType,
2748    pub pNext: *mut c_void,
2749    pub hdmi3DSupported: VkBool32,
2750}
2751
2752#[derive(Clone, Copy)]
2753#[repr(C)]
2754pub struct VkDisplayNativeHdrSurfaceCapabilitiesAMD {
2755    pub sType: VkStructureType,
2756    pub pNext: *mut c_void,
2757    pub localDimmingSupport: VkBool32,
2758}
2759
2760#[derive(Clone, Copy)]
2761#[repr(C)]
2762pub struct VkDisplayPlaneCapabilities2KHR {
2763    pub sType: VkStructureType,
2764    pub pNext: *mut c_void,
2765    pub capabilities: VkDisplayPlaneCapabilitiesKHR,
2766}
2767
2768#[derive(Clone, Copy)]
2769#[repr(C)]
2770pub struct VkDisplayPlaneCapabilitiesKHR {
2771    pub supportedAlpha: VkDisplayPlaneAlphaFlagsKHR,
2772    pub minSrcPosition: VkOffset2D,
2773    pub maxSrcPosition: VkOffset2D,
2774    pub minSrcExtent: VkExtent2D,
2775    pub maxSrcExtent: VkExtent2D,
2776    pub minDstPosition: VkOffset2D,
2777    pub maxDstPosition: VkOffset2D,
2778    pub minDstExtent: VkExtent2D,
2779    pub maxDstExtent: VkExtent2D,
2780}
2781
2782#[derive(Clone, Copy)]
2783#[repr(C)]
2784pub struct VkDisplayPlaneInfo2KHR {
2785    pub sType: VkStructureType,
2786    pub pNext: *const c_void,
2787    pub mode: VkDisplayModeKHR,
2788    pub planeIndex: u32,
2789}
2790
2791#[derive(Clone, Copy)]
2792#[repr(C)]
2793pub struct VkDisplayPlaneProperties2KHR {
2794    pub sType: VkStructureType,
2795    pub pNext: *mut c_void,
2796    pub displayPlaneProperties: VkDisplayPlanePropertiesKHR,
2797}
2798
2799#[derive(Clone, Copy)]
2800#[repr(C)]
2801pub struct VkDisplayPlanePropertiesKHR {
2802    pub currentDisplay: VkDisplayKHR,
2803    pub currentStackIndex: u32,
2804}
2805
2806#[derive(Clone, Copy)]
2807#[repr(C)]
2808pub struct VkDisplayPowerInfoEXT {
2809    pub sType: VkStructureType,
2810    pub pNext: *const c_void,
2811    pub powerState: VkDisplayPowerStateEXT,
2812}
2813
2814#[derive(Clone, Copy)]
2815#[repr(C)]
2816pub struct VkDisplayPresentInfoKHR {
2817    pub sType: VkStructureType,
2818    pub pNext: *const c_void,
2819    pub srcRect: VkRect2D,
2820    pub dstRect: VkRect2D,
2821    pub persistent: VkBool32,
2822}
2823
2824#[derive(Clone, Copy)]
2825#[repr(C)]
2826pub struct VkDisplayProperties2KHR {
2827    pub sType: VkStructureType,
2828    pub pNext: *mut c_void,
2829    pub displayProperties: VkDisplayPropertiesKHR,
2830}
2831
2832#[derive(Clone, Copy)]
2833#[repr(C)]
2834pub struct VkDisplayPropertiesKHR {
2835    pub display: VkDisplayKHR,
2836    pub displayName: *const c_char,
2837    pub physicalDimensions: VkExtent2D,
2838    pub physicalResolution: VkExtent2D,
2839    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
2840    pub planeReorderPossible: VkBool32,
2841    pub persistentContent: VkBool32,
2842}
2843
2844#[derive(Clone, Copy)]
2845#[repr(C)]
2846pub struct VkDisplaySurfaceCreateInfoKHR {
2847    pub sType: VkStructureType,
2848    pub pNext: *const c_void,
2849    pub flags: VkDisplaySurfaceCreateFlagsKHR,
2850    pub displayMode: VkDisplayModeKHR,
2851    pub planeIndex: u32,
2852    pub planeStackIndex: u32,
2853    pub transform: VkSurfaceTransformFlagBitsKHR,
2854    pub globalAlpha: f32,
2855    pub alphaMode: VkDisplayPlaneAlphaFlagBitsKHR,
2856    pub imageExtent: VkExtent2D,
2857}
2858
2859#[derive(Clone, Copy)]
2860#[repr(C)]
2861pub struct VkDisplaySurfaceStereoCreateInfoNV {
2862    pub sType: VkStructureType,
2863    pub pNext: *const c_void,
2864    pub stereoType: VkDisplaySurfaceStereoTypeNV,
2865}
2866
2867#[derive(Clone, Copy)]
2868#[repr(C)]
2869pub struct VkDrawIndexedIndirectCommand {
2870    pub indexCount: u32,
2871    pub instanceCount: u32,
2872    pub firstIndex: u32,
2873    pub vertexOffset: i32,
2874    pub firstInstance: u32,
2875}
2876
2877#[derive(Clone, Copy)]
2878#[repr(C)]
2879pub struct VkDrawIndirectCommand {
2880    pub vertexCount: u32,
2881    pub instanceCount: u32,
2882    pub firstVertex: u32,
2883    pub firstInstance: u32,
2884}
2885
2886#[derive(Clone, Copy)]
2887#[repr(C)]
2888pub struct VkDrawIndirectCountIndirectCommandEXT {
2889    pub bufferAddress: VkDeviceAddress,
2890    pub stride: u32,
2891    pub commandCount: u32,
2892}
2893
2894#[derive(Clone, Copy)]
2895#[repr(C)]
2896pub struct VkDrawMeshTasksIndirectCommandEXT {
2897    pub groupCountX: u32,
2898    pub groupCountY: u32,
2899    pub groupCountZ: u32,
2900}
2901
2902#[derive(Clone, Copy)]
2903#[repr(C)]
2904pub struct VkDrawMeshTasksIndirectCommandNV {
2905    pub taskCount: u32,
2906    pub firstTask: u32,
2907}
2908
2909#[derive(Clone, Copy)]
2910#[repr(C)]
2911pub struct VkDrmFormatModifierProperties2EXT {
2912    pub drmFormatModifier: u64,
2913    pub drmFormatModifierPlaneCount: u32,
2914    pub drmFormatModifierTilingFeatures: VkFormatFeatureFlags2,
2915}
2916
2917#[derive(Clone, Copy)]
2918#[repr(C)]
2919pub struct VkDrmFormatModifierPropertiesEXT {
2920    pub drmFormatModifier: u64,
2921    pub drmFormatModifierPlaneCount: u32,
2922    pub drmFormatModifierTilingFeatures: VkFormatFeatureFlags,
2923}
2924
2925#[derive(Clone, Copy)]
2926#[repr(C)]
2927pub struct VkDrmFormatModifierPropertiesList2EXT {
2928    pub sType: VkStructureType,
2929    pub pNext: *mut c_void,
2930    pub drmFormatModifierCount: u32,
2931    pub pDrmFormatModifierProperties: *mut VkDrmFormatModifierProperties2EXT,
2932}
2933
2934#[derive(Clone, Copy)]
2935#[repr(C)]
2936pub struct VkDrmFormatModifierPropertiesListEXT {
2937    pub sType: VkStructureType,
2938    pub pNext: *mut c_void,
2939    pub drmFormatModifierCount: u32,
2940    pub pDrmFormatModifierProperties: *mut VkDrmFormatModifierPropertiesEXT,
2941}
2942
2943#[derive(Clone, Copy)]
2944#[repr(C)]
2945pub struct VkEventCreateInfo {
2946    pub sType: VkStructureType,
2947    pub pNext: *const c_void,
2948    pub flags: VkEventCreateFlags,
2949}
2950
2951#[repr(C)]
2952pub struct VkEvent_T {
2953    _data: (),
2954    _marker: PhantomData<(*mut u8, PhantomPinned)>,
2955}
2956
2957#[derive(Clone, Copy)]
2958#[repr(C)]
2959pub struct VkExportFenceCreateInfo {
2960    pub sType: VkStructureType,
2961    pub pNext: *const c_void,
2962    pub handleTypes: VkExternalFenceHandleTypeFlags,
2963}
2964
2965#[derive(Clone, Copy)]
2966#[repr(C)]
2967pub struct VkExportMemoryAllocateInfo {
2968    pub sType: VkStructureType,
2969    pub pNext: *const c_void,
2970    pub handleTypes: VkExternalMemoryHandleTypeFlags,
2971}
2972
2973#[derive(Clone, Copy)]
2974#[repr(C)]
2975pub struct VkExportMemoryAllocateInfoNV {
2976    pub sType: VkStructureType,
2977    pub pNext: *const c_void,
2978    pub handleTypes: VkExternalMemoryHandleTypeFlagsNV,
2979}
2980
2981#[derive(Clone, Copy)]
2982#[repr(C)]
2983pub struct VkExportSemaphoreCreateInfo {
2984    pub sType: VkStructureType,
2985    pub pNext: *const c_void,
2986    pub handleTypes: VkExternalSemaphoreHandleTypeFlags,
2987}
2988
2989#[derive(Clone, Copy)]
2990#[repr(C)]
2991pub struct VkExtensionProperties {
2992    pub extensionName: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
2993    pub specVersion: u32,
2994}
2995
2996#[derive(Clone, Copy)]
2997#[repr(C)]
2998pub struct VkExtent2D {
2999    pub width: u32,
3000    pub height: u32,
3001}
3002
3003#[derive(Clone, Copy)]
3004#[repr(C)]
3005pub struct VkExtent3D {
3006    pub width: u32,
3007    pub height: u32,
3008    pub depth: u32,
3009}
3010
3011#[derive(Clone, Copy)]
3012#[repr(C)]
3013pub struct VkExternalBufferProperties {
3014    pub sType: VkStructureType,
3015    pub pNext: *mut c_void,
3016    pub externalMemoryProperties: VkExternalMemoryProperties,
3017}
3018
3019#[derive(Clone, Copy)]
3020#[repr(C)]
3021pub struct VkExternalComputeQueueCreateInfoNV {
3022    pub sType: VkStructureType,
3023    pub pNext: *const c_void,
3024    pub preferredQueue: VkQueue,
3025}
3026
3027#[derive(Clone, Copy)]
3028#[repr(C)]
3029pub struct VkExternalComputeQueueDataParamsNV {
3030    pub sType: VkStructureType,
3031    pub pNext: *const c_void,
3032    pub deviceIndex: u32,
3033}
3034
3035#[derive(Clone, Copy)]
3036#[repr(C)]
3037pub struct VkExternalComputeQueueDeviceCreateInfoNV {
3038    pub sType: VkStructureType,
3039    pub pNext: *const c_void,
3040    pub reservedExternalQueues: u32,
3041}
3042
3043#[repr(C)]
3044pub struct VkExternalComputeQueueNV_T {
3045    _data: (),
3046    _marker: PhantomData<(*mut u8, PhantomPinned)>,
3047}
3048
3049#[derive(Clone, Copy)]
3050#[repr(C)]
3051pub struct VkExternalFenceProperties {
3052    pub sType: VkStructureType,
3053    pub pNext: *mut c_void,
3054    pub exportFromImportedHandleTypes: VkExternalFenceHandleTypeFlags,
3055    pub compatibleHandleTypes: VkExternalFenceHandleTypeFlags,
3056    pub externalFenceFeatures: VkExternalFenceFeatureFlags,
3057}
3058
3059#[derive(Clone, Copy)]
3060#[repr(C)]
3061pub struct VkExternalImageFormatProperties {
3062    pub sType: VkStructureType,
3063    pub pNext: *mut c_void,
3064    pub externalMemoryProperties: VkExternalMemoryProperties,
3065}
3066
3067#[derive(Clone, Copy)]
3068#[repr(C)]
3069pub struct VkExternalImageFormatPropertiesNV {
3070    pub imageFormatProperties: VkImageFormatProperties,
3071    pub externalMemoryFeatures: VkExternalMemoryFeatureFlagsNV,
3072    pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlagsNV,
3073    pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlagsNV,
3074}
3075
3076#[derive(Clone, Copy)]
3077#[repr(C)]
3078pub struct VkExternalMemoryAcquireUnmodifiedEXT {
3079    pub sType: VkStructureType,
3080    pub pNext: *const c_void,
3081    pub acquireUnmodifiedMemory: VkBool32,
3082}
3083
3084#[derive(Clone, Copy)]
3085#[repr(C)]
3086pub struct VkExternalMemoryBufferCreateInfo {
3087    pub sType: VkStructureType,
3088    pub pNext: *const c_void,
3089    pub handleTypes: VkExternalMemoryHandleTypeFlags,
3090}
3091
3092#[derive(Clone, Copy)]
3093#[repr(C)]
3094pub struct VkExternalMemoryImageCreateInfo {
3095    pub sType: VkStructureType,
3096    pub pNext: *const c_void,
3097    pub handleTypes: VkExternalMemoryHandleTypeFlags,
3098}
3099
3100#[derive(Clone, Copy)]
3101#[repr(C)]
3102pub struct VkExternalMemoryImageCreateInfoNV {
3103    pub sType: VkStructureType,
3104    pub pNext: *const c_void,
3105    pub handleTypes: VkExternalMemoryHandleTypeFlagsNV,
3106}
3107
3108#[derive(Clone, Copy)]
3109#[repr(C)]
3110pub struct VkExternalMemoryProperties {
3111    pub externalMemoryFeatures: VkExternalMemoryFeatureFlags,
3112    pub exportFromImportedHandleTypes: VkExternalMemoryHandleTypeFlags,
3113    pub compatibleHandleTypes: VkExternalMemoryHandleTypeFlags,
3114}
3115
3116#[derive(Clone, Copy)]
3117#[repr(C)]
3118pub struct VkExternalMemoryTensorCreateInfoARM {
3119    pub sType: VkStructureType,
3120    pub pNext: *const c_void,
3121    pub handleTypes: VkExternalMemoryHandleTypeFlags,
3122}
3123
3124#[derive(Clone, Copy)]
3125#[repr(C)]
3126pub struct VkExternalSemaphoreProperties {
3127    pub sType: VkStructureType,
3128    pub pNext: *mut c_void,
3129    pub exportFromImportedHandleTypes: VkExternalSemaphoreHandleTypeFlags,
3130    pub compatibleHandleTypes: VkExternalSemaphoreHandleTypeFlags,
3131    pub externalSemaphoreFeatures: VkExternalSemaphoreFeatureFlags,
3132}
3133
3134#[derive(Clone, Copy)]
3135#[repr(C)]
3136pub struct VkExternalTensorPropertiesARM {
3137    pub sType: VkStructureType,
3138    pub pNext: *const c_void,
3139    pub externalMemoryProperties: VkExternalMemoryProperties,
3140}
3141
3142#[derive(Clone, Copy)]
3143#[repr(C)]
3144pub struct VkFenceCreateInfo {
3145    pub sType: VkStructureType,
3146    pub pNext: *const c_void,
3147    pub flags: VkFenceCreateFlags,
3148}
3149
3150#[derive(Clone, Copy)]
3151#[repr(C)]
3152pub struct VkFenceGetFdInfoKHR {
3153    pub sType: VkStructureType,
3154    pub pNext: *const c_void,
3155    pub fence: VkFence,
3156    pub handleType: VkExternalFenceHandleTypeFlagBits,
3157}
3158
3159#[repr(C)]
3160pub struct VkFence_T {
3161    _data: (),
3162    _marker: PhantomData<(*mut u8, PhantomPinned)>,
3163}
3164
3165#[derive(Clone, Copy)]
3166#[repr(C)]
3167pub struct VkFilterCubicImageViewImageFormatPropertiesEXT {
3168    pub sType: VkStructureType,
3169    pub pNext: *mut c_void,
3170    pub filterCubic: VkBool32,
3171    pub filterCubicMinmax: VkBool32,
3172}
3173
3174#[derive(Clone, Copy)]
3175#[repr(C)]
3176pub struct VkFormatProperties {
3177    pub linearTilingFeatures: VkFormatFeatureFlags,
3178    pub optimalTilingFeatures: VkFormatFeatureFlags,
3179    pub bufferFeatures: VkFormatFeatureFlags,
3180}
3181
3182#[derive(Clone, Copy)]
3183#[repr(C)]
3184pub struct VkFormatProperties2 {
3185    pub sType: VkStructureType,
3186    pub pNext: *mut c_void,
3187    pub formatProperties: VkFormatProperties,
3188}
3189
3190#[derive(Clone, Copy)]
3191#[repr(C)]
3192pub struct VkFormatProperties3 {
3193    pub sType: VkStructureType,
3194    pub pNext: *mut c_void,
3195    pub linearTilingFeatures: VkFormatFeatureFlags2,
3196    pub optimalTilingFeatures: VkFormatFeatureFlags2,
3197    pub bufferFeatures: VkFormatFeatureFlags2,
3198}
3199
3200#[derive(Clone, Copy)]
3201#[repr(C)]
3202pub struct VkFragmentShadingRateAttachmentInfoKHR {
3203    pub sType: VkStructureType,
3204    pub pNext: *const c_void,
3205    pub pFragmentShadingRateAttachment: *const VkAttachmentReference2,
3206    pub shadingRateAttachmentTexelSize: VkExtent2D,
3207}
3208
3209#[derive(Clone, Copy)]
3210#[repr(C)]
3211pub struct VkFrameBoundaryEXT {
3212    pub sType: VkStructureType,
3213    pub pNext: *const c_void,
3214    pub flags: VkFrameBoundaryFlagsEXT,
3215    pub frameID: u64,
3216    pub imageCount: u32,
3217    pub pImages: *const VkImage,
3218    pub bufferCount: u32,
3219    pub pBuffers: *const VkBuffer,
3220    pub tagName: u64,
3221    pub tagSize: usize,
3222    pub pTag: *const c_void,
3223}
3224
3225#[derive(Clone, Copy)]
3226#[repr(C)]
3227pub struct VkFrameBoundaryTensorsARM {
3228    pub sType: VkStructureType,
3229    pub pNext: *const c_void,
3230    pub tensorCount: u32,
3231    pub pTensors: *const VkTensorARM,
3232}
3233
3234#[derive(Clone, Copy)]
3235#[repr(C)]
3236pub struct VkFramebufferAttachmentImageInfo {
3237    pub sType: VkStructureType,
3238    pub pNext: *const c_void,
3239    pub flags: VkImageCreateFlags,
3240    pub usage: VkImageUsageFlags,
3241    pub width: u32,
3242    pub height: u32,
3243    pub layerCount: u32,
3244    pub viewFormatCount: u32,
3245    pub pViewFormats: *const VkFormat,
3246}
3247
3248#[derive(Clone, Copy)]
3249#[repr(C)]
3250pub struct VkFramebufferAttachmentsCreateInfo {
3251    pub sType: VkStructureType,
3252    pub pNext: *const c_void,
3253    pub attachmentImageInfoCount: u32,
3254    pub pAttachmentImageInfos: *const VkFramebufferAttachmentImageInfo,
3255}
3256
3257#[derive(Clone, Copy)]
3258#[repr(C)]
3259pub struct VkFramebufferCreateInfo {
3260    pub sType: VkStructureType,
3261    pub pNext: *const c_void,
3262    pub flags: VkFramebufferCreateFlags,
3263    pub renderPass: VkRenderPass,
3264    pub attachmentCount: u32,
3265    pub pAttachments: *const VkImageView,
3266    pub width: u32,
3267    pub height: u32,
3268    pub layers: u32,
3269}
3270
3271#[derive(Clone, Copy)]
3272#[repr(C)]
3273pub struct VkFramebufferMixedSamplesCombinationNV {
3274    pub sType: VkStructureType,
3275    pub pNext: *mut c_void,
3276    pub coverageReductionMode: VkCoverageReductionModeNV,
3277    pub rasterizationSamples: VkSampleCountFlagBits,
3278    pub depthStencilSamples: VkSampleCountFlags,
3279    pub colorSamples: VkSampleCountFlags,
3280}
3281
3282#[repr(C)]
3283pub struct VkFramebuffer_T {
3284    _data: (),
3285    _marker: PhantomData<(*mut u8, PhantomPinned)>,
3286}
3287
3288#[derive(Clone, Copy)]
3289#[repr(C)]
3290pub struct VkGeneratedCommandsInfoEXT {
3291    pub sType: VkStructureType,
3292    pub pNext: *const c_void,
3293    pub shaderStages: VkShaderStageFlags,
3294    pub indirectExecutionSet: VkIndirectExecutionSetEXT,
3295    pub indirectCommandsLayout: VkIndirectCommandsLayoutEXT,
3296    pub indirectAddress: VkDeviceAddress,
3297    pub indirectAddressSize: VkDeviceSize,
3298    pub preprocessAddress: VkDeviceAddress,
3299    pub preprocessSize: VkDeviceSize,
3300    pub maxSequenceCount: u32,
3301    pub sequenceCountAddress: VkDeviceAddress,
3302    pub maxDrawCount: u32,
3303}
3304
3305#[derive(Clone, Copy)]
3306#[repr(C)]
3307pub struct VkGeneratedCommandsInfoNV {
3308    pub sType: VkStructureType,
3309    pub pNext: *const c_void,
3310    pub pipelineBindPoint: VkPipelineBindPoint,
3311    pub pipeline: VkPipeline,
3312    pub indirectCommandsLayout: VkIndirectCommandsLayoutNV,
3313    pub streamCount: u32,
3314    pub pStreams: *const VkIndirectCommandsStreamNV,
3315    pub sequencesCount: u32,
3316    pub preprocessBuffer: VkBuffer,
3317    pub preprocessOffset: VkDeviceSize,
3318    pub preprocessSize: VkDeviceSize,
3319    pub sequencesCountBuffer: VkBuffer,
3320    pub sequencesCountOffset: VkDeviceSize,
3321    pub sequencesIndexBuffer: VkBuffer,
3322    pub sequencesIndexOffset: VkDeviceSize,
3323}
3324
3325#[derive(Clone, Copy)]
3326#[repr(C)]
3327pub struct VkGeneratedCommandsMemoryRequirementsInfoEXT {
3328    pub sType: VkStructureType,
3329    pub pNext: *const c_void,
3330    pub indirectExecutionSet: VkIndirectExecutionSetEXT,
3331    pub indirectCommandsLayout: VkIndirectCommandsLayoutEXT,
3332    pub maxSequenceCount: u32,
3333    pub maxDrawCount: u32,
3334}
3335
3336#[derive(Clone, Copy)]
3337#[repr(C)]
3338pub struct VkGeneratedCommandsMemoryRequirementsInfoNV {
3339    pub sType: VkStructureType,
3340    pub pNext: *const c_void,
3341    pub pipelineBindPoint: VkPipelineBindPoint,
3342    pub pipeline: VkPipeline,
3343    pub indirectCommandsLayout: VkIndirectCommandsLayoutNV,
3344    pub maxSequencesCount: u32,
3345}
3346
3347#[derive(Clone, Copy)]
3348#[repr(C)]
3349pub struct VkGeneratedCommandsPipelineInfoEXT {
3350    pub sType: VkStructureType,
3351    pub pNext: *mut c_void,
3352    pub pipeline: VkPipeline,
3353}
3354
3355#[derive(Clone, Copy)]
3356#[repr(C)]
3357pub struct VkGeneratedCommandsShaderInfoEXT {
3358    pub sType: VkStructureType,
3359    pub pNext: *mut c_void,
3360    pub shaderCount: u32,
3361    pub pShaders: *const VkShaderEXT,
3362}
3363
3364#[derive(Clone, Copy)]
3365#[repr(C)]
3366pub struct VkGeometryAABBNV {
3367    pub sType: VkStructureType,
3368    pub pNext: *const c_void,
3369    pub aabbData: VkBuffer,
3370    pub numAABBs: u32,
3371    pub stride: u32,
3372    pub offset: VkDeviceSize,
3373}
3374
3375#[derive(Clone, Copy)]
3376#[repr(C)]
3377pub struct VkGeometryDataNV {
3378    pub triangles: VkGeometryTrianglesNV,
3379    pub aabbs: VkGeometryAABBNV,
3380}
3381
3382#[derive(Clone, Copy)]
3383#[repr(C)]
3384pub struct VkGeometryNV {
3385    pub sType: VkStructureType,
3386    pub pNext: *const c_void,
3387    pub geometryType: VkGeometryTypeKHR,
3388    pub geometry: VkGeometryDataNV,
3389    pub flags: VkGeometryFlagsKHR,
3390}
3391
3392#[derive(Clone, Copy)]
3393#[repr(C)]
3394pub struct VkGeometryTrianglesNV {
3395    pub sType: VkStructureType,
3396    pub pNext: *const c_void,
3397    pub vertexData: VkBuffer,
3398    pub vertexOffset: VkDeviceSize,
3399    pub vertexCount: u32,
3400    pub vertexStride: VkDeviceSize,
3401    pub vertexFormat: VkFormat,
3402    pub indexData: VkBuffer,
3403    pub indexOffset: VkDeviceSize,
3404    pub indexCount: u32,
3405    pub indexType: VkIndexType,
3406    pub transformData: VkBuffer,
3407    pub transformOffset: VkDeviceSize,
3408}
3409
3410#[derive(Clone, Copy)]
3411#[repr(C)]
3412pub struct VkGetLatencyMarkerInfoNV {
3413    pub sType: VkStructureType,
3414    pub pNext: *const c_void,
3415    pub timingCount: u32,
3416    pub pTimings: *mut VkLatencyTimingsFrameReportNV,
3417}
3418
3419#[derive(Clone, Copy)]
3420#[repr(C)]
3421pub struct VkGraphicsPipelineCreateInfo {
3422    pub sType: VkStructureType,
3423    pub pNext: *const c_void,
3424    pub flags: VkPipelineCreateFlags,
3425    pub stageCount: u32,
3426    pub pStages: *const VkPipelineShaderStageCreateInfo,
3427    pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
3428    pub pInputAssemblyState: *const VkPipelineInputAssemblyStateCreateInfo,
3429    pub pTessellationState: *const VkPipelineTessellationStateCreateInfo,
3430    pub pViewportState: *const VkPipelineViewportStateCreateInfo,
3431    pub pRasterizationState: *const VkPipelineRasterizationStateCreateInfo,
3432    pub pMultisampleState: *const VkPipelineMultisampleStateCreateInfo,
3433    pub pDepthStencilState: *const VkPipelineDepthStencilStateCreateInfo,
3434    pub pColorBlendState: *const VkPipelineColorBlendStateCreateInfo,
3435    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
3436    pub layout: VkPipelineLayout,
3437    pub renderPass: VkRenderPass,
3438    pub subpass: u32,
3439    pub basePipelineHandle: VkPipeline,
3440    pub basePipelineIndex: i32,
3441}
3442
3443#[derive(Clone, Copy)]
3444#[repr(C)]
3445pub struct VkGraphicsPipelineLibraryCreateInfoEXT {
3446    pub sType: VkStructureType,
3447    pub pNext: *const c_void,
3448    pub flags: VkGraphicsPipelineLibraryFlagsEXT,
3449}
3450
3451#[derive(Clone, Copy)]
3452#[repr(C)]
3453pub struct VkGraphicsPipelineShaderGroupsCreateInfoNV {
3454    pub sType: VkStructureType,
3455    pub pNext: *const c_void,
3456    pub groupCount: u32,
3457    pub pGroups: *const VkGraphicsShaderGroupCreateInfoNV,
3458    pub pipelineCount: u32,
3459    pub pPipelines: *const VkPipeline,
3460}
3461
3462#[derive(Clone, Copy)]
3463#[repr(C)]
3464pub struct VkGraphicsShaderGroupCreateInfoNV {
3465    pub sType: VkStructureType,
3466    pub pNext: *const c_void,
3467    pub stageCount: u32,
3468    pub pStages: *const VkPipelineShaderStageCreateInfo,
3469    pub pVertexInputState: *const VkPipelineVertexInputStateCreateInfo,
3470    pub pTessellationState: *const VkPipelineTessellationStateCreateInfo,
3471}
3472
3473#[derive(Clone, Copy)]
3474#[repr(C)]
3475pub struct VkHdrMetadataEXT {
3476    pub sType: VkStructureType,
3477    pub pNext: *const c_void,
3478    pub displayPrimaryRed: VkXYColorEXT,
3479    pub displayPrimaryGreen: VkXYColorEXT,
3480    pub displayPrimaryBlue: VkXYColorEXT,
3481    pub whitePoint: VkXYColorEXT,
3482    pub maxLuminance: f32,
3483    pub minLuminance: f32,
3484    pub maxContentLightLevel: f32,
3485    pub maxFrameAverageLightLevel: f32,
3486}
3487
3488#[derive(Clone, Copy)]
3489#[repr(C)]
3490pub struct VkHdrVividDynamicMetadataHUAWEI {
3491    pub sType: VkStructureType,
3492    pub pNext: *const c_void,
3493    pub dynamicMetadataSize: usize,
3494    pub pDynamicMetadata: *const c_void,
3495}
3496
3497#[derive(Clone, Copy)]
3498#[repr(C)]
3499pub struct VkHeadlessSurfaceCreateInfoEXT {
3500    pub sType: VkStructureType,
3501    pub pNext: *const c_void,
3502    pub flags: VkHeadlessSurfaceCreateFlagsEXT,
3503}
3504
3505#[derive(Clone, Copy)]
3506#[repr(C)]
3507pub struct VkHostAddressRangeConstEXT {
3508    pub address: *const c_void,
3509    pub size: usize,
3510}
3511
3512#[derive(Clone, Copy)]
3513#[repr(C)]
3514pub struct VkHostAddressRangeEXT {
3515    pub address: *mut c_void,
3516    pub size: usize,
3517}
3518
3519#[derive(Clone, Copy)]
3520#[repr(C)]
3521pub struct VkHostImageCopyDevicePerformanceQuery {
3522    pub sType: VkStructureType,
3523    pub pNext: *mut c_void,
3524    pub optimalDeviceAccess: VkBool32,
3525    pub identicalMemoryLayout: VkBool32,
3526}
3527
3528#[derive(Clone, Copy)]
3529#[repr(C)]
3530pub struct VkHostImageLayoutTransitionInfo {
3531    pub sType: VkStructureType,
3532    pub pNext: *const c_void,
3533    pub image: VkImage,
3534    pub oldLayout: VkImageLayout,
3535    pub newLayout: VkImageLayout,
3536    pub subresourceRange: VkImageSubresourceRange,
3537}
3538
3539#[derive(Clone, Copy)]
3540#[repr(C)]
3541pub struct VkImageAlignmentControlCreateInfoMESA {
3542    pub sType: VkStructureType,
3543    pub pNext: *const c_void,
3544    pub maximumRequestedAlignment: u32,
3545}
3546
3547#[derive(Clone, Copy)]
3548#[repr(C)]
3549pub struct VkImageBlit {
3550    pub srcSubresource: VkImageSubresourceLayers,
3551    pub srcOffsets: [VkOffset3D; 2 as usize],
3552    pub dstSubresource: VkImageSubresourceLayers,
3553    pub dstOffsets: [VkOffset3D; 2 as usize],
3554}
3555
3556#[derive(Clone, Copy)]
3557#[repr(C)]
3558pub struct VkImageBlit2 {
3559    pub sType: VkStructureType,
3560    pub pNext: *const c_void,
3561    pub srcSubresource: VkImageSubresourceLayers,
3562    pub srcOffsets: [VkOffset3D; 2 as usize],
3563    pub dstSubresource: VkImageSubresourceLayers,
3564    pub dstOffsets: [VkOffset3D; 2 as usize],
3565}
3566
3567#[derive(Clone, Copy)]
3568#[repr(C)]
3569pub struct VkImageCaptureDescriptorDataInfoEXT {
3570    pub sType: VkStructureType,
3571    pub pNext: *const c_void,
3572    pub image: VkImage,
3573}
3574
3575#[derive(Clone, Copy)]
3576#[repr(C)]
3577pub struct VkImageCompressionControlEXT {
3578    pub sType: VkStructureType,
3579    pub pNext: *const c_void,
3580    pub flags: VkImageCompressionFlagsEXT,
3581    pub compressionControlPlaneCount: u32,
3582    pub pFixedRateFlags: *mut VkImageCompressionFixedRateFlagsEXT,
3583}
3584
3585#[derive(Clone, Copy)]
3586#[repr(C)]
3587pub struct VkImageCompressionPropertiesEXT {
3588    pub sType: VkStructureType,
3589    pub pNext: *mut c_void,
3590    pub imageCompressionFlags: VkImageCompressionFlagsEXT,
3591    pub imageCompressionFixedRateFlags: VkImageCompressionFixedRateFlagsEXT,
3592}
3593
3594#[derive(Clone, Copy)]
3595#[repr(C)]
3596pub struct VkImageCopy {
3597    pub srcSubresource: VkImageSubresourceLayers,
3598    pub srcOffset: VkOffset3D,
3599    pub dstSubresource: VkImageSubresourceLayers,
3600    pub dstOffset: VkOffset3D,
3601    pub extent: VkExtent3D,
3602}
3603
3604#[derive(Clone, Copy)]
3605#[repr(C)]
3606pub struct VkImageCopy2 {
3607    pub sType: VkStructureType,
3608    pub pNext: *const c_void,
3609    pub srcSubresource: VkImageSubresourceLayers,
3610    pub srcOffset: VkOffset3D,
3611    pub dstSubresource: VkImageSubresourceLayers,
3612    pub dstOffset: VkOffset3D,
3613    pub extent: VkExtent3D,
3614}
3615
3616#[derive(Clone, Copy)]
3617#[repr(C)]
3618pub struct VkImageCreateInfo {
3619    pub sType: VkStructureType,
3620    pub pNext: *const c_void,
3621    pub flags: VkImageCreateFlags,
3622    pub imageType: VkImageType,
3623    pub format: VkFormat,
3624    pub extent: VkExtent3D,
3625    pub mipLevels: u32,
3626    pub arrayLayers: u32,
3627    pub samples: VkSampleCountFlagBits,
3628    pub tiling: VkImageTiling,
3629    pub usage: VkImageUsageFlags,
3630    pub sharingMode: VkSharingMode,
3631    pub queueFamilyIndexCount: u32,
3632    pub pQueueFamilyIndices: *const u32,
3633    pub initialLayout: VkImageLayout,
3634}
3635
3636#[derive(Clone, Copy)]
3637#[repr(C)]
3638pub struct VkImageDescriptorInfoEXT {
3639    pub sType: VkStructureType,
3640    pub pNext: *const c_void,
3641    pub pView: *const VkImageViewCreateInfo,
3642    pub layout: VkImageLayout,
3643}
3644
3645#[derive(Clone, Copy)]
3646#[repr(C)]
3647pub struct VkImageDrmFormatModifierExplicitCreateInfoEXT {
3648    pub sType: VkStructureType,
3649    pub pNext: *const c_void,
3650    pub drmFormatModifier: u64,
3651    pub drmFormatModifierPlaneCount: u32,
3652    pub pPlaneLayouts: *const VkSubresourceLayout,
3653}
3654
3655#[derive(Clone, Copy)]
3656#[repr(C)]
3657pub struct VkImageDrmFormatModifierListCreateInfoEXT {
3658    pub sType: VkStructureType,
3659    pub pNext: *const c_void,
3660    pub drmFormatModifierCount: u32,
3661    pub pDrmFormatModifiers: *const u64,
3662}
3663
3664#[derive(Clone, Copy)]
3665#[repr(C)]
3666pub struct VkImageDrmFormatModifierPropertiesEXT {
3667    pub sType: VkStructureType,
3668    pub pNext: *mut c_void,
3669    pub drmFormatModifier: u64,
3670}
3671
3672#[derive(Clone, Copy)]
3673#[repr(C)]
3674pub struct VkImageFormatListCreateInfo {
3675    pub sType: VkStructureType,
3676    pub pNext: *const c_void,
3677    pub viewFormatCount: u32,
3678    pub pViewFormats: *const VkFormat,
3679}
3680
3681#[derive(Clone, Copy)]
3682#[repr(C)]
3683pub struct VkImageFormatProperties {
3684    pub maxExtent: VkExtent3D,
3685    pub maxMipLevels: u32,
3686    pub maxArrayLayers: u32,
3687    pub sampleCounts: VkSampleCountFlags,
3688    pub maxResourceSize: VkDeviceSize,
3689}
3690
3691#[derive(Clone, Copy)]
3692#[repr(C)]
3693pub struct VkImageFormatProperties2 {
3694    pub sType: VkStructureType,
3695    pub pNext: *mut c_void,
3696    pub imageFormatProperties: VkImageFormatProperties,
3697}
3698
3699#[derive(Clone, Copy)]
3700#[repr(C)]
3701pub struct VkImageMemoryBarrier {
3702    pub sType: VkStructureType,
3703    pub pNext: *const c_void,
3704    pub srcAccessMask: VkAccessFlags,
3705    pub dstAccessMask: VkAccessFlags,
3706    pub oldLayout: VkImageLayout,
3707    pub newLayout: VkImageLayout,
3708    pub srcQueueFamilyIndex: u32,
3709    pub dstQueueFamilyIndex: u32,
3710    pub image: VkImage,
3711    pub subresourceRange: VkImageSubresourceRange,
3712}
3713
3714#[derive(Clone, Copy)]
3715#[repr(C)]
3716pub struct VkImageMemoryBarrier2 {
3717    pub sType: VkStructureType,
3718    pub pNext: *const c_void,
3719    pub srcStageMask: VkPipelineStageFlags2,
3720    pub srcAccessMask: VkAccessFlags2,
3721    pub dstStageMask: VkPipelineStageFlags2,
3722    pub dstAccessMask: VkAccessFlags2,
3723    pub oldLayout: VkImageLayout,
3724    pub newLayout: VkImageLayout,
3725    pub srcQueueFamilyIndex: u32,
3726    pub dstQueueFamilyIndex: u32,
3727    pub image: VkImage,
3728    pub subresourceRange: VkImageSubresourceRange,
3729}
3730
3731#[derive(Clone, Copy)]
3732#[repr(C)]
3733pub struct VkImageMemoryRequirementsInfo2 {
3734    pub sType: VkStructureType,
3735    pub pNext: *const c_void,
3736    pub image: VkImage,
3737}
3738
3739#[derive(Clone, Copy)]
3740#[repr(C)]
3741pub struct VkImagePlaneMemoryRequirementsInfo {
3742    pub sType: VkStructureType,
3743    pub pNext: *const c_void,
3744    pub planeAspect: VkImageAspectFlagBits,
3745}
3746
3747#[derive(Clone, Copy)]
3748#[repr(C)]
3749pub struct VkImageResolve {
3750    pub srcSubresource: VkImageSubresourceLayers,
3751    pub srcOffset: VkOffset3D,
3752    pub dstSubresource: VkImageSubresourceLayers,
3753    pub dstOffset: VkOffset3D,
3754    pub extent: VkExtent3D,
3755}
3756
3757#[derive(Clone, Copy)]
3758#[repr(C)]
3759pub struct VkImageResolve2 {
3760    pub sType: VkStructureType,
3761    pub pNext: *const c_void,
3762    pub srcSubresource: VkImageSubresourceLayers,
3763    pub srcOffset: VkOffset3D,
3764    pub dstSubresource: VkImageSubresourceLayers,
3765    pub dstOffset: VkOffset3D,
3766    pub extent: VkExtent3D,
3767}
3768
3769#[derive(Clone, Copy)]
3770#[repr(C)]
3771pub struct VkImageSparseMemoryRequirementsInfo2 {
3772    pub sType: VkStructureType,
3773    pub pNext: *const c_void,
3774    pub image: VkImage,
3775}
3776
3777#[derive(Clone, Copy)]
3778#[repr(C)]
3779pub struct VkImageStencilUsageCreateInfo {
3780    pub sType: VkStructureType,
3781    pub pNext: *const c_void,
3782    pub stencilUsage: VkImageUsageFlags,
3783}
3784
3785#[derive(Clone, Copy)]
3786#[repr(C)]
3787pub struct VkImageSubresource {
3788    pub aspectMask: VkImageAspectFlags,
3789    pub mipLevel: u32,
3790    pub arrayLayer: u32,
3791}
3792
3793#[derive(Clone, Copy)]
3794#[repr(C)]
3795pub struct VkImageSubresource2 {
3796    pub sType: VkStructureType,
3797    pub pNext: *mut c_void,
3798    pub imageSubresource: VkImageSubresource,
3799}
3800
3801#[derive(Clone, Copy)]
3802#[repr(C)]
3803pub struct VkImageSubresourceLayers {
3804    pub aspectMask: VkImageAspectFlags,
3805    pub mipLevel: u32,
3806    pub baseArrayLayer: u32,
3807    pub layerCount: u32,
3808}
3809
3810#[derive(Clone, Copy)]
3811#[repr(C)]
3812pub struct VkImageSubresourceRange {
3813    pub aspectMask: VkImageAspectFlags,
3814    pub baseMipLevel: u32,
3815    pub levelCount: u32,
3816    pub baseArrayLayer: u32,
3817    pub layerCount: u32,
3818}
3819
3820#[derive(Clone, Copy)]
3821#[repr(C)]
3822pub struct VkImageSwapchainCreateInfoKHR {
3823    pub sType: VkStructureType,
3824    pub pNext: *const c_void,
3825    pub swapchain: VkSwapchainKHR,
3826}
3827
3828#[derive(Clone, Copy)]
3829#[repr(C)]
3830pub struct VkImageToMemoryCopy {
3831    pub sType: VkStructureType,
3832    pub pNext: *const c_void,
3833    pub pHostPointer: *mut c_void,
3834    pub memoryRowLength: u32,
3835    pub memoryImageHeight: u32,
3836    pub imageSubresource: VkImageSubresourceLayers,
3837    pub imageOffset: VkOffset3D,
3838    pub imageExtent: VkExtent3D,
3839}
3840
3841#[derive(Clone, Copy)]
3842#[repr(C)]
3843pub struct VkImageViewASTCDecodeModeEXT {
3844    pub sType: VkStructureType,
3845    pub pNext: *const c_void,
3846    pub decodeMode: VkFormat,
3847}
3848
3849#[derive(Clone, Copy)]
3850#[repr(C)]
3851pub struct VkImageViewAddressPropertiesNVX {
3852    pub sType: VkStructureType,
3853    pub pNext: *mut c_void,
3854    pub deviceAddress: VkDeviceAddress,
3855    pub size: VkDeviceSize,
3856}
3857
3858#[derive(Clone, Copy)]
3859#[repr(C)]
3860pub struct VkImageViewCaptureDescriptorDataInfoEXT {
3861    pub sType: VkStructureType,
3862    pub pNext: *const c_void,
3863    pub imageView: VkImageView,
3864}
3865
3866#[derive(Clone, Copy)]
3867#[repr(C)]
3868pub struct VkImageViewCreateInfo {
3869    pub sType: VkStructureType,
3870    pub pNext: *const c_void,
3871    pub flags: VkImageViewCreateFlags,
3872    pub image: VkImage,
3873    pub viewType: VkImageViewType,
3874    pub format: VkFormat,
3875    pub components: VkComponentMapping,
3876    pub subresourceRange: VkImageSubresourceRange,
3877}
3878
3879#[derive(Clone, Copy)]
3880#[repr(C)]
3881pub struct VkImageViewHandleInfoNVX {
3882    pub sType: VkStructureType,
3883    pub pNext: *const c_void,
3884    pub imageView: VkImageView,
3885    pub descriptorType: VkDescriptorType,
3886    pub sampler: VkSampler,
3887}
3888
3889#[derive(Clone, Copy)]
3890#[repr(C)]
3891pub struct VkImageViewMinLodCreateInfoEXT {
3892    pub sType: VkStructureType,
3893    pub pNext: *const c_void,
3894    pub minLod: f32,
3895}
3896
3897#[derive(Clone, Copy)]
3898#[repr(C)]
3899pub struct VkImageViewSampleWeightCreateInfoQCOM {
3900    pub sType: VkStructureType,
3901    pub pNext: *const c_void,
3902    pub filterCenter: VkOffset2D,
3903    pub filterSize: VkExtent2D,
3904    pub numPhases: u32,
3905}
3906
3907#[derive(Clone, Copy)]
3908#[repr(C)]
3909pub struct VkImageViewSlicedCreateInfoEXT {
3910    pub sType: VkStructureType,
3911    pub pNext: *const c_void,
3912    pub sliceOffset: u32,
3913    pub sliceCount: u32,
3914}
3915
3916#[derive(Clone, Copy)]
3917#[repr(C)]
3918pub struct VkImageViewUsageCreateInfo {
3919    pub sType: VkStructureType,
3920    pub pNext: *const c_void,
3921    pub usage: VkImageUsageFlags,
3922}
3923
3924#[repr(C)]
3925pub struct VkImageView_T {
3926    _data: (),
3927    _marker: PhantomData<(*mut u8, PhantomPinned)>,
3928}
3929
3930#[repr(C)]
3931pub struct VkImage_T {
3932    _data: (),
3933    _marker: PhantomData<(*mut u8, PhantomPinned)>,
3934}
3935
3936#[derive(Clone, Copy)]
3937#[repr(C)]
3938pub struct VkImportFenceFdInfoKHR {
3939    pub sType: VkStructureType,
3940    pub pNext: *const c_void,
3941    pub fence: VkFence,
3942    pub flags: VkFenceImportFlags,
3943    pub handleType: VkExternalFenceHandleTypeFlagBits,
3944    pub fd: c_int,
3945}
3946
3947#[derive(Clone, Copy)]
3948#[repr(C)]
3949pub struct VkImportMemoryFdInfoKHR {
3950    pub sType: VkStructureType,
3951    pub pNext: *const c_void,
3952    pub handleType: VkExternalMemoryHandleTypeFlagBits,
3953    pub fd: c_int,
3954}
3955
3956#[derive(Clone, Copy)]
3957#[repr(C)]
3958pub struct VkImportMemoryHostPointerInfoEXT {
3959    pub sType: VkStructureType,
3960    pub pNext: *const c_void,
3961    pub handleType: VkExternalMemoryHandleTypeFlagBits,
3962    pub pHostPointer: *mut c_void,
3963}
3964
3965#[derive(Clone, Copy)]
3966#[repr(C)]
3967pub struct VkImportSemaphoreFdInfoKHR {
3968    pub sType: VkStructureType,
3969    pub pNext: *const c_void,
3970    pub semaphore: VkSemaphore,
3971    pub flags: VkSemaphoreImportFlags,
3972    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
3973    pub fd: c_int,
3974}
3975
3976#[derive(Clone, Copy)]
3977#[repr(C)]
3978pub struct VkIndirectCommandsExecutionSetTokenEXT {
3979    pub typ: VkIndirectExecutionSetInfoTypeEXT,
3980    pub shaderStages: VkShaderStageFlags,
3981}
3982
3983#[derive(Clone, Copy)]
3984#[repr(C)]
3985pub struct VkIndirectCommandsIndexBufferTokenEXT {
3986    pub mode: VkIndirectCommandsInputModeFlagBitsEXT,
3987}
3988
3989#[derive(Clone, Copy)]
3990#[repr(C)]
3991pub struct VkIndirectCommandsLayoutCreateInfoEXT {
3992    pub sType: VkStructureType,
3993    pub pNext: *const c_void,
3994    pub flags: VkIndirectCommandsLayoutUsageFlagsEXT,
3995    pub shaderStages: VkShaderStageFlags,
3996    pub indirectStride: u32,
3997    pub pipelineLayout: VkPipelineLayout,
3998    pub tokenCount: u32,
3999    pub pTokens: *const VkIndirectCommandsLayoutTokenEXT,
4000}
4001
4002#[derive(Clone, Copy)]
4003#[repr(C)]
4004pub struct VkIndirectCommandsLayoutCreateInfoNV {
4005    pub sType: VkStructureType,
4006    pub pNext: *const c_void,
4007    pub flags: VkIndirectCommandsLayoutUsageFlagsNV,
4008    pub pipelineBindPoint: VkPipelineBindPoint,
4009    pub tokenCount: u32,
4010    pub pTokens: *const VkIndirectCommandsLayoutTokenNV,
4011    pub streamCount: u32,
4012    pub pStreamStrides: *const u32,
4013}
4014
4015#[repr(C)]
4016pub struct VkIndirectCommandsLayoutEXT_T {
4017    _data: (),
4018    _marker: PhantomData<(*mut u8, PhantomPinned)>,
4019}
4020
4021#[repr(C)]
4022pub struct VkIndirectCommandsLayoutNV_T {
4023    _data: (),
4024    _marker: PhantomData<(*mut u8, PhantomPinned)>,
4025}
4026
4027#[derive(Clone, Copy)]
4028#[repr(C)]
4029pub struct VkIndirectCommandsLayoutPushDataTokenNV {
4030    pub sType: VkStructureType,
4031    pub pNext: *const c_void,
4032    pub pushDataOffset: u32,
4033    pub pushDataSize: u32,
4034}
4035
4036#[derive(Clone, Copy)]
4037#[repr(C)]
4038pub struct VkIndirectCommandsLayoutTokenEXT {
4039    pub sType: VkStructureType,
4040    pub pNext: *const c_void,
4041    pub typ: VkIndirectCommandsTokenTypeEXT,
4042    pub data: VkIndirectCommandsTokenDataEXT,
4043    pub offset: u32,
4044}
4045
4046#[derive(Clone, Copy)]
4047#[repr(C)]
4048pub struct VkIndirectCommandsLayoutTokenNV {
4049    pub sType: VkStructureType,
4050    pub pNext: *const c_void,
4051    pub tokenType: VkIndirectCommandsTokenTypeNV,
4052    pub stream: u32,
4053    pub offset: u32,
4054    pub vertexBindingUnit: u32,
4055    pub vertexDynamicStride: VkBool32,
4056    pub pushconstantPipelineLayout: VkPipelineLayout,
4057    pub pushconstantShaderStageFlags: VkShaderStageFlags,
4058    pub pushconstantOffset: u32,
4059    pub pushconstantSize: u32,
4060    pub indirectStateFlags: VkIndirectStateFlagsNV,
4061    pub indexTypeCount: u32,
4062    pub pIndexTypes: *const VkIndexType,
4063    pub pIndexTypeValues: *const u32,
4064}
4065
4066#[derive(Clone, Copy)]
4067#[repr(C)]
4068pub struct VkIndirectCommandsPushConstantTokenEXT {
4069    pub updateRange: VkPushConstantRange,
4070}
4071
4072#[derive(Clone, Copy)]
4073#[repr(C)]
4074pub struct VkIndirectCommandsStreamNV {
4075    pub buffer: VkBuffer,
4076    pub offset: VkDeviceSize,
4077}
4078
4079#[derive(Clone, Copy)]
4080#[repr(C)]
4081pub struct VkIndirectCommandsVertexBufferTokenEXT {
4082    pub vertexBindingUnit: u32,
4083}
4084
4085#[derive(Clone, Copy)]
4086#[repr(C)]
4087pub struct VkIndirectExecutionSetCreateInfoEXT {
4088    pub sType: VkStructureType,
4089    pub pNext: *const c_void,
4090    pub typ: VkIndirectExecutionSetInfoTypeEXT,
4091    pub info: VkIndirectExecutionSetInfoEXT,
4092}
4093
4094#[repr(C)]
4095pub struct VkIndirectExecutionSetEXT_T {
4096    _data: (),
4097    _marker: PhantomData<(*mut u8, PhantomPinned)>,
4098}
4099
4100#[derive(Clone, Copy)]
4101#[repr(C)]
4102pub struct VkIndirectExecutionSetPipelineInfoEXT {
4103    pub sType: VkStructureType,
4104    pub pNext: *const c_void,
4105    pub initialPipeline: VkPipeline,
4106    pub maxPipelineCount: u32,
4107}
4108
4109#[derive(Clone, Copy)]
4110#[repr(C)]
4111pub struct VkIndirectExecutionSetShaderInfoEXT {
4112    pub sType: VkStructureType,
4113    pub pNext: *const c_void,
4114    pub shaderCount: u32,
4115    pub pInitialShaders: *const VkShaderEXT,
4116    pub pSetLayoutInfos: *const VkIndirectExecutionSetShaderLayoutInfoEXT,
4117    pub maxShaderCount: u32,
4118    pub pushConstantRangeCount: u32,
4119    pub pPushConstantRanges: *const VkPushConstantRange,
4120}
4121
4122#[derive(Clone, Copy)]
4123#[repr(C)]
4124pub struct VkIndirectExecutionSetShaderLayoutInfoEXT {
4125    pub sType: VkStructureType,
4126    pub pNext: *const c_void,
4127    pub setLayoutCount: u32,
4128    pub pSetLayouts: *const VkDescriptorSetLayout,
4129}
4130
4131#[derive(Clone, Copy)]
4132#[repr(C)]
4133pub struct VkInitializePerformanceApiInfoINTEL {
4134    pub sType: VkStructureType,
4135    pub pNext: *const c_void,
4136    pub pUserData: *mut c_void,
4137}
4138
4139#[derive(Clone, Copy)]
4140#[repr(C)]
4141pub struct VkInputAttachmentAspectReference {
4142    pub subpass: u32,
4143    pub inputAttachmentIndex: u32,
4144    pub aspectMask: VkImageAspectFlags,
4145}
4146
4147#[derive(Clone, Copy)]
4148#[repr(C)]
4149pub struct VkInstanceCreateInfo {
4150    pub sType: VkStructureType,
4151    pub pNext: *const c_void,
4152    pub flags: VkInstanceCreateFlags,
4153    pub pApplicationInfo: *const VkApplicationInfo,
4154    pub enabledLayerCount: u32,
4155    pub ppEnabledLayerNames: *const *const c_char,
4156    pub enabledExtensionCount: u32,
4157    pub ppEnabledExtensionNames: *const *const c_char,
4158}
4159
4160#[repr(C)]
4161pub struct VkInstance_T {
4162    _data: (),
4163    _marker: PhantomData<(*mut u8, PhantomPinned)>,
4164}
4165
4166#[derive(Clone, Copy)]
4167#[repr(C)]
4168pub struct VkLatencySleepInfoNV {
4169    pub sType: VkStructureType,
4170    pub pNext: *const c_void,
4171    pub signalSemaphore: VkSemaphore,
4172    pub value: u64,
4173}
4174
4175#[derive(Clone, Copy)]
4176#[repr(C)]
4177pub struct VkLatencySleepModeInfoNV {
4178    pub sType: VkStructureType,
4179    pub pNext: *const c_void,
4180    pub lowLatencyMode: VkBool32,
4181    pub lowLatencyBoost: VkBool32,
4182    pub minimumIntervalUs: u32,
4183}
4184
4185#[derive(Clone, Copy)]
4186#[repr(C)]
4187pub struct VkLatencySubmissionPresentIdNV {
4188    pub sType: VkStructureType,
4189    pub pNext: *const c_void,
4190    pub presentID: u64,
4191}
4192
4193#[derive(Clone, Copy)]
4194#[repr(C)]
4195pub struct VkLatencySurfaceCapabilitiesNV {
4196    pub sType: VkStructureType,
4197    pub pNext: *const c_void,
4198    pub presentModeCount: u32,
4199    pub pPresentModes: *mut VkPresentModeKHR,
4200}
4201
4202#[derive(Clone, Copy)]
4203#[repr(C)]
4204pub struct VkLatencyTimingsFrameReportNV {
4205    pub sType: VkStructureType,
4206    pub pNext: *mut c_void,
4207    pub presentID: u64,
4208    pub inputSampleTimeUs: u64,
4209    pub simStartTimeUs: u64,
4210    pub simEndTimeUs: u64,
4211    pub renderSubmitStartTimeUs: u64,
4212    pub renderSubmitEndTimeUs: u64,
4213    pub presentStartTimeUs: u64,
4214    pub presentEndTimeUs: u64,
4215    pub driverStartTimeUs: u64,
4216    pub driverEndTimeUs: u64,
4217    pub osRenderQueueStartTimeUs: u64,
4218    pub osRenderQueueEndTimeUs: u64,
4219    pub gpuRenderStartTimeUs: u64,
4220    pub gpuRenderEndTimeUs: u64,
4221}
4222
4223#[derive(Clone, Copy)]
4224#[repr(C)]
4225pub struct VkLayerProperties {
4226    pub layerName: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
4227    pub specVersion: u32,
4228    pub implementationVersion: u32,
4229    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
4230}
4231
4232#[derive(Clone, Copy)]
4233#[repr(C)]
4234pub struct VkLayerSettingEXT {
4235    pub pLayerName: *const c_char,
4236    pub pSettingName: *const c_char,
4237    pub typ: VkLayerSettingTypeEXT,
4238    pub valueCount: u32,
4239    pub pValues: *const c_void,
4240}
4241
4242#[derive(Clone, Copy)]
4243#[repr(C)]
4244pub struct VkLayerSettingsCreateInfoEXT {
4245    pub sType: VkStructureType,
4246    pub pNext: *const c_void,
4247    pub settingCount: u32,
4248    pub pSettings: *const VkLayerSettingEXT,
4249}
4250
4251#[derive(Clone, Copy)]
4252#[repr(C)]
4253pub struct VkMappedMemoryRange {
4254    pub sType: VkStructureType,
4255    pub pNext: *const c_void,
4256    pub memory: VkDeviceMemory,
4257    pub offset: VkDeviceSize,
4258    pub size: VkDeviceSize,
4259}
4260
4261#[derive(Clone, Copy)]
4262#[repr(C)]
4263pub struct VkMemoryAllocateFlagsInfo {
4264    pub sType: VkStructureType,
4265    pub pNext: *const c_void,
4266    pub flags: VkMemoryAllocateFlags,
4267    pub deviceMask: u32,
4268}
4269
4270#[derive(Clone, Copy)]
4271#[repr(C)]
4272pub struct VkMemoryAllocateInfo {
4273    pub sType: VkStructureType,
4274    pub pNext: *const c_void,
4275    pub allocationSize: VkDeviceSize,
4276    pub memoryTypeIndex: u32,
4277}
4278
4279#[derive(Clone, Copy)]
4280#[repr(C)]
4281pub struct VkMemoryBarrier {
4282    pub sType: VkStructureType,
4283    pub pNext: *const c_void,
4284    pub srcAccessMask: VkAccessFlags,
4285    pub dstAccessMask: VkAccessFlags,
4286}
4287
4288#[derive(Clone, Copy)]
4289#[repr(C)]
4290pub struct VkMemoryBarrier2 {
4291    pub sType: VkStructureType,
4292    pub pNext: *const c_void,
4293    pub srcStageMask: VkPipelineStageFlags2,
4294    pub srcAccessMask: VkAccessFlags2,
4295    pub dstStageMask: VkPipelineStageFlags2,
4296    pub dstAccessMask: VkAccessFlags2,
4297}
4298
4299#[derive(Clone, Copy)]
4300#[repr(C)]
4301pub struct VkMemoryBarrierAccessFlags3KHR {
4302    pub sType: VkStructureType,
4303    pub pNext: *const c_void,
4304    pub srcAccessMask3: VkAccessFlags3KHR,
4305    pub dstAccessMask3: VkAccessFlags3KHR,
4306}
4307
4308#[derive(Clone, Copy)]
4309#[repr(C)]
4310pub struct VkMemoryDedicatedAllocateInfo {
4311    pub sType: VkStructureType,
4312    pub pNext: *const c_void,
4313    pub image: VkImage,
4314    pub buffer: VkBuffer,
4315}
4316
4317#[derive(Clone, Copy)]
4318#[repr(C)]
4319pub struct VkMemoryDedicatedAllocateInfoTensorARM {
4320    pub sType: VkStructureType,
4321    pub pNext: *const c_void,
4322    pub tensor: VkTensorARM,
4323}
4324
4325#[derive(Clone, Copy)]
4326#[repr(C)]
4327pub struct VkMemoryDedicatedRequirements {
4328    pub sType: VkStructureType,
4329    pub pNext: *mut c_void,
4330    pub prefersDedicatedAllocation: VkBool32,
4331    pub requiresDedicatedAllocation: VkBool32,
4332}
4333
4334#[derive(Clone, Copy)]
4335#[repr(C)]
4336pub struct VkMemoryFdPropertiesKHR {
4337    pub sType: VkStructureType,
4338    pub pNext: *mut c_void,
4339    pub memoryTypeBits: u32,
4340}
4341
4342#[derive(Clone, Copy)]
4343#[repr(C)]
4344pub struct VkMemoryGetFdInfoKHR {
4345    pub sType: VkStructureType,
4346    pub pNext: *const c_void,
4347    pub memory: VkDeviceMemory,
4348    pub handleType: VkExternalMemoryHandleTypeFlagBits,
4349}
4350
4351#[derive(Clone, Copy)]
4352#[repr(C)]
4353pub struct VkMemoryGetRemoteAddressInfoNV {
4354    pub sType: VkStructureType,
4355    pub pNext: *const c_void,
4356    pub memory: VkDeviceMemory,
4357    pub handleType: VkExternalMemoryHandleTypeFlagBits,
4358}
4359
4360#[derive(Clone, Copy)]
4361#[repr(C)]
4362pub struct VkMemoryHeap {
4363    pub size: VkDeviceSize,
4364    pub flags: VkMemoryHeapFlags,
4365}
4366
4367#[derive(Clone, Copy)]
4368#[repr(C)]
4369pub struct VkMemoryHostPointerPropertiesEXT {
4370    pub sType: VkStructureType,
4371    pub pNext: *mut c_void,
4372    pub memoryTypeBits: u32,
4373}
4374
4375#[derive(Clone, Copy)]
4376#[repr(C)]
4377pub struct VkMemoryMapInfo {
4378    pub sType: VkStructureType,
4379    pub pNext: *const c_void,
4380    pub flags: VkMemoryMapFlags,
4381    pub memory: VkDeviceMemory,
4382    pub offset: VkDeviceSize,
4383    pub size: VkDeviceSize,
4384}
4385
4386#[derive(Clone, Copy)]
4387#[repr(C)]
4388pub struct VkMemoryMapPlacedInfoEXT {
4389    pub sType: VkStructureType,
4390    pub pNext: *const c_void,
4391    pub pPlacedAddress: *mut c_void,
4392}
4393
4394#[derive(Clone, Copy)]
4395#[repr(C)]
4396pub struct VkMemoryOpaqueCaptureAddressAllocateInfo {
4397    pub sType: VkStructureType,
4398    pub pNext: *const c_void,
4399    pub opaqueCaptureAddress: u64,
4400}
4401
4402#[derive(Clone, Copy)]
4403#[repr(C)]
4404pub struct VkMemoryPriorityAllocateInfoEXT {
4405    pub sType: VkStructureType,
4406    pub pNext: *const c_void,
4407    pub priority: f32,
4408}
4409
4410#[derive(Clone, Copy)]
4411#[repr(C)]
4412pub struct VkMemoryRequirements {
4413    pub size: VkDeviceSize,
4414    pub alignment: VkDeviceSize,
4415    pub memoryTypeBits: u32,
4416}
4417
4418#[derive(Clone, Copy)]
4419#[repr(C)]
4420pub struct VkMemoryRequirements2 {
4421    pub sType: VkStructureType,
4422    pub pNext: *mut c_void,
4423    pub memoryRequirements: VkMemoryRequirements,
4424}
4425
4426#[derive(Clone, Copy)]
4427#[repr(C)]
4428pub struct VkMemoryToImageCopy {
4429    pub sType: VkStructureType,
4430    pub pNext: *const c_void,
4431    pub pHostPointer: *const c_void,
4432    pub memoryRowLength: u32,
4433    pub memoryImageHeight: u32,
4434    pub imageSubresource: VkImageSubresourceLayers,
4435    pub imageOffset: VkOffset3D,
4436    pub imageExtent: VkExtent3D,
4437}
4438
4439#[derive(Clone, Copy)]
4440#[repr(C)]
4441pub struct VkMemoryType {
4442    pub propertyFlags: VkMemoryPropertyFlags,
4443    pub heapIndex: u32,
4444}
4445
4446#[derive(Clone, Copy)]
4447#[repr(C)]
4448pub struct VkMemoryUnmapInfo {
4449    pub sType: VkStructureType,
4450    pub pNext: *const c_void,
4451    pub flags: VkMemoryUnmapFlags,
4452    pub memory: VkDeviceMemory,
4453}
4454
4455#[derive(Clone, Copy)]
4456#[repr(C)]
4457pub struct VkMicromapBuildInfoEXT {
4458    pub sType: VkStructureType,
4459    pub pNext: *const c_void,
4460    pub typ: VkMicromapTypeEXT,
4461    pub flags: VkBuildMicromapFlagsEXT,
4462    pub mode: VkBuildMicromapModeEXT,
4463    pub dstMicromap: VkMicromapEXT,
4464    pub usageCountsCount: u32,
4465    pub pUsageCounts: *const VkMicromapUsageEXT,
4466    pub ppUsageCounts: *const *const VkMicromapUsageEXT,
4467    pub data: VkDeviceOrHostAddressConstKHR,
4468    pub scratchData: VkDeviceOrHostAddressKHR,
4469    pub triangleArray: VkDeviceOrHostAddressConstKHR,
4470    pub triangleArrayStride: VkDeviceSize,
4471}
4472
4473#[derive(Clone, Copy)]
4474#[repr(C)]
4475pub struct VkMicromapBuildSizesInfoEXT {
4476    pub sType: VkStructureType,
4477    pub pNext: *const c_void,
4478    pub micromapSize: VkDeviceSize,
4479    pub buildScratchSize: VkDeviceSize,
4480    pub discardable: VkBool32,
4481}
4482
4483#[derive(Clone, Copy)]
4484#[repr(C)]
4485pub struct VkMicromapCreateInfoEXT {
4486    pub sType: VkStructureType,
4487    pub pNext: *const c_void,
4488    pub createFlags: VkMicromapCreateFlagsEXT,
4489    pub buffer: VkBuffer,
4490    pub offset: VkDeviceSize,
4491    pub size: VkDeviceSize,
4492    pub typ: VkMicromapTypeEXT,
4493    pub deviceAddress: VkDeviceAddress,
4494}
4495
4496#[repr(C)]
4497pub struct VkMicromapEXT_T {
4498    _data: (),
4499    _marker: PhantomData<(*mut u8, PhantomPinned)>,
4500}
4501
4502#[derive(Clone, Copy)]
4503#[repr(C)]
4504pub struct VkMicromapTriangleEXT {
4505    pub dataOffset: u32,
4506    pub subdivisionLevel: u16,
4507    pub format: u16,
4508}
4509
4510#[derive(Clone, Copy)]
4511#[repr(C)]
4512pub struct VkMicromapUsageEXT {
4513    pub count: u32,
4514    pub subdivisionLevel: u32,
4515    pub format: u32,
4516}
4517
4518#[derive(Clone, Copy)]
4519#[repr(C)]
4520pub struct VkMicromapVersionInfoEXT {
4521    pub sType: VkStructureType,
4522    pub pNext: *const c_void,
4523    pub pVersionData: *const u8,
4524}
4525
4526#[derive(Clone, Copy)]
4527#[repr(C)]
4528pub struct VkMultiDrawIndexedInfoEXT {
4529    pub firstIndex: u32,
4530    pub indexCount: u32,
4531    pub vertexOffset: i32,
4532}
4533
4534#[derive(Clone, Copy)]
4535#[repr(C)]
4536pub struct VkMultiDrawInfoEXT {
4537    pub firstVertex: u32,
4538    pub vertexCount: u32,
4539}
4540
4541#[derive(Clone, Copy)]
4542#[repr(C)]
4543pub struct VkMultisamplePropertiesEXT {
4544    pub sType: VkStructureType,
4545    pub pNext: *mut c_void,
4546    pub maxSampleLocationGridSize: VkExtent2D,
4547}
4548
4549#[derive(Clone, Copy)]
4550#[repr(C)]
4551pub struct VkMultisampledRenderToSingleSampledInfoEXT {
4552    pub sType: VkStructureType,
4553    pub pNext: *const c_void,
4554    pub multisampledRenderToSingleSampledEnable: VkBool32,
4555    pub rasterizationSamples: VkSampleCountFlagBits,
4556}
4557
4558#[derive(Clone, Copy)]
4559#[repr(C)]
4560pub struct VkMultiviewPerViewAttributesInfoNVX {
4561    pub sType: VkStructureType,
4562    pub pNext: *const c_void,
4563    pub perViewAttributes: VkBool32,
4564    pub perViewAttributesPositionXOnly: VkBool32,
4565}
4566
4567#[derive(Clone, Copy)]
4568#[repr(C)]
4569pub struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
4570    pub sType: VkStructureType,
4571    pub pNext: *const c_void,
4572    pub perViewRenderAreaCount: u32,
4573    pub pPerViewRenderAreas: *const VkRect2D,
4574}
4575
4576#[derive(Clone, Copy)]
4577#[repr(C)]
4578pub struct VkMutableDescriptorTypeCreateInfoEXT {
4579    pub sType: VkStructureType,
4580    pub pNext: *const c_void,
4581    pub mutableDescriptorTypeListCount: u32,
4582    pub pMutableDescriptorTypeLists: *const VkMutableDescriptorTypeListEXT,
4583}
4584
4585#[derive(Clone, Copy)]
4586#[repr(C)]
4587pub struct VkMutableDescriptorTypeListEXT {
4588    pub descriptorTypeCount: u32,
4589    pub pDescriptorTypes: *const VkDescriptorType,
4590}
4591
4592#[derive(Clone, Copy)]
4593#[repr(C)]
4594pub struct VkOffset2D {
4595    pub x: i32,
4596    pub y: i32,
4597}
4598
4599#[derive(Clone, Copy)]
4600#[repr(C)]
4601pub struct VkOffset3D {
4602    pub x: i32,
4603    pub y: i32,
4604    pub z: i32,
4605}
4606
4607#[derive(Clone, Copy)]
4608#[repr(C)]
4609pub struct VkOpaqueCaptureDataCreateInfoEXT {
4610    pub sType: VkStructureType,
4611    pub pNext: *const c_void,
4612    pub pData: *const VkHostAddressRangeConstEXT,
4613}
4614
4615#[derive(Clone, Copy)]
4616#[repr(C)]
4617pub struct VkOpaqueCaptureDescriptorDataCreateInfoEXT {
4618    pub sType: VkStructureType,
4619    pub pNext: *const c_void,
4620    pub opaqueCaptureDescriptorData: *const c_void,
4621}
4622
4623#[derive(Clone, Copy)]
4624#[repr(C)]
4625pub struct VkOpticalFlowExecuteInfoNV {
4626    pub sType: VkStructureType,
4627    pub pNext: *mut c_void,
4628    pub flags: VkOpticalFlowExecuteFlagsNV,
4629    pub regionCount: u32,
4630    pub pRegions: *const VkRect2D,
4631}
4632
4633#[derive(Clone, Copy)]
4634#[repr(C)]
4635pub struct VkOpticalFlowImageFormatInfoNV {
4636    pub sType: VkStructureType,
4637    pub pNext: *const c_void,
4638    pub usage: VkOpticalFlowUsageFlagsNV,
4639}
4640
4641#[derive(Clone, Copy)]
4642#[repr(C)]
4643pub struct VkOpticalFlowImageFormatPropertiesNV {
4644    pub sType: VkStructureType,
4645    pub pNext: *mut c_void,
4646    pub format: VkFormat,
4647}
4648
4649#[derive(Clone, Copy)]
4650#[repr(C)]
4651pub struct VkOpticalFlowSessionCreateInfoNV {
4652    pub sType: VkStructureType,
4653    pub pNext: *mut c_void,
4654    pub width: u32,
4655    pub height: u32,
4656    pub imageFormat: VkFormat,
4657    pub flowVectorFormat: VkFormat,
4658    pub costFormat: VkFormat,
4659    pub outputGridSize: VkOpticalFlowGridSizeFlagsNV,
4660    pub hintGridSize: VkOpticalFlowGridSizeFlagsNV,
4661    pub performanceLevel: VkOpticalFlowPerformanceLevelNV,
4662    pub flags: VkOpticalFlowSessionCreateFlagsNV,
4663}
4664
4665#[derive(Clone, Copy)]
4666#[repr(C)]
4667pub struct VkOpticalFlowSessionCreatePrivateDataInfoNV {
4668    pub sType: VkStructureType,
4669    pub pNext: *mut c_void,
4670    pub id: u32,
4671    pub size: u32,
4672    pub pPrivateData: *const c_void,
4673}
4674
4675#[repr(C)]
4676pub struct VkOpticalFlowSessionNV_T {
4677    _data: (),
4678    _marker: PhantomData<(*mut u8, PhantomPinned)>,
4679}
4680
4681#[derive(Clone, Copy)]
4682#[repr(C)]
4683pub struct VkOutOfBandQueueTypeInfoNV {
4684    pub sType: VkStructureType,
4685    pub pNext: *const c_void,
4686    pub queueType: VkOutOfBandQueueTypeNV,
4687}
4688
4689#[derive(Clone, Copy)]
4690#[repr(C)]
4691pub struct VkPartitionedAccelerationStructureFlagsNV {
4692    pub sType: VkStructureType,
4693    pub pNext: *mut c_void,
4694    pub enablePartitionTranslation: VkBool32,
4695}
4696
4697#[derive(Clone, Copy)]
4698#[repr(C)]
4699pub struct VkPartitionedAccelerationStructureInstancesInputNV {
4700    pub sType: VkStructureType,
4701    pub pNext: *mut c_void,
4702    pub flags: VkBuildAccelerationStructureFlagsKHR,
4703    pub instanceCount: u32,
4704    pub maxInstancePerPartitionCount: u32,
4705    pub partitionCount: u32,
4706    pub maxInstanceInGlobalPartitionCount: u32,
4707}
4708
4709#[derive(Clone, Copy)]
4710#[repr(C)]
4711pub struct VkPartitionedAccelerationStructureUpdateInstanceDataNV {
4712    pub instanceIndex: u32,
4713    pub instanceContributionToHitGroupIndex: u32,
4714    pub accelerationStructure: VkDeviceAddress,
4715}
4716
4717#[derive(Clone, Copy)]
4718#[repr(C)]
4719pub struct VkPartitionedAccelerationStructureWriteInstanceDataNV {
4720    pub transform: VkTransformMatrixKHR,
4721    pub explicitAABB: [f32; 6 as usize],
4722    pub instanceID: u32,
4723    pub instanceMask: u32,
4724    pub instanceContributionToHitGroupIndex: u32,
4725    pub instanceFlags: VkPartitionedAccelerationStructureInstanceFlagsNV,
4726    pub instanceIndex: u32,
4727    pub partitionIndex: u32,
4728    pub accelerationStructure: VkDeviceAddress,
4729}
4730
4731#[derive(Clone, Copy)]
4732#[repr(C)]
4733pub struct VkPartitionedAccelerationStructureWritePartitionTranslationDataNV {
4734    pub partitionIndex: u32,
4735    pub partitionTranslation: [f32; 3 as usize],
4736}
4737
4738#[derive(Clone, Copy)]
4739#[repr(C)]
4740pub struct VkPastPresentationTimingEXT {
4741    pub sType: VkStructureType,
4742    pub pNext: *mut c_void,
4743    pub presentId: u64,
4744    pub targetTime: u64,
4745    pub presentStageCount: u32,
4746    pub pPresentStages: *mut VkPresentStageTimeEXT,
4747    pub timeDomain: VkTimeDomainKHR,
4748    pub timeDomainId: u64,
4749    pub reportComplete: VkBool32,
4750}
4751
4752#[derive(Clone, Copy)]
4753#[repr(C)]
4754pub struct VkPastPresentationTimingGOOGLE {
4755    pub presentID: u32,
4756    pub desiredPresentTime: u64,
4757    pub actualPresentTime: u64,
4758    pub earliestPresentTime: u64,
4759    pub presentMargin: u64,
4760}
4761
4762#[derive(Clone, Copy)]
4763#[repr(C)]
4764pub struct VkPastPresentationTimingInfoEXT {
4765    pub sType: VkStructureType,
4766    pub pNext: *const c_void,
4767    pub flags: VkPastPresentationTimingFlagsEXT,
4768    pub swapchain: VkSwapchainKHR,
4769}
4770
4771#[derive(Clone, Copy)]
4772#[repr(C)]
4773pub struct VkPastPresentationTimingPropertiesEXT {
4774    pub sType: VkStructureType,
4775    pub pNext: *mut c_void,
4776    pub timingPropertiesCounter: u64,
4777    pub timeDomainsCounter: u64,
4778    pub presentationTimingCount: u32,
4779    pub pPresentationTimings: *mut VkPastPresentationTimingEXT,
4780}
4781
4782#[derive(Clone, Copy)]
4783#[repr(C)]
4784pub struct VkPerTileBeginInfoQCOM {
4785    pub sType: VkStructureType,
4786    pub pNext: *const c_void,
4787}
4788
4789#[derive(Clone, Copy)]
4790#[repr(C)]
4791pub struct VkPerTileEndInfoQCOM {
4792    pub sType: VkStructureType,
4793    pub pNext: *const c_void,
4794}
4795
4796#[derive(Clone, Copy)]
4797#[repr(C)]
4798pub struct VkPerformanceConfigurationAcquireInfoINTEL {
4799    pub sType: VkStructureType,
4800    pub pNext: *const c_void,
4801    pub typ: VkPerformanceConfigurationTypeINTEL,
4802}
4803
4804#[repr(C)]
4805pub struct VkPerformanceConfigurationINTEL_T {
4806    _data: (),
4807    _marker: PhantomData<(*mut u8, PhantomPinned)>,
4808}
4809
4810#[derive(Clone, Copy)]
4811#[repr(C)]
4812pub struct VkPerformanceCounterARM {
4813    pub sType: VkStructureType,
4814    pub pNext: *mut c_void,
4815    pub counterID: u32,
4816}
4817
4818#[derive(Clone, Copy)]
4819#[repr(C)]
4820pub struct VkPerformanceCounterDescriptionARM {
4821    pub sType: VkStructureType,
4822    pub pNext: *mut c_void,
4823    pub flags: VkPerformanceCounterDescriptionFlagsARM,
4824    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
4825}
4826
4827#[derive(Clone, Copy)]
4828#[repr(C)]
4829pub struct VkPerformanceCounterDescriptionKHR {
4830    pub sType: VkStructureType,
4831    pub pNext: *mut c_void,
4832    pub flags: VkPerformanceCounterDescriptionFlagsKHR,
4833    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
4834    pub category: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
4835    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
4836}
4837
4838#[derive(Clone, Copy)]
4839#[repr(C)]
4840pub struct VkPerformanceCounterKHR {
4841    pub sType: VkStructureType,
4842    pub pNext: *mut c_void,
4843    pub unit: VkPerformanceCounterUnitKHR,
4844    pub scope: VkPerformanceCounterScopeKHR,
4845    pub storage: VkPerformanceCounterStorageKHR,
4846    pub uuid: [u8; VK_UUID_SIZE as usize],
4847}
4848
4849#[derive(Clone, Copy)]
4850#[repr(C)]
4851pub struct VkPerformanceMarkerInfoINTEL {
4852    pub sType: VkStructureType,
4853    pub pNext: *const c_void,
4854    pub marker: u64,
4855}
4856
4857#[derive(Clone, Copy)]
4858#[repr(C)]
4859pub struct VkPerformanceOverrideInfoINTEL {
4860    pub sType: VkStructureType,
4861    pub pNext: *const c_void,
4862    pub typ: VkPerformanceOverrideTypeINTEL,
4863    pub enable: VkBool32,
4864    pub parameter: u64,
4865}
4866
4867#[derive(Clone, Copy)]
4868#[repr(C)]
4869pub struct VkPerformanceQuerySubmitInfoKHR {
4870    pub sType: VkStructureType,
4871    pub pNext: *const c_void,
4872    pub counterPassIndex: u32,
4873}
4874
4875#[derive(Clone, Copy)]
4876#[repr(C)]
4877pub struct VkPerformanceStreamMarkerInfoINTEL {
4878    pub sType: VkStructureType,
4879    pub pNext: *const c_void,
4880    pub marker: u32,
4881}
4882
4883#[derive(Clone, Copy)]
4884#[repr(C)]
4885pub struct VkPerformanceValueINTEL {
4886    pub typ: VkPerformanceValueTypeINTEL,
4887    pub data: VkPerformanceValueDataINTEL,
4888}
4889
4890#[derive(Clone, Copy)]
4891#[repr(C)]
4892pub struct VkPhysicalDevice16BitStorageFeatures {
4893    pub sType: VkStructureType,
4894    pub pNext: *mut c_void,
4895    pub storageBuffer16BitAccess: VkBool32,
4896    pub uniformAndStorageBuffer16BitAccess: VkBool32,
4897    pub storagePushConstant16: VkBool32,
4898    pub storageInputOutput16: VkBool32,
4899}
4900
4901#[derive(Clone, Copy)]
4902#[repr(C)]
4903pub struct VkPhysicalDevice4444FormatsFeaturesEXT {
4904    pub sType: VkStructureType,
4905    pub pNext: *mut c_void,
4906    pub formatA4R4G4B4: VkBool32,
4907    pub formatA4B4G4R4: VkBool32,
4908}
4909
4910#[derive(Clone, Copy)]
4911#[repr(C)]
4912pub struct VkPhysicalDevice8BitStorageFeatures {
4913    pub sType: VkStructureType,
4914    pub pNext: *mut c_void,
4915    pub storageBuffer8BitAccess: VkBool32,
4916    pub uniformAndStorageBuffer8BitAccess: VkBool32,
4917    pub storagePushConstant8: VkBool32,
4918}
4919
4920#[derive(Clone, Copy)]
4921#[repr(C)]
4922pub struct VkPhysicalDeviceASTCDecodeFeaturesEXT {
4923    pub sType: VkStructureType,
4924    pub pNext: *mut c_void,
4925    pub decodeModeSharedExponent: VkBool32,
4926}
4927
4928#[derive(Clone, Copy)]
4929#[repr(C)]
4930pub struct VkPhysicalDeviceAccelerationStructureFeaturesKHR {
4931    pub sType: VkStructureType,
4932    pub pNext: *mut c_void,
4933    pub accelerationStructure: VkBool32,
4934    pub accelerationStructureCaptureReplay: VkBool32,
4935    pub accelerationStructureIndirectBuild: VkBool32,
4936    pub accelerationStructureHostCommands: VkBool32,
4937    pub descriptorBindingAccelerationStructureUpdateAfterBind: VkBool32,
4938}
4939
4940#[derive(Clone, Copy)]
4941#[repr(C)]
4942pub struct VkPhysicalDeviceAccelerationStructurePropertiesKHR {
4943    pub sType: VkStructureType,
4944    pub pNext: *mut c_void,
4945    pub maxGeometryCount: u64,
4946    pub maxInstanceCount: u64,
4947    pub maxPrimitiveCount: u64,
4948    pub maxPerStageDescriptorAccelerationStructures: u32,
4949    pub maxPerStageDescriptorUpdateAfterBindAccelerationStructures: u32,
4950    pub maxDescriptorSetAccelerationStructures: u32,
4951    pub maxDescriptorSetUpdateAfterBindAccelerationStructures: u32,
4952    pub minAccelerationStructureScratchOffsetAlignment: u32,
4953}
4954
4955#[derive(Clone, Copy)]
4956#[repr(C)]
4957pub struct VkPhysicalDeviceAddressBindingReportFeaturesEXT {
4958    pub sType: VkStructureType,
4959    pub pNext: *mut c_void,
4960    pub reportAddressBinding: VkBool32,
4961}
4962
4963#[derive(Clone, Copy)]
4964#[repr(C)]
4965pub struct VkPhysicalDeviceAmigoProfilingFeaturesSEC {
4966    pub sType: VkStructureType,
4967    pub pNext: *mut c_void,
4968    pub amigoProfiling: VkBool32,
4969}
4970
4971#[derive(Clone, Copy)]
4972#[repr(C)]
4973pub struct VkPhysicalDeviceAntiLagFeaturesAMD {
4974    pub sType: VkStructureType,
4975    pub pNext: *mut c_void,
4976    pub antiLag: VkBool32,
4977}
4978
4979#[derive(Clone, Copy)]
4980#[repr(C)]
4981pub struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
4982    pub sType: VkStructureType,
4983    pub pNext: *mut c_void,
4984    pub attachmentFeedbackLoopDynamicState: VkBool32,
4985}
4986
4987#[derive(Clone, Copy)]
4988#[repr(C)]
4989pub struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
4990    pub sType: VkStructureType,
4991    pub pNext: *mut c_void,
4992    pub attachmentFeedbackLoopLayout: VkBool32,
4993}
4994
4995#[derive(Clone, Copy)]
4996#[repr(C)]
4997pub struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT {
4998    pub sType: VkStructureType,
4999    pub pNext: *mut c_void,
5000    pub advancedBlendCoherentOperations: VkBool32,
5001}
5002
5003#[derive(Clone, Copy)]
5004#[repr(C)]
5005pub struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT {
5006    pub sType: VkStructureType,
5007    pub pNext: *mut c_void,
5008    pub advancedBlendMaxColorAttachments: u32,
5009    pub advancedBlendIndependentBlend: VkBool32,
5010    pub advancedBlendNonPremultipliedSrcColor: VkBool32,
5011    pub advancedBlendNonPremultipliedDstColor: VkBool32,
5012    pub advancedBlendCorrelatedOverlap: VkBool32,
5013    pub advancedBlendAllOperations: VkBool32,
5014}
5015
5016#[derive(Clone, Copy)]
5017#[repr(C)]
5018pub struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT {
5019    pub sType: VkStructureType,
5020    pub pNext: *mut c_void,
5021    pub borderColorSwizzle: VkBool32,
5022    pub borderColorSwizzleFromImage: VkBool32,
5023}
5024
5025#[derive(Clone, Copy)]
5026#[repr(C)]
5027pub struct VkPhysicalDeviceBufferDeviceAddressFeatures {
5028    pub sType: VkStructureType,
5029    pub pNext: *mut c_void,
5030    pub bufferDeviceAddress: VkBool32,
5031    pub bufferDeviceAddressCaptureReplay: VkBool32,
5032    pub bufferDeviceAddressMultiDevice: VkBool32,
5033}
5034
5035#[derive(Clone, Copy)]
5036#[repr(C)]
5037pub struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT {
5038    pub sType: VkStructureType,
5039    pub pNext: *mut c_void,
5040    pub bufferDeviceAddress: VkBool32,
5041    pub bufferDeviceAddressCaptureReplay: VkBool32,
5042    pub bufferDeviceAddressMultiDevice: VkBool32,
5043}
5044
5045#[derive(Clone, Copy)]
5046#[repr(C)]
5047pub struct VkPhysicalDeviceClusterAccelerationStructureFeaturesNV {
5048    pub sType: VkStructureType,
5049    pub pNext: *mut c_void,
5050    pub clusterAccelerationStructure: VkBool32,
5051}
5052
5053#[derive(Clone, Copy)]
5054#[repr(C)]
5055pub struct VkPhysicalDeviceClusterAccelerationStructurePropertiesNV {
5056    pub sType: VkStructureType,
5057    pub pNext: *mut c_void,
5058    pub maxVerticesPerCluster: u32,
5059    pub maxTrianglesPerCluster: u32,
5060    pub clusterScratchByteAlignment: u32,
5061    pub clusterByteAlignment: u32,
5062    pub clusterTemplateByteAlignment: u32,
5063    pub clusterBottomLevelByteAlignment: u32,
5064    pub clusterTemplateBoundsByteAlignment: u32,
5065    pub maxClusterGeometryIndex: u32,
5066}
5067
5068#[derive(Clone, Copy)]
5069#[repr(C)]
5070pub struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
5071    pub sType: VkStructureType,
5072    pub pNext: *mut c_void,
5073    pub clustercullingShader: VkBool32,
5074    pub multiviewClusterCullingShader: VkBool32,
5075}
5076
5077#[derive(Clone, Copy)]
5078#[repr(C)]
5079pub struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
5080    pub sType: VkStructureType,
5081    pub pNext: *mut c_void,
5082    pub maxWorkGroupCount: [u32; 3 as usize],
5083    pub maxWorkGroupSize: [u32; 3 as usize],
5084    pub maxOutputClusterCount: u32,
5085    pub indirectBufferOffsetAlignment: VkDeviceSize,
5086}
5087
5088#[derive(Clone, Copy)]
5089#[repr(C)]
5090pub struct VkPhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
5091    pub sType: VkStructureType,
5092    pub pNext: *mut c_void,
5093    pub clusterShadingRate: VkBool32,
5094}
5095
5096#[derive(Clone, Copy)]
5097#[repr(C)]
5098pub struct VkPhysicalDeviceCoherentMemoryFeaturesAMD {
5099    pub sType: VkStructureType,
5100    pub pNext: *mut c_void,
5101    pub deviceCoherentMemory: VkBool32,
5102}
5103
5104#[derive(Clone, Copy)]
5105#[repr(C)]
5106pub struct VkPhysicalDeviceColorWriteEnableFeaturesEXT {
5107    pub sType: VkStructureType,
5108    pub pNext: *mut c_void,
5109    pub colorWriteEnable: VkBool32,
5110}
5111
5112#[derive(Clone, Copy)]
5113#[repr(C)]
5114pub struct VkPhysicalDeviceCommandBufferInheritanceFeaturesNV {
5115    pub sType: VkStructureType,
5116    pub pNext: *mut c_void,
5117    pub commandBufferInheritance: VkBool32,
5118}
5119
5120#[derive(Clone, Copy)]
5121#[repr(C)]
5122pub struct VkPhysicalDeviceComputeOccupancyPriorityFeaturesNV {
5123    pub sType: VkStructureType,
5124    pub pNext: *mut c_void,
5125    pub computeOccupancyPriority: VkBool32,
5126}
5127
5128#[derive(Clone, Copy)]
5129#[repr(C)]
5130pub struct VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR {
5131    pub sType: VkStructureType,
5132    pub pNext: *mut c_void,
5133    pub computeDerivativeGroupQuads: VkBool32,
5134    pub computeDerivativeGroupLinear: VkBool32,
5135}
5136
5137#[derive(Clone, Copy)]
5138#[repr(C)]
5139pub struct VkPhysicalDeviceComputeShaderDerivativesPropertiesKHR {
5140    pub sType: VkStructureType,
5141    pub pNext: *mut c_void,
5142    pub meshAndTaskShaderDerivatives: VkBool32,
5143}
5144
5145#[derive(Clone, Copy)]
5146#[repr(C)]
5147pub struct VkPhysicalDeviceConditionalRenderingFeaturesEXT {
5148    pub sType: VkStructureType,
5149    pub pNext: *mut c_void,
5150    pub conditionalRendering: VkBool32,
5151    pub inheritedConditionalRendering: VkBool32,
5152}
5153
5154#[derive(Clone, Copy)]
5155#[repr(C)]
5156pub struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT {
5157    pub sType: VkStructureType,
5158    pub pNext: *mut c_void,
5159    pub primitiveOverestimationSize: f32,
5160    pub maxExtraPrimitiveOverestimationSize: f32,
5161    pub extraPrimitiveOverestimationSizeGranularity: f32,
5162    pub primitiveUnderestimation: VkBool32,
5163    pub conservativePointAndLineRasterization: VkBool32,
5164    pub degenerateTrianglesRasterized: VkBool32,
5165    pub degenerateLinesRasterized: VkBool32,
5166    pub fullyCoveredFragmentShaderInputVariable: VkBool32,
5167    pub conservativeRasterizationPostDepthCoverage: VkBool32,
5168}
5169
5170#[derive(Clone, Copy)]
5171#[repr(C)]
5172pub struct VkPhysicalDeviceCooperativeMatrix2FeaturesNV {
5173    pub sType: VkStructureType,
5174    pub pNext: *mut c_void,
5175    pub cooperativeMatrixWorkgroupScope: VkBool32,
5176    pub cooperativeMatrixFlexibleDimensions: VkBool32,
5177    pub cooperativeMatrixReductions: VkBool32,
5178    pub cooperativeMatrixConversions: VkBool32,
5179    pub cooperativeMatrixPerElementOperations: VkBool32,
5180    pub cooperativeMatrixTensorAddressing: VkBool32,
5181    pub cooperativeMatrixBlockLoads: VkBool32,
5182}
5183
5184#[derive(Clone, Copy)]
5185#[repr(C)]
5186pub struct VkPhysicalDeviceCooperativeMatrix2PropertiesNV {
5187    pub sType: VkStructureType,
5188    pub pNext: *mut c_void,
5189    pub cooperativeMatrixWorkgroupScopeMaxWorkgroupSize: u32,
5190    pub cooperativeMatrixFlexibleDimensionsMaxDimension: u32,
5191    pub cooperativeMatrixWorkgroupScopeReservedSharedMemory: u32,
5192}
5193
5194#[derive(Clone, Copy)]
5195#[repr(C)]
5196pub struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR {
5197    pub sType: VkStructureType,
5198    pub pNext: *mut c_void,
5199    pub cooperativeMatrix: VkBool32,
5200    pub cooperativeMatrixRobustBufferAccess: VkBool32,
5201}
5202
5203#[derive(Clone, Copy)]
5204#[repr(C)]
5205pub struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
5206    pub sType: VkStructureType,
5207    pub pNext: *mut c_void,
5208    pub cooperativeMatrix: VkBool32,
5209    pub cooperativeMatrixRobustBufferAccess: VkBool32,
5210}
5211
5212#[derive(Clone, Copy)]
5213#[repr(C)]
5214pub struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
5215    pub sType: VkStructureType,
5216    pub pNext: *mut c_void,
5217    pub cooperativeMatrixSupportedStages: VkShaderStageFlags,
5218}
5219
5220#[derive(Clone, Copy)]
5221#[repr(C)]
5222pub struct VkPhysicalDeviceCooperativeMatrixPropertiesNV {
5223    pub sType: VkStructureType,
5224    pub pNext: *mut c_void,
5225    pub cooperativeMatrixSupportedStages: VkShaderStageFlags,
5226}
5227
5228#[derive(Clone, Copy)]
5229#[repr(C)]
5230pub struct VkPhysicalDeviceCooperativeVectorFeaturesNV {
5231    pub sType: VkStructureType,
5232    pub pNext: *mut c_void,
5233    pub cooperativeVector: VkBool32,
5234    pub cooperativeVectorTraining: VkBool32,
5235}
5236
5237#[derive(Clone, Copy)]
5238#[repr(C)]
5239pub struct VkPhysicalDeviceCooperativeVectorPropertiesNV {
5240    pub sType: VkStructureType,
5241    pub pNext: *mut c_void,
5242    pub cooperativeVectorSupportedStages: VkShaderStageFlags,
5243    pub cooperativeVectorTrainingFloat16Accumulation: VkBool32,
5244    pub cooperativeVectorTrainingFloat32Accumulation: VkBool32,
5245    pub maxCooperativeVectorComponents: u32,
5246}
5247
5248#[derive(Clone, Copy)]
5249#[repr(C)]
5250pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR {
5251    pub sType: VkStructureType,
5252    pub pNext: *mut c_void,
5253    pub indirectMemoryCopy: VkBool32,
5254    pub indirectMemoryToImageCopy: VkBool32,
5255}
5256
5257#[derive(Clone, Copy)]
5258#[repr(C)]
5259pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
5260    pub sType: VkStructureType,
5261    pub pNext: *mut c_void,
5262    pub indirectCopy: VkBool32,
5263}
5264
5265#[derive(Clone, Copy)]
5266#[repr(C)]
5267pub struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR {
5268    pub sType: VkStructureType,
5269    pub pNext: *mut c_void,
5270    pub supportedQueues: VkQueueFlags,
5271}
5272
5273#[derive(Clone, Copy)]
5274#[repr(C)]
5275pub struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
5276    pub sType: VkStructureType,
5277    pub pNext: *mut c_void,
5278    pub cornerSampledImage: VkBool32,
5279}
5280
5281#[derive(Clone, Copy)]
5282#[repr(C)]
5283pub struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
5284    pub sType: VkStructureType,
5285    pub pNext: *mut c_void,
5286    pub coverageReductionMode: VkBool32,
5287}
5288
5289#[derive(Clone, Copy)]
5290#[repr(C)]
5291pub struct VkPhysicalDeviceCubicClampFeaturesQCOM {
5292    pub sType: VkStructureType,
5293    pub pNext: *mut c_void,
5294    pub cubicRangeClamp: VkBool32,
5295}
5296
5297#[derive(Clone, Copy)]
5298#[repr(C)]
5299pub struct VkPhysicalDeviceCubicWeightsFeaturesQCOM {
5300    pub sType: VkStructureType,
5301    pub pNext: *mut c_void,
5302    pub selectableCubicWeights: VkBool32,
5303}
5304
5305#[derive(Clone, Copy)]
5306#[repr(C)]
5307pub struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
5308    pub sType: VkStructureType,
5309    pub pNext: *mut c_void,
5310    pub customBorderColors: VkBool32,
5311    pub customBorderColorWithoutFormat: VkBool32,
5312}
5313
5314#[derive(Clone, Copy)]
5315#[repr(C)]
5316pub struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
5317    pub sType: VkStructureType,
5318    pub pNext: *mut c_void,
5319    pub maxCustomBorderColorSamplers: u32,
5320}
5321
5322#[derive(Clone, Copy)]
5323#[repr(C)]
5324pub struct VkPhysicalDeviceCustomResolveFeaturesEXT {
5325    pub sType: VkStructureType,
5326    pub pNext: *mut c_void,
5327    pub customResolve: VkBool32,
5328}
5329
5330#[derive(Clone, Copy)]
5331#[repr(C)]
5332pub struct VkPhysicalDeviceDataGraphFeaturesARM {
5333    pub sType: VkStructureType,
5334    pub pNext: *mut c_void,
5335    pub dataGraph: VkBool32,
5336    pub dataGraphUpdateAfterBind: VkBool32,
5337    pub dataGraphSpecializationConstants: VkBool32,
5338    pub dataGraphDescriptorBuffer: VkBool32,
5339    pub dataGraphShaderModule: VkBool32,
5340}
5341
5342#[derive(Clone, Copy)]
5343#[repr(C)]
5344pub struct VkPhysicalDeviceDataGraphModelFeaturesQCOM {
5345    pub sType: VkStructureType,
5346    pub pNext: *mut c_void,
5347    pub dataGraphModel: VkBool32,
5348}
5349
5350#[derive(Clone, Copy)]
5351#[repr(C)]
5352pub struct VkPhysicalDeviceDataGraphOperationSupportARM {
5353    pub operationType: VkPhysicalDeviceDataGraphOperationTypeARM,
5354    pub name: [c_char; VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM as usize],
5355    pub version: u32,
5356}
5357
5358#[derive(Clone, Copy)]
5359#[repr(C)]
5360pub struct VkPhysicalDeviceDataGraphProcessingEngineARM {
5361    pub typ: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
5362    pub isForeign: VkBool32,
5363}
5364
5365#[derive(Clone, Copy)]
5366#[repr(C)]
5367pub struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
5368    pub sType: VkStructureType,
5369    pub pNext: *mut c_void,
5370    pub dedicatedAllocationImageAliasing: VkBool32,
5371}
5372
5373#[derive(Clone, Copy)]
5374#[repr(C)]
5375pub struct VkPhysicalDeviceDepthBiasControlFeaturesEXT {
5376    pub sType: VkStructureType,
5377    pub pNext: *mut c_void,
5378    pub depthBiasControl: VkBool32,
5379    pub leastRepresentableValueForceUnormRepresentation: VkBool32,
5380    pub floatRepresentation: VkBool32,
5381    pub depthBiasExact: VkBool32,
5382}
5383
5384#[derive(Clone, Copy)]
5385#[repr(C)]
5386pub struct VkPhysicalDeviceDepthClampControlFeaturesEXT {
5387    pub sType: VkStructureType,
5388    pub pNext: *mut c_void,
5389    pub depthClampControl: VkBool32,
5390}
5391
5392#[derive(Clone, Copy)]
5393#[repr(C)]
5394pub struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
5395    pub sType: VkStructureType,
5396    pub pNext: *mut c_void,
5397    pub depthClampZeroOne: VkBool32,
5398}
5399
5400#[derive(Clone, Copy)]
5401#[repr(C)]
5402pub struct VkPhysicalDeviceDepthClipControlFeaturesEXT {
5403    pub sType: VkStructureType,
5404    pub pNext: *mut c_void,
5405    pub depthClipControl: VkBool32,
5406}
5407
5408#[derive(Clone, Copy)]
5409#[repr(C)]
5410pub struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
5411    pub sType: VkStructureType,
5412    pub pNext: *mut c_void,
5413    pub depthClipEnable: VkBool32,
5414}
5415
5416#[derive(Clone, Copy)]
5417#[repr(C)]
5418pub struct VkPhysicalDeviceDepthStencilResolveProperties {
5419    pub sType: VkStructureType,
5420    pub pNext: *mut c_void,
5421    pub supportedDepthResolveModes: VkResolveModeFlags,
5422    pub supportedStencilResolveModes: VkResolveModeFlags,
5423    pub independentResolveNone: VkBool32,
5424    pub independentResolve: VkBool32,
5425}
5426
5427#[derive(Clone, Copy)]
5428#[repr(C)]
5429pub struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
5430    pub sType: VkStructureType,
5431    pub pNext: *mut c_void,
5432    pub combinedImageSamplerDensityMapDescriptorSize: usize,
5433}
5434
5435#[derive(Clone, Copy)]
5436#[repr(C)]
5437pub struct VkPhysicalDeviceDescriptorBufferFeaturesEXT {
5438    pub sType: VkStructureType,
5439    pub pNext: *mut c_void,
5440    pub descriptorBuffer: VkBool32,
5441    pub descriptorBufferCaptureReplay: VkBool32,
5442    pub descriptorBufferImageLayoutIgnored: VkBool32,
5443    pub descriptorBufferPushDescriptors: VkBool32,
5444}
5445
5446#[derive(Clone, Copy)]
5447#[repr(C)]
5448pub struct VkPhysicalDeviceDescriptorBufferPropertiesEXT {
5449    pub sType: VkStructureType,
5450    pub pNext: *mut c_void,
5451    pub combinedImageSamplerDescriptorSingleArray: VkBool32,
5452    pub bufferlessPushDescriptors: VkBool32,
5453    pub allowSamplerImageViewPostSubmitCreation: VkBool32,
5454    pub descriptorBufferOffsetAlignment: VkDeviceSize,
5455    pub maxDescriptorBufferBindings: u32,
5456    pub maxResourceDescriptorBufferBindings: u32,
5457    pub maxSamplerDescriptorBufferBindings: u32,
5458    pub maxEmbeddedImmutableSamplerBindings: u32,
5459    pub maxEmbeddedImmutableSamplers: u32,
5460    pub bufferCaptureReplayDescriptorDataSize: usize,
5461    pub imageCaptureReplayDescriptorDataSize: usize,
5462    pub imageViewCaptureReplayDescriptorDataSize: usize,
5463    pub samplerCaptureReplayDescriptorDataSize: usize,
5464    pub accelerationStructureCaptureReplayDescriptorDataSize: usize,
5465    pub samplerDescriptorSize: usize,
5466    pub combinedImageSamplerDescriptorSize: usize,
5467    pub sampledImageDescriptorSize: usize,
5468    pub storageImageDescriptorSize: usize,
5469    pub uniformTexelBufferDescriptorSize: usize,
5470    pub robustUniformTexelBufferDescriptorSize: usize,
5471    pub storageTexelBufferDescriptorSize: usize,
5472    pub robustStorageTexelBufferDescriptorSize: usize,
5473    pub uniformBufferDescriptorSize: usize,
5474    pub robustUniformBufferDescriptorSize: usize,
5475    pub storageBufferDescriptorSize: usize,
5476    pub robustStorageBufferDescriptorSize: usize,
5477    pub inputAttachmentDescriptorSize: usize,
5478    pub accelerationStructureDescriptorSize: usize,
5479    pub maxSamplerDescriptorBufferRange: VkDeviceSize,
5480    pub maxResourceDescriptorBufferRange: VkDeviceSize,
5481    pub samplerDescriptorBufferAddressSpaceSize: VkDeviceSize,
5482    pub resourceDescriptorBufferAddressSpaceSize: VkDeviceSize,
5483    pub descriptorBufferAddressSpaceSize: VkDeviceSize,
5484}
5485
5486#[derive(Clone, Copy)]
5487#[repr(C)]
5488pub struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM {
5489    pub sType: VkStructureType,
5490    pub pNext: *mut c_void,
5491    pub descriptorBufferTensorDescriptors: VkBool32,
5492}
5493
5494#[derive(Clone, Copy)]
5495#[repr(C)]
5496pub struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM {
5497    pub sType: VkStructureType,
5498    pub pNext: *mut c_void,
5499    pub tensorCaptureReplayDescriptorDataSize: usize,
5500    pub tensorViewCaptureReplayDescriptorDataSize: usize,
5501    pub tensorDescriptorSize: usize,
5502}
5503
5504#[derive(Clone, Copy)]
5505#[repr(C)]
5506pub struct VkPhysicalDeviceDescriptorHeapFeaturesEXT {
5507    pub sType: VkStructureType,
5508    pub pNext: *mut c_void,
5509    pub descriptorHeap: VkBool32,
5510    pub descriptorHeapCaptureReplay: VkBool32,
5511}
5512
5513#[derive(Clone, Copy)]
5514#[repr(C)]
5515pub struct VkPhysicalDeviceDescriptorHeapPropertiesEXT {
5516    pub sType: VkStructureType,
5517    pub pNext: *mut c_void,
5518    pub samplerHeapAlignment: VkDeviceSize,
5519    pub resourceHeapAlignment: VkDeviceSize,
5520    pub maxSamplerHeapSize: VkDeviceSize,
5521    pub maxResourceHeapSize: VkDeviceSize,
5522    pub minSamplerHeapReservedRange: VkDeviceSize,
5523    pub minSamplerHeapReservedRangeWithEmbedded: VkDeviceSize,
5524    pub minResourceHeapReservedRange: VkDeviceSize,
5525    pub samplerDescriptorSize: VkDeviceSize,
5526    pub imageDescriptorSize: VkDeviceSize,
5527    pub bufferDescriptorSize: VkDeviceSize,
5528    pub samplerDescriptorAlignment: VkDeviceSize,
5529    pub imageDescriptorAlignment: VkDeviceSize,
5530    pub bufferDescriptorAlignment: VkDeviceSize,
5531    pub maxPushDataSize: VkDeviceSize,
5532    pub imageCaptureReplayOpaqueDataSize: usize,
5533    pub maxDescriptorHeapEmbeddedSamplers: u32,
5534    pub samplerYcbcrConversionCount: u32,
5535    pub sparseDescriptorHeaps: VkBool32,
5536    pub protectedDescriptorHeaps: VkBool32,
5537}
5538
5539#[derive(Clone, Copy)]
5540#[repr(C)]
5541pub struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM {
5542    pub sType: VkStructureType,
5543    pub pNext: *mut c_void,
5544    pub tensorDescriptorSize: VkDeviceSize,
5545    pub tensorDescriptorAlignment: VkDeviceSize,
5546    pub tensorCaptureReplayOpaqueDataSize: usize,
5547}
5548
5549#[derive(Clone, Copy)]
5550#[repr(C)]
5551pub struct VkPhysicalDeviceDescriptorIndexingFeatures {
5552    pub sType: VkStructureType,
5553    pub pNext: *mut c_void,
5554    pub shaderInputAttachmentArrayDynamicIndexing: VkBool32,
5555    pub shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
5556    pub shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
5557    pub shaderUniformBufferArrayNonUniformIndexing: VkBool32,
5558    pub shaderSampledImageArrayNonUniformIndexing: VkBool32,
5559    pub shaderStorageBufferArrayNonUniformIndexing: VkBool32,
5560    pub shaderStorageImageArrayNonUniformIndexing: VkBool32,
5561    pub shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
5562    pub shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
5563    pub shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
5564    pub descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
5565    pub descriptorBindingSampledImageUpdateAfterBind: VkBool32,
5566    pub descriptorBindingStorageImageUpdateAfterBind: VkBool32,
5567    pub descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
5568    pub descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
5569    pub descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
5570    pub descriptorBindingUpdateUnusedWhilePending: VkBool32,
5571    pub descriptorBindingPartiallyBound: VkBool32,
5572    pub descriptorBindingVariableDescriptorCount: VkBool32,
5573    pub runtimeDescriptorArray: VkBool32,
5574}
5575
5576#[derive(Clone, Copy)]
5577#[repr(C)]
5578pub struct VkPhysicalDeviceDescriptorIndexingProperties {
5579    pub sType: VkStructureType,
5580    pub pNext: *mut c_void,
5581    pub maxUpdateAfterBindDescriptorsInAllPools: u32,
5582    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
5583    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
5584    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
5585    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
5586    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
5587    pub robustBufferAccessUpdateAfterBind: VkBool32,
5588    pub quadDivergentImplicitLod: VkBool32,
5589    pub maxPerStageDescriptorUpdateAfterBindSamplers: u32,
5590    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
5591    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
5592    pub maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
5593    pub maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
5594    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
5595    pub maxPerStageUpdateAfterBindResources: u32,
5596    pub maxDescriptorSetUpdateAfterBindSamplers: u32,
5597    pub maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
5598    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
5599    pub maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
5600    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
5601    pub maxDescriptorSetUpdateAfterBindSampledImages: u32,
5602    pub maxDescriptorSetUpdateAfterBindStorageImages: u32,
5603    pub maxDescriptorSetUpdateAfterBindInputAttachments: u32,
5604}
5605
5606#[derive(Clone, Copy)]
5607#[repr(C)]
5608pub struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
5609    pub sType: VkStructureType,
5610    pub pNext: *mut c_void,
5611    pub descriptorPoolOverallocation: VkBool32,
5612}
5613
5614#[derive(Clone, Copy)]
5615#[repr(C)]
5616pub struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
5617    pub sType: VkStructureType,
5618    pub pNext: *mut c_void,
5619    pub descriptorSetHostMapping: VkBool32,
5620}
5621
5622#[derive(Clone, Copy)]
5623#[repr(C)]
5624pub struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
5625    pub sType: VkStructureType,
5626    pub pNext: *mut c_void,
5627    pub deviceGeneratedCompute: VkBool32,
5628    pub deviceGeneratedComputePipelines: VkBool32,
5629    pub deviceGeneratedComputeCaptureReplay: VkBool32,
5630}
5631
5632#[derive(Clone, Copy)]
5633#[repr(C)]
5634pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
5635    pub sType: VkStructureType,
5636    pub pNext: *mut c_void,
5637    pub deviceGeneratedCommands: VkBool32,
5638    pub dynamicGeneratedPipelineLayout: VkBool32,
5639}
5640
5641#[derive(Clone, Copy)]
5642#[repr(C)]
5643pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
5644    pub sType: VkStructureType,
5645    pub pNext: *mut c_void,
5646    pub deviceGeneratedCommands: VkBool32,
5647}
5648
5649#[derive(Clone, Copy)]
5650#[repr(C)]
5651pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
5652    pub sType: VkStructureType,
5653    pub pNext: *mut c_void,
5654    pub maxIndirectPipelineCount: u32,
5655    pub maxIndirectShaderObjectCount: u32,
5656    pub maxIndirectSequenceCount: u32,
5657    pub maxIndirectCommandsTokenCount: u32,
5658    pub maxIndirectCommandsTokenOffset: u32,
5659    pub maxIndirectCommandsIndirectStride: u32,
5660    pub supportedIndirectCommandsInputModes: VkIndirectCommandsInputModeFlagsEXT,
5661    pub supportedIndirectCommandsShaderStages: VkShaderStageFlags,
5662    pub supportedIndirectCommandsShaderStagesPipelineBinding: VkShaderStageFlags,
5663    pub supportedIndirectCommandsShaderStagesShaderBinding: VkShaderStageFlags,
5664    pub deviceGeneratedCommandsTransformFeedback: VkBool32,
5665    pub deviceGeneratedCommandsMultiDrawIndirectCount: VkBool32,
5666}
5667
5668#[derive(Clone, Copy)]
5669#[repr(C)]
5670pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
5671    pub sType: VkStructureType,
5672    pub pNext: *mut c_void,
5673    pub maxGraphicsShaderGroupCount: u32,
5674    pub maxIndirectSequenceCount: u32,
5675    pub maxIndirectCommandsTokenCount: u32,
5676    pub maxIndirectCommandsStreamCount: u32,
5677    pub maxIndirectCommandsTokenOffset: u32,
5678    pub maxIndirectCommandsStreamStride: u32,
5679    pub minSequencesCountBufferOffsetAlignment: u32,
5680    pub minSequencesIndexBufferOffsetAlignment: u32,
5681    pub minIndirectCommandsBufferOffsetAlignment: u32,
5682}
5683
5684#[derive(Clone, Copy)]
5685#[repr(C)]
5686pub struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
5687    pub sType: VkStructureType,
5688    pub pNext: *mut c_void,
5689    pub deviceMemoryReport: VkBool32,
5690}
5691
5692#[derive(Clone, Copy)]
5693#[repr(C)]
5694pub struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
5695    pub sType: VkStructureType,
5696    pub pNext: *mut c_void,
5697    pub diagnosticsConfig: VkBool32,
5698}
5699
5700#[derive(Clone, Copy)]
5701#[repr(C)]
5702pub struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
5703    pub sType: VkStructureType,
5704    pub pNext: *mut c_void,
5705    pub maxDiscardRectangles: u32,
5706}
5707
5708#[derive(Clone, Copy)]
5709#[repr(C)]
5710pub struct VkPhysicalDeviceDriverProperties {
5711    pub sType: VkStructureType,
5712    pub pNext: *mut c_void,
5713    pub driverID: VkDriverId,
5714    pub driverName: [c_char; VK_MAX_DRIVER_NAME_SIZE as usize],
5715    pub driverInfo: [c_char; VK_MAX_DRIVER_INFO_SIZE as usize],
5716    pub conformanceVersion: VkConformanceVersion,
5717}
5718
5719#[derive(Clone, Copy)]
5720#[repr(C)]
5721pub struct VkPhysicalDeviceDrmPropertiesEXT {
5722    pub sType: VkStructureType,
5723    pub pNext: *mut c_void,
5724    pub hasPrimary: VkBool32,
5725    pub hasRender: VkBool32,
5726    pub primaryMajor: i64,
5727    pub primaryMinor: i64,
5728    pub renderMajor: i64,
5729    pub renderMinor: i64,
5730}
5731
5732#[derive(Clone, Copy)]
5733#[repr(C)]
5734pub struct VkPhysicalDeviceDynamicRenderingFeatures {
5735    pub sType: VkStructureType,
5736    pub pNext: *mut c_void,
5737    pub dynamicRendering: VkBool32,
5738}
5739
5740#[derive(Clone, Copy)]
5741#[repr(C)]
5742pub struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures {
5743    pub sType: VkStructureType,
5744    pub pNext: *mut c_void,
5745    pub dynamicRenderingLocalRead: VkBool32,
5746}
5747
5748#[derive(Clone, Copy)]
5749#[repr(C)]
5750pub struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
5751    pub sType: VkStructureType,
5752    pub pNext: *mut c_void,
5753    pub dynamicRenderingUnusedAttachments: VkBool32,
5754}
5755
5756#[derive(Clone, Copy)]
5757#[repr(C)]
5758pub struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
5759    pub sType: VkStructureType,
5760    pub pNext: *mut c_void,
5761    pub exclusiveScissor: VkBool32,
5762}
5763
5764#[derive(Clone, Copy)]
5765#[repr(C)]
5766pub struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
5767    pub sType: VkStructureType,
5768    pub pNext: *mut c_void,
5769    pub extendedDynamicState2: VkBool32,
5770    pub extendedDynamicState2LogicOp: VkBool32,
5771    pub extendedDynamicState2PatchControlPoints: VkBool32,
5772}
5773
5774#[derive(Clone, Copy)]
5775#[repr(C)]
5776pub struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
5777    pub sType: VkStructureType,
5778    pub pNext: *mut c_void,
5779    pub extendedDynamicState3TessellationDomainOrigin: VkBool32,
5780    pub extendedDynamicState3DepthClampEnable: VkBool32,
5781    pub extendedDynamicState3PolygonMode: VkBool32,
5782    pub extendedDynamicState3RasterizationSamples: VkBool32,
5783    pub extendedDynamicState3SampleMask: VkBool32,
5784    pub extendedDynamicState3AlphaToCoverageEnable: VkBool32,
5785    pub extendedDynamicState3AlphaToOneEnable: VkBool32,
5786    pub extendedDynamicState3LogicOpEnable: VkBool32,
5787    pub extendedDynamicState3ColorBlendEnable: VkBool32,
5788    pub extendedDynamicState3ColorBlendEquation: VkBool32,
5789    pub extendedDynamicState3ColorWriteMask: VkBool32,
5790    pub extendedDynamicState3RasterizationStream: VkBool32,
5791    pub extendedDynamicState3ConservativeRasterizationMode: VkBool32,
5792    pub extendedDynamicState3ExtraPrimitiveOverestimationSize: VkBool32,
5793    pub extendedDynamicState3DepthClipEnable: VkBool32,
5794    pub extendedDynamicState3SampleLocationsEnable: VkBool32,
5795    pub extendedDynamicState3ColorBlendAdvanced: VkBool32,
5796    pub extendedDynamicState3ProvokingVertexMode: VkBool32,
5797    pub extendedDynamicState3LineRasterizationMode: VkBool32,
5798    pub extendedDynamicState3LineStippleEnable: VkBool32,
5799    pub extendedDynamicState3DepthClipNegativeOneToOne: VkBool32,
5800    pub extendedDynamicState3ViewportWScalingEnable: VkBool32,
5801    pub extendedDynamicState3ViewportSwizzle: VkBool32,
5802    pub extendedDynamicState3CoverageToColorEnable: VkBool32,
5803    pub extendedDynamicState3CoverageToColorLocation: VkBool32,
5804    pub extendedDynamicState3CoverageModulationMode: VkBool32,
5805    pub extendedDynamicState3CoverageModulationTableEnable: VkBool32,
5806    pub extendedDynamicState3CoverageModulationTable: VkBool32,
5807    pub extendedDynamicState3CoverageReductionMode: VkBool32,
5808    pub extendedDynamicState3RepresentativeFragmentTestEnable: VkBool32,
5809    pub extendedDynamicState3ShadingRateImageEnable: VkBool32,
5810}
5811
5812#[derive(Clone, Copy)]
5813#[repr(C)]
5814pub struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
5815    pub sType: VkStructureType,
5816    pub pNext: *mut c_void,
5817    pub dynamicPrimitiveTopologyUnrestricted: VkBool32,
5818}
5819
5820#[derive(Clone, Copy)]
5821#[repr(C)]
5822pub struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
5823    pub sType: VkStructureType,
5824    pub pNext: *mut c_void,
5825    pub extendedDynamicState: VkBool32,
5826}
5827
5828#[derive(Clone, Copy)]
5829#[repr(C)]
5830pub struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
5831    pub sType: VkStructureType,
5832    pub pNext: *mut c_void,
5833    pub extendedSparseAddressSpace: VkBool32,
5834}
5835
5836#[derive(Clone, Copy)]
5837#[repr(C)]
5838pub struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
5839    pub sType: VkStructureType,
5840    pub pNext: *mut c_void,
5841    pub extendedSparseAddressSpaceSize: VkDeviceSize,
5842    pub extendedSparseImageUsageFlags: VkImageUsageFlags,
5843    pub extendedSparseBufferUsageFlags: VkBufferUsageFlags,
5844}
5845
5846#[derive(Clone, Copy)]
5847#[repr(C)]
5848pub struct VkPhysicalDeviceExternalBufferInfo {
5849    pub sType: VkStructureType,
5850    pub pNext: *const c_void,
5851    pub flags: VkBufferCreateFlags,
5852    pub usage: VkBufferUsageFlags,
5853    pub handleType: VkExternalMemoryHandleTypeFlagBits,
5854}
5855
5856#[derive(Clone, Copy)]
5857#[repr(C)]
5858pub struct VkPhysicalDeviceExternalComputeQueuePropertiesNV {
5859    pub sType: VkStructureType,
5860    pub pNext: *mut c_void,
5861    pub externalDataSize: u32,
5862    pub maxExternalQueues: u32,
5863}
5864
5865#[derive(Clone, Copy)]
5866#[repr(C)]
5867pub struct VkPhysicalDeviceExternalFenceInfo {
5868    pub sType: VkStructureType,
5869    pub pNext: *const c_void,
5870    pub handleType: VkExternalFenceHandleTypeFlagBits,
5871}
5872
5873#[derive(Clone, Copy)]
5874#[repr(C)]
5875pub struct VkPhysicalDeviceExternalImageFormatInfo {
5876    pub sType: VkStructureType,
5877    pub pNext: *const c_void,
5878    pub handleType: VkExternalMemoryHandleTypeFlagBits,
5879}
5880
5881#[derive(Clone, Copy)]
5882#[repr(C)]
5883pub struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
5884    pub sType: VkStructureType,
5885    pub pNext: *mut c_void,
5886    pub minImportedHostPointerAlignment: VkDeviceSize,
5887}
5888
5889#[derive(Clone, Copy)]
5890#[repr(C)]
5891pub struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
5892    pub sType: VkStructureType,
5893    pub pNext: *mut c_void,
5894    pub externalMemoryRDMA: VkBool32,
5895}
5896
5897#[derive(Clone, Copy)]
5898#[repr(C)]
5899pub struct VkPhysicalDeviceExternalSemaphoreInfo {
5900    pub sType: VkStructureType,
5901    pub pNext: *const c_void,
5902    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
5903}
5904
5905#[derive(Clone, Copy)]
5906#[repr(C)]
5907pub struct VkPhysicalDeviceExternalTensorInfoARM {
5908    pub sType: VkStructureType,
5909    pub pNext: *const c_void,
5910    pub flags: VkTensorCreateFlagsARM,
5911    pub pDescription: *const VkTensorDescriptionARM,
5912    pub handleType: VkExternalMemoryHandleTypeFlagBits,
5913}
5914
5915#[derive(Clone, Copy)]
5916#[repr(C)]
5917pub struct VkPhysicalDeviceFaultFeaturesEXT {
5918    pub sType: VkStructureType,
5919    pub pNext: *mut c_void,
5920    pub deviceFault: VkBool32,
5921    pub deviceFaultVendorBinary: VkBool32,
5922}
5923
5924#[derive(Clone, Copy)]
5925#[repr(C)]
5926pub struct VkPhysicalDeviceFeatures {
5927    pub robustBufferAccess: VkBool32,
5928    pub fullDrawIndexUint32: VkBool32,
5929    pub imageCubeArray: VkBool32,
5930    pub independentBlend: VkBool32,
5931    pub geometryShader: VkBool32,
5932    pub tessellationShader: VkBool32,
5933    pub sampleRateShading: VkBool32,
5934    pub dualSrcBlend: VkBool32,
5935    pub logicOp: VkBool32,
5936    pub multiDrawIndirect: VkBool32,
5937    pub drawIndirectFirstInstance: VkBool32,
5938    pub depthClamp: VkBool32,
5939    pub depthBiasClamp: VkBool32,
5940    pub fillModeNonSolid: VkBool32,
5941    pub depthBounds: VkBool32,
5942    pub wideLines: VkBool32,
5943    pub largePoints: VkBool32,
5944    pub alphaToOne: VkBool32,
5945    pub multiViewport: VkBool32,
5946    pub samplerAnisotropy: VkBool32,
5947    pub textureCompressionETC2: VkBool32,
5948    pub textureCompressionASTC_LDR: VkBool32,
5949    pub textureCompressionBC: VkBool32,
5950    pub occlusionQueryPrecise: VkBool32,
5951    pub pipelineStatisticsQuery: VkBool32,
5952    pub vertexPipelineStoresAndAtomics: VkBool32,
5953    pub fragmentStoresAndAtomics: VkBool32,
5954    pub shaderTessellationAndGeometryPointSize: VkBool32,
5955    pub shaderImageGatherExtended: VkBool32,
5956    pub shaderStorageImageExtendedFormats: VkBool32,
5957    pub shaderStorageImageMultisample: VkBool32,
5958    pub shaderStorageImageReadWithoutFormat: VkBool32,
5959    pub shaderStorageImageWriteWithoutFormat: VkBool32,
5960    pub shaderUniformBufferArrayDynamicIndexing: VkBool32,
5961    pub shaderSampledImageArrayDynamicIndexing: VkBool32,
5962    pub shaderStorageBufferArrayDynamicIndexing: VkBool32,
5963    pub shaderStorageImageArrayDynamicIndexing: VkBool32,
5964    pub shaderClipDistance: VkBool32,
5965    pub shaderCullDistance: VkBool32,
5966    pub shaderFloat64: VkBool32,
5967    pub shaderInt64: VkBool32,
5968    pub shaderInt16: VkBool32,
5969    pub shaderResourceResidency: VkBool32,
5970    pub shaderResourceMinLod: VkBool32,
5971    pub sparseBinding: VkBool32,
5972    pub sparseResidencyBuffer: VkBool32,
5973    pub sparseResidencyImage2D: VkBool32,
5974    pub sparseResidencyImage3D: VkBool32,
5975    pub sparseResidency2Samples: VkBool32,
5976    pub sparseResidency4Samples: VkBool32,
5977    pub sparseResidency8Samples: VkBool32,
5978    pub sparseResidency16Samples: VkBool32,
5979    pub sparseResidencyAliased: VkBool32,
5980    pub variableMultisampleRate: VkBool32,
5981    pub inheritedQueries: VkBool32,
5982}
5983
5984#[derive(Clone, Copy)]
5985#[repr(C)]
5986pub struct VkPhysicalDeviceFeatures2 {
5987    pub sType: VkStructureType,
5988    pub pNext: *mut c_void,
5989    pub features: VkPhysicalDeviceFeatures,
5990}
5991
5992#[derive(Clone, Copy)]
5993#[repr(C)]
5994pub struct VkPhysicalDeviceFloatControlsProperties {
5995    pub sType: VkStructureType,
5996    pub pNext: *mut c_void,
5997    pub denormBehaviorIndependence: VkShaderFloatControlsIndependence,
5998    pub roundingModeIndependence: VkShaderFloatControlsIndependence,
5999    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
6000    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
6001    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
6002    pub shaderDenormPreserveFloat16: VkBool32,
6003    pub shaderDenormPreserveFloat32: VkBool32,
6004    pub shaderDenormPreserveFloat64: VkBool32,
6005    pub shaderDenormFlushToZeroFloat16: VkBool32,
6006    pub shaderDenormFlushToZeroFloat32: VkBool32,
6007    pub shaderDenormFlushToZeroFloat64: VkBool32,
6008    pub shaderRoundingModeRTEFloat16: VkBool32,
6009    pub shaderRoundingModeRTEFloat32: VkBool32,
6010    pub shaderRoundingModeRTEFloat64: VkBool32,
6011    pub shaderRoundingModeRTZFloat16: VkBool32,
6012    pub shaderRoundingModeRTZFloat32: VkBool32,
6013    pub shaderRoundingModeRTZFloat64: VkBool32,
6014}
6015
6016#[derive(Clone, Copy)]
6017#[repr(C)]
6018pub struct VkPhysicalDeviceFormatPackFeaturesARM {
6019    pub sType: VkStructureType,
6020    pub pNext: *mut c_void,
6021    pub formatPack: VkBool32,
6022}
6023
6024#[derive(Clone, Copy)]
6025#[repr(C)]
6026pub struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
6027    pub sType: VkStructureType,
6028    pub pNext: *mut c_void,
6029    pub fragmentDensityMapDeferred: VkBool32,
6030}
6031
6032#[derive(Clone, Copy)]
6033#[repr(C)]
6034pub struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
6035    pub sType: VkStructureType,
6036    pub pNext: *mut c_void,
6037    pub subsampledLoads: VkBool32,
6038    pub subsampledCoarseReconstructionEarlyAccess: VkBool32,
6039    pub maxSubsampledArrayLayers: u32,
6040    pub maxDescriptorSetSubsampledSamplers: u32,
6041}
6042
6043#[derive(Clone, Copy)]
6044#[repr(C)]
6045pub struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
6046    pub sType: VkStructureType,
6047    pub pNext: *mut c_void,
6048    pub fragmentDensityMap: VkBool32,
6049    pub fragmentDensityMapDynamic: VkBool32,
6050    pub fragmentDensityMapNonSubsampledImages: VkBool32,
6051}
6052
6053#[derive(Clone, Copy)]
6054#[repr(C)]
6055pub struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {
6056    pub sType: VkStructureType,
6057    pub pNext: *mut c_void,
6058    pub fragmentDensityMapLayered: VkBool32,
6059}
6060
6061#[derive(Clone, Copy)]
6062#[repr(C)]
6063pub struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {
6064    pub sType: VkStructureType,
6065    pub pNext: *mut c_void,
6066    pub maxFragmentDensityMapLayers: u32,
6067}
6068
6069#[derive(Clone, Copy)]
6070#[repr(C)]
6071pub struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
6072    pub sType: VkStructureType,
6073    pub pNext: *mut c_void,
6074    pub fragmentDensityMapOffset: VkBool32,
6075}
6076
6077#[derive(Clone, Copy)]
6078#[repr(C)]
6079pub struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
6080    pub sType: VkStructureType,
6081    pub pNext: *mut c_void,
6082    pub fragmentDensityOffsetGranularity: VkExtent2D,
6083}
6084
6085#[derive(Clone, Copy)]
6086#[repr(C)]
6087pub struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
6088    pub sType: VkStructureType,
6089    pub pNext: *mut c_void,
6090    pub minFragmentDensityTexelSize: VkExtent2D,
6091    pub maxFragmentDensityTexelSize: VkExtent2D,
6092    pub fragmentDensityInvocations: VkBool32,
6093}
6094
6095#[derive(Clone, Copy)]
6096#[repr(C)]
6097pub struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
6098    pub sType: VkStructureType,
6099    pub pNext: *mut c_void,
6100    pub fragmentShaderBarycentric: VkBool32,
6101}
6102
6103#[derive(Clone, Copy)]
6104#[repr(C)]
6105pub struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
6106    pub sType: VkStructureType,
6107    pub pNext: *mut c_void,
6108    pub triStripVertexOrderIndependentOfProvokingVertex: VkBool32,
6109}
6110
6111#[derive(Clone, Copy)]
6112#[repr(C)]
6113pub struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
6114    pub sType: VkStructureType,
6115    pub pNext: *mut c_void,
6116    pub fragmentShaderSampleInterlock: VkBool32,
6117    pub fragmentShaderPixelInterlock: VkBool32,
6118    pub fragmentShaderShadingRateInterlock: VkBool32,
6119}
6120
6121#[derive(Clone, Copy)]
6122#[repr(C)]
6123pub struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
6124    pub sType: VkStructureType,
6125    pub pNext: *mut c_void,
6126    pub fragmentShadingRateEnums: VkBool32,
6127    pub supersampleFragmentShadingRates: VkBool32,
6128    pub noInvocationFragmentShadingRates: VkBool32,
6129}
6130
6131#[derive(Clone, Copy)]
6132#[repr(C)]
6133pub struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
6134    pub sType: VkStructureType,
6135    pub pNext: *mut c_void,
6136    pub maxFragmentShadingRateInvocationCount: VkSampleCountFlagBits,
6137}
6138
6139#[derive(Clone, Copy)]
6140#[repr(C)]
6141pub struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
6142    pub sType: VkStructureType,
6143    pub pNext: *mut c_void,
6144    pub pipelineFragmentShadingRate: VkBool32,
6145    pub primitiveFragmentShadingRate: VkBool32,
6146    pub attachmentFragmentShadingRate: VkBool32,
6147}
6148
6149#[derive(Clone, Copy)]
6150#[repr(C)]
6151pub struct VkPhysicalDeviceFragmentShadingRateKHR {
6152    pub sType: VkStructureType,
6153    pub pNext: *mut c_void,
6154    pub sampleCounts: VkSampleCountFlags,
6155    pub fragmentSize: VkExtent2D,
6156}
6157
6158#[derive(Clone, Copy)]
6159#[repr(C)]
6160pub struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
6161    pub sType: VkStructureType,
6162    pub pNext: *mut c_void,
6163    pub minFragmentShadingRateAttachmentTexelSize: VkExtent2D,
6164    pub maxFragmentShadingRateAttachmentTexelSize: VkExtent2D,
6165    pub maxFragmentShadingRateAttachmentTexelSizeAspectRatio: u32,
6166    pub primitiveFragmentShadingRateWithMultipleViewports: VkBool32,
6167    pub layeredShadingRateAttachments: VkBool32,
6168    pub fragmentShadingRateNonTrivialCombinerOps: VkBool32,
6169    pub maxFragmentSize: VkExtent2D,
6170    pub maxFragmentSizeAspectRatio: u32,
6171    pub maxFragmentShadingRateCoverageSamples: u32,
6172    pub maxFragmentShadingRateRasterizationSamples: VkSampleCountFlagBits,
6173    pub fragmentShadingRateWithShaderDepthStencilWrites: VkBool32,
6174    pub fragmentShadingRateWithSampleMask: VkBool32,
6175    pub fragmentShadingRateWithShaderSampleMask: VkBool32,
6176    pub fragmentShadingRateWithConservativeRasterization: VkBool32,
6177    pub fragmentShadingRateWithFragmentShaderInterlock: VkBool32,
6178    pub fragmentShadingRateWithCustomSampleLocations: VkBool32,
6179    pub fragmentShadingRateStrictMultiplyCombiner: VkBool32,
6180}
6181
6182#[derive(Clone, Copy)]
6183#[repr(C)]
6184pub struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
6185    pub sType: VkStructureType,
6186    pub pNext: *mut c_void,
6187    pub frameBoundary: VkBool32,
6188}
6189
6190#[derive(Clone, Copy)]
6191#[repr(C)]
6192pub struct VkPhysicalDeviceGlobalPriorityQueryFeatures {
6193    pub sType: VkStructureType,
6194    pub pNext: *mut c_void,
6195    pub globalPriorityQuery: VkBool32,
6196}
6197
6198#[derive(Clone, Copy)]
6199#[repr(C)]
6200pub struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
6201    pub sType: VkStructureType,
6202    pub pNext: *mut c_void,
6203    pub graphicsPipelineLibrary: VkBool32,
6204}
6205
6206#[derive(Clone, Copy)]
6207#[repr(C)]
6208pub struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
6209    pub sType: VkStructureType,
6210    pub pNext: *mut c_void,
6211    pub graphicsPipelineLibraryFastLinking: VkBool32,
6212    pub graphicsPipelineLibraryIndependentInterpolationDecoration: VkBool32,
6213}
6214
6215#[derive(Clone, Copy)]
6216#[repr(C)]
6217pub struct VkPhysicalDeviceGroupProperties {
6218    pub sType: VkStructureType,
6219    pub pNext: *mut c_void,
6220    pub physicalDeviceCount: u32,
6221    pub physicalDevices: [VkPhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE as usize],
6222    pub subsetAllocation: VkBool32,
6223}
6224
6225#[derive(Clone, Copy)]
6226#[repr(C)]
6227pub struct VkPhysicalDeviceHdrVividFeaturesHUAWEI {
6228    pub sType: VkStructureType,
6229    pub pNext: *mut c_void,
6230    pub hdrVivid: VkBool32,
6231}
6232
6233#[derive(Clone, Copy)]
6234#[repr(C)]
6235pub struct VkPhysicalDeviceHostImageCopyFeatures {
6236    pub sType: VkStructureType,
6237    pub pNext: *mut c_void,
6238    pub hostImageCopy: VkBool32,
6239}
6240
6241#[derive(Clone, Copy)]
6242#[repr(C)]
6243pub struct VkPhysicalDeviceHostImageCopyProperties {
6244    pub sType: VkStructureType,
6245    pub pNext: *mut c_void,
6246    pub copySrcLayoutCount: u32,
6247    pub pCopySrcLayouts: *mut VkImageLayout,
6248    pub copyDstLayoutCount: u32,
6249    pub pCopyDstLayouts: *mut VkImageLayout,
6250    pub optimalTilingLayoutUUID: [u8; VK_UUID_SIZE as usize],
6251    pub identicalMemoryTypeRequirements: VkBool32,
6252}
6253
6254#[derive(Clone, Copy)]
6255#[repr(C)]
6256pub struct VkPhysicalDeviceHostQueryResetFeatures {
6257    pub sType: VkStructureType,
6258    pub pNext: *mut c_void,
6259    pub hostQueryReset: VkBool32,
6260}
6261
6262#[derive(Clone, Copy)]
6263#[repr(C)]
6264pub struct VkPhysicalDeviceIDProperties {
6265    pub sType: VkStructureType,
6266    pub pNext: *mut c_void,
6267    pub deviceUUID: [u8; VK_UUID_SIZE as usize],
6268    pub driverUUID: [u8; VK_UUID_SIZE as usize],
6269    pub deviceLUID: [u8; VK_LUID_SIZE as usize],
6270    pub deviceNodeMask: u32,
6271    pub deviceLUIDValid: VkBool32,
6272}
6273
6274#[derive(Clone, Copy)]
6275#[repr(C)]
6276pub struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
6277    pub sType: VkStructureType,
6278    pub pNext: *mut c_void,
6279    pub image2DViewOf3D: VkBool32,
6280    pub sampler2DViewOf3D: VkBool32,
6281}
6282
6283#[derive(Clone, Copy)]
6284#[repr(C)]
6285pub struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
6286    pub sType: VkStructureType,
6287    pub pNext: *mut c_void,
6288    pub imageAlignmentControl: VkBool32,
6289}
6290
6291#[derive(Clone, Copy)]
6292#[repr(C)]
6293pub struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
6294    pub sType: VkStructureType,
6295    pub pNext: *mut c_void,
6296    pub supportedImageAlignmentMask: u32,
6297}
6298
6299#[derive(Clone, Copy)]
6300#[repr(C)]
6301pub struct VkPhysicalDeviceImageCompressionControlFeaturesEXT {
6302    pub sType: VkStructureType,
6303    pub pNext: *mut c_void,
6304    pub imageCompressionControl: VkBool32,
6305}
6306
6307#[derive(Clone, Copy)]
6308#[repr(C)]
6309pub struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
6310    pub sType: VkStructureType,
6311    pub pNext: *mut c_void,
6312    pub imageCompressionControlSwapchain: VkBool32,
6313}
6314
6315#[derive(Clone, Copy)]
6316#[repr(C)]
6317pub struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
6318    pub sType: VkStructureType,
6319    pub pNext: *const c_void,
6320    pub drmFormatModifier: u64,
6321    pub sharingMode: VkSharingMode,
6322    pub queueFamilyIndexCount: u32,
6323    pub pQueueFamilyIndices: *const u32,
6324}
6325
6326#[derive(Clone, Copy)]
6327#[repr(C)]
6328pub struct VkPhysicalDeviceImageFormatInfo2 {
6329    pub sType: VkStructureType,
6330    pub pNext: *const c_void,
6331    pub format: VkFormat,
6332    pub typ: VkImageType,
6333    pub tiling: VkImageTiling,
6334    pub usage: VkImageUsageFlags,
6335    pub flags: VkImageCreateFlags,
6336}
6337
6338#[derive(Clone, Copy)]
6339#[repr(C)]
6340pub struct VkPhysicalDeviceImageProcessing2FeaturesQCOM {
6341    pub sType: VkStructureType,
6342    pub pNext: *mut c_void,
6343    pub textureBlockMatch2: VkBool32,
6344}
6345
6346#[derive(Clone, Copy)]
6347#[repr(C)]
6348pub struct VkPhysicalDeviceImageProcessing2PropertiesQCOM {
6349    pub sType: VkStructureType,
6350    pub pNext: *mut c_void,
6351    pub maxBlockMatchWindow: VkExtent2D,
6352}
6353
6354#[derive(Clone, Copy)]
6355#[repr(C)]
6356pub struct VkPhysicalDeviceImageProcessingFeaturesQCOM {
6357    pub sType: VkStructureType,
6358    pub pNext: *mut c_void,
6359    pub textureSampleWeighted: VkBool32,
6360    pub textureBoxFilter: VkBool32,
6361    pub textureBlockMatch: VkBool32,
6362}
6363
6364#[derive(Clone, Copy)]
6365#[repr(C)]
6366pub struct VkPhysicalDeviceImageProcessingPropertiesQCOM {
6367    pub sType: VkStructureType,
6368    pub pNext: *mut c_void,
6369    pub maxWeightFilterPhases: u32,
6370    pub maxWeightFilterDimension: VkExtent2D,
6371    pub maxBlockMatchRegion: VkExtent2D,
6372    pub maxBoxFilterBlockSize: VkExtent2D,
6373}
6374
6375#[derive(Clone, Copy)]
6376#[repr(C)]
6377pub struct VkPhysicalDeviceImageRobustnessFeatures {
6378    pub sType: VkStructureType,
6379    pub pNext: *mut c_void,
6380    pub robustImageAccess: VkBool32,
6381}
6382
6383#[derive(Clone, Copy)]
6384#[repr(C)]
6385pub struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
6386    pub sType: VkStructureType,
6387    pub pNext: *mut c_void,
6388    pub imageSlicedViewOf3D: VkBool32,
6389}
6390
6391#[derive(Clone, Copy)]
6392#[repr(C)]
6393pub struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
6394    pub sType: VkStructureType,
6395    pub pNext: *mut c_void,
6396    pub imageViewType: VkImageViewType,
6397}
6398
6399#[derive(Clone, Copy)]
6400#[repr(C)]
6401pub struct VkPhysicalDeviceImageViewMinLodFeaturesEXT {
6402    pub sType: VkStructureType,
6403    pub pNext: *mut c_void,
6404    pub minLod: VkBool32,
6405}
6406
6407#[derive(Clone, Copy)]
6408#[repr(C)]
6409pub struct VkPhysicalDeviceImagelessFramebufferFeatures {
6410    pub sType: VkStructureType,
6411    pub pNext: *mut c_void,
6412    pub imagelessFramebuffer: VkBool32,
6413}
6414
6415#[derive(Clone, Copy)]
6416#[repr(C)]
6417pub struct VkPhysicalDeviceIndexTypeUint8Features {
6418    pub sType: VkStructureType,
6419    pub pNext: *mut c_void,
6420    pub indexTypeUint8: VkBool32,
6421}
6422
6423#[derive(Clone, Copy)]
6424#[repr(C)]
6425pub struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
6426    pub sType: VkStructureType,
6427    pub pNext: *mut c_void,
6428    pub inheritedViewportScissor2D: VkBool32,
6429}
6430
6431#[derive(Clone, Copy)]
6432#[repr(C)]
6433pub struct VkPhysicalDeviceInlineUniformBlockFeatures {
6434    pub sType: VkStructureType,
6435    pub pNext: *mut c_void,
6436    pub inlineUniformBlock: VkBool32,
6437    pub descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
6438}
6439
6440#[derive(Clone, Copy)]
6441#[repr(C)]
6442pub struct VkPhysicalDeviceInlineUniformBlockProperties {
6443    pub sType: VkStructureType,
6444    pub pNext: *mut c_void,
6445    pub maxInlineUniformBlockSize: u32,
6446    pub maxPerStageDescriptorInlineUniformBlocks: u32,
6447    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
6448    pub maxDescriptorSetInlineUniformBlocks: u32,
6449    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32,
6450}
6451
6452#[derive(Clone, Copy)]
6453#[repr(C)]
6454pub struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR {
6455    pub sType: VkStructureType,
6456    pub pNext: *mut c_void,
6457    pub internallySynchronizedQueues: VkBool32,
6458}
6459
6460#[derive(Clone, Copy)]
6461#[repr(C)]
6462pub struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
6463    pub sType: VkStructureType,
6464    pub pNext: *mut c_void,
6465    pub invocationMask: VkBool32,
6466}
6467
6468#[derive(Clone, Copy)]
6469#[repr(C)]
6470pub struct VkPhysicalDeviceLayeredApiPropertiesKHR {
6471    pub sType: VkStructureType,
6472    pub pNext: *mut c_void,
6473    pub vendorID: u32,
6474    pub deviceID: u32,
6475    pub layeredAPI: VkPhysicalDeviceLayeredApiKHR,
6476    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
6477}
6478
6479#[derive(Clone, Copy)]
6480#[repr(C)]
6481pub struct VkPhysicalDeviceLayeredApiPropertiesListKHR {
6482    pub sType: VkStructureType,
6483    pub pNext: *mut c_void,
6484    pub layeredApiCount: u32,
6485    pub pLayeredApis: *mut VkPhysicalDeviceLayeredApiPropertiesKHR,
6486}
6487
6488#[derive(Clone, Copy)]
6489#[repr(C)]
6490pub struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
6491    pub sType: VkStructureType,
6492    pub pNext: *mut c_void,
6493    pub properties: VkPhysicalDeviceProperties2,
6494}
6495
6496#[derive(Clone, Copy)]
6497#[repr(C)]
6498pub struct VkPhysicalDeviceLayeredDriverPropertiesMSFT {
6499    pub sType: VkStructureType,
6500    pub pNext: *mut c_void,
6501    pub underlyingAPI: VkLayeredDriverUnderlyingApiMSFT,
6502}
6503
6504#[derive(Clone, Copy)]
6505#[repr(C)]
6506pub struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
6507    pub sType: VkStructureType,
6508    pub pNext: *mut c_void,
6509    pub legacyDithering: VkBool32,
6510}
6511
6512#[derive(Clone, Copy)]
6513#[repr(C)]
6514pub struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT {
6515    pub sType: VkStructureType,
6516    pub pNext: *mut c_void,
6517    pub legacyVertexAttributes: VkBool32,
6518}
6519
6520#[derive(Clone, Copy)]
6521#[repr(C)]
6522pub struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT {
6523    pub sType: VkStructureType,
6524    pub pNext: *mut c_void,
6525    pub nativeUnalignedPerformance: VkBool32,
6526}
6527
6528#[derive(Clone, Copy)]
6529#[repr(C)]
6530pub struct VkPhysicalDeviceLimits {
6531    pub maxImageDimension1D: u32,
6532    pub maxImageDimension2D: u32,
6533    pub maxImageDimension3D: u32,
6534    pub maxImageDimensionCube: u32,
6535    pub maxImageArrayLayers: u32,
6536    pub maxTexelBufferElements: u32,
6537    pub maxUniformBufferRange: u32,
6538    pub maxStorageBufferRange: u32,
6539    pub maxPushConstantsSize: u32,
6540    pub maxMemoryAllocationCount: u32,
6541    pub maxSamplerAllocationCount: u32,
6542    pub bufferImageGranularity: VkDeviceSize,
6543    pub sparseAddressSpaceSize: VkDeviceSize,
6544    pub maxBoundDescriptorSets: u32,
6545    pub maxPerStageDescriptorSamplers: u32,
6546    pub maxPerStageDescriptorUniformBuffers: u32,
6547    pub maxPerStageDescriptorStorageBuffers: u32,
6548    pub maxPerStageDescriptorSampledImages: u32,
6549    pub maxPerStageDescriptorStorageImages: u32,
6550    pub maxPerStageDescriptorInputAttachments: u32,
6551    pub maxPerStageResources: u32,
6552    pub maxDescriptorSetSamplers: u32,
6553    pub maxDescriptorSetUniformBuffers: u32,
6554    pub maxDescriptorSetUniformBuffersDynamic: u32,
6555    pub maxDescriptorSetStorageBuffers: u32,
6556    pub maxDescriptorSetStorageBuffersDynamic: u32,
6557    pub maxDescriptorSetSampledImages: u32,
6558    pub maxDescriptorSetStorageImages: u32,
6559    pub maxDescriptorSetInputAttachments: u32,
6560    pub maxVertexInputAttributes: u32,
6561    pub maxVertexInputBindings: u32,
6562    pub maxVertexInputAttributeOffset: u32,
6563    pub maxVertexInputBindingStride: u32,
6564    pub maxVertexOutputComponents: u32,
6565    pub maxTessellationGenerationLevel: u32,
6566    pub maxTessellationPatchSize: u32,
6567    pub maxTessellationControlPerVertexInputComponents: u32,
6568    pub maxTessellationControlPerVertexOutputComponents: u32,
6569    pub maxTessellationControlPerPatchOutputComponents: u32,
6570    pub maxTessellationControlTotalOutputComponents: u32,
6571    pub maxTessellationEvaluationInputComponents: u32,
6572    pub maxTessellationEvaluationOutputComponents: u32,
6573    pub maxGeometryShaderInvocations: u32,
6574    pub maxGeometryInputComponents: u32,
6575    pub maxGeometryOutputComponents: u32,
6576    pub maxGeometryOutputVertices: u32,
6577    pub maxGeometryTotalOutputComponents: u32,
6578    pub maxFragmentInputComponents: u32,
6579    pub maxFragmentOutputAttachments: u32,
6580    pub maxFragmentDualSrcAttachments: u32,
6581    pub maxFragmentCombinedOutputResources: u32,
6582    pub maxComputeSharedMemorySize: u32,
6583    pub maxComputeWorkGroupCount: [u32; 3 as usize],
6584    pub maxComputeWorkGroupInvocations: u32,
6585    pub maxComputeWorkGroupSize: [u32; 3 as usize],
6586    pub subPixelPrecisionBits: u32,
6587    pub subTexelPrecisionBits: u32,
6588    pub mipmapPrecisionBits: u32,
6589    pub maxDrawIndexedIndexValue: u32,
6590    pub maxDrawIndirectCount: u32,
6591    pub maxSamplerLodBias: f32,
6592    pub maxSamplerAnisotropy: f32,
6593    pub maxViewports: u32,
6594    pub maxViewportDimensions: [u32; 2 as usize],
6595    pub viewportBoundsRange: [f32; 2 as usize],
6596    pub viewportSubPixelBits: u32,
6597    pub minMemoryMapAlignment: usize,
6598    pub minTexelBufferOffsetAlignment: VkDeviceSize,
6599    pub minUniformBufferOffsetAlignment: VkDeviceSize,
6600    pub minStorageBufferOffsetAlignment: VkDeviceSize,
6601    pub minTexelOffset: i32,
6602    pub maxTexelOffset: u32,
6603    pub minTexelGatherOffset: i32,
6604    pub maxTexelGatherOffset: u32,
6605    pub minInterpolationOffset: f32,
6606    pub maxInterpolationOffset: f32,
6607    pub subPixelInterpolationOffsetBits: u32,
6608    pub maxFramebufferWidth: u32,
6609    pub maxFramebufferHeight: u32,
6610    pub maxFramebufferLayers: u32,
6611    pub framebufferColorSampleCounts: VkSampleCountFlags,
6612    pub framebufferDepthSampleCounts: VkSampleCountFlags,
6613    pub framebufferStencilSampleCounts: VkSampleCountFlags,
6614    pub framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
6615    pub maxColorAttachments: u32,
6616    pub sampledImageColorSampleCounts: VkSampleCountFlags,
6617    pub sampledImageIntegerSampleCounts: VkSampleCountFlags,
6618    pub sampledImageDepthSampleCounts: VkSampleCountFlags,
6619    pub sampledImageStencilSampleCounts: VkSampleCountFlags,
6620    pub storageImageSampleCounts: VkSampleCountFlags,
6621    pub maxSampleMaskWords: u32,
6622    pub timestampComputeAndGraphics: VkBool32,
6623    pub timestampPeriod: f32,
6624    pub maxClipDistances: u32,
6625    pub maxCullDistances: u32,
6626    pub maxCombinedClipAndCullDistances: u32,
6627    pub discreteQueuePriorities: u32,
6628    pub pointSizeRange: [f32; 2 as usize],
6629    pub lineWidthRange: [f32; 2 as usize],
6630    pub pointSizeGranularity: f32,
6631    pub lineWidthGranularity: f32,
6632    pub strictLines: VkBool32,
6633    pub standardSampleLocations: VkBool32,
6634    pub optimalBufferCopyOffsetAlignment: VkDeviceSize,
6635    pub optimalBufferCopyRowPitchAlignment: VkDeviceSize,
6636    pub nonCoherentAtomSize: VkDeviceSize,
6637}
6638
6639#[derive(Clone, Copy)]
6640#[repr(C)]
6641pub struct VkPhysicalDeviceLineRasterizationFeatures {
6642    pub sType: VkStructureType,
6643    pub pNext: *mut c_void,
6644    pub rectangularLines: VkBool32,
6645    pub bresenhamLines: VkBool32,
6646    pub smoothLines: VkBool32,
6647    pub stippledRectangularLines: VkBool32,
6648    pub stippledBresenhamLines: VkBool32,
6649    pub stippledSmoothLines: VkBool32,
6650}
6651
6652#[derive(Clone, Copy)]
6653#[repr(C)]
6654pub struct VkPhysicalDeviceLineRasterizationProperties {
6655    pub sType: VkStructureType,
6656    pub pNext: *mut c_void,
6657    pub lineSubPixelPrecisionBits: u32,
6658}
6659
6660#[derive(Clone, Copy)]
6661#[repr(C)]
6662pub struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
6663    pub sType: VkStructureType,
6664    pub pNext: *mut c_void,
6665    pub linearColorAttachment: VkBool32,
6666}
6667
6668#[derive(Clone, Copy)]
6669#[repr(C)]
6670pub struct VkPhysicalDeviceMaintenance10FeaturesKHR {
6671    pub sType: VkStructureType,
6672    pub pNext: *mut c_void,
6673    pub maintenance10: VkBool32,
6674}
6675
6676#[derive(Clone, Copy)]
6677#[repr(C)]
6678pub struct VkPhysicalDeviceMaintenance10PropertiesKHR {
6679    pub sType: VkStructureType,
6680    pub pNext: *mut c_void,
6681    pub rgba4OpaqueBlackSwizzled: VkBool32,
6682    pub resolveSrgbFormatAppliesTransferFunction: VkBool32,
6683    pub resolveSrgbFormatSupportsTransferFunctionControl: VkBool32,
6684}
6685
6686#[derive(Clone, Copy)]
6687#[repr(C)]
6688pub struct VkPhysicalDeviceMaintenance3Properties {
6689    pub sType: VkStructureType,
6690    pub pNext: *mut c_void,
6691    pub maxPerSetDescriptors: u32,
6692    pub maxMemoryAllocationSize: VkDeviceSize,
6693}
6694
6695#[derive(Clone, Copy)]
6696#[repr(C)]
6697pub struct VkPhysicalDeviceMaintenance4Features {
6698    pub sType: VkStructureType,
6699    pub pNext: *mut c_void,
6700    pub maintenance4: VkBool32,
6701}
6702
6703#[derive(Clone, Copy)]
6704#[repr(C)]
6705pub struct VkPhysicalDeviceMaintenance4Properties {
6706    pub sType: VkStructureType,
6707    pub pNext: *mut c_void,
6708    pub maxBufferSize: VkDeviceSize,
6709}
6710
6711#[derive(Clone, Copy)]
6712#[repr(C)]
6713pub struct VkPhysicalDeviceMaintenance5Features {
6714    pub sType: VkStructureType,
6715    pub pNext: *mut c_void,
6716    pub maintenance5: VkBool32,
6717}
6718
6719#[derive(Clone, Copy)]
6720#[repr(C)]
6721pub struct VkPhysicalDeviceMaintenance5Properties {
6722    pub sType: VkStructureType,
6723    pub pNext: *mut c_void,
6724    pub earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
6725    pub earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
6726    pub depthStencilSwizzleOneSupport: VkBool32,
6727    pub polygonModePointSize: VkBool32,
6728    pub nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
6729    pub nonStrictWideLinesUseParallelogram: VkBool32,
6730}
6731
6732#[derive(Clone, Copy)]
6733#[repr(C)]
6734pub struct VkPhysicalDeviceMaintenance6Features {
6735    pub sType: VkStructureType,
6736    pub pNext: *mut c_void,
6737    pub maintenance6: VkBool32,
6738}
6739
6740#[derive(Clone, Copy)]
6741#[repr(C)]
6742pub struct VkPhysicalDeviceMaintenance6Properties {
6743    pub sType: VkStructureType,
6744    pub pNext: *mut c_void,
6745    pub blockTexelViewCompatibleMultipleLayers: VkBool32,
6746    pub maxCombinedImageSamplerDescriptorCount: u32,
6747    pub fragmentShadingRateClampCombinerInputs: VkBool32,
6748}
6749
6750#[derive(Clone, Copy)]
6751#[repr(C)]
6752pub struct VkPhysicalDeviceMaintenance7FeaturesKHR {
6753    pub sType: VkStructureType,
6754    pub pNext: *mut c_void,
6755    pub maintenance7: VkBool32,
6756}
6757
6758#[derive(Clone, Copy)]
6759#[repr(C)]
6760pub struct VkPhysicalDeviceMaintenance7PropertiesKHR {
6761    pub sType: VkStructureType,
6762    pub pNext: *mut c_void,
6763    pub robustFragmentShadingRateAttachmentAccess: VkBool32,
6764    pub separateDepthStencilAttachmentAccess: VkBool32,
6765    pub maxDescriptorSetTotalUniformBuffersDynamic: u32,
6766    pub maxDescriptorSetTotalStorageBuffersDynamic: u32,
6767    pub maxDescriptorSetTotalBuffersDynamic: u32,
6768    pub maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic: u32,
6769    pub maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic: u32,
6770    pub maxDescriptorSetUpdateAfterBindTotalBuffersDynamic: u32,
6771}
6772
6773#[derive(Clone, Copy)]
6774#[repr(C)]
6775pub struct VkPhysicalDeviceMaintenance8FeaturesKHR {
6776    pub sType: VkStructureType,
6777    pub pNext: *mut c_void,
6778    pub maintenance8: VkBool32,
6779}
6780
6781#[derive(Clone, Copy)]
6782#[repr(C)]
6783pub struct VkPhysicalDeviceMaintenance9FeaturesKHR {
6784    pub sType: VkStructureType,
6785    pub pNext: *mut c_void,
6786    pub maintenance9: VkBool32,
6787}
6788
6789#[derive(Clone, Copy)]
6790#[repr(C)]
6791pub struct VkPhysicalDeviceMaintenance9PropertiesKHR {
6792    pub sType: VkStructureType,
6793    pub pNext: *mut c_void,
6794    pub image2DViewOf3DSparse: VkBool32,
6795    pub defaultVertexAttributeValue: VkDefaultVertexAttributeValueKHR,
6796}
6797
6798#[derive(Clone, Copy)]
6799#[repr(C)]
6800pub struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
6801    pub sType: VkStructureType,
6802    pub pNext: *mut c_void,
6803    pub memoryMapPlaced: VkBool32,
6804    pub memoryMapRangePlaced: VkBool32,
6805    pub memoryUnmapReserve: VkBool32,
6806}
6807
6808#[derive(Clone, Copy)]
6809#[repr(C)]
6810pub struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT {
6811    pub sType: VkStructureType,
6812    pub pNext: *mut c_void,
6813    pub minPlacedMemoryMapAlignment: VkDeviceSize,
6814}
6815
6816#[derive(Clone, Copy)]
6817#[repr(C)]
6818pub struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
6819    pub sType: VkStructureType,
6820    pub pNext: *mut c_void,
6821    pub heapBudget: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
6822    pub heapUsage: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
6823}
6824
6825#[derive(Clone, Copy)]
6826#[repr(C)]
6827pub struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT {
6828    pub sType: VkStructureType,
6829    pub pNext: *mut c_void,
6830    pub memoryDecompression: VkBool32,
6831}
6832
6833#[derive(Clone, Copy)]
6834#[repr(C)]
6835pub struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT {
6836    pub sType: VkStructureType,
6837    pub pNext: *mut c_void,
6838    pub decompressionMethods: VkMemoryDecompressionMethodFlagsEXT,
6839    pub maxDecompressionIndirectCount: u64,
6840}
6841
6842#[derive(Clone, Copy)]
6843#[repr(C)]
6844pub struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
6845    pub sType: VkStructureType,
6846    pub pNext: *mut c_void,
6847    pub memoryPriority: VkBool32,
6848}
6849
6850#[derive(Clone, Copy)]
6851#[repr(C)]
6852pub struct VkPhysicalDeviceMemoryProperties {
6853    pub memoryTypeCount: u32,
6854    pub memoryTypes: [VkMemoryType; VK_MAX_MEMORY_TYPES as usize],
6855    pub memoryHeapCount: u32,
6856    pub memoryHeaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS as usize],
6857}
6858
6859#[derive(Clone, Copy)]
6860#[repr(C)]
6861pub struct VkPhysicalDeviceMemoryProperties2 {
6862    pub sType: VkStructureType,
6863    pub pNext: *mut c_void,
6864    pub memoryProperties: VkPhysicalDeviceMemoryProperties,
6865}
6866
6867#[derive(Clone, Copy)]
6868#[repr(C)]
6869pub struct VkPhysicalDeviceMeshShaderFeaturesEXT {
6870    pub sType: VkStructureType,
6871    pub pNext: *mut c_void,
6872    pub taskShader: VkBool32,
6873    pub meshShader: VkBool32,
6874    pub multiviewMeshShader: VkBool32,
6875    pub primitiveFragmentShadingRateMeshShader: VkBool32,
6876    pub meshShaderQueries: VkBool32,
6877}
6878
6879#[derive(Clone, Copy)]
6880#[repr(C)]
6881pub struct VkPhysicalDeviceMeshShaderFeaturesNV {
6882    pub sType: VkStructureType,
6883    pub pNext: *mut c_void,
6884    pub taskShader: VkBool32,
6885    pub meshShader: VkBool32,
6886}
6887
6888#[derive(Clone, Copy)]
6889#[repr(C)]
6890pub struct VkPhysicalDeviceMeshShaderPropertiesEXT {
6891    pub sType: VkStructureType,
6892    pub pNext: *mut c_void,
6893    pub maxTaskWorkGroupTotalCount: u32,
6894    pub maxTaskWorkGroupCount: [u32; 3 as usize],
6895    pub maxTaskWorkGroupInvocations: u32,
6896    pub maxTaskWorkGroupSize: [u32; 3 as usize],
6897    pub maxTaskPayloadSize: u32,
6898    pub maxTaskSharedMemorySize: u32,
6899    pub maxTaskPayloadAndSharedMemorySize: u32,
6900    pub maxMeshWorkGroupTotalCount: u32,
6901    pub maxMeshWorkGroupCount: [u32; 3 as usize],
6902    pub maxMeshWorkGroupInvocations: u32,
6903    pub maxMeshWorkGroupSize: [u32; 3 as usize],
6904    pub maxMeshSharedMemorySize: u32,
6905    pub maxMeshPayloadAndSharedMemorySize: u32,
6906    pub maxMeshOutputMemorySize: u32,
6907    pub maxMeshPayloadAndOutputMemorySize: u32,
6908    pub maxMeshOutputComponents: u32,
6909    pub maxMeshOutputVertices: u32,
6910    pub maxMeshOutputPrimitives: u32,
6911    pub maxMeshOutputLayers: u32,
6912    pub maxMeshMultiviewViewCount: u32,
6913    pub meshOutputPerVertexGranularity: u32,
6914    pub meshOutputPerPrimitiveGranularity: u32,
6915    pub maxPreferredTaskWorkGroupInvocations: u32,
6916    pub maxPreferredMeshWorkGroupInvocations: u32,
6917    pub prefersLocalInvocationVertexOutput: VkBool32,
6918    pub prefersLocalInvocationPrimitiveOutput: VkBool32,
6919    pub prefersCompactVertexOutput: VkBool32,
6920    pub prefersCompactPrimitiveOutput: VkBool32,
6921}
6922
6923#[derive(Clone, Copy)]
6924#[repr(C)]
6925pub struct VkPhysicalDeviceMeshShaderPropertiesNV {
6926    pub sType: VkStructureType,
6927    pub pNext: *mut c_void,
6928    pub maxDrawMeshTasksCount: u32,
6929    pub maxTaskWorkGroupInvocations: u32,
6930    pub maxTaskWorkGroupSize: [u32; 3 as usize],
6931    pub maxTaskTotalMemorySize: u32,
6932    pub maxTaskOutputCount: u32,
6933    pub maxMeshWorkGroupInvocations: u32,
6934    pub maxMeshWorkGroupSize: [u32; 3 as usize],
6935    pub maxMeshTotalMemorySize: u32,
6936    pub maxMeshOutputVertices: u32,
6937    pub maxMeshOutputPrimitives: u32,
6938    pub maxMeshMultiviewViewCount: u32,
6939    pub meshOutputPerVertexGranularity: u32,
6940    pub meshOutputPerPrimitiveGranularity: u32,
6941}
6942
6943#[derive(Clone, Copy)]
6944#[repr(C)]
6945pub struct VkPhysicalDeviceMultiDrawFeaturesEXT {
6946    pub sType: VkStructureType,
6947    pub pNext: *mut c_void,
6948    pub multiDraw: VkBool32,
6949}
6950
6951#[derive(Clone, Copy)]
6952#[repr(C)]
6953pub struct VkPhysicalDeviceMultiDrawPropertiesEXT {
6954    pub sType: VkStructureType,
6955    pub pNext: *mut c_void,
6956    pub maxMultiDrawCount: u32,
6957}
6958
6959#[derive(Clone, Copy)]
6960#[repr(C)]
6961pub struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
6962    pub sType: VkStructureType,
6963    pub pNext: *mut c_void,
6964    pub multisampledRenderToSingleSampled: VkBool32,
6965}
6966
6967#[derive(Clone, Copy)]
6968#[repr(C)]
6969pub struct VkPhysicalDeviceMultiviewFeatures {
6970    pub sType: VkStructureType,
6971    pub pNext: *mut c_void,
6972    pub multiview: VkBool32,
6973    pub multiviewGeometryShader: VkBool32,
6974    pub multiviewTessellationShader: VkBool32,
6975}
6976
6977#[derive(Clone, Copy)]
6978#[repr(C)]
6979pub struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
6980    pub sType: VkStructureType,
6981    pub pNext: *mut c_void,
6982    pub perViewPositionAllComponents: VkBool32,
6983}
6984
6985#[derive(Clone, Copy)]
6986#[repr(C)]
6987pub struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
6988    pub sType: VkStructureType,
6989    pub pNext: *mut c_void,
6990    pub multiviewPerViewRenderAreas: VkBool32,
6991}
6992
6993#[derive(Clone, Copy)]
6994#[repr(C)]
6995pub struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
6996    pub sType: VkStructureType,
6997    pub pNext: *mut c_void,
6998    pub multiviewPerViewViewports: VkBool32,
6999}
7000
7001#[derive(Clone, Copy)]
7002#[repr(C)]
7003pub struct VkPhysicalDeviceMultiviewProperties {
7004    pub sType: VkStructureType,
7005    pub pNext: *mut c_void,
7006    pub maxMultiviewViewCount: u32,
7007    pub maxMultiviewInstanceIndex: u32,
7008}
7009
7010#[derive(Clone, Copy)]
7011#[repr(C)]
7012pub struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT {
7013    pub sType: VkStructureType,
7014    pub pNext: *mut c_void,
7015    pub mutableDescriptorType: VkBool32,
7016}
7017
7018#[derive(Clone, Copy)]
7019#[repr(C)]
7020pub struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
7021    pub sType: VkStructureType,
7022    pub pNext: *mut c_void,
7023    pub nestedCommandBuffer: VkBool32,
7024    pub nestedCommandBufferRendering: VkBool32,
7025    pub nestedCommandBufferSimultaneousUse: VkBool32,
7026}
7027
7028#[derive(Clone, Copy)]
7029#[repr(C)]
7030pub struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT {
7031    pub sType: VkStructureType,
7032    pub pNext: *mut c_void,
7033    pub maxCommandBufferNestingLevel: u32,
7034}
7035
7036#[derive(Clone, Copy)]
7037#[repr(C)]
7038pub struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
7039    pub sType: VkStructureType,
7040    pub pNext: *mut c_void,
7041    pub nonSeamlessCubeMap: VkBool32,
7042}
7043
7044#[derive(Clone, Copy)]
7045#[repr(C)]
7046pub struct VkPhysicalDeviceOpacityMicromapFeaturesEXT {
7047    pub sType: VkStructureType,
7048    pub pNext: *mut c_void,
7049    pub micromap: VkBool32,
7050    pub micromapCaptureReplay: VkBool32,
7051    pub micromapHostCommands: VkBool32,
7052}
7053
7054#[derive(Clone, Copy)]
7055#[repr(C)]
7056pub struct VkPhysicalDeviceOpacityMicromapPropertiesEXT {
7057    pub sType: VkStructureType,
7058    pub pNext: *mut c_void,
7059    pub maxOpacity2StateSubdivisionLevel: u32,
7060    pub maxOpacity4StateSubdivisionLevel: u32,
7061}
7062
7063#[derive(Clone, Copy)]
7064#[repr(C)]
7065pub struct VkPhysicalDeviceOpticalFlowFeaturesNV {
7066    pub sType: VkStructureType,
7067    pub pNext: *mut c_void,
7068    pub opticalFlow: VkBool32,
7069}
7070
7071#[derive(Clone, Copy)]
7072#[repr(C)]
7073pub struct VkPhysicalDeviceOpticalFlowPropertiesNV {
7074    pub sType: VkStructureType,
7075    pub pNext: *mut c_void,
7076    pub supportedOutputGridSizes: VkOpticalFlowGridSizeFlagsNV,
7077    pub supportedHintGridSizes: VkOpticalFlowGridSizeFlagsNV,
7078    pub hintSupported: VkBool32,
7079    pub costSupported: VkBool32,
7080    pub bidirectionalFlowSupported: VkBool32,
7081    pub globalFlowSupported: VkBool32,
7082    pub minWidth: u32,
7083    pub minHeight: u32,
7084    pub maxWidth: u32,
7085    pub maxHeight: u32,
7086    pub maxNumRegionsOfInterest: u32,
7087}
7088
7089#[derive(Clone, Copy)]
7090#[repr(C)]
7091pub struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
7092    pub sType: VkStructureType,
7093    pub pNext: *mut c_void,
7094    pub pciDomain: u32,
7095    pub pciBus: u32,
7096    pub pciDevice: u32,
7097    pub pciFunction: u32,
7098}
7099
7100#[derive(Clone, Copy)]
7101#[repr(C)]
7102pub struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
7103    pub sType: VkStructureType,
7104    pub pNext: *mut c_void,
7105    pub pageableDeviceLocalMemory: VkBool32,
7106}
7107
7108#[derive(Clone, Copy)]
7109#[repr(C)]
7110pub struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV {
7111    pub sType: VkStructureType,
7112    pub pNext: *mut c_void,
7113    pub partitionedAccelerationStructure: VkBool32,
7114}
7115
7116#[derive(Clone, Copy)]
7117#[repr(C)]
7118pub struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV {
7119    pub sType: VkStructureType,
7120    pub pNext: *mut c_void,
7121    pub maxPartitionCount: u32,
7122}
7123
7124#[derive(Clone, Copy)]
7125#[repr(C)]
7126pub struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV {
7127    pub sType: VkStructureType,
7128    pub pNext: *mut c_void,
7129    pub perStageDescriptorSet: VkBool32,
7130    pub dynamicPipelineLayout: VkBool32,
7131}
7132
7133#[derive(Clone, Copy)]
7134#[repr(C)]
7135pub struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM {
7136    pub sType: VkStructureType,
7137    pub pNext: *mut c_void,
7138    pub performanceCountersByRegion: VkBool32,
7139}
7140
7141#[derive(Clone, Copy)]
7142#[repr(C)]
7143pub struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM {
7144    pub sType: VkStructureType,
7145    pub pNext: *mut c_void,
7146    pub maxPerRegionPerformanceCounters: u32,
7147    pub performanceCounterRegionSize: VkExtent2D,
7148    pub rowStrideAlignment: u32,
7149    pub regionAlignment: u32,
7150    pub identityTransformOrder: VkBool32,
7151}
7152
7153#[derive(Clone, Copy)]
7154#[repr(C)]
7155pub struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
7156    pub sType: VkStructureType,
7157    pub pNext: *mut c_void,
7158    pub performanceCounterQueryPools: VkBool32,
7159    pub performanceCounterMultipleQueryPools: VkBool32,
7160}
7161
7162#[derive(Clone, Copy)]
7163#[repr(C)]
7164pub struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
7165    pub sType: VkStructureType,
7166    pub pNext: *mut c_void,
7167    pub allowCommandBufferQueryCopies: VkBool32,
7168}
7169
7170#[derive(Clone, Copy)]
7171#[repr(C)]
7172pub struct VkPhysicalDevicePipelineBinaryFeaturesKHR {
7173    pub sType: VkStructureType,
7174    pub pNext: *mut c_void,
7175    pub pipelineBinaries: VkBool32,
7176}
7177
7178#[derive(Clone, Copy)]
7179#[repr(C)]
7180pub struct VkPhysicalDevicePipelineBinaryPropertiesKHR {
7181    pub sType: VkStructureType,
7182    pub pNext: *mut c_void,
7183    pub pipelineBinaryInternalCache: VkBool32,
7184    pub pipelineBinaryInternalCacheControl: VkBool32,
7185    pub pipelineBinaryPrefersInternalCache: VkBool32,
7186    pub pipelineBinaryPrecompiledInternalCache: VkBool32,
7187    pub pipelineBinaryCompressedData: VkBool32,
7188}
7189
7190#[derive(Clone, Copy)]
7191#[repr(C)]
7192pub struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {
7193    pub sType: VkStructureType,
7194    pub pNext: *mut c_void,
7195    pub pipelineCacheIncrementalMode: VkBool32,
7196}
7197
7198#[derive(Clone, Copy)]
7199#[repr(C)]
7200pub struct VkPhysicalDevicePipelineCreationCacheControlFeatures {
7201    pub sType: VkStructureType,
7202    pub pNext: *mut c_void,
7203    pub pipelineCreationCacheControl: VkBool32,
7204}
7205
7206#[derive(Clone, Copy)]
7207#[repr(C)]
7208pub struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
7209    pub sType: VkStructureType,
7210    pub pNext: *mut c_void,
7211    pub pipelineExecutableInfo: VkBool32,
7212}
7213
7214#[derive(Clone, Copy)]
7215#[repr(C)]
7216pub struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
7217    pub sType: VkStructureType,
7218    pub pNext: *mut c_void,
7219    pub pipelineLibraryGroupHandles: VkBool32,
7220}
7221
7222#[derive(Clone, Copy)]
7223#[repr(C)]
7224pub struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM {
7225    pub sType: VkStructureType,
7226    pub pNext: *mut c_void,
7227    pub pipelineOpacityMicromap: VkBool32,
7228}
7229
7230#[derive(Clone, Copy)]
7231#[repr(C)]
7232pub struct VkPhysicalDevicePipelinePropertiesFeaturesEXT {
7233    pub sType: VkStructureType,
7234    pub pNext: *mut c_void,
7235    pub pipelinePropertiesIdentifier: VkBool32,
7236}
7237
7238#[derive(Clone, Copy)]
7239#[repr(C)]
7240pub struct VkPhysicalDevicePipelineProtectedAccessFeatures {
7241    pub sType: VkStructureType,
7242    pub pNext: *mut c_void,
7243    pub pipelineProtectedAccess: VkBool32,
7244}
7245
7246#[derive(Clone, Copy)]
7247#[repr(C)]
7248pub struct VkPhysicalDevicePipelineRobustnessFeatures {
7249    pub sType: VkStructureType,
7250    pub pNext: *mut c_void,
7251    pub pipelineRobustness: VkBool32,
7252}
7253
7254#[derive(Clone, Copy)]
7255#[repr(C)]
7256pub struct VkPhysicalDevicePipelineRobustnessProperties {
7257    pub sType: VkStructureType,
7258    pub pNext: *mut c_void,
7259    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
7260    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
7261    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
7262    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
7263}
7264
7265#[derive(Clone, Copy)]
7266#[repr(C)]
7267pub struct VkPhysicalDevicePointClippingProperties {
7268    pub sType: VkStructureType,
7269    pub pNext: *mut c_void,
7270    pub pointClippingBehavior: VkPointClippingBehavior,
7271}
7272
7273#[derive(Clone, Copy)]
7274#[repr(C)]
7275pub struct VkPhysicalDevicePresentBarrierFeaturesNV {
7276    pub sType: VkStructureType,
7277    pub pNext: *mut c_void,
7278    pub presentBarrier: VkBool32,
7279}
7280
7281#[derive(Clone, Copy)]
7282#[repr(C)]
7283pub struct VkPhysicalDevicePresentId2FeaturesKHR {
7284    pub sType: VkStructureType,
7285    pub pNext: *mut c_void,
7286    pub presentId2: VkBool32,
7287}
7288
7289#[derive(Clone, Copy)]
7290#[repr(C)]
7291pub struct VkPhysicalDevicePresentIdFeaturesKHR {
7292    pub sType: VkStructureType,
7293    pub pNext: *mut c_void,
7294    pub presentId: VkBool32,
7295}
7296
7297#[derive(Clone, Copy)]
7298#[repr(C)]
7299pub struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {
7300    pub sType: VkStructureType,
7301    pub pNext: *mut c_void,
7302    pub presentModeFifoLatestReady: VkBool32,
7303}
7304
7305#[derive(Clone, Copy)]
7306#[repr(C)]
7307pub struct VkPhysicalDevicePresentTimingFeaturesEXT {
7308    pub sType: VkStructureType,
7309    pub pNext: *mut c_void,
7310    pub presentTiming: VkBool32,
7311    pub presentAtAbsoluteTime: VkBool32,
7312    pub presentAtRelativeTime: VkBool32,
7313}
7314
7315#[derive(Clone, Copy)]
7316#[repr(C)]
7317pub struct VkPhysicalDevicePresentWait2FeaturesKHR {
7318    pub sType: VkStructureType,
7319    pub pNext: *mut c_void,
7320    pub presentWait2: VkBool32,
7321}
7322
7323#[derive(Clone, Copy)]
7324#[repr(C)]
7325pub struct VkPhysicalDevicePresentWaitFeaturesKHR {
7326    pub sType: VkStructureType,
7327    pub pNext: *mut c_void,
7328    pub presentWait: VkBool32,
7329}
7330
7331#[derive(Clone, Copy)]
7332#[repr(C)]
7333pub struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
7334    pub sType: VkStructureType,
7335    pub pNext: *mut c_void,
7336    pub primitiveTopologyListRestart: VkBool32,
7337    pub primitiveTopologyPatchListRestart: VkBool32,
7338}
7339
7340#[derive(Clone, Copy)]
7341#[repr(C)]
7342pub struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
7343    pub sType: VkStructureType,
7344    pub pNext: *mut c_void,
7345    pub primitivesGeneratedQuery: VkBool32,
7346    pub primitivesGeneratedQueryWithRasterizerDiscard: VkBool32,
7347    pub primitivesGeneratedQueryWithNonZeroStreams: VkBool32,
7348}
7349
7350#[derive(Clone, Copy)]
7351#[repr(C)]
7352pub struct VkPhysicalDevicePrivateDataFeatures {
7353    pub sType: VkStructureType,
7354    pub pNext: *mut c_void,
7355    pub privateData: VkBool32,
7356}
7357
7358#[derive(Clone, Copy)]
7359#[repr(C)]
7360pub struct VkPhysicalDeviceProperties {
7361    pub apiVersion: u32,
7362    pub driverVersion: u32,
7363    pub vendorID: u32,
7364    pub deviceID: u32,
7365    pub deviceType: VkPhysicalDeviceType,
7366    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
7367    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
7368    pub limits: VkPhysicalDeviceLimits,
7369    pub sparseProperties: VkPhysicalDeviceSparseProperties,
7370}
7371
7372#[derive(Clone, Copy)]
7373#[repr(C)]
7374pub struct VkPhysicalDeviceProperties2 {
7375    pub sType: VkStructureType,
7376    pub pNext: *mut c_void,
7377    pub properties: VkPhysicalDeviceProperties,
7378}
7379
7380#[derive(Clone, Copy)]
7381#[repr(C)]
7382pub struct VkPhysicalDeviceProtectedMemoryFeatures {
7383    pub sType: VkStructureType,
7384    pub pNext: *mut c_void,
7385    pub protectedMemory: VkBool32,
7386}
7387
7388#[derive(Clone, Copy)]
7389#[repr(C)]
7390pub struct VkPhysicalDeviceProtectedMemoryProperties {
7391    pub sType: VkStructureType,
7392    pub pNext: *mut c_void,
7393    pub protectedNoFault: VkBool32,
7394}
7395
7396#[derive(Clone, Copy)]
7397#[repr(C)]
7398pub struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
7399    pub sType: VkStructureType,
7400    pub pNext: *mut c_void,
7401    pub provokingVertexLast: VkBool32,
7402    pub transformFeedbackPreservesProvokingVertex: VkBool32,
7403}
7404
7405#[derive(Clone, Copy)]
7406#[repr(C)]
7407pub struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
7408    pub sType: VkStructureType,
7409    pub pNext: *mut c_void,
7410    pub provokingVertexModePerPipeline: VkBool32,
7411    pub transformFeedbackPreservesTriangleFanProvokingVertex: VkBool32,
7412}
7413
7414#[derive(Clone, Copy)]
7415#[repr(C)]
7416pub struct VkPhysicalDevicePushConstantBankFeaturesNV {
7417    pub sType: VkStructureType,
7418    pub pNext: *mut c_void,
7419    pub pushConstantBank: VkBool32,
7420}
7421
7422#[derive(Clone, Copy)]
7423#[repr(C)]
7424pub struct VkPhysicalDevicePushConstantBankPropertiesNV {
7425    pub sType: VkStructureType,
7426    pub pNext: *mut c_void,
7427    pub maxGraphicsPushConstantBanks: u32,
7428    pub maxComputePushConstantBanks: u32,
7429    pub maxGraphicsPushDataBanks: u32,
7430    pub maxComputePushDataBanks: u32,
7431}
7432
7433#[derive(Clone, Copy)]
7434#[repr(C)]
7435pub struct VkPhysicalDevicePushDescriptorProperties {
7436    pub sType: VkStructureType,
7437    pub pNext: *mut c_void,
7438    pub maxPushDescriptors: u32,
7439}
7440
7441#[derive(Clone, Copy)]
7442#[repr(C)]
7443pub struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {
7444    pub sType: VkStructureType,
7445    pub pNext: *const c_void,
7446    pub queueFamilyIndex: u32,
7447    pub engineType: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
7448}
7449
7450#[derive(Clone, Copy)]
7451#[repr(C)]
7452pub struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
7453    pub sType: VkStructureType,
7454    pub pNext: *mut c_void,
7455    pub formatRgba10x6WithoutYCbCrSampler: VkBool32,
7456}
7457
7458#[derive(Clone, Copy)]
7459#[repr(C)]
7460pub struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
7461    pub sType: VkStructureType,
7462    pub pNext: *mut c_void,
7463    pub rasterizationOrderColorAttachmentAccess: VkBool32,
7464    pub rasterizationOrderDepthAttachmentAccess: VkBool32,
7465    pub rasterizationOrderStencilAttachmentAccess: VkBool32,
7466}
7467
7468#[derive(Clone, Copy)]
7469#[repr(C)]
7470pub struct VkPhysicalDeviceRawAccessChainsFeaturesNV {
7471    pub sType: VkStructureType,
7472    pub pNext: *mut c_void,
7473    pub shaderRawAccessChains: VkBool32,
7474}
7475
7476#[derive(Clone, Copy)]
7477#[repr(C)]
7478pub struct VkPhysicalDeviceRayQueryFeaturesKHR {
7479    pub sType: VkStructureType,
7480    pub pNext: *mut c_void,
7481    pub rayQuery: VkBool32,
7482}
7483
7484#[derive(Clone, Copy)]
7485#[repr(C)]
7486pub struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT {
7487    pub sType: VkStructureType,
7488    pub pNext: *mut c_void,
7489    pub rayTracingInvocationReorder: VkBool32,
7490}
7491
7492#[derive(Clone, Copy)]
7493#[repr(C)]
7494pub struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
7495    pub sType: VkStructureType,
7496    pub pNext: *mut c_void,
7497    pub rayTracingInvocationReorder: VkBool32,
7498}
7499
7500#[derive(Clone, Copy)]
7501#[repr(C)]
7502pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT {
7503    pub sType: VkStructureType,
7504    pub pNext: *mut c_void,
7505    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
7506    pub maxShaderBindingTableRecordIndex: u32,
7507}
7508
7509#[derive(Clone, Copy)]
7510#[repr(C)]
7511pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
7512    pub sType: VkStructureType,
7513    pub pNext: *mut c_void,
7514    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
7515}
7516
7517#[derive(Clone, Copy)]
7518#[repr(C)]
7519pub struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
7520    pub sType: VkStructureType,
7521    pub pNext: *mut c_void,
7522    pub spheres: VkBool32,
7523    pub linearSweptSpheres: VkBool32,
7524}
7525
7526#[derive(Clone, Copy)]
7527#[repr(C)]
7528pub struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
7529    pub sType: VkStructureType,
7530    pub pNext: *mut c_void,
7531    pub rayTracingMaintenance1: VkBool32,
7532    pub rayTracingPipelineTraceRaysIndirect2: VkBool32,
7533}
7534
7535#[derive(Clone, Copy)]
7536#[repr(C)]
7537pub struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
7538    pub sType: VkStructureType,
7539    pub pNext: *mut c_void,
7540    pub rayTracingMotionBlur: VkBool32,
7541    pub rayTracingMotionBlurPipelineTraceRaysIndirect: VkBool32,
7542}
7543
7544#[derive(Clone, Copy)]
7545#[repr(C)]
7546pub struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
7547    pub sType: VkStructureType,
7548    pub pNext: *mut c_void,
7549    pub rayTracingPipeline: VkBool32,
7550    pub rayTracingPipelineShaderGroupHandleCaptureReplay: VkBool32,
7551    pub rayTracingPipelineShaderGroupHandleCaptureReplayMixed: VkBool32,
7552    pub rayTracingPipelineTraceRaysIndirect: VkBool32,
7553    pub rayTraversalPrimitiveCulling: VkBool32,
7554}
7555
7556#[derive(Clone, Copy)]
7557#[repr(C)]
7558pub struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
7559    pub sType: VkStructureType,
7560    pub pNext: *mut c_void,
7561    pub shaderGroupHandleSize: u32,
7562    pub maxRayRecursionDepth: u32,
7563    pub maxShaderGroupStride: u32,
7564    pub shaderGroupBaseAlignment: u32,
7565    pub shaderGroupHandleCaptureReplaySize: u32,
7566    pub maxRayDispatchInvocationCount: u32,
7567    pub shaderGroupHandleAlignment: u32,
7568    pub maxRayHitAttributeSize: u32,
7569}
7570
7571#[derive(Clone, Copy)]
7572#[repr(C)]
7573pub struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
7574    pub sType: VkStructureType,
7575    pub pNext: *mut c_void,
7576    pub rayTracingPositionFetch: VkBool32,
7577}
7578
7579#[derive(Clone, Copy)]
7580#[repr(C)]
7581pub struct VkPhysicalDeviceRayTracingPropertiesNV {
7582    pub sType: VkStructureType,
7583    pub pNext: *mut c_void,
7584    pub shaderGroupHandleSize: u32,
7585    pub maxRecursionDepth: u32,
7586    pub maxShaderGroupStride: u32,
7587    pub shaderGroupBaseAlignment: u32,
7588    pub maxGeometryCount: u64,
7589    pub maxInstanceCount: u64,
7590    pub maxTriangleCount: u64,
7591    pub maxDescriptorSetAccelerationStructures: u32,
7592}
7593
7594#[derive(Clone, Copy)]
7595#[repr(C)]
7596pub struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
7597    pub sType: VkStructureType,
7598    pub pNext: *mut c_void,
7599    pub rayTracingValidation: VkBool32,
7600}
7601
7602#[derive(Clone, Copy)]
7603#[repr(C)]
7604pub struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
7605    pub sType: VkStructureType,
7606    pub pNext: *mut c_void,
7607    pub relaxedLineRasterization: VkBool32,
7608}
7609
7610#[derive(Clone, Copy)]
7611#[repr(C)]
7612pub struct VkPhysicalDeviceRenderPassStripedFeaturesARM {
7613    pub sType: VkStructureType,
7614    pub pNext: *mut c_void,
7615    pub renderPassStriped: VkBool32,
7616}
7617
7618#[derive(Clone, Copy)]
7619#[repr(C)]
7620pub struct VkPhysicalDeviceRenderPassStripedPropertiesARM {
7621    pub sType: VkStructureType,
7622    pub pNext: *mut c_void,
7623    pub renderPassStripeGranularity: VkExtent2D,
7624    pub maxRenderPassStripes: u32,
7625}
7626
7627#[derive(Clone, Copy)]
7628#[repr(C)]
7629pub struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
7630    pub sType: VkStructureType,
7631    pub pNext: *mut c_void,
7632    pub representativeFragmentTest: VkBool32,
7633}
7634
7635#[derive(Clone, Copy)]
7636#[repr(C)]
7637pub struct VkPhysicalDeviceRobustness2FeaturesKHR {
7638    pub sType: VkStructureType,
7639    pub pNext: *mut c_void,
7640    pub robustBufferAccess2: VkBool32,
7641    pub robustImageAccess2: VkBool32,
7642    pub nullDescriptor: VkBool32,
7643}
7644
7645#[derive(Clone, Copy)]
7646#[repr(C)]
7647pub struct VkPhysicalDeviceRobustness2PropertiesKHR {
7648    pub sType: VkStructureType,
7649    pub pNext: *mut c_void,
7650    pub robustStorageBufferAccessSizeAlignment: VkDeviceSize,
7651    pub robustUniformBufferAccessSizeAlignment: VkDeviceSize,
7652}
7653
7654#[derive(Clone, Copy)]
7655#[repr(C)]
7656pub struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
7657    pub sType: VkStructureType,
7658    pub pNext: *mut c_void,
7659    pub sampleLocationSampleCounts: VkSampleCountFlags,
7660    pub maxSampleLocationGridSize: VkExtent2D,
7661    pub sampleLocationCoordinateRange: [f32; 2 as usize],
7662    pub sampleLocationSubPixelBits: u32,
7663    pub variableSampleLocations: VkBool32,
7664}
7665
7666#[derive(Clone, Copy)]
7667#[repr(C)]
7668pub struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
7669    pub sType: VkStructureType,
7670    pub pNext: *mut c_void,
7671    pub filterMinmaxSingleComponentFormats: VkBool32,
7672    pub filterMinmaxImageComponentMapping: VkBool32,
7673}
7674
7675#[derive(Clone, Copy)]
7676#[repr(C)]
7677pub struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
7678    pub sType: VkStructureType,
7679    pub pNext: *mut c_void,
7680    pub samplerYcbcrConversion: VkBool32,
7681}
7682
7683#[derive(Clone, Copy)]
7684#[repr(C)]
7685pub struct VkPhysicalDeviceScalarBlockLayoutFeatures {
7686    pub sType: VkStructureType,
7687    pub pNext: *mut c_void,
7688    pub scalarBlockLayout: VkBool32,
7689}
7690
7691#[derive(Clone, Copy)]
7692#[repr(C)]
7693pub struct VkPhysicalDeviceSchedulingControlsFeaturesARM {
7694    pub sType: VkStructureType,
7695    pub pNext: *mut c_void,
7696    pub schedulingControls: VkBool32,
7697}
7698
7699#[derive(Clone, Copy)]
7700#[repr(C)]
7701pub struct VkPhysicalDeviceSchedulingControlsPropertiesARM {
7702    pub sType: VkStructureType,
7703    pub pNext: *mut c_void,
7704    pub schedulingControlsFlags: VkPhysicalDeviceSchedulingControlsFlagsARM,
7705}
7706
7707#[derive(Clone, Copy)]
7708#[repr(C)]
7709pub struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
7710    pub sType: VkStructureType,
7711    pub pNext: *mut c_void,
7712    pub separateDepthStencilLayouts: VkBool32,
7713}
7714
7715#[derive(Clone, Copy)]
7716#[repr(C)]
7717pub struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT {
7718    pub sType: VkStructureType,
7719    pub pNext: *mut c_void,
7720    pub shader64BitIndexing: VkBool32,
7721}
7722
7723#[derive(Clone, Copy)]
7724#[repr(C)]
7725pub struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
7726    pub sType: VkStructureType,
7727    pub pNext: *mut c_void,
7728    pub shaderFloat16VectorAtomics: VkBool32,
7729}
7730
7731#[derive(Clone, Copy)]
7732#[repr(C)]
7733pub struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
7734    pub sType: VkStructureType,
7735    pub pNext: *mut c_void,
7736    pub shaderBufferFloat16Atomics: VkBool32,
7737    pub shaderBufferFloat16AtomicAdd: VkBool32,
7738    pub shaderBufferFloat16AtomicMinMax: VkBool32,
7739    pub shaderBufferFloat32AtomicMinMax: VkBool32,
7740    pub shaderBufferFloat64AtomicMinMax: VkBool32,
7741    pub shaderSharedFloat16Atomics: VkBool32,
7742    pub shaderSharedFloat16AtomicAdd: VkBool32,
7743    pub shaderSharedFloat16AtomicMinMax: VkBool32,
7744    pub shaderSharedFloat32AtomicMinMax: VkBool32,
7745    pub shaderSharedFloat64AtomicMinMax: VkBool32,
7746    pub shaderImageFloat32AtomicMinMax: VkBool32,
7747    pub sparseImageFloat32AtomicMinMax: VkBool32,
7748}
7749
7750#[derive(Clone, Copy)]
7751#[repr(C)]
7752pub struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
7753    pub sType: VkStructureType,
7754    pub pNext: *mut c_void,
7755    pub shaderBufferFloat32Atomics: VkBool32,
7756    pub shaderBufferFloat32AtomicAdd: VkBool32,
7757    pub shaderBufferFloat64Atomics: VkBool32,
7758    pub shaderBufferFloat64AtomicAdd: VkBool32,
7759    pub shaderSharedFloat32Atomics: VkBool32,
7760    pub shaderSharedFloat32AtomicAdd: VkBool32,
7761    pub shaderSharedFloat64Atomics: VkBool32,
7762    pub shaderSharedFloat64AtomicAdd: VkBool32,
7763    pub shaderImageFloat32Atomics: VkBool32,
7764    pub shaderImageFloat32AtomicAdd: VkBool32,
7765    pub sparseImageFloat32Atomics: VkBool32,
7766    pub sparseImageFloat32AtomicAdd: VkBool32,
7767}
7768
7769#[derive(Clone, Copy)]
7770#[repr(C)]
7771pub struct VkPhysicalDeviceShaderAtomicInt64Features {
7772    pub sType: VkStructureType,
7773    pub pNext: *mut c_void,
7774    pub shaderBufferInt64Atomics: VkBool32,
7775    pub shaderSharedInt64Atomics: VkBool32,
7776}
7777
7778#[derive(Clone, Copy)]
7779#[repr(C)]
7780pub struct VkPhysicalDeviceShaderBfloat16FeaturesKHR {
7781    pub sType: VkStructureType,
7782    pub pNext: *mut c_void,
7783    pub shaderBFloat16Type: VkBool32,
7784    pub shaderBFloat16DotProduct: VkBool32,
7785    pub shaderBFloat16CooperativeMatrix: VkBool32,
7786}
7787
7788#[derive(Clone, Copy)]
7789#[repr(C)]
7790pub struct VkPhysicalDeviceShaderClockFeaturesKHR {
7791    pub sType: VkStructureType,
7792    pub pNext: *mut c_void,
7793    pub shaderSubgroupClock: VkBool32,
7794    pub shaderDeviceClock: VkBool32,
7795}
7796
7797#[derive(Clone, Copy)]
7798#[repr(C)]
7799pub struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM {
7800    pub sType: VkStructureType,
7801    pub pNext: *mut c_void,
7802    pub shaderCoreBuiltins: VkBool32,
7803}
7804
7805#[derive(Clone, Copy)]
7806#[repr(C)]
7807pub struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
7808    pub sType: VkStructureType,
7809    pub pNext: *mut c_void,
7810    pub shaderCoreMask: u64,
7811    pub shaderCoreCount: u32,
7812    pub shaderWarpsPerCore: u32,
7813}
7814
7815#[derive(Clone, Copy)]
7816#[repr(C)]
7817pub struct VkPhysicalDeviceShaderCoreProperties2AMD {
7818    pub sType: VkStructureType,
7819    pub pNext: *mut c_void,
7820    pub shaderCoreFeatures: VkShaderCorePropertiesFlagsAMD,
7821    pub activeComputeUnitCount: u32,
7822}
7823
7824#[derive(Clone, Copy)]
7825#[repr(C)]
7826pub struct VkPhysicalDeviceShaderCorePropertiesAMD {
7827    pub sType: VkStructureType,
7828    pub pNext: *mut c_void,
7829    pub shaderEngineCount: u32,
7830    pub shaderArraysPerEngineCount: u32,
7831    pub computeUnitsPerShaderArray: u32,
7832    pub simdPerComputeUnit: u32,
7833    pub wavefrontsPerSimd: u32,
7834    pub wavefrontSize: u32,
7835    pub sgprsPerSimd: u32,
7836    pub minSgprAllocation: u32,
7837    pub maxSgprAllocation: u32,
7838    pub sgprAllocationGranularity: u32,
7839    pub vgprsPerSimd: u32,
7840    pub minVgprAllocation: u32,
7841    pub maxVgprAllocation: u32,
7842    pub vgprAllocationGranularity: u32,
7843}
7844
7845#[derive(Clone, Copy)]
7846#[repr(C)]
7847pub struct VkPhysicalDeviceShaderCorePropertiesARM {
7848    pub sType: VkStructureType,
7849    pub pNext: *mut c_void,
7850    pub pixelRate: u32,
7851    pub texelRate: u32,
7852    pub fmaRate: u32,
7853}
7854
7855#[derive(Clone, Copy)]
7856#[repr(C)]
7857pub struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {
7858    pub sType: VkStructureType,
7859    pub pNext: *mut c_void,
7860    pub shaderDemoteToHelperInvocation: VkBool32,
7861}
7862
7863#[derive(Clone, Copy)]
7864#[repr(C)]
7865pub struct VkPhysicalDeviceShaderDrawParametersFeatures {
7866    pub sType: VkStructureType,
7867    pub pNext: *mut c_void,
7868    pub shaderDrawParameters: VkBool32,
7869}
7870
7871#[derive(Clone, Copy)]
7872#[repr(C)]
7873pub struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
7874    pub sType: VkStructureType,
7875    pub pNext: *mut c_void,
7876    pub shaderEarlyAndLateFragmentTests: VkBool32,
7877}
7878
7879#[derive(Clone, Copy)]
7880#[repr(C)]
7881pub struct VkPhysicalDeviceShaderExpectAssumeFeatures {
7882    pub sType: VkStructureType,
7883    pub pNext: *mut c_void,
7884    pub shaderExpectAssume: VkBool32,
7885}
7886
7887#[derive(Clone, Copy)]
7888#[repr(C)]
7889pub struct VkPhysicalDeviceShaderFloat16Int8Features {
7890    pub sType: VkStructureType,
7891    pub pNext: *mut c_void,
7892    pub shaderFloat16: VkBool32,
7893    pub shaderInt8: VkBool32,
7894}
7895
7896#[derive(Clone, Copy)]
7897#[repr(C)]
7898pub struct VkPhysicalDeviceShaderFloat8FeaturesEXT {
7899    pub sType: VkStructureType,
7900    pub pNext: *mut c_void,
7901    pub shaderFloat8: VkBool32,
7902    pub shaderFloat8CooperativeMatrix: VkBool32,
7903}
7904
7905#[derive(Clone, Copy)]
7906#[repr(C)]
7907pub struct VkPhysicalDeviceShaderFloatControls2Features {
7908    pub sType: VkStructureType,
7909    pub pNext: *mut c_void,
7910    pub shaderFloatControls2: VkBool32,
7911}
7912
7913#[derive(Clone, Copy)]
7914#[repr(C)]
7915pub struct VkPhysicalDeviceShaderFmaFeaturesKHR {
7916    pub sType: VkStructureType,
7917    pub pNext: *mut c_void,
7918    pub shaderFmaFloat16: VkBool32,
7919    pub shaderFmaFloat32: VkBool32,
7920    pub shaderFmaFloat64: VkBool32,
7921}
7922
7923#[derive(Clone, Copy)]
7924#[repr(C)]
7925pub struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
7926    pub sType: VkStructureType,
7927    pub pNext: *mut c_void,
7928    pub shaderImageInt64Atomics: VkBool32,
7929    pub sparseImageInt64Atomics: VkBool32,
7930}
7931
7932#[derive(Clone, Copy)]
7933#[repr(C)]
7934pub struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
7935    pub sType: VkStructureType,
7936    pub pNext: *mut c_void,
7937    pub imageFootprint: VkBool32,
7938}
7939
7940#[derive(Clone, Copy)]
7941#[repr(C)]
7942pub struct VkPhysicalDeviceShaderIntegerDotProductFeatures {
7943    pub sType: VkStructureType,
7944    pub pNext: *mut c_void,
7945    pub shaderIntegerDotProduct: VkBool32,
7946}
7947
7948#[derive(Clone, Copy)]
7949#[repr(C)]
7950pub struct VkPhysicalDeviceShaderIntegerDotProductProperties {
7951    pub sType: VkStructureType,
7952    pub pNext: *mut c_void,
7953    pub integerDotProduct8BitUnsignedAccelerated: VkBool32,
7954    pub integerDotProduct8BitSignedAccelerated: VkBool32,
7955    pub integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
7956    pub integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
7957    pub integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
7958    pub integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
7959    pub integerDotProduct16BitUnsignedAccelerated: VkBool32,
7960    pub integerDotProduct16BitSignedAccelerated: VkBool32,
7961    pub integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
7962    pub integerDotProduct32BitUnsignedAccelerated: VkBool32,
7963    pub integerDotProduct32BitSignedAccelerated: VkBool32,
7964    pub integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
7965    pub integerDotProduct64BitUnsignedAccelerated: VkBool32,
7966    pub integerDotProduct64BitSignedAccelerated: VkBool32,
7967    pub integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
7968    pub integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
7969    pub integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
7970    pub integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
7971    pub integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
7972    pub integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
7973    pub integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
7974    pub integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
7975    pub integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
7976    pub integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
7977    pub integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
7978    pub integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
7979    pub integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
7980    pub integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
7981    pub integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
7982    pub integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
7983}
7984
7985#[derive(Clone, Copy)]
7986#[repr(C)]
7987pub struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
7988    pub sType: VkStructureType,
7989    pub pNext: *mut c_void,
7990    pub shaderIntegerFunctions2: VkBool32,
7991}
7992
7993#[derive(Clone, Copy)]
7994#[repr(C)]
7995pub struct VkPhysicalDeviceShaderLongVectorFeaturesEXT {
7996    pub sType: VkStructureType,
7997    pub pNext: *mut c_void,
7998    pub longVector: VkBool32,
7999}
8000
8001#[derive(Clone, Copy)]
8002#[repr(C)]
8003pub struct VkPhysicalDeviceShaderLongVectorPropertiesEXT {
8004    pub sType: VkStructureType,
8005    pub pNext: *mut c_void,
8006    pub maxVectorComponents: u32,
8007}
8008
8009#[derive(Clone, Copy)]
8010#[repr(C)]
8011pub struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
8012    pub sType: VkStructureType,
8013    pub pNext: *mut c_void,
8014    pub shaderMaximalReconvergence: VkBool32,
8015}
8016
8017#[derive(Clone, Copy)]
8018#[repr(C)]
8019pub struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
8020    pub sType: VkStructureType,
8021    pub pNext: *mut c_void,
8022    pub shaderModuleIdentifier: VkBool32,
8023}
8024
8025#[derive(Clone, Copy)]
8026#[repr(C)]
8027pub struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
8028    pub sType: VkStructureType,
8029    pub pNext: *mut c_void,
8030    pub shaderModuleIdentifierAlgorithmUUID: [u8; VK_UUID_SIZE as usize],
8031}
8032
8033#[derive(Clone, Copy)]
8034#[repr(C)]
8035pub struct VkPhysicalDeviceShaderObjectFeaturesEXT {
8036    pub sType: VkStructureType,
8037    pub pNext: *mut c_void,
8038    pub shaderObject: VkBool32,
8039}
8040
8041#[derive(Clone, Copy)]
8042#[repr(C)]
8043pub struct VkPhysicalDeviceShaderObjectPropertiesEXT {
8044    pub sType: VkStructureType,
8045    pub pNext: *mut c_void,
8046    pub shaderBinaryUUID: [u8; VK_UUID_SIZE as usize],
8047    pub shaderBinaryVersion: u32,
8048}
8049
8050#[derive(Clone, Copy)]
8051#[repr(C)]
8052pub struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
8053    pub sType: VkStructureType,
8054    pub pNext: *mut c_void,
8055    pub shaderQuadControl: VkBool32,
8056}
8057
8058#[derive(Clone, Copy)]
8059#[repr(C)]
8060pub struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
8061    pub sType: VkStructureType,
8062    pub pNext: *mut c_void,
8063    pub shaderRelaxedExtendedInstruction: VkBool32,
8064}
8065
8066#[derive(Clone, Copy)]
8067#[repr(C)]
8068pub struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
8069    pub sType: VkStructureType,
8070    pub pNext: *mut c_void,
8071    pub shaderReplicatedComposites: VkBool32,
8072}
8073
8074#[derive(Clone, Copy)]
8075#[repr(C)]
8076pub struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
8077    pub sType: VkStructureType,
8078    pub pNext: *mut c_void,
8079    pub shaderSMBuiltins: VkBool32,
8080}
8081
8082#[derive(Clone, Copy)]
8083#[repr(C)]
8084pub struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
8085    pub sType: VkStructureType,
8086    pub pNext: *mut c_void,
8087    pub shaderSMCount: u32,
8088    pub shaderWarpsPerSM: u32,
8089}
8090
8091#[derive(Clone, Copy)]
8092#[repr(C)]
8093pub struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
8094    pub sType: VkStructureType,
8095    pub pNext: *mut c_void,
8096    pub shaderSubgroupExtendedTypes: VkBool32,
8097}
8098
8099#[derive(Clone, Copy)]
8100#[repr(C)]
8101pub struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT {
8102    pub sType: VkStructureType,
8103    pub pNext: *mut c_void,
8104    pub shaderSubgroupPartitioned: VkBool32,
8105}
8106
8107#[derive(Clone, Copy)]
8108#[repr(C)]
8109pub struct VkPhysicalDeviceShaderSubgroupRotateFeatures {
8110    pub sType: VkStructureType,
8111    pub pNext: *mut c_void,
8112    pub shaderSubgroupRotate: VkBool32,
8113    pub shaderSubgroupRotateClustered: VkBool32,
8114}
8115
8116#[derive(Clone, Copy)]
8117#[repr(C)]
8118pub struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
8119    pub sType: VkStructureType,
8120    pub pNext: *mut c_void,
8121    pub shaderSubgroupUniformControlFlow: VkBool32,
8122}
8123
8124#[derive(Clone, Copy)]
8125#[repr(C)]
8126pub struct VkPhysicalDeviceShaderTerminateInvocationFeatures {
8127    pub sType: VkStructureType,
8128    pub pNext: *mut c_void,
8129    pub shaderTerminateInvocation: VkBool32,
8130}
8131
8132#[derive(Clone, Copy)]
8133#[repr(C)]
8134pub struct VkPhysicalDeviceShaderTileImageFeaturesEXT {
8135    pub sType: VkStructureType,
8136    pub pNext: *mut c_void,
8137    pub shaderTileImageColorReadAccess: VkBool32,
8138    pub shaderTileImageDepthReadAccess: VkBool32,
8139    pub shaderTileImageStencilReadAccess: VkBool32,
8140}
8141
8142#[derive(Clone, Copy)]
8143#[repr(C)]
8144pub struct VkPhysicalDeviceShaderTileImagePropertiesEXT {
8145    pub sType: VkStructureType,
8146    pub pNext: *mut c_void,
8147    pub shaderTileImageCoherentReadAccelerated: VkBool32,
8148    pub shaderTileImageReadSampleFromPixelRateInvocation: VkBool32,
8149    pub shaderTileImageReadFromHelperInvocation: VkBool32,
8150}
8151
8152#[derive(Clone, Copy)]
8153#[repr(C)]
8154pub struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT {
8155    pub sType: VkStructureType,
8156    pub pNext: *mut c_void,
8157    pub shaderUniformBufferUnsizedArray: VkBool32,
8158}
8159
8160#[derive(Clone, Copy)]
8161#[repr(C)]
8162pub struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR {
8163    pub sType: VkStructureType,
8164    pub pNext: *mut c_void,
8165    pub shaderUntypedPointers: VkBool32,
8166}
8167
8168#[derive(Clone, Copy)]
8169#[repr(C)]
8170pub struct VkPhysicalDeviceShadingRateImageFeaturesNV {
8171    pub sType: VkStructureType,
8172    pub pNext: *mut c_void,
8173    pub shadingRateImage: VkBool32,
8174    pub shadingRateCoarseSampleOrder: VkBool32,
8175}
8176
8177#[derive(Clone, Copy)]
8178#[repr(C)]
8179pub struct VkPhysicalDeviceShadingRateImagePropertiesNV {
8180    pub sType: VkStructureType,
8181    pub pNext: *mut c_void,
8182    pub shadingRateTexelSize: VkExtent2D,
8183    pub shadingRatePaletteSize: u32,
8184    pub shadingRateMaxCoarseSamples: u32,
8185}
8186
8187#[derive(Clone, Copy)]
8188#[repr(C)]
8189pub struct VkPhysicalDeviceSparseImageFormatInfo2 {
8190    pub sType: VkStructureType,
8191    pub pNext: *const c_void,
8192    pub format: VkFormat,
8193    pub typ: VkImageType,
8194    pub samples: VkSampleCountFlagBits,
8195    pub usage: VkImageUsageFlags,
8196    pub tiling: VkImageTiling,
8197}
8198
8199#[derive(Clone, Copy)]
8200#[repr(C)]
8201pub struct VkPhysicalDeviceSparseProperties {
8202    pub residencyStandard2DBlockShape: VkBool32,
8203    pub residencyStandard2DMultisampleBlockShape: VkBool32,
8204    pub residencyStandard3DBlockShape: VkBool32,
8205    pub residencyAlignedMipSize: VkBool32,
8206    pub residencyNonResidentStrict: VkBool32,
8207}
8208
8209#[derive(Clone, Copy)]
8210#[repr(C)]
8211pub struct VkPhysicalDeviceSubgroupProperties {
8212    pub sType: VkStructureType,
8213    pub pNext: *mut c_void,
8214    pub subgroupSize: u32,
8215    pub supportedStages: VkShaderStageFlags,
8216    pub supportedOperations: VkSubgroupFeatureFlags,
8217    pub quadOperationsInAllStages: VkBool32,
8218}
8219
8220#[derive(Clone, Copy)]
8221#[repr(C)]
8222pub struct VkPhysicalDeviceSubgroupSizeControlFeatures {
8223    pub sType: VkStructureType,
8224    pub pNext: *mut c_void,
8225    pub subgroupSizeControl: VkBool32,
8226    pub computeFullSubgroups: VkBool32,
8227}
8228
8229#[derive(Clone, Copy)]
8230#[repr(C)]
8231pub struct VkPhysicalDeviceSubgroupSizeControlProperties {
8232    pub sType: VkStructureType,
8233    pub pNext: *mut c_void,
8234    pub minSubgroupSize: u32,
8235    pub maxSubgroupSize: u32,
8236    pub maxComputeWorkgroupSubgroups: u32,
8237    pub requiredSubgroupSizeStages: VkShaderStageFlags,
8238}
8239
8240#[derive(Clone, Copy)]
8241#[repr(C)]
8242pub struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
8243    pub sType: VkStructureType,
8244    pub pNext: *mut c_void,
8245    pub subpassMergeFeedback: VkBool32,
8246}
8247
8248#[derive(Clone, Copy)]
8249#[repr(C)]
8250pub struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
8251    pub sType: VkStructureType,
8252    pub pNext: *mut c_void,
8253    pub subpassShading: VkBool32,
8254}
8255
8256#[derive(Clone, Copy)]
8257#[repr(C)]
8258pub struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
8259    pub sType: VkStructureType,
8260    pub pNext: *mut c_void,
8261    pub maxSubpassShadingWorkgroupSizeAspectRatio: u32,
8262}
8263
8264#[derive(Clone, Copy)]
8265#[repr(C)]
8266pub struct VkPhysicalDeviceSurfaceInfo2KHR {
8267    pub sType: VkStructureType,
8268    pub pNext: *const c_void,
8269    pub surface: VkSurfaceKHR,
8270}
8271
8272#[derive(Clone, Copy)]
8273#[repr(C)]
8274pub struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR {
8275    pub sType: VkStructureType,
8276    pub pNext: *mut c_void,
8277    pub swapchainMaintenance1: VkBool32,
8278}
8279
8280#[derive(Clone, Copy)]
8281#[repr(C)]
8282pub struct VkPhysicalDeviceSynchronization2Features {
8283    pub sType: VkStructureType,
8284    pub pNext: *mut c_void,
8285    pub synchronization2: VkBool32,
8286}
8287
8288#[derive(Clone, Copy)]
8289#[repr(C)]
8290pub struct VkPhysicalDeviceTensorFeaturesARM {
8291    pub sType: VkStructureType,
8292    pub pNext: *mut c_void,
8293    pub tensorNonPacked: VkBool32,
8294    pub shaderTensorAccess: VkBool32,
8295    pub shaderStorageTensorArrayDynamicIndexing: VkBool32,
8296    pub shaderStorageTensorArrayNonUniformIndexing: VkBool32,
8297    pub descriptorBindingStorageTensorUpdateAfterBind: VkBool32,
8298    pub tensors: VkBool32,
8299}
8300
8301#[derive(Clone, Copy)]
8302#[repr(C)]
8303pub struct VkPhysicalDeviceTensorPropertiesARM {
8304    pub sType: VkStructureType,
8305    pub pNext: *mut c_void,
8306    pub maxTensorDimensionCount: u32,
8307    pub maxTensorElements: u64,
8308    pub maxPerDimensionTensorElements: u64,
8309    pub maxTensorStride: i64,
8310    pub maxTensorSize: u64,
8311    pub maxTensorShaderAccessArrayLength: u32,
8312    pub maxTensorShaderAccessSize: u32,
8313    pub maxDescriptorSetStorageTensors: u32,
8314    pub maxPerStageDescriptorSetStorageTensors: u32,
8315    pub maxDescriptorSetUpdateAfterBindStorageTensors: u32,
8316    pub maxPerStageDescriptorUpdateAfterBindStorageTensors: u32,
8317    pub shaderStorageTensorArrayNonUniformIndexingNative: VkBool32,
8318    pub shaderTensorSupportedStages: VkShaderStageFlags,
8319}
8320
8321#[derive(Clone, Copy)]
8322#[repr(C)]
8323pub struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
8324    pub sType: VkStructureType,
8325    pub pNext: *mut c_void,
8326    pub texelBufferAlignment: VkBool32,
8327}
8328
8329#[derive(Clone, Copy)]
8330#[repr(C)]
8331pub struct VkPhysicalDeviceTexelBufferAlignmentProperties {
8332    pub sType: VkStructureType,
8333    pub pNext: *mut c_void,
8334    pub storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8335    pub storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
8336    pub uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8337    pub uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
8338}
8339
8340#[derive(Clone, Copy)]
8341#[repr(C)]
8342pub struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT {
8343    pub sType: VkStructureType,
8344    pub pNext: *mut c_void,
8345    pub textureCompressionASTC_3D: VkBool32,
8346}
8347
8348#[derive(Clone, Copy)]
8349#[repr(C)]
8350pub struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures {
8351    pub sType: VkStructureType,
8352    pub pNext: *mut c_void,
8353    pub textureCompressionASTC_HDR: VkBool32,
8354}
8355
8356#[derive(Clone, Copy)]
8357#[repr(C)]
8358pub struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM {
8359    pub sType: VkStructureType,
8360    pub pNext: *mut c_void,
8361    pub tileMemoryHeap: VkBool32,
8362}
8363
8364#[derive(Clone, Copy)]
8365#[repr(C)]
8366pub struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM {
8367    pub sType: VkStructureType,
8368    pub pNext: *mut c_void,
8369    pub queueSubmitBoundary: VkBool32,
8370    pub tileBufferTransfers: VkBool32,
8371}
8372
8373#[derive(Clone, Copy)]
8374#[repr(C)]
8375pub struct VkPhysicalDeviceTilePropertiesFeaturesQCOM {
8376    pub sType: VkStructureType,
8377    pub pNext: *mut c_void,
8378    pub tileProperties: VkBool32,
8379}
8380
8381#[derive(Clone, Copy)]
8382#[repr(C)]
8383pub struct VkPhysicalDeviceTileShadingFeaturesQCOM {
8384    pub sType: VkStructureType,
8385    pub pNext: *mut c_void,
8386    pub tileShading: VkBool32,
8387    pub tileShadingFragmentStage: VkBool32,
8388    pub tileShadingColorAttachments: VkBool32,
8389    pub tileShadingDepthAttachments: VkBool32,
8390    pub tileShadingStencilAttachments: VkBool32,
8391    pub tileShadingInputAttachments: VkBool32,
8392    pub tileShadingSampledAttachments: VkBool32,
8393    pub tileShadingPerTileDraw: VkBool32,
8394    pub tileShadingPerTileDispatch: VkBool32,
8395    pub tileShadingDispatchTile: VkBool32,
8396    pub tileShadingApron: VkBool32,
8397    pub tileShadingAnisotropicApron: VkBool32,
8398    pub tileShadingAtomicOps: VkBool32,
8399    pub tileShadingImageProcessing: VkBool32,
8400}
8401
8402#[derive(Clone, Copy)]
8403#[repr(C)]
8404pub struct VkPhysicalDeviceTileShadingPropertiesQCOM {
8405    pub sType: VkStructureType,
8406    pub pNext: *mut c_void,
8407    pub maxApronSize: u32,
8408    pub preferNonCoherent: VkBool32,
8409    pub tileGranularity: VkExtent2D,
8410    pub maxTileShadingRate: VkExtent2D,
8411}
8412
8413#[derive(Clone, Copy)]
8414#[repr(C)]
8415pub struct VkPhysicalDeviceTimelineSemaphoreFeatures {
8416    pub sType: VkStructureType,
8417    pub pNext: *mut c_void,
8418    pub timelineSemaphore: VkBool32,
8419}
8420
8421#[derive(Clone, Copy)]
8422#[repr(C)]
8423pub struct VkPhysicalDeviceTimelineSemaphoreProperties {
8424    pub sType: VkStructureType,
8425    pub pNext: *mut c_void,
8426    pub maxTimelineSemaphoreValueDifference: u64,
8427}
8428
8429#[derive(Clone, Copy)]
8430#[repr(C)]
8431pub struct VkPhysicalDeviceToolProperties {
8432    pub sType: VkStructureType,
8433    pub pNext: *mut c_void,
8434    pub name: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
8435    pub version: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
8436    pub purposes: VkToolPurposeFlags,
8437    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
8438    pub layer: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
8439}
8440
8441#[derive(Clone, Copy)]
8442#[repr(C)]
8443pub struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
8444    pub sType: VkStructureType,
8445    pub pNext: *mut c_void,
8446    pub transformFeedback: VkBool32,
8447    pub geometryStreams: VkBool32,
8448}
8449
8450#[derive(Clone, Copy)]
8451#[repr(C)]
8452pub struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
8453    pub sType: VkStructureType,
8454    pub pNext: *mut c_void,
8455    pub maxTransformFeedbackStreams: u32,
8456    pub maxTransformFeedbackBuffers: u32,
8457    pub maxTransformFeedbackBufferSize: VkDeviceSize,
8458    pub maxTransformFeedbackStreamDataSize: u32,
8459    pub maxTransformFeedbackBufferDataSize: u32,
8460    pub maxTransformFeedbackBufferDataStride: u32,
8461    pub transformFeedbackQueries: VkBool32,
8462    pub transformFeedbackStreamsLinesTriangles: VkBool32,
8463    pub transformFeedbackRasterizationStreamSelect: VkBool32,
8464    pub transformFeedbackDraw: VkBool32,
8465}
8466
8467#[derive(Clone, Copy)]
8468#[repr(C)]
8469pub struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR {
8470    pub sType: VkStructureType,
8471    pub pNext: *mut c_void,
8472    pub unifiedImageLayouts: VkBool32,
8473    pub unifiedImageLayoutsVideo: VkBool32,
8474}
8475
8476#[derive(Clone, Copy)]
8477#[repr(C)]
8478pub struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
8479    pub sType: VkStructureType,
8480    pub pNext: *mut c_void,
8481    pub uniformBufferStandardLayout: VkBool32,
8482}
8483
8484#[derive(Clone, Copy)]
8485#[repr(C)]
8486pub struct VkPhysicalDeviceVariablePointersFeatures {
8487    pub sType: VkStructureType,
8488    pub pNext: *mut c_void,
8489    pub variablePointersStorageBuffer: VkBool32,
8490    pub variablePointers: VkBool32,
8491}
8492
8493#[derive(Clone, Copy)]
8494#[repr(C)]
8495pub struct VkPhysicalDeviceVertexAttributeDivisorFeatures {
8496    pub sType: VkStructureType,
8497    pub pNext: *mut c_void,
8498    pub vertexAttributeInstanceRateDivisor: VkBool32,
8499    pub vertexAttributeInstanceRateZeroDivisor: VkBool32,
8500}
8501
8502#[derive(Clone, Copy)]
8503#[repr(C)]
8504pub struct VkPhysicalDeviceVertexAttributeDivisorProperties {
8505    pub sType: VkStructureType,
8506    pub pNext: *mut c_void,
8507    pub maxVertexAttribDivisor: u32,
8508    pub supportsNonZeroFirstInstance: VkBool32,
8509}
8510
8511#[derive(Clone, Copy)]
8512#[repr(C)]
8513pub struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
8514    pub sType: VkStructureType,
8515    pub pNext: *mut c_void,
8516    pub maxVertexAttribDivisor: u32,
8517}
8518
8519#[derive(Clone, Copy)]
8520#[repr(C)]
8521pub struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
8522    pub sType: VkStructureType,
8523    pub pNext: *mut c_void,
8524    pub vertexAttributeRobustness: VkBool32,
8525}
8526
8527#[derive(Clone, Copy)]
8528#[repr(C)]
8529pub struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
8530    pub sType: VkStructureType,
8531    pub pNext: *mut c_void,
8532    pub vertexInputDynamicState: VkBool32,
8533}
8534
8535#[derive(Clone, Copy)]
8536#[repr(C)]
8537pub struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR {
8538    pub sType: VkStructureType,
8539    pub pNext: *mut c_void,
8540    pub videoDecodeVP9: VkBool32,
8541}
8542
8543#[derive(Clone, Copy)]
8544#[repr(C)]
8545pub struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR {
8546    pub sType: VkStructureType,
8547    pub pNext: *mut c_void,
8548    pub videoEncodeAV1: VkBool32,
8549}
8550
8551#[derive(Clone, Copy)]
8552#[repr(C)]
8553pub struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {
8554    pub sType: VkStructureType,
8555    pub pNext: *mut c_void,
8556    pub videoEncodeIntraRefresh: VkBool32,
8557}
8558
8559#[derive(Clone, Copy)]
8560#[repr(C)]
8561pub struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
8562    pub sType: VkStructureType,
8563    pub pNext: *const c_void,
8564    pub pVideoProfile: *const VkVideoProfileInfoKHR,
8565    pub qualityLevel: u32,
8566}
8567
8568#[derive(Clone, Copy)]
8569#[repr(C)]
8570pub struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
8571    pub sType: VkStructureType,
8572    pub pNext: *mut c_void,
8573    pub videoEncodeQuantizationMap: VkBool32,
8574}
8575
8576#[derive(Clone, Copy)]
8577#[repr(C)]
8578pub struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
8579    pub sType: VkStructureType,
8580    pub pNext: *mut c_void,
8581    pub videoEncodeRgbConversion: VkBool32,
8582}
8583
8584#[derive(Clone, Copy)]
8585#[repr(C)]
8586pub struct VkPhysicalDeviceVideoFormatInfoKHR {
8587    pub sType: VkStructureType,
8588    pub pNext: *const c_void,
8589    pub imageUsage: VkImageUsageFlags,
8590}
8591
8592#[derive(Clone, Copy)]
8593#[repr(C)]
8594pub struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
8595    pub sType: VkStructureType,
8596    pub pNext: *mut c_void,
8597    pub videoMaintenance1: VkBool32,
8598}
8599
8600#[derive(Clone, Copy)]
8601#[repr(C)]
8602pub struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
8603    pub sType: VkStructureType,
8604    pub pNext: *mut c_void,
8605    pub videoMaintenance2: VkBool32,
8606}
8607
8608#[derive(Clone, Copy)]
8609#[repr(C)]
8610pub struct VkPhysicalDeviceVulkan11Features {
8611    pub sType: VkStructureType,
8612    pub pNext: *mut c_void,
8613    pub storageBuffer16BitAccess: VkBool32,
8614    pub uniformAndStorageBuffer16BitAccess: VkBool32,
8615    pub storagePushConstant16: VkBool32,
8616    pub storageInputOutput16: VkBool32,
8617    pub multiview: VkBool32,
8618    pub multiviewGeometryShader: VkBool32,
8619    pub multiviewTessellationShader: VkBool32,
8620    pub variablePointersStorageBuffer: VkBool32,
8621    pub variablePointers: VkBool32,
8622    pub protectedMemory: VkBool32,
8623    pub samplerYcbcrConversion: VkBool32,
8624    pub shaderDrawParameters: VkBool32,
8625}
8626
8627#[derive(Clone, Copy)]
8628#[repr(C)]
8629pub struct VkPhysicalDeviceVulkan11Properties {
8630    pub sType: VkStructureType,
8631    pub pNext: *mut c_void,
8632    pub deviceUUID: [u8; VK_UUID_SIZE as usize],
8633    pub driverUUID: [u8; VK_UUID_SIZE as usize],
8634    pub deviceLUID: [u8; VK_LUID_SIZE as usize],
8635    pub deviceNodeMask: u32,
8636    pub deviceLUIDValid: VkBool32,
8637    pub subgroupSize: u32,
8638    pub subgroupSupportedStages: VkShaderStageFlags,
8639    pub subgroupSupportedOperations: VkSubgroupFeatureFlags,
8640    pub subgroupQuadOperationsInAllStages: VkBool32,
8641    pub pointClippingBehavior: VkPointClippingBehavior,
8642    pub maxMultiviewViewCount: u32,
8643    pub maxMultiviewInstanceIndex: u32,
8644    pub protectedNoFault: VkBool32,
8645    pub maxPerSetDescriptors: u32,
8646    pub maxMemoryAllocationSize: VkDeviceSize,
8647}
8648
8649#[derive(Clone, Copy)]
8650#[repr(C)]
8651pub struct VkPhysicalDeviceVulkan12Features {
8652    pub sType: VkStructureType,
8653    pub pNext: *mut c_void,
8654    pub samplerMirrorClampToEdge: VkBool32,
8655    pub drawIndirectCount: VkBool32,
8656    pub storageBuffer8BitAccess: VkBool32,
8657    pub uniformAndStorageBuffer8BitAccess: VkBool32,
8658    pub storagePushConstant8: VkBool32,
8659    pub shaderBufferInt64Atomics: VkBool32,
8660    pub shaderSharedInt64Atomics: VkBool32,
8661    pub shaderFloat16: VkBool32,
8662    pub shaderInt8: VkBool32,
8663    pub descriptorIndexing: VkBool32,
8664    pub shaderInputAttachmentArrayDynamicIndexing: VkBool32,
8665    pub shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
8666    pub shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
8667    pub shaderUniformBufferArrayNonUniformIndexing: VkBool32,
8668    pub shaderSampledImageArrayNonUniformIndexing: VkBool32,
8669    pub shaderStorageBufferArrayNonUniformIndexing: VkBool32,
8670    pub shaderStorageImageArrayNonUniformIndexing: VkBool32,
8671    pub shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
8672    pub shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
8673    pub shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
8674    pub descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
8675    pub descriptorBindingSampledImageUpdateAfterBind: VkBool32,
8676    pub descriptorBindingStorageImageUpdateAfterBind: VkBool32,
8677    pub descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
8678    pub descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
8679    pub descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
8680    pub descriptorBindingUpdateUnusedWhilePending: VkBool32,
8681    pub descriptorBindingPartiallyBound: VkBool32,
8682    pub descriptorBindingVariableDescriptorCount: VkBool32,
8683    pub runtimeDescriptorArray: VkBool32,
8684    pub samplerFilterMinmax: VkBool32,
8685    pub scalarBlockLayout: VkBool32,
8686    pub imagelessFramebuffer: VkBool32,
8687    pub uniformBufferStandardLayout: VkBool32,
8688    pub shaderSubgroupExtendedTypes: VkBool32,
8689    pub separateDepthStencilLayouts: VkBool32,
8690    pub hostQueryReset: VkBool32,
8691    pub timelineSemaphore: VkBool32,
8692    pub bufferDeviceAddress: VkBool32,
8693    pub bufferDeviceAddressCaptureReplay: VkBool32,
8694    pub bufferDeviceAddressMultiDevice: VkBool32,
8695    pub vulkanMemoryModel: VkBool32,
8696    pub vulkanMemoryModelDeviceScope: VkBool32,
8697    pub vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
8698    pub shaderOutputViewportIndex: VkBool32,
8699    pub shaderOutputLayer: VkBool32,
8700    pub subgroupBroadcastDynamicId: VkBool32,
8701}
8702
8703#[derive(Clone, Copy)]
8704#[repr(C)]
8705pub struct VkPhysicalDeviceVulkan12Properties {
8706    pub sType: VkStructureType,
8707    pub pNext: *mut c_void,
8708    pub driverID: VkDriverId,
8709    pub driverName: [c_char; VK_MAX_DRIVER_NAME_SIZE as usize],
8710    pub driverInfo: [c_char; VK_MAX_DRIVER_INFO_SIZE as usize],
8711    pub conformanceVersion: VkConformanceVersion,
8712    pub denormBehaviorIndependence: VkShaderFloatControlsIndependence,
8713    pub roundingModeIndependence: VkShaderFloatControlsIndependence,
8714    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
8715    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
8716    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
8717    pub shaderDenormPreserveFloat16: VkBool32,
8718    pub shaderDenormPreserveFloat32: VkBool32,
8719    pub shaderDenormPreserveFloat64: VkBool32,
8720    pub shaderDenormFlushToZeroFloat16: VkBool32,
8721    pub shaderDenormFlushToZeroFloat32: VkBool32,
8722    pub shaderDenormFlushToZeroFloat64: VkBool32,
8723    pub shaderRoundingModeRTEFloat16: VkBool32,
8724    pub shaderRoundingModeRTEFloat32: VkBool32,
8725    pub shaderRoundingModeRTEFloat64: VkBool32,
8726    pub shaderRoundingModeRTZFloat16: VkBool32,
8727    pub shaderRoundingModeRTZFloat32: VkBool32,
8728    pub shaderRoundingModeRTZFloat64: VkBool32,
8729    pub maxUpdateAfterBindDescriptorsInAllPools: u32,
8730    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
8731    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
8732    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
8733    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
8734    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
8735    pub robustBufferAccessUpdateAfterBind: VkBool32,
8736    pub quadDivergentImplicitLod: VkBool32,
8737    pub maxPerStageDescriptorUpdateAfterBindSamplers: u32,
8738    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
8739    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
8740    pub maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
8741    pub maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
8742    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
8743    pub maxPerStageUpdateAfterBindResources: u32,
8744    pub maxDescriptorSetUpdateAfterBindSamplers: u32,
8745    pub maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
8746    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
8747    pub maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
8748    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
8749    pub maxDescriptorSetUpdateAfterBindSampledImages: u32,
8750    pub maxDescriptorSetUpdateAfterBindStorageImages: u32,
8751    pub maxDescriptorSetUpdateAfterBindInputAttachments: u32,
8752    pub supportedDepthResolveModes: VkResolveModeFlags,
8753    pub supportedStencilResolveModes: VkResolveModeFlags,
8754    pub independentResolveNone: VkBool32,
8755    pub independentResolve: VkBool32,
8756    pub filterMinmaxSingleComponentFormats: VkBool32,
8757    pub filterMinmaxImageComponentMapping: VkBool32,
8758    pub maxTimelineSemaphoreValueDifference: u64,
8759    pub framebufferIntegerColorSampleCounts: VkSampleCountFlags,
8760}
8761
8762#[derive(Clone, Copy)]
8763#[repr(C)]
8764pub struct VkPhysicalDeviceVulkan13Features {
8765    pub sType: VkStructureType,
8766    pub pNext: *mut c_void,
8767    pub robustImageAccess: VkBool32,
8768    pub inlineUniformBlock: VkBool32,
8769    pub descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
8770    pub pipelineCreationCacheControl: VkBool32,
8771    pub privateData: VkBool32,
8772    pub shaderDemoteToHelperInvocation: VkBool32,
8773    pub shaderTerminateInvocation: VkBool32,
8774    pub subgroupSizeControl: VkBool32,
8775    pub computeFullSubgroups: VkBool32,
8776    pub synchronization2: VkBool32,
8777    pub textureCompressionASTC_HDR: VkBool32,
8778    pub shaderZeroInitializeWorkgroupMemory: VkBool32,
8779    pub dynamicRendering: VkBool32,
8780    pub shaderIntegerDotProduct: VkBool32,
8781    pub maintenance4: VkBool32,
8782}
8783
8784#[derive(Clone, Copy)]
8785#[repr(C)]
8786pub struct VkPhysicalDeviceVulkan13Properties {
8787    pub sType: VkStructureType,
8788    pub pNext: *mut c_void,
8789    pub minSubgroupSize: u32,
8790    pub maxSubgroupSize: u32,
8791    pub maxComputeWorkgroupSubgroups: u32,
8792    pub requiredSubgroupSizeStages: VkShaderStageFlags,
8793    pub maxInlineUniformBlockSize: u32,
8794    pub maxPerStageDescriptorInlineUniformBlocks: u32,
8795    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
8796    pub maxDescriptorSetInlineUniformBlocks: u32,
8797    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32,
8798    pub maxInlineUniformTotalSize: u32,
8799    pub integerDotProduct8BitUnsignedAccelerated: VkBool32,
8800    pub integerDotProduct8BitSignedAccelerated: VkBool32,
8801    pub integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
8802    pub integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
8803    pub integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
8804    pub integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
8805    pub integerDotProduct16BitUnsignedAccelerated: VkBool32,
8806    pub integerDotProduct16BitSignedAccelerated: VkBool32,
8807    pub integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
8808    pub integerDotProduct32BitUnsignedAccelerated: VkBool32,
8809    pub integerDotProduct32BitSignedAccelerated: VkBool32,
8810    pub integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
8811    pub integerDotProduct64BitUnsignedAccelerated: VkBool32,
8812    pub integerDotProduct64BitSignedAccelerated: VkBool32,
8813    pub integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
8814    pub integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
8815    pub integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
8816    pub integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
8817    pub integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
8818    pub integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
8819    pub integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
8820    pub integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
8821    pub integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
8822    pub integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
8823    pub integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
8824    pub integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
8825    pub integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
8826    pub integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
8827    pub integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
8828    pub integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
8829    pub storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8830    pub storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
8831    pub uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8832    pub uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
8833    pub maxBufferSize: VkDeviceSize,
8834}
8835
8836#[derive(Clone, Copy)]
8837#[repr(C)]
8838pub struct VkPhysicalDeviceVulkan14Features {
8839    pub sType: VkStructureType,
8840    pub pNext: *mut c_void,
8841    pub globalPriorityQuery: VkBool32,
8842    pub shaderSubgroupRotate: VkBool32,
8843    pub shaderSubgroupRotateClustered: VkBool32,
8844    pub shaderFloatControls2: VkBool32,
8845    pub shaderExpectAssume: VkBool32,
8846    pub rectangularLines: VkBool32,
8847    pub bresenhamLines: VkBool32,
8848    pub smoothLines: VkBool32,
8849    pub stippledRectangularLines: VkBool32,
8850    pub stippledBresenhamLines: VkBool32,
8851    pub stippledSmoothLines: VkBool32,
8852    pub vertexAttributeInstanceRateDivisor: VkBool32,
8853    pub vertexAttributeInstanceRateZeroDivisor: VkBool32,
8854    pub indexTypeUint8: VkBool32,
8855    pub dynamicRenderingLocalRead: VkBool32,
8856    pub maintenance5: VkBool32,
8857    pub maintenance6: VkBool32,
8858    pub pipelineProtectedAccess: VkBool32,
8859    pub pipelineRobustness: VkBool32,
8860    pub hostImageCopy: VkBool32,
8861    pub pushDescriptor: VkBool32,
8862}
8863
8864#[derive(Clone, Copy)]
8865#[repr(C)]
8866pub struct VkPhysicalDeviceVulkan14Properties {
8867    pub sType: VkStructureType,
8868    pub pNext: *mut c_void,
8869    pub lineSubPixelPrecisionBits: u32,
8870    pub maxVertexAttribDivisor: u32,
8871    pub supportsNonZeroFirstInstance: VkBool32,
8872    pub maxPushDescriptors: u32,
8873    pub dynamicRenderingLocalReadDepthStencilAttachments: VkBool32,
8874    pub dynamicRenderingLocalReadMultisampledAttachments: VkBool32,
8875    pub earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
8876    pub earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
8877    pub depthStencilSwizzleOneSupport: VkBool32,
8878    pub polygonModePointSize: VkBool32,
8879    pub nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
8880    pub nonStrictWideLinesUseParallelogram: VkBool32,
8881    pub blockTexelViewCompatibleMultipleLayers: VkBool32,
8882    pub maxCombinedImageSamplerDescriptorCount: u32,
8883    pub fragmentShadingRateClampCombinerInputs: VkBool32,
8884    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
8885    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
8886    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
8887    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
8888    pub copySrcLayoutCount: u32,
8889    pub pCopySrcLayouts: *mut VkImageLayout,
8890    pub copyDstLayoutCount: u32,
8891    pub pCopyDstLayouts: *mut VkImageLayout,
8892    pub optimalTilingLayoutUUID: [u8; VK_UUID_SIZE as usize],
8893    pub identicalMemoryTypeRequirements: VkBool32,
8894}
8895
8896#[derive(Clone, Copy)]
8897#[repr(C)]
8898pub struct VkPhysicalDeviceVulkanMemoryModelFeatures {
8899    pub sType: VkStructureType,
8900    pub pNext: *mut c_void,
8901    pub vulkanMemoryModel: VkBool32,
8902    pub vulkanMemoryModelDeviceScope: VkBool32,
8903    pub vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
8904}
8905
8906#[derive(Clone, Copy)]
8907#[repr(C)]
8908pub struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
8909    pub sType: VkStructureType,
8910    pub pNext: *mut c_void,
8911    pub workgroupMemoryExplicitLayout: VkBool32,
8912    pub workgroupMemoryExplicitLayoutScalarBlockLayout: VkBool32,
8913    pub workgroupMemoryExplicitLayout8BitAccess: VkBool32,
8914    pub workgroupMemoryExplicitLayout16BitAccess: VkBool32,
8915}
8916
8917#[derive(Clone, Copy)]
8918#[repr(C)]
8919pub struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
8920    pub sType: VkStructureType,
8921    pub pNext: *mut c_void,
8922    pub ycbcr2plane444Formats: VkBool32,
8923}
8924
8925#[derive(Clone, Copy)]
8926#[repr(C)]
8927pub struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
8928    pub sType: VkStructureType,
8929    pub pNext: *mut c_void,
8930    pub ycbcrDegamma: VkBool32,
8931}
8932
8933#[derive(Clone, Copy)]
8934#[repr(C)]
8935pub struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
8936    pub sType: VkStructureType,
8937    pub pNext: *mut c_void,
8938    pub ycbcrImageArrays: VkBool32,
8939}
8940
8941#[derive(Clone, Copy)]
8942#[repr(C)]
8943pub struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {
8944    pub sType: VkStructureType,
8945    pub pNext: *mut c_void,
8946    pub zeroInitializeDeviceMemory: VkBool32,
8947}
8948
8949#[derive(Clone, Copy)]
8950#[repr(C)]
8951pub struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
8952    pub sType: VkStructureType,
8953    pub pNext: *mut c_void,
8954    pub shaderZeroInitializeWorkgroupMemory: VkBool32,
8955}
8956
8957#[repr(C)]
8958pub struct VkPhysicalDevice_T {
8959    _data: (),
8960    _marker: PhantomData<(*mut u8, PhantomPinned)>,
8961}
8962
8963#[derive(Clone, Copy)]
8964#[repr(C)]
8965pub struct VkPipelineBinaryCreateInfoKHR {
8966    pub sType: VkStructureType,
8967    pub pNext: *const c_void,
8968    pub pKeysAndDataInfo: *const VkPipelineBinaryKeysAndDataKHR,
8969    pub pipeline: VkPipeline,
8970    pub pPipelineCreateInfo: *const VkPipelineCreateInfoKHR,
8971}
8972
8973#[derive(Clone, Copy)]
8974#[repr(C)]
8975pub struct VkPipelineBinaryDataInfoKHR {
8976    pub sType: VkStructureType,
8977    pub pNext: *mut c_void,
8978    pub pipelineBinary: VkPipelineBinaryKHR,
8979}
8980
8981#[derive(Clone, Copy)]
8982#[repr(C)]
8983pub struct VkPipelineBinaryDataKHR {
8984    pub dataSize: usize,
8985    pub pData: *mut c_void,
8986}
8987
8988#[derive(Clone, Copy)]
8989#[repr(C)]
8990pub struct VkPipelineBinaryHandlesInfoKHR {
8991    pub sType: VkStructureType,
8992    pub pNext: *const c_void,
8993    pub pipelineBinaryCount: u32,
8994    pub pPipelineBinaries: *mut VkPipelineBinaryKHR,
8995}
8996
8997#[derive(Clone, Copy)]
8998#[repr(C)]
8999pub struct VkPipelineBinaryInfoKHR {
9000    pub sType: VkStructureType,
9001    pub pNext: *const c_void,
9002    pub binaryCount: u32,
9003    pub pPipelineBinaries: *const VkPipelineBinaryKHR,
9004}
9005
9006#[repr(C)]
9007pub struct VkPipelineBinaryKHR_T {
9008    _data: (),
9009    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9010}
9011
9012#[derive(Clone, Copy)]
9013#[repr(C)]
9014pub struct VkPipelineBinaryKeyKHR {
9015    pub sType: VkStructureType,
9016    pub pNext: *mut c_void,
9017    pub keySize: u32,
9018    pub key: [u8; VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR as usize],
9019}
9020
9021#[derive(Clone, Copy)]
9022#[repr(C)]
9023pub struct VkPipelineBinaryKeysAndDataKHR {
9024    pub binaryCount: u32,
9025    pub pPipelineBinaryKeys: *const VkPipelineBinaryKeyKHR,
9026    pub pPipelineBinaryData: *const VkPipelineBinaryDataKHR,
9027}
9028
9029#[derive(Clone, Copy)]
9030#[repr(C)]
9031pub struct VkPipelineCacheCreateInfo {
9032    pub sType: VkStructureType,
9033    pub pNext: *const c_void,
9034    pub flags: VkPipelineCacheCreateFlags,
9035    pub initialDataSize: usize,
9036    pub pInitialData: *const c_void,
9037}
9038
9039#[derive(Clone, Copy)]
9040#[repr(C)]
9041pub struct VkPipelineCacheHeaderVersionDataGraphQCOM {
9042    pub headerSize: u32,
9043    pub headerVersion: VkPipelineCacheHeaderVersion,
9044    pub cacheType: VkDataGraphModelCacheTypeQCOM,
9045    pub cacheVersion: u32,
9046    pub toolchainVersion: [u32; VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM as usize],
9047}
9048
9049#[derive(Clone, Copy)]
9050#[repr(C)]
9051pub struct VkPipelineCacheHeaderVersionOne {
9052    pub headerSize: u32,
9053    pub headerVersion: VkPipelineCacheHeaderVersion,
9054    pub vendorID: u32,
9055    pub deviceID: u32,
9056    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
9057}
9058
9059#[repr(C)]
9060pub struct VkPipelineCache_T {
9061    _data: (),
9062    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9063}
9064
9065#[derive(Clone, Copy)]
9066#[repr(C)]
9067pub struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
9068    pub sType: VkStructureType,
9069    pub pNext: *const c_void,
9070    pub srcPremultiplied: VkBool32,
9071    pub dstPremultiplied: VkBool32,
9072    pub blendOverlap: VkBlendOverlapEXT,
9073}
9074
9075#[derive(Clone, Copy)]
9076#[repr(C)]
9077pub struct VkPipelineColorBlendAttachmentState {
9078    pub blendEnable: VkBool32,
9079    pub srcColorBlendFactor: VkBlendFactor,
9080    pub dstColorBlendFactor: VkBlendFactor,
9081    pub colorBlendOp: VkBlendOp,
9082    pub srcAlphaBlendFactor: VkBlendFactor,
9083    pub dstAlphaBlendFactor: VkBlendFactor,
9084    pub alphaBlendOp: VkBlendOp,
9085    pub colorWriteMask: VkColorComponentFlags,
9086}
9087
9088#[derive(Clone, Copy)]
9089#[repr(C)]
9090pub struct VkPipelineColorBlendStateCreateInfo {
9091    pub sType: VkStructureType,
9092    pub pNext: *const c_void,
9093    pub flags: VkPipelineColorBlendStateCreateFlags,
9094    pub logicOpEnable: VkBool32,
9095    pub logicOp: VkLogicOp,
9096    pub attachmentCount: u32,
9097    pub pAttachments: *const VkPipelineColorBlendAttachmentState,
9098    pub blendConstants: [f32; 4 as usize],
9099}
9100
9101#[derive(Clone, Copy)]
9102#[repr(C)]
9103pub struct VkPipelineColorWriteCreateInfoEXT {
9104    pub sType: VkStructureType,
9105    pub pNext: *const c_void,
9106    pub attachmentCount: u32,
9107    pub pColorWriteEnables: *const VkBool32,
9108}
9109
9110#[derive(Clone, Copy)]
9111#[repr(C)]
9112pub struct VkPipelineCompilerControlCreateInfoAMD {
9113    pub sType: VkStructureType,
9114    pub pNext: *const c_void,
9115    pub compilerControlFlags: VkPipelineCompilerControlFlagsAMD,
9116}
9117
9118#[derive(Clone, Copy)]
9119#[repr(C)]
9120pub struct VkPipelineCoverageModulationStateCreateInfoNV {
9121    pub sType: VkStructureType,
9122    pub pNext: *const c_void,
9123    pub flags: VkPipelineCoverageModulationStateCreateFlagsNV,
9124    pub coverageModulationMode: VkCoverageModulationModeNV,
9125    pub coverageModulationTableEnable: VkBool32,
9126    pub coverageModulationTableCount: u32,
9127    pub pCoverageModulationTable: *const f32,
9128}
9129
9130#[derive(Clone, Copy)]
9131#[repr(C)]
9132pub struct VkPipelineCoverageReductionStateCreateInfoNV {
9133    pub sType: VkStructureType,
9134    pub pNext: *const c_void,
9135    pub flags: VkPipelineCoverageReductionStateCreateFlagsNV,
9136    pub coverageReductionMode: VkCoverageReductionModeNV,
9137}
9138
9139#[derive(Clone, Copy)]
9140#[repr(C)]
9141pub struct VkPipelineCoverageToColorStateCreateInfoNV {
9142    pub sType: VkStructureType,
9143    pub pNext: *const c_void,
9144    pub flags: VkPipelineCoverageToColorStateCreateFlagsNV,
9145    pub coverageToColorEnable: VkBool32,
9146    pub coverageToColorLocation: u32,
9147}
9148
9149#[derive(Clone, Copy)]
9150#[repr(C)]
9151pub struct VkPipelineCreateFlags2CreateInfo {
9152    pub sType: VkStructureType,
9153    pub pNext: *const c_void,
9154    pub flags: VkPipelineCreateFlags2,
9155}
9156
9157#[derive(Clone, Copy)]
9158#[repr(C)]
9159pub struct VkPipelineCreateInfoKHR {
9160    pub sType: VkStructureType,
9161    pub pNext: *mut c_void,
9162}
9163
9164#[derive(Clone, Copy)]
9165#[repr(C)]
9166pub struct VkPipelineCreationFeedback {
9167    pub flags: VkPipelineCreationFeedbackFlags,
9168    pub duration: u64,
9169}
9170
9171#[derive(Clone, Copy)]
9172#[repr(C)]
9173pub struct VkPipelineCreationFeedbackCreateInfo {
9174    pub sType: VkStructureType,
9175    pub pNext: *const c_void,
9176    pub pPipelineCreationFeedback: *mut VkPipelineCreationFeedback,
9177    pub pipelineStageCreationFeedbackCount: u32,
9178    pub pPipelineStageCreationFeedbacks: *mut VkPipelineCreationFeedback,
9179}
9180
9181#[derive(Clone, Copy)]
9182#[repr(C)]
9183pub struct VkPipelineDepthStencilStateCreateInfo {
9184    pub sType: VkStructureType,
9185    pub pNext: *const c_void,
9186    pub flags: VkPipelineDepthStencilStateCreateFlags,
9187    pub depthTestEnable: VkBool32,
9188    pub depthWriteEnable: VkBool32,
9189    pub depthCompareOp: VkCompareOp,
9190    pub depthBoundsTestEnable: VkBool32,
9191    pub stencilTestEnable: VkBool32,
9192    pub front: VkStencilOpState,
9193    pub back: VkStencilOpState,
9194    pub minDepthBounds: f32,
9195    pub maxDepthBounds: f32,
9196}
9197
9198#[derive(Clone, Copy)]
9199#[repr(C)]
9200pub struct VkPipelineDiscardRectangleStateCreateInfoEXT {
9201    pub sType: VkStructureType,
9202    pub pNext: *const c_void,
9203    pub flags: VkPipelineDiscardRectangleStateCreateFlagsEXT,
9204    pub discardRectangleMode: VkDiscardRectangleModeEXT,
9205    pub discardRectangleCount: u32,
9206    pub pDiscardRectangles: *const VkRect2D,
9207}
9208
9209#[derive(Clone, Copy)]
9210#[repr(C)]
9211pub struct VkPipelineDynamicStateCreateInfo {
9212    pub sType: VkStructureType,
9213    pub pNext: *const c_void,
9214    pub flags: VkPipelineDynamicStateCreateFlags,
9215    pub dynamicStateCount: u32,
9216    pub pDynamicStates: *const VkDynamicState,
9217}
9218
9219#[derive(Clone, Copy)]
9220#[repr(C)]
9221pub struct VkPipelineExecutableInfoKHR {
9222    pub sType: VkStructureType,
9223    pub pNext: *const c_void,
9224    pub pipeline: VkPipeline,
9225    pub executableIndex: u32,
9226}
9227
9228#[derive(Clone, Copy)]
9229#[repr(C)]
9230pub struct VkPipelineExecutableInternalRepresentationKHR {
9231    pub sType: VkStructureType,
9232    pub pNext: *mut c_void,
9233    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9234    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9235    pub isText: VkBool32,
9236    pub dataSize: usize,
9237    pub pData: *mut c_void,
9238}
9239
9240#[derive(Clone, Copy)]
9241#[repr(C)]
9242pub struct VkPipelineExecutablePropertiesKHR {
9243    pub sType: VkStructureType,
9244    pub pNext: *mut c_void,
9245    pub stages: VkShaderStageFlags,
9246    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9247    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9248    pub subgroupSize: u32,
9249}
9250
9251#[derive(Clone, Copy)]
9252#[repr(C)]
9253pub struct VkPipelineExecutableStatisticKHR {
9254    pub sType: VkStructureType,
9255    pub pNext: *mut c_void,
9256    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9257    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9258    pub format: VkPipelineExecutableStatisticFormatKHR,
9259    pub value: VkPipelineExecutableStatisticValueKHR,
9260}
9261
9262#[derive(Clone, Copy)]
9263#[repr(C)]
9264pub struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE {
9265    pub sType: VkStructureType,
9266    pub pNext: *const c_void,
9267    pub maxFragmentDensityMapLayers: u32,
9268}
9269
9270#[derive(Clone, Copy)]
9271#[repr(C)]
9272pub struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
9273    pub sType: VkStructureType,
9274    pub pNext: *const c_void,
9275    pub shadingRateType: VkFragmentShadingRateTypeNV,
9276    pub shadingRate: VkFragmentShadingRateNV,
9277    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
9278}
9279
9280#[derive(Clone, Copy)]
9281#[repr(C)]
9282pub struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
9283    pub sType: VkStructureType,
9284    pub pNext: *const c_void,
9285    pub fragmentSize: VkExtent2D,
9286    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
9287}
9288
9289#[derive(Clone, Copy)]
9290#[repr(C)]
9291pub struct VkPipelineIndirectDeviceAddressInfoNV {
9292    pub sType: VkStructureType,
9293    pub pNext: *const c_void,
9294    pub pipelineBindPoint: VkPipelineBindPoint,
9295    pub pipeline: VkPipeline,
9296}
9297
9298#[derive(Clone, Copy)]
9299#[repr(C)]
9300pub struct VkPipelineInfoKHR {
9301    pub sType: VkStructureType,
9302    pub pNext: *const c_void,
9303    pub pipeline: VkPipeline,
9304}
9305
9306#[derive(Clone, Copy)]
9307#[repr(C)]
9308pub struct VkPipelineInputAssemblyStateCreateInfo {
9309    pub sType: VkStructureType,
9310    pub pNext: *const c_void,
9311    pub flags: VkPipelineInputAssemblyStateCreateFlags,
9312    pub topology: VkPrimitiveTopology,
9313    pub primitiveRestartEnable: VkBool32,
9314}
9315
9316#[derive(Clone, Copy)]
9317#[repr(C)]
9318pub struct VkPipelineLayoutCreateInfo {
9319    pub sType: VkStructureType,
9320    pub pNext: *const c_void,
9321    pub flags: VkPipelineLayoutCreateFlags,
9322    pub setLayoutCount: u32,
9323    pub pSetLayouts: *const VkDescriptorSetLayout,
9324    pub pushConstantRangeCount: u32,
9325    pub pPushConstantRanges: *const VkPushConstantRange,
9326}
9327
9328#[repr(C)]
9329pub struct VkPipelineLayout_T {
9330    _data: (),
9331    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9332}
9333
9334#[derive(Clone, Copy)]
9335#[repr(C)]
9336pub struct VkPipelineLibraryCreateInfoKHR {
9337    pub sType: VkStructureType,
9338    pub pNext: *const c_void,
9339    pub libraryCount: u32,
9340    pub pLibraries: *const VkPipeline,
9341}
9342
9343#[derive(Clone, Copy)]
9344#[repr(C)]
9345pub struct VkPipelineMultisampleStateCreateInfo {
9346    pub sType: VkStructureType,
9347    pub pNext: *const c_void,
9348    pub flags: VkPipelineMultisampleStateCreateFlags,
9349    pub rasterizationSamples: VkSampleCountFlagBits,
9350    pub sampleShadingEnable: VkBool32,
9351    pub minSampleShading: f32,
9352    pub pSampleMask: *const VkSampleMask,
9353    pub alphaToCoverageEnable: VkBool32,
9354    pub alphaToOneEnable: VkBool32,
9355}
9356
9357#[derive(Clone, Copy)]
9358#[repr(C)]
9359pub struct VkPipelinePropertiesIdentifierEXT {
9360    pub sType: VkStructureType,
9361    pub pNext: *mut c_void,
9362    pub pipelineIdentifier: [u8; VK_UUID_SIZE as usize],
9363}
9364
9365#[derive(Clone, Copy)]
9366#[repr(C)]
9367pub struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
9368    pub sType: VkStructureType,
9369    pub pNext: *const c_void,
9370    pub flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT,
9371    pub conservativeRasterizationMode: VkConservativeRasterizationModeEXT,
9372    pub extraPrimitiveOverestimationSize: f32,
9373}
9374
9375#[derive(Clone, Copy)]
9376#[repr(C)]
9377pub struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
9378    pub sType: VkStructureType,
9379    pub pNext: *const c_void,
9380    pub flags: VkPipelineRasterizationDepthClipStateCreateFlagsEXT,
9381    pub depthClipEnable: VkBool32,
9382}
9383
9384#[derive(Clone, Copy)]
9385#[repr(C)]
9386pub struct VkPipelineRasterizationLineStateCreateInfo {
9387    pub sType: VkStructureType,
9388    pub pNext: *const c_void,
9389    pub lineRasterizationMode: VkLineRasterizationMode,
9390    pub stippledLineEnable: VkBool32,
9391    pub lineStippleFactor: u32,
9392    pub lineStipplePattern: u16,
9393}
9394
9395#[derive(Clone, Copy)]
9396#[repr(C)]
9397pub struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
9398    pub sType: VkStructureType,
9399    pub pNext: *const c_void,
9400    pub provokingVertexMode: VkProvokingVertexModeEXT,
9401}
9402
9403#[derive(Clone, Copy)]
9404#[repr(C)]
9405pub struct VkPipelineRasterizationStateCreateInfo {
9406    pub sType: VkStructureType,
9407    pub pNext: *const c_void,
9408    pub flags: VkPipelineRasterizationStateCreateFlags,
9409    pub depthClampEnable: VkBool32,
9410    pub rasterizerDiscardEnable: VkBool32,
9411    pub polygonMode: VkPolygonMode,
9412    pub cullMode: VkCullModeFlags,
9413    pub frontFace: VkFrontFace,
9414    pub depthBiasEnable: VkBool32,
9415    pub depthBiasConstantFactor: f32,
9416    pub depthBiasClamp: f32,
9417    pub depthBiasSlopeFactor: f32,
9418    pub lineWidth: f32,
9419}
9420
9421#[derive(Clone, Copy)]
9422#[repr(C)]
9423pub struct VkPipelineRasterizationStateRasterizationOrderAMD {
9424    pub sType: VkStructureType,
9425    pub pNext: *const c_void,
9426    pub rasterizationOrder: VkRasterizationOrderAMD,
9427}
9428
9429#[derive(Clone, Copy)]
9430#[repr(C)]
9431pub struct VkPipelineRasterizationStateStreamCreateInfoEXT {
9432    pub sType: VkStructureType,
9433    pub pNext: *const c_void,
9434    pub flags: VkPipelineRasterizationStateStreamCreateFlagsEXT,
9435    pub rasterizationStream: u32,
9436}
9437
9438#[derive(Clone, Copy)]
9439#[repr(C)]
9440pub struct VkPipelineRenderingCreateInfo {
9441    pub sType: VkStructureType,
9442    pub pNext: *const c_void,
9443    pub viewMask: u32,
9444    pub colorAttachmentCount: u32,
9445    pub pColorAttachmentFormats: *const VkFormat,
9446    pub depthAttachmentFormat: VkFormat,
9447    pub stencilAttachmentFormat: VkFormat,
9448}
9449
9450#[derive(Clone, Copy)]
9451#[repr(C)]
9452pub struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
9453    pub sType: VkStructureType,
9454    pub pNext: *const c_void,
9455    pub representativeFragmentTestEnable: VkBool32,
9456}
9457
9458#[derive(Clone, Copy)]
9459#[repr(C)]
9460pub struct VkPipelineRobustnessCreateInfo {
9461    pub sType: VkStructureType,
9462    pub pNext: *const c_void,
9463    pub storageBuffers: VkPipelineRobustnessBufferBehavior,
9464    pub uniformBuffers: VkPipelineRobustnessBufferBehavior,
9465    pub vertexInputs: VkPipelineRobustnessBufferBehavior,
9466    pub images: VkPipelineRobustnessImageBehavior,
9467}
9468
9469#[derive(Clone, Copy)]
9470#[repr(C)]
9471pub struct VkPipelineSampleLocationsStateCreateInfoEXT {
9472    pub sType: VkStructureType,
9473    pub pNext: *const c_void,
9474    pub sampleLocationsEnable: VkBool32,
9475    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
9476}
9477
9478#[derive(Clone, Copy)]
9479#[repr(C)]
9480pub struct VkPipelineShaderStageCreateInfo {
9481    pub sType: VkStructureType,
9482    pub pNext: *const c_void,
9483    pub flags: VkPipelineShaderStageCreateFlags,
9484    pub stage: VkShaderStageFlagBits,
9485    pub module: VkShaderModule,
9486    pub pName: *const c_char,
9487    pub pSpecializationInfo: *const VkSpecializationInfo,
9488}
9489
9490#[derive(Clone, Copy)]
9491#[repr(C)]
9492pub struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
9493    pub sType: VkStructureType,
9494    pub pNext: *const c_void,
9495    pub identifierSize: u32,
9496    pub pIdentifier: *const u8,
9497}
9498
9499#[derive(Clone, Copy)]
9500#[repr(C)]
9501pub struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
9502    pub sType: VkStructureType,
9503    pub pNext: *const c_void,
9504    pub requiredSubgroupSize: u32,
9505}
9506
9507#[derive(Clone, Copy)]
9508#[repr(C)]
9509pub struct VkPipelineTessellationDomainOriginStateCreateInfo {
9510    pub sType: VkStructureType,
9511    pub pNext: *const c_void,
9512    pub domainOrigin: VkTessellationDomainOrigin,
9513}
9514
9515#[derive(Clone, Copy)]
9516#[repr(C)]
9517pub struct VkPipelineTessellationStateCreateInfo {
9518    pub sType: VkStructureType,
9519    pub pNext: *const c_void,
9520    pub flags: VkPipelineTessellationStateCreateFlags,
9521    pub patchControlPoints: u32,
9522}
9523
9524#[derive(Clone, Copy)]
9525#[repr(C)]
9526pub struct VkPipelineVertexInputDivisorStateCreateInfo {
9527    pub sType: VkStructureType,
9528    pub pNext: *const c_void,
9529    pub vertexBindingDivisorCount: u32,
9530    pub pVertexBindingDivisors: *const VkVertexInputBindingDivisorDescription,
9531}
9532
9533#[derive(Clone, Copy)]
9534#[repr(C)]
9535pub struct VkPipelineVertexInputStateCreateInfo {
9536    pub sType: VkStructureType,
9537    pub pNext: *const c_void,
9538    pub flags: VkPipelineVertexInputStateCreateFlags,
9539    pub vertexBindingDescriptionCount: u32,
9540    pub pVertexBindingDescriptions: *const VkVertexInputBindingDescription,
9541    pub vertexAttributeDescriptionCount: u32,
9542    pub pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription,
9543}
9544
9545#[derive(Clone, Copy)]
9546#[repr(C)]
9547pub struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
9548    pub sType: VkStructureType,
9549    pub pNext: *const c_void,
9550    pub sampleOrderType: VkCoarseSampleOrderTypeNV,
9551    pub customSampleOrderCount: u32,
9552    pub pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV,
9553}
9554
9555#[derive(Clone, Copy)]
9556#[repr(C)]
9557pub struct VkPipelineViewportDepthClampControlCreateInfoEXT {
9558    pub sType: VkStructureType,
9559    pub pNext: *const c_void,
9560    pub depthClampMode: VkDepthClampModeEXT,
9561    pub pDepthClampRange: *const VkDepthClampRangeEXT,
9562}
9563
9564#[derive(Clone, Copy)]
9565#[repr(C)]
9566pub struct VkPipelineViewportDepthClipControlCreateInfoEXT {
9567    pub sType: VkStructureType,
9568    pub pNext: *const c_void,
9569    pub negativeOneToOne: VkBool32,
9570}
9571
9572#[derive(Clone, Copy)]
9573#[repr(C)]
9574pub struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
9575    pub sType: VkStructureType,
9576    pub pNext: *const c_void,
9577    pub exclusiveScissorCount: u32,
9578    pub pExclusiveScissors: *const VkRect2D,
9579}
9580
9581#[derive(Clone, Copy)]
9582#[repr(C)]
9583pub struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
9584    pub sType: VkStructureType,
9585    pub pNext: *const c_void,
9586    pub shadingRateImageEnable: VkBool32,
9587    pub viewportCount: u32,
9588    pub pShadingRatePalettes: *const VkShadingRatePaletteNV,
9589}
9590
9591#[derive(Clone, Copy)]
9592#[repr(C)]
9593pub struct VkPipelineViewportStateCreateInfo {
9594    pub sType: VkStructureType,
9595    pub pNext: *const c_void,
9596    pub flags: VkPipelineViewportStateCreateFlags,
9597    pub viewportCount: u32,
9598    pub pViewports: *const VkViewport,
9599    pub scissorCount: u32,
9600    pub pScissors: *const VkRect2D,
9601}
9602
9603#[derive(Clone, Copy)]
9604#[repr(C)]
9605pub struct VkPipelineViewportSwizzleStateCreateInfoNV {
9606    pub sType: VkStructureType,
9607    pub pNext: *const c_void,
9608    pub flags: VkPipelineViewportSwizzleStateCreateFlagsNV,
9609    pub viewportCount: u32,
9610    pub pViewportSwizzles: *const VkViewportSwizzleNV,
9611}
9612
9613#[derive(Clone, Copy)]
9614#[repr(C)]
9615pub struct VkPipelineViewportWScalingStateCreateInfoNV {
9616    pub sType: VkStructureType,
9617    pub pNext: *const c_void,
9618    pub viewportWScalingEnable: VkBool32,
9619    pub viewportCount: u32,
9620    pub pViewportWScalings: *const VkViewportWScalingNV,
9621}
9622
9623#[repr(C)]
9624pub struct VkPipeline_T {
9625    _data: (),
9626    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9627}
9628
9629#[derive(Clone, Copy)]
9630#[repr(C)]
9631pub struct VkPresentId2KHR {
9632    pub sType: VkStructureType,
9633    pub pNext: *const c_void,
9634    pub swapchainCount: u32,
9635    pub pPresentIds: *const u64,
9636}
9637
9638#[derive(Clone, Copy)]
9639#[repr(C)]
9640pub struct VkPresentIdKHR {
9641    pub sType: VkStructureType,
9642    pub pNext: *const c_void,
9643    pub swapchainCount: u32,
9644    pub pPresentIds: *const u64,
9645}
9646
9647#[derive(Clone, Copy)]
9648#[repr(C)]
9649pub struct VkPresentInfoKHR {
9650    pub sType: VkStructureType,
9651    pub pNext: *const c_void,
9652    pub waitSemaphoreCount: u32,
9653    pub pWaitSemaphores: *const VkSemaphore,
9654    pub swapchainCount: u32,
9655    pub pSwapchains: *const VkSwapchainKHR,
9656    pub pImageIndices: *const u32,
9657    pub pResults: *mut VkResult,
9658}
9659
9660#[derive(Clone, Copy)]
9661#[repr(C)]
9662pub struct VkPresentRegionKHR {
9663    pub rectangleCount: u32,
9664    pub pRectangles: *const VkRectLayerKHR,
9665}
9666
9667#[derive(Clone, Copy)]
9668#[repr(C)]
9669pub struct VkPresentRegionsKHR {
9670    pub sType: VkStructureType,
9671    pub pNext: *const c_void,
9672    pub swapchainCount: u32,
9673    pub pRegions: *const VkPresentRegionKHR,
9674}
9675
9676#[derive(Clone, Copy)]
9677#[repr(C)]
9678pub struct VkPresentStageTimeEXT {
9679    pub stage: VkPresentStageFlagsEXT,
9680    pub time: u64,
9681}
9682
9683#[derive(Clone, Copy)]
9684#[repr(C)]
9685pub struct VkPresentTimeGOOGLE {
9686    pub presentID: u32,
9687    pub desiredPresentTime: u64,
9688}
9689
9690#[derive(Clone, Copy)]
9691#[repr(C)]
9692pub struct VkPresentTimesInfoGOOGLE {
9693    pub sType: VkStructureType,
9694    pub pNext: *const c_void,
9695    pub swapchainCount: u32,
9696    pub pTimes: *const VkPresentTimeGOOGLE,
9697}
9698
9699#[derive(Clone, Copy)]
9700#[repr(C)]
9701pub struct VkPresentTimingInfoEXT {
9702    pub sType: VkStructureType,
9703    pub pNext: *const c_void,
9704    pub flags: VkPresentTimingInfoFlagsEXT,
9705    pub targetTime: u64,
9706    pub timeDomainId: u64,
9707    pub presentStageQueries: VkPresentStageFlagsEXT,
9708    pub targetTimeDomainPresentStage: VkPresentStageFlagsEXT,
9709}
9710
9711#[derive(Clone, Copy)]
9712#[repr(C)]
9713pub struct VkPresentTimingSurfaceCapabilitiesEXT {
9714    pub sType: VkStructureType,
9715    pub pNext: *mut c_void,
9716    pub presentTimingSupported: VkBool32,
9717    pub presentAtAbsoluteTimeSupported: VkBool32,
9718    pub presentAtRelativeTimeSupported: VkBool32,
9719    pub presentStageQueries: VkPresentStageFlagsEXT,
9720}
9721
9722#[derive(Clone, Copy)]
9723#[repr(C)]
9724pub struct VkPresentTimingsInfoEXT {
9725    pub sType: VkStructureType,
9726    pub pNext: *const c_void,
9727    pub swapchainCount: u32,
9728    pub pTimingInfos: *const VkPresentTimingInfoEXT,
9729}
9730
9731#[derive(Clone, Copy)]
9732#[repr(C)]
9733pub struct VkPresentWait2InfoKHR {
9734    pub sType: VkStructureType,
9735    pub pNext: *const c_void,
9736    pub presentId: u64,
9737    pub timeout: u64,
9738}
9739
9740#[derive(Clone, Copy)]
9741#[repr(C)]
9742pub struct VkPrivateDataSlotCreateInfo {
9743    pub sType: VkStructureType,
9744    pub pNext: *const c_void,
9745    pub flags: VkPrivateDataSlotCreateFlags,
9746}
9747
9748#[repr(C)]
9749pub struct VkPrivateDataSlot_T {
9750    _data: (),
9751    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9752}
9753
9754#[derive(Clone, Copy)]
9755#[repr(C)]
9756pub struct VkProtectedSubmitInfo {
9757    pub sType: VkStructureType,
9758    pub pNext: *const c_void,
9759    pub protectedSubmit: VkBool32,
9760}
9761
9762#[derive(Clone, Copy)]
9763#[repr(C)]
9764pub struct VkPushConstantBankInfoNV {
9765    pub sType: VkStructureType,
9766    pub pNext: *const c_void,
9767    pub bank: u32,
9768}
9769
9770#[derive(Clone, Copy)]
9771#[repr(C)]
9772pub struct VkPushConstantRange {
9773    pub stageFlags: VkShaderStageFlags,
9774    pub offset: u32,
9775    pub size: u32,
9776}
9777
9778#[derive(Clone, Copy)]
9779#[repr(C)]
9780pub struct VkPushConstantsInfo {
9781    pub sType: VkStructureType,
9782    pub pNext: *const c_void,
9783    pub layout: VkPipelineLayout,
9784    pub stageFlags: VkShaderStageFlags,
9785    pub offset: u32,
9786    pub size: u32,
9787    pub pValues: *const c_void,
9788}
9789
9790#[derive(Clone, Copy)]
9791#[repr(C)]
9792pub struct VkPushDataInfoEXT {
9793    pub sType: VkStructureType,
9794    pub pNext: *const c_void,
9795    pub offset: u32,
9796    pub data: VkHostAddressRangeConstEXT,
9797}
9798
9799#[derive(Clone, Copy)]
9800#[repr(C)]
9801pub struct VkPushDescriptorSetInfo {
9802    pub sType: VkStructureType,
9803    pub pNext: *const c_void,
9804    pub stageFlags: VkShaderStageFlags,
9805    pub layout: VkPipelineLayout,
9806    pub set: u32,
9807    pub descriptorWriteCount: u32,
9808    pub pDescriptorWrites: *const VkWriteDescriptorSet,
9809}
9810
9811#[derive(Clone, Copy)]
9812#[repr(C)]
9813pub struct VkPushDescriptorSetWithTemplateInfo {
9814    pub sType: VkStructureType,
9815    pub pNext: *const c_void,
9816    pub descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
9817    pub layout: VkPipelineLayout,
9818    pub set: u32,
9819    pub pData: *const c_void,
9820}
9821
9822#[derive(Clone, Copy)]
9823#[repr(C)]
9824pub struct VkQueryLowLatencySupportNV {
9825    pub sType: VkStructureType,
9826    pub pNext: *const c_void,
9827    pub pQueriedLowLatencyData: *mut c_void,
9828}
9829
9830#[derive(Clone, Copy)]
9831#[repr(C)]
9832pub struct VkQueryPoolCreateInfo {
9833    pub sType: VkStructureType,
9834    pub pNext: *const c_void,
9835    pub flags: VkQueryPoolCreateFlags,
9836    pub queryType: VkQueryType,
9837    pub queryCount: u32,
9838    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
9839}
9840
9841#[derive(Clone, Copy)]
9842#[repr(C)]
9843pub struct VkQueryPoolPerformanceCreateInfoKHR {
9844    pub sType: VkStructureType,
9845    pub pNext: *const c_void,
9846    pub queueFamilyIndex: u32,
9847    pub counterIndexCount: u32,
9848    pub pCounterIndices: *const u32,
9849}
9850
9851#[derive(Clone, Copy)]
9852#[repr(C)]
9853pub struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
9854    pub sType: VkStructureType,
9855    pub pNext: *const c_void,
9856    pub performanceCountersSampling: VkQueryPoolSamplingModeINTEL,
9857}
9858
9859#[derive(Clone, Copy)]
9860#[repr(C)]
9861pub struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
9862    pub sType: VkStructureType,
9863    pub pNext: *const c_void,
9864    pub encodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
9865}
9866
9867#[repr(C)]
9868pub struct VkQueryPool_T {
9869    _data: (),
9870    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9871}
9872
9873#[derive(Clone, Copy)]
9874#[repr(C)]
9875pub struct VkQueueFamilyCheckpointProperties2NV {
9876    pub sType: VkStructureType,
9877    pub pNext: *mut c_void,
9878    pub checkpointExecutionStageMask: VkPipelineStageFlags2,
9879}
9880
9881#[derive(Clone, Copy)]
9882#[repr(C)]
9883pub struct VkQueueFamilyCheckpointPropertiesNV {
9884    pub sType: VkStructureType,
9885    pub pNext: *mut c_void,
9886    pub checkpointExecutionStageMask: VkPipelineStageFlags,
9887}
9888
9889#[derive(Clone, Copy)]
9890#[repr(C)]
9891pub struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM {
9892    pub sType: VkStructureType,
9893    pub pNext: *mut c_void,
9894    pub foreignSemaphoreHandleTypes: VkExternalSemaphoreHandleTypeFlags,
9895    pub foreignMemoryHandleTypes: VkExternalMemoryHandleTypeFlags,
9896}
9897
9898#[derive(Clone, Copy)]
9899#[repr(C)]
9900pub struct VkQueueFamilyDataGraphPropertiesARM {
9901    pub sType: VkStructureType,
9902    pub pNext: *mut c_void,
9903    pub engine: VkPhysicalDeviceDataGraphProcessingEngineARM,
9904    pub operation: VkPhysicalDeviceDataGraphOperationSupportARM,
9905}
9906
9907#[derive(Clone, Copy)]
9908#[repr(C)]
9909pub struct VkQueueFamilyGlobalPriorityProperties {
9910    pub sType: VkStructureType,
9911    pub pNext: *mut c_void,
9912    pub priorityCount: u32,
9913    pub priorities: [VkQueueGlobalPriority; VK_MAX_GLOBAL_PRIORITY_SIZE as usize],
9914}
9915
9916#[derive(Clone, Copy)]
9917#[repr(C)]
9918pub struct VkQueueFamilyOwnershipTransferPropertiesKHR {
9919    pub sType: VkStructureType,
9920    pub pNext: *mut c_void,
9921    pub optimalImageTransferToQueueFamilies: u32,
9922}
9923
9924#[derive(Clone, Copy)]
9925#[repr(C)]
9926pub struct VkQueueFamilyProperties {
9927    pub queueFlags: VkQueueFlags,
9928    pub queueCount: u32,
9929    pub timestampValidBits: u32,
9930    pub minImageTransferGranularity: VkExtent3D,
9931}
9932
9933#[derive(Clone, Copy)]
9934#[repr(C)]
9935pub struct VkQueueFamilyProperties2 {
9936    pub sType: VkStructureType,
9937    pub pNext: *mut c_void,
9938    pub queueFamilyProperties: VkQueueFamilyProperties,
9939}
9940
9941#[derive(Clone, Copy)]
9942#[repr(C)]
9943pub struct VkQueueFamilyQueryResultStatusPropertiesKHR {
9944    pub sType: VkStructureType,
9945    pub pNext: *mut c_void,
9946    pub queryResultStatusSupport: VkBool32,
9947}
9948
9949#[derive(Clone, Copy)]
9950#[repr(C)]
9951pub struct VkQueueFamilyVideoPropertiesKHR {
9952    pub sType: VkStructureType,
9953    pub pNext: *mut c_void,
9954    pub videoCodecOperations: VkVideoCodecOperationFlagsKHR,
9955}
9956
9957#[repr(C)]
9958pub struct VkQueue_T {
9959    _data: (),
9960    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9961}
9962
9963#[derive(Clone, Copy)]
9964#[repr(C)]
9965pub struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV {
9966    pub sType: VkStructureType,
9967    pub pNext: *mut c_void,
9968    pub allowClusterAccelerationStructure: VkBool32,
9969}
9970
9971#[derive(Clone, Copy)]
9972#[repr(C)]
9973pub struct VkRayTracingPipelineCreateInfoKHR {
9974    pub sType: VkStructureType,
9975    pub pNext: *const c_void,
9976    pub flags: VkPipelineCreateFlags,
9977    pub stageCount: u32,
9978    pub pStages: *const VkPipelineShaderStageCreateInfo,
9979    pub groupCount: u32,
9980    pub pGroups: *const VkRayTracingShaderGroupCreateInfoKHR,
9981    pub maxPipelineRayRecursionDepth: u32,
9982    pub pLibraryInfo: *const VkPipelineLibraryCreateInfoKHR,
9983    pub pLibraryInterface: *const VkRayTracingPipelineInterfaceCreateInfoKHR,
9984    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
9985    pub layout: VkPipelineLayout,
9986    pub basePipelineHandle: VkPipeline,
9987    pub basePipelineIndex: i32,
9988}
9989
9990#[derive(Clone, Copy)]
9991#[repr(C)]
9992pub struct VkRayTracingPipelineCreateInfoNV {
9993    pub sType: VkStructureType,
9994    pub pNext: *const c_void,
9995    pub flags: VkPipelineCreateFlags,
9996    pub stageCount: u32,
9997    pub pStages: *const VkPipelineShaderStageCreateInfo,
9998    pub groupCount: u32,
9999    pub pGroups: *const VkRayTracingShaderGroupCreateInfoNV,
10000    pub maxRecursionDepth: u32,
10001    pub layout: VkPipelineLayout,
10002    pub basePipelineHandle: VkPipeline,
10003    pub basePipelineIndex: i32,
10004}
10005
10006#[derive(Clone, Copy)]
10007#[repr(C)]
10008pub struct VkRayTracingPipelineInterfaceCreateInfoKHR {
10009    pub sType: VkStructureType,
10010    pub pNext: *const c_void,
10011    pub maxPipelineRayPayloadSize: u32,
10012    pub maxPipelineRayHitAttributeSize: u32,
10013}
10014
10015#[derive(Clone, Copy)]
10016#[repr(C)]
10017pub struct VkRayTracingShaderGroupCreateInfoKHR {
10018    pub sType: VkStructureType,
10019    pub pNext: *const c_void,
10020    pub typ: VkRayTracingShaderGroupTypeKHR,
10021    pub generalShader: u32,
10022    pub closestHitShader: u32,
10023    pub anyHitShader: u32,
10024    pub intersectionShader: u32,
10025    pub pShaderGroupCaptureReplayHandle: *const c_void,
10026}
10027
10028#[derive(Clone, Copy)]
10029#[repr(C)]
10030pub struct VkRayTracingShaderGroupCreateInfoNV {
10031    pub sType: VkStructureType,
10032    pub pNext: *const c_void,
10033    pub typ: VkRayTracingShaderGroupTypeKHR,
10034    pub generalShader: u32,
10035    pub closestHitShader: u32,
10036    pub anyHitShader: u32,
10037    pub intersectionShader: u32,
10038}
10039
10040#[derive(Clone, Copy)]
10041#[repr(C)]
10042pub struct VkRect2D {
10043    pub offset: VkOffset2D,
10044    pub extent: VkExtent2D,
10045}
10046
10047#[derive(Clone, Copy)]
10048#[repr(C)]
10049pub struct VkRectLayerKHR {
10050    pub offset: VkOffset2D,
10051    pub extent: VkExtent2D,
10052    pub layer: u32,
10053}
10054
10055#[derive(Clone, Copy)]
10056#[repr(C)]
10057pub struct VkRefreshCycleDurationGOOGLE {
10058    pub refreshDuration: u64,
10059}
10060
10061#[derive(Clone, Copy)]
10062#[repr(C)]
10063pub struct VkReleaseCapturedPipelineDataInfoKHR {
10064    pub sType: VkStructureType,
10065    pub pNext: *mut c_void,
10066    pub pipeline: VkPipeline,
10067}
10068
10069#[derive(Clone, Copy)]
10070#[repr(C)]
10071pub struct VkReleaseSwapchainImagesInfoKHR {
10072    pub sType: VkStructureType,
10073    pub pNext: *const c_void,
10074    pub swapchain: VkSwapchainKHR,
10075    pub imageIndexCount: u32,
10076    pub pImageIndices: *const u32,
10077}
10078
10079#[derive(Clone, Copy)]
10080#[repr(C)]
10081pub struct VkRenderPassAttachmentBeginInfo {
10082    pub sType: VkStructureType,
10083    pub pNext: *const c_void,
10084    pub attachmentCount: u32,
10085    pub pAttachments: *const VkImageView,
10086}
10087
10088#[derive(Clone, Copy)]
10089#[repr(C)]
10090pub struct VkRenderPassBeginInfo {
10091    pub sType: VkStructureType,
10092    pub pNext: *const c_void,
10093    pub renderPass: VkRenderPass,
10094    pub framebuffer: VkFramebuffer,
10095    pub renderArea: VkRect2D,
10096    pub clearValueCount: u32,
10097    pub pClearValues: *const VkClearValue,
10098}
10099
10100#[derive(Clone, Copy)]
10101#[repr(C)]
10102pub struct VkRenderPassCreateInfo {
10103    pub sType: VkStructureType,
10104    pub pNext: *const c_void,
10105    pub flags: VkRenderPassCreateFlags,
10106    pub attachmentCount: u32,
10107    pub pAttachments: *const VkAttachmentDescription,
10108    pub subpassCount: u32,
10109    pub pSubpasses: *const VkSubpassDescription,
10110    pub dependencyCount: u32,
10111    pub pDependencies: *const VkSubpassDependency,
10112}
10113
10114#[derive(Clone, Copy)]
10115#[repr(C)]
10116pub struct VkRenderPassCreateInfo2 {
10117    pub sType: VkStructureType,
10118    pub pNext: *const c_void,
10119    pub flags: VkRenderPassCreateFlags,
10120    pub attachmentCount: u32,
10121    pub pAttachments: *const VkAttachmentDescription2,
10122    pub subpassCount: u32,
10123    pub pSubpasses: *const VkSubpassDescription2,
10124    pub dependencyCount: u32,
10125    pub pDependencies: *const VkSubpassDependency2,
10126    pub correlatedViewMaskCount: u32,
10127    pub pCorrelatedViewMasks: *const u32,
10128}
10129
10130#[derive(Clone, Copy)]
10131#[repr(C)]
10132pub struct VkRenderPassCreationControlEXT {
10133    pub sType: VkStructureType,
10134    pub pNext: *const c_void,
10135    pub disallowMerging: VkBool32,
10136}
10137
10138#[derive(Clone, Copy)]
10139#[repr(C)]
10140pub struct VkRenderPassCreationFeedbackCreateInfoEXT {
10141    pub sType: VkStructureType,
10142    pub pNext: *const c_void,
10143    pub pRenderPassFeedback: *mut VkRenderPassCreationFeedbackInfoEXT,
10144}
10145
10146#[derive(Clone, Copy)]
10147#[repr(C)]
10148pub struct VkRenderPassCreationFeedbackInfoEXT {
10149    pub postMergeSubpassCount: u32,
10150}
10151
10152#[derive(Clone, Copy)]
10153#[repr(C)]
10154pub struct VkRenderPassFragmentDensityMapCreateInfoEXT {
10155    pub sType: VkStructureType,
10156    pub pNext: *const c_void,
10157    pub fragmentDensityMapAttachment: VkAttachmentReference,
10158}
10159
10160#[derive(Clone, Copy)]
10161#[repr(C)]
10162pub struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
10163    pub sType: VkStructureType,
10164    pub pNext: *const c_void,
10165    pub fragmentDensityOffsetCount: u32,
10166    pub pFragmentDensityOffsets: *const VkOffset2D,
10167}
10168
10169#[derive(Clone, Copy)]
10170#[repr(C)]
10171pub struct VkRenderPassInputAttachmentAspectCreateInfo {
10172    pub sType: VkStructureType,
10173    pub pNext: *const c_void,
10174    pub aspectReferenceCount: u32,
10175    pub pAspectReferences: *const VkInputAttachmentAspectReference,
10176}
10177
10178#[derive(Clone, Copy)]
10179#[repr(C)]
10180pub struct VkRenderPassMultiviewCreateInfo {
10181    pub sType: VkStructureType,
10182    pub pNext: *const c_void,
10183    pub subpassCount: u32,
10184    pub pViewMasks: *const u32,
10185    pub dependencyCount: u32,
10186    pub pViewOffsets: *const i32,
10187    pub correlationMaskCount: u32,
10188    pub pCorrelationMasks: *const u32,
10189}
10190
10191#[derive(Clone, Copy)]
10192#[repr(C)]
10193pub struct VkRenderPassPerformanceCountersByRegionBeginInfoARM {
10194    pub sType: VkStructureType,
10195    pub pNext: *mut c_void,
10196    pub counterAddressCount: u32,
10197    pub pCounterAddresses: *const VkDeviceAddress,
10198    pub serializeRegions: VkBool32,
10199    pub counterIndexCount: u32,
10200    pub pCounterIndices: *mut u32,
10201}
10202
10203#[derive(Clone, Copy)]
10204#[repr(C)]
10205pub struct VkRenderPassSampleLocationsBeginInfoEXT {
10206    pub sType: VkStructureType,
10207    pub pNext: *const c_void,
10208    pub attachmentInitialSampleLocationsCount: u32,
10209    pub pAttachmentInitialSampleLocations: *const VkAttachmentSampleLocationsEXT,
10210    pub postSubpassSampleLocationsCount: u32,
10211    pub pPostSubpassSampleLocations: *const VkSubpassSampleLocationsEXT,
10212}
10213
10214#[derive(Clone, Copy)]
10215#[repr(C)]
10216pub struct VkRenderPassStripeBeginInfoARM {
10217    pub sType: VkStructureType,
10218    pub pNext: *const c_void,
10219    pub stripeInfoCount: u32,
10220    pub pStripeInfos: *const VkRenderPassStripeInfoARM,
10221}
10222
10223#[derive(Clone, Copy)]
10224#[repr(C)]
10225pub struct VkRenderPassStripeInfoARM {
10226    pub sType: VkStructureType,
10227    pub pNext: *const c_void,
10228    pub stripeArea: VkRect2D,
10229}
10230
10231#[derive(Clone, Copy)]
10232#[repr(C)]
10233pub struct VkRenderPassStripeSubmitInfoARM {
10234    pub sType: VkStructureType,
10235    pub pNext: *const c_void,
10236    pub stripeSemaphoreInfoCount: u32,
10237    pub pStripeSemaphoreInfos: *const VkSemaphoreSubmitInfo,
10238}
10239
10240#[derive(Clone, Copy)]
10241#[repr(C)]
10242pub struct VkRenderPassSubpassFeedbackCreateInfoEXT {
10243    pub sType: VkStructureType,
10244    pub pNext: *const c_void,
10245    pub pSubpassFeedback: *mut VkRenderPassSubpassFeedbackInfoEXT,
10246}
10247
10248#[derive(Clone, Copy)]
10249#[repr(C)]
10250pub struct VkRenderPassSubpassFeedbackInfoEXT {
10251    pub subpassMergeStatus: VkSubpassMergeStatusEXT,
10252    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
10253    pub postMergeIndex: u32,
10254}
10255
10256#[derive(Clone, Copy)]
10257#[repr(C)]
10258pub struct VkRenderPassTileShadingCreateInfoQCOM {
10259    pub sType: VkStructureType,
10260    pub pNext: *const c_void,
10261    pub flags: VkTileShadingRenderPassFlagsQCOM,
10262    pub tileApronSize: VkExtent2D,
10263}
10264
10265#[derive(Clone, Copy)]
10266#[repr(C)]
10267pub struct VkRenderPassTransformBeginInfoQCOM {
10268    pub sType: VkStructureType,
10269    pub pNext: *const c_void,
10270    pub transform: VkSurfaceTransformFlagBitsKHR,
10271}
10272
10273#[repr(C)]
10274pub struct VkRenderPass_T {
10275    _data: (),
10276    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10277}
10278
10279#[derive(Clone, Copy)]
10280#[repr(C)]
10281pub struct VkRenderingAreaInfo {
10282    pub sType: VkStructureType,
10283    pub pNext: *const c_void,
10284    pub viewMask: u32,
10285    pub colorAttachmentCount: u32,
10286    pub pColorAttachmentFormats: *const VkFormat,
10287    pub depthAttachmentFormat: VkFormat,
10288    pub stencilAttachmentFormat: VkFormat,
10289}
10290
10291#[derive(Clone, Copy)]
10292#[repr(C)]
10293pub struct VkRenderingAttachmentFlagsInfoKHR {
10294    pub sType: VkStructureType,
10295    pub pNext: *const c_void,
10296    pub flags: VkRenderingAttachmentFlagsKHR,
10297}
10298
10299#[derive(Clone, Copy)]
10300#[repr(C)]
10301pub struct VkRenderingAttachmentInfo {
10302    pub sType: VkStructureType,
10303    pub pNext: *const c_void,
10304    pub imageView: VkImageView,
10305    pub imageLayout: VkImageLayout,
10306    pub resolveMode: VkResolveModeFlagBits,
10307    pub resolveImageView: VkImageView,
10308    pub resolveImageLayout: VkImageLayout,
10309    pub loadOp: VkAttachmentLoadOp,
10310    pub storeOp: VkAttachmentStoreOp,
10311    pub clearValue: VkClearValue,
10312}
10313
10314#[derive(Clone, Copy)]
10315#[repr(C)]
10316pub struct VkRenderingAttachmentLocationInfo {
10317    pub sType: VkStructureType,
10318    pub pNext: *const c_void,
10319    pub colorAttachmentCount: u32,
10320    pub pColorAttachmentLocations: *const u32,
10321}
10322
10323#[derive(Clone, Copy)]
10324#[repr(C)]
10325pub struct VkRenderingEndInfoKHR {
10326    pub sType: VkStructureType,
10327    pub pNext: *const c_void,
10328}
10329
10330#[derive(Clone, Copy)]
10331#[repr(C)]
10332pub struct VkRenderingFragmentDensityMapAttachmentInfoEXT {
10333    pub sType: VkStructureType,
10334    pub pNext: *const c_void,
10335    pub imageView: VkImageView,
10336    pub imageLayout: VkImageLayout,
10337}
10338
10339#[derive(Clone, Copy)]
10340#[repr(C)]
10341pub struct VkRenderingFragmentShadingRateAttachmentInfoKHR {
10342    pub sType: VkStructureType,
10343    pub pNext: *const c_void,
10344    pub imageView: VkImageView,
10345    pub imageLayout: VkImageLayout,
10346    pub shadingRateAttachmentTexelSize: VkExtent2D,
10347}
10348
10349#[derive(Clone, Copy)]
10350#[repr(C)]
10351pub struct VkRenderingInfo {
10352    pub sType: VkStructureType,
10353    pub pNext: *const c_void,
10354    pub flags: VkRenderingFlags,
10355    pub renderArea: VkRect2D,
10356    pub layerCount: u32,
10357    pub viewMask: u32,
10358    pub colorAttachmentCount: u32,
10359    pub pColorAttachments: *const VkRenderingAttachmentInfo,
10360    pub pDepthAttachment: *const VkRenderingAttachmentInfo,
10361    pub pStencilAttachment: *const VkRenderingAttachmentInfo,
10362}
10363
10364#[derive(Clone, Copy)]
10365#[repr(C)]
10366pub struct VkRenderingInputAttachmentIndexInfo {
10367    pub sType: VkStructureType,
10368    pub pNext: *const c_void,
10369    pub colorAttachmentCount: u32,
10370    pub pColorAttachmentInputIndices: *const u32,
10371    pub pDepthInputAttachmentIndex: *const u32,
10372    pub pStencilInputAttachmentIndex: *const u32,
10373}
10374
10375#[derive(Clone, Copy)]
10376#[repr(C)]
10377pub struct VkResolveImageInfo2 {
10378    pub sType: VkStructureType,
10379    pub pNext: *const c_void,
10380    pub srcImage: VkImage,
10381    pub srcImageLayout: VkImageLayout,
10382    pub dstImage: VkImage,
10383    pub dstImageLayout: VkImageLayout,
10384    pub regionCount: u32,
10385    pub pRegions: *const VkImageResolve2,
10386}
10387
10388#[derive(Clone, Copy)]
10389#[repr(C)]
10390pub struct VkResolveImageModeInfoKHR {
10391    pub sType: VkStructureType,
10392    pub pNext: *const c_void,
10393    pub flags: VkResolveImageFlagsKHR,
10394    pub resolveMode: VkResolveModeFlagBits,
10395    pub stencilResolveMode: VkResolveModeFlagBits,
10396}
10397
10398#[derive(Clone, Copy)]
10399#[repr(C)]
10400pub struct VkResourceDescriptorInfoEXT {
10401    pub sType: VkStructureType,
10402    pub pNext: *const c_void,
10403    pub typ: VkDescriptorType,
10404    pub data: VkResourceDescriptorDataEXT,
10405}
10406
10407#[derive(Clone, Copy)]
10408#[repr(C)]
10409pub struct VkSRTDataNV {
10410    pub sx: f32,
10411    pub a: f32,
10412    pub b: f32,
10413    pub pvx: f32,
10414    pub sy: f32,
10415    pub c: f32,
10416    pub pvy: f32,
10417    pub sz: f32,
10418    pub pvz: f32,
10419    pub qx: f32,
10420    pub qy: f32,
10421    pub qz: f32,
10422    pub qw: f32,
10423    pub tx: f32,
10424    pub ty: f32,
10425    pub tz: f32,
10426}
10427
10428#[derive(Clone, Copy)]
10429#[repr(C)]
10430pub struct VkSampleLocationEXT {
10431    pub x: f32,
10432    pub y: f32,
10433}
10434
10435#[derive(Clone, Copy)]
10436#[repr(C)]
10437pub struct VkSampleLocationsInfoEXT {
10438    pub sType: VkStructureType,
10439    pub pNext: *const c_void,
10440    pub sampleLocationsPerPixel: VkSampleCountFlagBits,
10441    pub sampleLocationGridSize: VkExtent2D,
10442    pub sampleLocationsCount: u32,
10443    pub pSampleLocations: *const VkSampleLocationEXT,
10444}
10445
10446#[derive(Clone, Copy)]
10447#[repr(C)]
10448pub struct VkSamplerBlockMatchWindowCreateInfoQCOM {
10449    pub sType: VkStructureType,
10450    pub pNext: *const c_void,
10451    pub windowExtent: VkExtent2D,
10452    pub windowCompareMode: VkBlockMatchWindowCompareModeQCOM,
10453}
10454
10455#[derive(Clone, Copy)]
10456#[repr(C)]
10457pub struct VkSamplerBorderColorComponentMappingCreateInfoEXT {
10458    pub sType: VkStructureType,
10459    pub pNext: *const c_void,
10460    pub components: VkComponentMapping,
10461    pub srgb: VkBool32,
10462}
10463
10464#[derive(Clone, Copy)]
10465#[repr(C)]
10466pub struct VkSamplerCaptureDescriptorDataInfoEXT {
10467    pub sType: VkStructureType,
10468    pub pNext: *const c_void,
10469    pub sampler: VkSampler,
10470}
10471
10472#[derive(Clone, Copy)]
10473#[repr(C)]
10474pub struct VkSamplerCreateInfo {
10475    pub sType: VkStructureType,
10476    pub pNext: *const c_void,
10477    pub flags: VkSamplerCreateFlags,
10478    pub magFilter: VkFilter,
10479    pub minFilter: VkFilter,
10480    pub mipmapMode: VkSamplerMipmapMode,
10481    pub addressModeU: VkSamplerAddressMode,
10482    pub addressModeV: VkSamplerAddressMode,
10483    pub addressModeW: VkSamplerAddressMode,
10484    pub mipLodBias: f32,
10485    pub anisotropyEnable: VkBool32,
10486    pub maxAnisotropy: f32,
10487    pub compareEnable: VkBool32,
10488    pub compareOp: VkCompareOp,
10489    pub minLod: f32,
10490    pub maxLod: f32,
10491    pub borderColor: VkBorderColor,
10492    pub unnormalizedCoordinates: VkBool32,
10493}
10494
10495#[derive(Clone, Copy)]
10496#[repr(C)]
10497pub struct VkSamplerCubicWeightsCreateInfoQCOM {
10498    pub sType: VkStructureType,
10499    pub pNext: *const c_void,
10500    pub cubicWeights: VkCubicFilterWeightsQCOM,
10501}
10502
10503#[derive(Clone, Copy)]
10504#[repr(C)]
10505pub struct VkSamplerCustomBorderColorCreateInfoEXT {
10506    pub sType: VkStructureType,
10507    pub pNext: *const c_void,
10508    pub customBorderColor: VkClearColorValue,
10509    pub format: VkFormat,
10510}
10511
10512#[derive(Clone, Copy)]
10513#[repr(C)]
10514pub struct VkSamplerCustomBorderColorIndexCreateInfoEXT {
10515    pub sType: VkStructureType,
10516    pub pNext: *const c_void,
10517    pub index: u32,
10518}
10519
10520#[derive(Clone, Copy)]
10521#[repr(C)]
10522pub struct VkSamplerReductionModeCreateInfo {
10523    pub sType: VkStructureType,
10524    pub pNext: *const c_void,
10525    pub reductionMode: VkSamplerReductionMode,
10526}
10527
10528#[derive(Clone, Copy)]
10529#[repr(C)]
10530pub struct VkSamplerYcbcrConversionCreateInfo {
10531    pub sType: VkStructureType,
10532    pub pNext: *const c_void,
10533    pub format: VkFormat,
10534    pub ycbcrModel: VkSamplerYcbcrModelConversion,
10535    pub ycbcrRange: VkSamplerYcbcrRange,
10536    pub components: VkComponentMapping,
10537    pub xChromaOffset: VkChromaLocation,
10538    pub yChromaOffset: VkChromaLocation,
10539    pub chromaFilter: VkFilter,
10540    pub forceExplicitReconstruction: VkBool32,
10541}
10542
10543#[derive(Clone, Copy)]
10544#[repr(C)]
10545pub struct VkSamplerYcbcrConversionImageFormatProperties {
10546    pub sType: VkStructureType,
10547    pub pNext: *mut c_void,
10548    pub combinedImageSamplerDescriptorCount: u32,
10549}
10550
10551#[derive(Clone, Copy)]
10552#[repr(C)]
10553pub struct VkSamplerYcbcrConversionInfo {
10554    pub sType: VkStructureType,
10555    pub pNext: *const c_void,
10556    pub conversion: VkSamplerYcbcrConversion,
10557}
10558
10559#[derive(Clone, Copy)]
10560#[repr(C)]
10561pub struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
10562    pub sType: VkStructureType,
10563    pub pNext: *mut c_void,
10564    pub enableYDegamma: VkBool32,
10565    pub enableCbCrDegamma: VkBool32,
10566}
10567
10568#[repr(C)]
10569pub struct VkSamplerYcbcrConversion_T {
10570    _data: (),
10571    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10572}
10573
10574#[repr(C)]
10575pub struct VkSampler_T {
10576    _data: (),
10577    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10578}
10579
10580#[derive(Clone, Copy)]
10581#[repr(C)]
10582pub struct VkSemaphoreCreateInfo {
10583    pub sType: VkStructureType,
10584    pub pNext: *const c_void,
10585    pub flags: VkSemaphoreCreateFlags,
10586}
10587
10588#[derive(Clone, Copy)]
10589#[repr(C)]
10590pub struct VkSemaphoreGetFdInfoKHR {
10591    pub sType: VkStructureType,
10592    pub pNext: *const c_void,
10593    pub semaphore: VkSemaphore,
10594    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
10595}
10596
10597#[derive(Clone, Copy)]
10598#[repr(C)]
10599pub struct VkSemaphoreSignalInfo {
10600    pub sType: VkStructureType,
10601    pub pNext: *const c_void,
10602    pub semaphore: VkSemaphore,
10603    pub value: u64,
10604}
10605
10606#[derive(Clone, Copy)]
10607#[repr(C)]
10608pub struct VkSemaphoreSubmitInfo {
10609    pub sType: VkStructureType,
10610    pub pNext: *const c_void,
10611    pub semaphore: VkSemaphore,
10612    pub value: u64,
10613    pub stageMask: VkPipelineStageFlags2,
10614    pub deviceIndex: u32,
10615}
10616
10617#[derive(Clone, Copy)]
10618#[repr(C)]
10619pub struct VkSemaphoreTypeCreateInfo {
10620    pub sType: VkStructureType,
10621    pub pNext: *const c_void,
10622    pub semaphoreType: VkSemaphoreType,
10623    pub initialValue: u64,
10624}
10625
10626#[derive(Clone, Copy)]
10627#[repr(C)]
10628pub struct VkSemaphoreWaitInfo {
10629    pub sType: VkStructureType,
10630    pub pNext: *const c_void,
10631    pub flags: VkSemaphoreWaitFlags,
10632    pub semaphoreCount: u32,
10633    pub pSemaphores: *const VkSemaphore,
10634    pub pValues: *const u64,
10635}
10636
10637#[repr(C)]
10638pub struct VkSemaphore_T {
10639    _data: (),
10640    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10641}
10642
10643#[derive(Clone, Copy)]
10644#[repr(C)]
10645pub struct VkSetDescriptorBufferOffsetsInfoEXT {
10646    pub sType: VkStructureType,
10647    pub pNext: *const c_void,
10648    pub stageFlags: VkShaderStageFlags,
10649    pub layout: VkPipelineLayout,
10650    pub firstSet: u32,
10651    pub setCount: u32,
10652    pub pBufferIndices: *const u32,
10653    pub pOffsets: *const VkDeviceSize,
10654}
10655
10656#[derive(Clone, Copy)]
10657#[repr(C)]
10658pub struct VkSetLatencyMarkerInfoNV {
10659    pub sType: VkStructureType,
10660    pub pNext: *const c_void,
10661    pub presentID: u64,
10662    pub marker: VkLatencyMarkerNV,
10663}
10664
10665#[derive(Clone, Copy)]
10666#[repr(C)]
10667pub struct VkSetStateFlagsIndirectCommandNV {
10668    pub data: u32,
10669}
10670
10671#[derive(Clone, Copy)]
10672#[repr(C)]
10673pub struct VkShaderCreateInfoEXT {
10674    pub sType: VkStructureType,
10675    pub pNext: *const c_void,
10676    pub flags: VkShaderCreateFlagsEXT,
10677    pub stage: VkShaderStageFlagBits,
10678    pub nextStage: VkShaderStageFlags,
10679    pub codeType: VkShaderCodeTypeEXT,
10680    pub codeSize: usize,
10681    pub pCode: *const c_void,
10682    pub pName: *const c_char,
10683    pub setLayoutCount: u32,
10684    pub pSetLayouts: *const VkDescriptorSetLayout,
10685    pub pushConstantRangeCount: u32,
10686    pub pPushConstantRanges: *const VkPushConstantRange,
10687    pub pSpecializationInfo: *const VkSpecializationInfo,
10688}
10689
10690#[derive(Clone, Copy)]
10691#[repr(C)]
10692pub struct VkShaderDescriptorSetAndBindingMappingInfoEXT {
10693    pub sType: VkStructureType,
10694    pub pNext: *const c_void,
10695    pub mappingCount: u32,
10696    pub pMappings: *const VkDescriptorSetAndBindingMappingEXT,
10697}
10698
10699#[repr(C)]
10700pub struct VkShaderEXT_T {
10701    _data: (),
10702    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10703}
10704
10705#[derive(Clone, Copy)]
10706#[repr(C)]
10707pub struct VkShaderModuleCreateInfo {
10708    pub sType: VkStructureType,
10709    pub pNext: *const c_void,
10710    pub flags: VkShaderModuleCreateFlags,
10711    pub codeSize: usize,
10712    pub pCode: *const u32,
10713}
10714
10715#[derive(Clone, Copy)]
10716#[repr(C)]
10717pub struct VkShaderModuleIdentifierEXT {
10718    pub sType: VkStructureType,
10719    pub pNext: *mut c_void,
10720    pub identifierSize: u32,
10721    pub identifier: [u8; VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as usize],
10722}
10723
10724#[derive(Clone, Copy)]
10725#[repr(C)]
10726pub struct VkShaderModuleValidationCacheCreateInfoEXT {
10727    pub sType: VkStructureType,
10728    pub pNext: *const c_void,
10729    pub validationCache: VkValidationCacheEXT,
10730}
10731
10732#[repr(C)]
10733pub struct VkShaderModule_T {
10734    _data: (),
10735    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10736}
10737
10738#[derive(Clone, Copy)]
10739#[repr(C)]
10740pub struct VkShaderResourceUsageAMD {
10741    pub numUsedVgprs: u32,
10742    pub numUsedSgprs: u32,
10743    pub ldsSizePerLocalWorkGroup: u32,
10744    pub ldsUsageSizeInBytes: usize,
10745    pub scratchMemUsageInBytes: usize,
10746}
10747
10748#[derive(Clone, Copy)]
10749#[repr(C)]
10750pub struct VkShaderStatisticsInfoAMD {
10751    pub shaderStageMask: VkShaderStageFlags,
10752    pub resourceUsage: VkShaderResourceUsageAMD,
10753    pub numPhysicalVgprs: u32,
10754    pub numPhysicalSgprs: u32,
10755    pub numAvailableVgprs: u32,
10756    pub numAvailableSgprs: u32,
10757    pub computeWorkGroupSize: [u32; 3 as usize],
10758}
10759
10760#[derive(Clone, Copy)]
10761#[repr(C)]
10762pub struct VkShadingRatePaletteNV {
10763    pub shadingRatePaletteEntryCount: u32,
10764    pub pShadingRatePaletteEntries: *const VkShadingRatePaletteEntryNV,
10765}
10766
10767#[derive(Clone, Copy)]
10768#[repr(C)]
10769pub struct VkSharedPresentSurfaceCapabilitiesKHR {
10770    pub sType: VkStructureType,
10771    pub pNext: *mut c_void,
10772    pub sharedPresentSupportedUsageFlags: VkImageUsageFlags,
10773}
10774
10775#[derive(Clone, Copy)]
10776#[repr(C)]
10777pub struct VkSparseBufferMemoryBindInfo {
10778    pub buffer: VkBuffer,
10779    pub bindCount: u32,
10780    pub pBinds: *const VkSparseMemoryBind,
10781}
10782
10783#[derive(Clone, Copy)]
10784#[repr(C)]
10785pub struct VkSparseImageFormatProperties {
10786    pub aspectMask: VkImageAspectFlags,
10787    pub imageGranularity: VkExtent3D,
10788    pub flags: VkSparseImageFormatFlags,
10789}
10790
10791#[derive(Clone, Copy)]
10792#[repr(C)]
10793pub struct VkSparseImageFormatProperties2 {
10794    pub sType: VkStructureType,
10795    pub pNext: *mut c_void,
10796    pub properties: VkSparseImageFormatProperties,
10797}
10798
10799#[derive(Clone, Copy)]
10800#[repr(C)]
10801pub struct VkSparseImageMemoryBind {
10802    pub subresource: VkImageSubresource,
10803    pub offset: VkOffset3D,
10804    pub extent: VkExtent3D,
10805    pub memory: VkDeviceMemory,
10806    pub memoryOffset: VkDeviceSize,
10807    pub flags: VkSparseMemoryBindFlags,
10808}
10809
10810#[derive(Clone, Copy)]
10811#[repr(C)]
10812pub struct VkSparseImageMemoryBindInfo {
10813    pub image: VkImage,
10814    pub bindCount: u32,
10815    pub pBinds: *const VkSparseImageMemoryBind,
10816}
10817
10818#[derive(Clone, Copy)]
10819#[repr(C)]
10820pub struct VkSparseImageMemoryRequirements {
10821    pub formatProperties: VkSparseImageFormatProperties,
10822    pub imageMipTailFirstLod: u32,
10823    pub imageMipTailSize: VkDeviceSize,
10824    pub imageMipTailOffset: VkDeviceSize,
10825    pub imageMipTailStride: VkDeviceSize,
10826}
10827
10828#[derive(Clone, Copy)]
10829#[repr(C)]
10830pub struct VkSparseImageMemoryRequirements2 {
10831    pub sType: VkStructureType,
10832    pub pNext: *mut c_void,
10833    pub memoryRequirements: VkSparseImageMemoryRequirements,
10834}
10835
10836#[derive(Clone, Copy)]
10837#[repr(C)]
10838pub struct VkSparseImageOpaqueMemoryBindInfo {
10839    pub image: VkImage,
10840    pub bindCount: u32,
10841    pub pBinds: *const VkSparseMemoryBind,
10842}
10843
10844#[derive(Clone, Copy)]
10845#[repr(C)]
10846pub struct VkSparseMemoryBind {
10847    pub resourceOffset: VkDeviceSize,
10848    pub size: VkDeviceSize,
10849    pub memory: VkDeviceMemory,
10850    pub memoryOffset: VkDeviceSize,
10851    pub flags: VkSparseMemoryBindFlags,
10852}
10853
10854#[derive(Clone, Copy)]
10855#[repr(C)]
10856pub struct VkSpecializationInfo {
10857    pub mapEntryCount: u32,
10858    pub pMapEntries: *const VkSpecializationMapEntry,
10859    pub dataSize: usize,
10860    pub pData: *const c_void,
10861}
10862
10863#[derive(Clone, Copy)]
10864#[repr(C)]
10865pub struct VkSpecializationMapEntry {
10866    pub constantID: u32,
10867    pub offset: u32,
10868    pub size: usize,
10869}
10870
10871#[derive(Clone, Copy)]
10872#[repr(C)]
10873pub struct VkStencilOpState {
10874    pub failOp: VkStencilOp,
10875    pub passOp: VkStencilOp,
10876    pub depthFailOp: VkStencilOp,
10877    pub compareOp: VkCompareOp,
10878    pub compareMask: u32,
10879    pub writeMask: u32,
10880    pub reference: u32,
10881}
10882
10883#[derive(Clone, Copy)]
10884#[repr(C)]
10885pub struct VkStridedDeviceAddressNV {
10886    pub startAddress: VkDeviceAddress,
10887    pub strideInBytes: VkDeviceSize,
10888}
10889
10890#[derive(Clone, Copy)]
10891#[repr(C)]
10892pub struct VkStridedDeviceAddressRangeKHR {
10893    pub address: VkDeviceAddress,
10894    pub size: VkDeviceSize,
10895    pub stride: VkDeviceSize,
10896}
10897
10898#[derive(Clone, Copy)]
10899#[repr(C)]
10900pub struct VkStridedDeviceAddressRegionKHR {
10901    pub deviceAddress: VkDeviceAddress,
10902    pub stride: VkDeviceSize,
10903    pub size: VkDeviceSize,
10904}
10905
10906#[derive(Clone, Copy)]
10907#[repr(C)]
10908pub struct VkSubmitInfo {
10909    pub sType: VkStructureType,
10910    pub pNext: *const c_void,
10911    pub waitSemaphoreCount: u32,
10912    pub pWaitSemaphores: *const VkSemaphore,
10913    pub pWaitDstStageMask: *const VkPipelineStageFlags,
10914    pub commandBufferCount: u32,
10915    pub pCommandBuffers: *const VkCommandBuffer,
10916    pub signalSemaphoreCount: u32,
10917    pub pSignalSemaphores: *const VkSemaphore,
10918}
10919
10920#[derive(Clone, Copy)]
10921#[repr(C)]
10922pub struct VkSubmitInfo2 {
10923    pub sType: VkStructureType,
10924    pub pNext: *const c_void,
10925    pub flags: VkSubmitFlags,
10926    pub waitSemaphoreInfoCount: u32,
10927    pub pWaitSemaphoreInfos: *const VkSemaphoreSubmitInfo,
10928    pub commandBufferInfoCount: u32,
10929    pub pCommandBufferInfos: *const VkCommandBufferSubmitInfo,
10930    pub signalSemaphoreInfoCount: u32,
10931    pub pSignalSemaphoreInfos: *const VkSemaphoreSubmitInfo,
10932}
10933
10934#[derive(Clone, Copy)]
10935#[repr(C)]
10936pub struct VkSubpassBeginInfo {
10937    pub sType: VkStructureType,
10938    pub pNext: *const c_void,
10939    pub contents: VkSubpassContents,
10940}
10941
10942#[derive(Clone, Copy)]
10943#[repr(C)]
10944pub struct VkSubpassDependency {
10945    pub srcSubpass: u32,
10946    pub dstSubpass: u32,
10947    pub srcStageMask: VkPipelineStageFlags,
10948    pub dstStageMask: VkPipelineStageFlags,
10949    pub srcAccessMask: VkAccessFlags,
10950    pub dstAccessMask: VkAccessFlags,
10951    pub dependencyFlags: VkDependencyFlags,
10952}
10953
10954#[derive(Clone, Copy)]
10955#[repr(C)]
10956pub struct VkSubpassDependency2 {
10957    pub sType: VkStructureType,
10958    pub pNext: *const c_void,
10959    pub srcSubpass: u32,
10960    pub dstSubpass: u32,
10961    pub srcStageMask: VkPipelineStageFlags,
10962    pub dstStageMask: VkPipelineStageFlags,
10963    pub srcAccessMask: VkAccessFlags,
10964    pub dstAccessMask: VkAccessFlags,
10965    pub dependencyFlags: VkDependencyFlags,
10966    pub viewOffset: i32,
10967}
10968
10969#[derive(Clone, Copy)]
10970#[repr(C)]
10971pub struct VkSubpassDescription {
10972    pub flags: VkSubpassDescriptionFlags,
10973    pub pipelineBindPoint: VkPipelineBindPoint,
10974    pub inputAttachmentCount: u32,
10975    pub pInputAttachments: *const VkAttachmentReference,
10976    pub colorAttachmentCount: u32,
10977    pub pColorAttachments: *const VkAttachmentReference,
10978    pub pResolveAttachments: *const VkAttachmentReference,
10979    pub pDepthStencilAttachment: *const VkAttachmentReference,
10980    pub preserveAttachmentCount: u32,
10981    pub pPreserveAttachments: *const u32,
10982}
10983
10984#[derive(Clone, Copy)]
10985#[repr(C)]
10986pub struct VkSubpassDescription2 {
10987    pub sType: VkStructureType,
10988    pub pNext: *const c_void,
10989    pub flags: VkSubpassDescriptionFlags,
10990    pub pipelineBindPoint: VkPipelineBindPoint,
10991    pub viewMask: u32,
10992    pub inputAttachmentCount: u32,
10993    pub pInputAttachments: *const VkAttachmentReference2,
10994    pub colorAttachmentCount: u32,
10995    pub pColorAttachments: *const VkAttachmentReference2,
10996    pub pResolveAttachments: *const VkAttachmentReference2,
10997    pub pDepthStencilAttachment: *const VkAttachmentReference2,
10998    pub preserveAttachmentCount: u32,
10999    pub pPreserveAttachments: *const u32,
11000}
11001
11002#[derive(Clone, Copy)]
11003#[repr(C)]
11004pub struct VkSubpassDescriptionDepthStencilResolve {
11005    pub sType: VkStructureType,
11006    pub pNext: *const c_void,
11007    pub depthResolveMode: VkResolveModeFlagBits,
11008    pub stencilResolveMode: VkResolveModeFlagBits,
11009    pub pDepthStencilResolveAttachment: *const VkAttachmentReference2,
11010}
11011
11012#[derive(Clone, Copy)]
11013#[repr(C)]
11014pub struct VkSubpassEndInfo {
11015    pub sType: VkStructureType,
11016    pub pNext: *const c_void,
11017}
11018
11019#[derive(Clone, Copy)]
11020#[repr(C)]
11021pub struct VkSubpassResolvePerformanceQueryEXT {
11022    pub sType: VkStructureType,
11023    pub pNext: *mut c_void,
11024    pub optimal: VkBool32,
11025}
11026
11027#[derive(Clone, Copy)]
11028#[repr(C)]
11029pub struct VkSubpassSampleLocationsEXT {
11030    pub subpassIndex: u32,
11031    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
11032}
11033
11034#[derive(Clone, Copy)]
11035#[repr(C)]
11036pub struct VkSubpassShadingPipelineCreateInfoHUAWEI {
11037    pub sType: VkStructureType,
11038    pub pNext: *mut c_void,
11039    pub renderPass: VkRenderPass,
11040    pub subpass: u32,
11041}
11042
11043#[derive(Clone, Copy)]
11044#[repr(C)]
11045pub struct VkSubresourceHostMemcpySize {
11046    pub sType: VkStructureType,
11047    pub pNext: *mut c_void,
11048    pub size: VkDeviceSize,
11049}
11050
11051#[derive(Clone, Copy)]
11052#[repr(C)]
11053pub struct VkSubresourceLayout {
11054    pub offset: VkDeviceSize,
11055    pub size: VkDeviceSize,
11056    pub rowPitch: VkDeviceSize,
11057    pub arrayPitch: VkDeviceSize,
11058    pub depthPitch: VkDeviceSize,
11059}
11060
11061#[derive(Clone, Copy)]
11062#[repr(C)]
11063pub struct VkSubresourceLayout2 {
11064    pub sType: VkStructureType,
11065    pub pNext: *mut c_void,
11066    pub subresourceLayout: VkSubresourceLayout,
11067}
11068
11069#[derive(Clone, Copy)]
11070#[repr(C)]
11071pub struct VkSubsampledImageFormatPropertiesEXT {
11072    pub sType: VkStructureType,
11073    pub pNext: *const c_void,
11074    pub subsampledImageDescriptorCount: u32,
11075}
11076
11077#[derive(Clone, Copy)]
11078#[repr(C)]
11079pub struct VkSurfaceCapabilities2EXT {
11080    pub sType: VkStructureType,
11081    pub pNext: *mut c_void,
11082    pub minImageCount: u32,
11083    pub maxImageCount: u32,
11084    pub currentExtent: VkExtent2D,
11085    pub minImageExtent: VkExtent2D,
11086    pub maxImageExtent: VkExtent2D,
11087    pub maxImageArrayLayers: u32,
11088    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
11089    pub currentTransform: VkSurfaceTransformFlagBitsKHR,
11090    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
11091    pub supportedUsageFlags: VkImageUsageFlags,
11092    pub supportedSurfaceCounters: VkSurfaceCounterFlagsEXT,
11093}
11094
11095#[derive(Clone, Copy)]
11096#[repr(C)]
11097pub struct VkSurfaceCapabilities2KHR {
11098    pub sType: VkStructureType,
11099    pub pNext: *mut c_void,
11100    pub surfaceCapabilities: VkSurfaceCapabilitiesKHR,
11101}
11102
11103#[derive(Clone, Copy)]
11104#[repr(C)]
11105pub struct VkSurfaceCapabilitiesKHR {
11106    pub minImageCount: u32,
11107    pub maxImageCount: u32,
11108    pub currentExtent: VkExtent2D,
11109    pub minImageExtent: VkExtent2D,
11110    pub maxImageExtent: VkExtent2D,
11111    pub maxImageArrayLayers: u32,
11112    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
11113    pub currentTransform: VkSurfaceTransformFlagBitsKHR,
11114    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
11115    pub supportedUsageFlags: VkImageUsageFlags,
11116}
11117
11118#[derive(Clone, Copy)]
11119#[repr(C)]
11120pub struct VkSurfaceCapabilitiesPresentBarrierNV {
11121    pub sType: VkStructureType,
11122    pub pNext: *mut c_void,
11123    pub presentBarrierSupported: VkBool32,
11124}
11125
11126#[derive(Clone, Copy)]
11127#[repr(C)]
11128pub struct VkSurfaceCapabilitiesPresentId2KHR {
11129    pub sType: VkStructureType,
11130    pub pNext: *mut c_void,
11131    pub presentId2Supported: VkBool32,
11132}
11133
11134#[derive(Clone, Copy)]
11135#[repr(C)]
11136pub struct VkSurfaceCapabilitiesPresentWait2KHR {
11137    pub sType: VkStructureType,
11138    pub pNext: *mut c_void,
11139    pub presentWait2Supported: VkBool32,
11140}
11141
11142#[derive(Clone, Copy)]
11143#[repr(C)]
11144pub struct VkSurfaceFormat2KHR {
11145    pub sType: VkStructureType,
11146    pub pNext: *mut c_void,
11147    pub surfaceFormat: VkSurfaceFormatKHR,
11148}
11149
11150#[derive(Clone, Copy)]
11151#[repr(C)]
11152pub struct VkSurfaceFormatKHR {
11153    pub format: VkFormat,
11154    pub colorSpace: VkColorSpaceKHR,
11155}
11156
11157#[repr(C)]
11158pub struct VkSurfaceKHR_T {
11159    _data: (),
11160    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11161}
11162
11163#[derive(Clone, Copy)]
11164#[repr(C)]
11165pub struct VkSurfacePresentModeCompatibilityKHR {
11166    pub sType: VkStructureType,
11167    pub pNext: *mut c_void,
11168    pub presentModeCount: u32,
11169    pub pPresentModes: *mut VkPresentModeKHR,
11170}
11171
11172#[derive(Clone, Copy)]
11173#[repr(C)]
11174pub struct VkSurfacePresentModeKHR {
11175    pub sType: VkStructureType,
11176    pub pNext: *mut c_void,
11177    pub presentMode: VkPresentModeKHR,
11178}
11179
11180#[derive(Clone, Copy)]
11181#[repr(C)]
11182pub struct VkSurfacePresentScalingCapabilitiesKHR {
11183    pub sType: VkStructureType,
11184    pub pNext: *mut c_void,
11185    pub supportedPresentScaling: VkPresentScalingFlagsKHR,
11186    pub supportedPresentGravityX: VkPresentGravityFlagsKHR,
11187    pub supportedPresentGravityY: VkPresentGravityFlagsKHR,
11188    pub minScaledImageExtent: VkExtent2D,
11189    pub maxScaledImageExtent: VkExtent2D,
11190}
11191
11192#[derive(Clone, Copy)]
11193#[repr(C)]
11194pub struct VkSurfaceProtectedCapabilitiesKHR {
11195    pub sType: VkStructureType,
11196    pub pNext: *mut c_void,
11197    pub supportsProtected: VkBool32,
11198}
11199
11200#[derive(Clone, Copy)]
11201#[repr(C)]
11202pub struct VkSwapchainCalibratedTimestampInfoEXT {
11203    pub sType: VkStructureType,
11204    pub pNext: *const c_void,
11205    pub swapchain: VkSwapchainKHR,
11206    pub presentStage: VkPresentStageFlagsEXT,
11207    pub timeDomainId: u64,
11208}
11209
11210#[derive(Clone, Copy)]
11211#[repr(C)]
11212pub struct VkSwapchainCounterCreateInfoEXT {
11213    pub sType: VkStructureType,
11214    pub pNext: *const c_void,
11215    pub surfaceCounters: VkSurfaceCounterFlagsEXT,
11216}
11217
11218#[derive(Clone, Copy)]
11219#[repr(C)]
11220pub struct VkSwapchainCreateInfoKHR {
11221    pub sType: VkStructureType,
11222    pub pNext: *const c_void,
11223    pub flags: VkSwapchainCreateFlagsKHR,
11224    pub surface: VkSurfaceKHR,
11225    pub minImageCount: u32,
11226    pub imageFormat: VkFormat,
11227    pub imageColorSpace: VkColorSpaceKHR,
11228    pub imageExtent: VkExtent2D,
11229    pub imageArrayLayers: u32,
11230    pub imageUsage: VkImageUsageFlags,
11231    pub imageSharingMode: VkSharingMode,
11232    pub queueFamilyIndexCount: u32,
11233    pub pQueueFamilyIndices: *const u32,
11234    pub preTransform: VkSurfaceTransformFlagBitsKHR,
11235    pub compositeAlpha: VkCompositeAlphaFlagBitsKHR,
11236    pub presentMode: VkPresentModeKHR,
11237    pub clipped: VkBool32,
11238    pub oldSwapchain: VkSwapchainKHR,
11239}
11240
11241#[derive(Clone, Copy)]
11242#[repr(C)]
11243pub struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
11244    pub sType: VkStructureType,
11245    pub pNext: *const c_void,
11246    pub localDimmingEnable: VkBool32,
11247}
11248
11249#[repr(C)]
11250pub struct VkSwapchainKHR_T {
11251    _data: (),
11252    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11253}
11254
11255#[derive(Clone, Copy)]
11256#[repr(C)]
11257pub struct VkSwapchainLatencyCreateInfoNV {
11258    pub sType: VkStructureType,
11259    pub pNext: *const c_void,
11260    pub latencyModeEnable: VkBool32,
11261}
11262
11263#[derive(Clone, Copy)]
11264#[repr(C)]
11265pub struct VkSwapchainPresentBarrierCreateInfoNV {
11266    pub sType: VkStructureType,
11267    pub pNext: *mut c_void,
11268    pub presentBarrierEnable: VkBool32,
11269}
11270
11271#[derive(Clone, Copy)]
11272#[repr(C)]
11273pub struct VkSwapchainPresentFenceInfoKHR {
11274    pub sType: VkStructureType,
11275    pub pNext: *const c_void,
11276    pub swapchainCount: u32,
11277    pub pFences: *const VkFence,
11278}
11279
11280#[derive(Clone, Copy)]
11281#[repr(C)]
11282pub struct VkSwapchainPresentModeInfoKHR {
11283    pub sType: VkStructureType,
11284    pub pNext: *const c_void,
11285    pub swapchainCount: u32,
11286    pub pPresentModes: *const VkPresentModeKHR,
11287}
11288
11289#[derive(Clone, Copy)]
11290#[repr(C)]
11291pub struct VkSwapchainPresentModesCreateInfoKHR {
11292    pub sType: VkStructureType,
11293    pub pNext: *const c_void,
11294    pub presentModeCount: u32,
11295    pub pPresentModes: *const VkPresentModeKHR,
11296}
11297
11298#[derive(Clone, Copy)]
11299#[repr(C)]
11300pub struct VkSwapchainPresentScalingCreateInfoKHR {
11301    pub sType: VkStructureType,
11302    pub pNext: *const c_void,
11303    pub scalingBehavior: VkPresentScalingFlagsKHR,
11304    pub presentGravityX: VkPresentGravityFlagsKHR,
11305    pub presentGravityY: VkPresentGravityFlagsKHR,
11306}
11307
11308#[derive(Clone, Copy)]
11309#[repr(C)]
11310pub struct VkSwapchainTimeDomainPropertiesEXT {
11311    pub sType: VkStructureType,
11312    pub pNext: *mut c_void,
11313    pub timeDomainCount: u32,
11314    pub pTimeDomains: *mut VkTimeDomainKHR,
11315    pub pTimeDomainIds: *mut u64,
11316}
11317
11318#[derive(Clone, Copy)]
11319#[repr(C)]
11320pub struct VkSwapchainTimingPropertiesEXT {
11321    pub sType: VkStructureType,
11322    pub pNext: *mut c_void,
11323    pub refreshDuration: u64,
11324    pub refreshInterval: u64,
11325}
11326
11327#[repr(C)]
11328pub struct VkTensorARM_T {
11329    _data: (),
11330    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11331}
11332
11333#[derive(Clone, Copy)]
11334#[repr(C)]
11335pub struct VkTensorCaptureDescriptorDataInfoARM {
11336    pub sType: VkStructureType,
11337    pub pNext: *const c_void,
11338    pub tensor: VkTensorARM,
11339}
11340
11341#[derive(Clone, Copy)]
11342#[repr(C)]
11343pub struct VkTensorCopyARM {
11344    pub sType: VkStructureType,
11345    pub pNext: *const c_void,
11346    pub dimensionCount: u32,
11347    pub pSrcOffset: *const u64,
11348    pub pDstOffset: *const u64,
11349    pub pExtent: *const u64,
11350}
11351
11352#[derive(Clone, Copy)]
11353#[repr(C)]
11354pub struct VkTensorCreateInfoARM {
11355    pub sType: VkStructureType,
11356    pub pNext: *const c_void,
11357    pub flags: VkTensorCreateFlagsARM,
11358    pub pDescription: *const VkTensorDescriptionARM,
11359    pub sharingMode: VkSharingMode,
11360    pub queueFamilyIndexCount: u32,
11361    pub pQueueFamilyIndices: *const u32,
11362}
11363
11364#[derive(Clone, Copy)]
11365#[repr(C)]
11366pub struct VkTensorDependencyInfoARM {
11367    pub sType: VkStructureType,
11368    pub pNext: *const c_void,
11369    pub tensorMemoryBarrierCount: u32,
11370    pub pTensorMemoryBarriers: *const VkTensorMemoryBarrierARM,
11371}
11372
11373#[derive(Clone, Copy)]
11374#[repr(C)]
11375pub struct VkTensorDescriptionARM {
11376    pub sType: VkStructureType,
11377    pub pNext: *const c_void,
11378    pub tiling: VkTensorTilingARM,
11379    pub format: VkFormat,
11380    pub dimensionCount: u32,
11381    pub pDimensions: *const i64,
11382    pub pStrides: *const i64,
11383    pub usage: VkTensorUsageFlagsARM,
11384}
11385
11386#[derive(Clone, Copy)]
11387#[repr(C)]
11388pub struct VkTensorFormatPropertiesARM {
11389    pub sType: VkStructureType,
11390    pub pNext: *mut c_void,
11391    pub optimalTilingTensorFeatures: VkFormatFeatureFlags2,
11392    pub linearTilingTensorFeatures: VkFormatFeatureFlags2,
11393}
11394
11395#[derive(Clone, Copy)]
11396#[repr(C)]
11397pub struct VkTensorMemoryBarrierARM {
11398    pub sType: VkStructureType,
11399    pub pNext: *const c_void,
11400    pub srcStageMask: VkPipelineStageFlags2,
11401    pub srcAccessMask: VkAccessFlags2,
11402    pub dstStageMask: VkPipelineStageFlags2,
11403    pub dstAccessMask: VkAccessFlags2,
11404    pub srcQueueFamilyIndex: u32,
11405    pub dstQueueFamilyIndex: u32,
11406    pub tensor: VkTensorARM,
11407}
11408
11409#[derive(Clone, Copy)]
11410#[repr(C)]
11411pub struct VkTensorMemoryRequirementsInfoARM {
11412    pub sType: VkStructureType,
11413    pub pNext: *const c_void,
11414    pub tensor: VkTensorARM,
11415}
11416
11417#[repr(C)]
11418pub struct VkTensorViewARM_T {
11419    _data: (),
11420    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11421}
11422
11423#[derive(Clone, Copy)]
11424#[repr(C)]
11425pub struct VkTensorViewCaptureDescriptorDataInfoARM {
11426    pub sType: VkStructureType,
11427    pub pNext: *const c_void,
11428    pub tensorView: VkTensorViewARM,
11429}
11430
11431#[derive(Clone, Copy)]
11432#[repr(C)]
11433pub struct VkTensorViewCreateInfoARM {
11434    pub sType: VkStructureType,
11435    pub pNext: *const c_void,
11436    pub flags: VkTensorViewCreateFlagsARM,
11437    pub tensor: VkTensorARM,
11438    pub format: VkFormat,
11439}
11440
11441#[derive(Clone, Copy)]
11442#[repr(C)]
11443pub struct VkTexelBufferDescriptorInfoEXT {
11444    pub sType: VkStructureType,
11445    pub pNext: *const c_void,
11446    pub format: VkFormat,
11447    pub addressRange: VkDeviceAddressRangeEXT,
11448}
11449
11450#[derive(Clone, Copy)]
11451#[repr(C)]
11452pub struct VkTextureLODGatherFormatPropertiesAMD {
11453    pub sType: VkStructureType,
11454    pub pNext: *mut c_void,
11455    pub supportsTextureGatherLODBiasAMD: VkBool32,
11456}
11457
11458#[derive(Clone, Copy)]
11459#[repr(C)]
11460pub struct VkTileMemoryBindInfoQCOM {
11461    pub sType: VkStructureType,
11462    pub pNext: *const c_void,
11463    pub memory: VkDeviceMemory,
11464}
11465
11466#[derive(Clone, Copy)]
11467#[repr(C)]
11468pub struct VkTileMemoryRequirementsQCOM {
11469    pub sType: VkStructureType,
11470    pub pNext: *mut c_void,
11471    pub size: VkDeviceSize,
11472    pub alignment: VkDeviceSize,
11473}
11474
11475#[derive(Clone, Copy)]
11476#[repr(C)]
11477pub struct VkTileMemorySizeInfoQCOM {
11478    pub sType: VkStructureType,
11479    pub pNext: *const c_void,
11480    pub size: VkDeviceSize,
11481}
11482
11483#[derive(Clone, Copy)]
11484#[repr(C)]
11485pub struct VkTilePropertiesQCOM {
11486    pub sType: VkStructureType,
11487    pub pNext: *mut c_void,
11488    pub tileSize: VkExtent3D,
11489    pub apronSize: VkExtent2D,
11490    pub origin: VkOffset2D,
11491}
11492
11493#[derive(Clone, Copy)]
11494#[repr(C)]
11495pub struct VkTimelineSemaphoreSubmitInfo {
11496    pub sType: VkStructureType,
11497    pub pNext: *const c_void,
11498    pub waitSemaphoreValueCount: u32,
11499    pub pWaitSemaphoreValues: *const u64,
11500    pub signalSemaphoreValueCount: u32,
11501    pub pSignalSemaphoreValues: *const u64,
11502}
11503
11504#[derive(Clone, Copy)]
11505#[repr(C)]
11506pub struct VkTraceRaysIndirectCommand2KHR {
11507    pub raygenShaderRecordAddress: VkDeviceAddress,
11508    pub raygenShaderRecordSize: VkDeviceSize,
11509    pub missShaderBindingTableAddress: VkDeviceAddress,
11510    pub missShaderBindingTableSize: VkDeviceSize,
11511    pub missShaderBindingTableStride: VkDeviceSize,
11512    pub hitShaderBindingTableAddress: VkDeviceAddress,
11513    pub hitShaderBindingTableSize: VkDeviceSize,
11514    pub hitShaderBindingTableStride: VkDeviceSize,
11515    pub callableShaderBindingTableAddress: VkDeviceAddress,
11516    pub callableShaderBindingTableSize: VkDeviceSize,
11517    pub callableShaderBindingTableStride: VkDeviceSize,
11518    pub width: u32,
11519    pub height: u32,
11520    pub depth: u32,
11521}
11522
11523#[derive(Clone, Copy)]
11524#[repr(C)]
11525pub struct VkTraceRaysIndirectCommandKHR {
11526    pub width: u32,
11527    pub height: u32,
11528    pub depth: u32,
11529}
11530
11531#[derive(Clone, Copy)]
11532#[repr(C)]
11533pub struct VkTransformMatrixKHR {
11534    pub matrix: [[f32; 4 as usize]; 3 as usize],
11535}
11536
11537#[derive(Clone, Copy)]
11538#[repr(C)]
11539pub struct VkValidationCacheCreateInfoEXT {
11540    pub sType: VkStructureType,
11541    pub pNext: *const c_void,
11542    pub flags: VkValidationCacheCreateFlagsEXT,
11543    pub initialDataSize: usize,
11544    pub pInitialData: *const c_void,
11545}
11546
11547#[repr(C)]
11548pub struct VkValidationCacheEXT_T {
11549    _data: (),
11550    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11551}
11552
11553#[derive(Clone, Copy)]
11554#[repr(C)]
11555pub struct VkValidationFeaturesEXT {
11556    pub sType: VkStructureType,
11557    pub pNext: *const c_void,
11558    pub enabledValidationFeatureCount: u32,
11559    pub pEnabledValidationFeatures: *const VkValidationFeatureEnableEXT,
11560    pub disabledValidationFeatureCount: u32,
11561    pub pDisabledValidationFeatures: *const VkValidationFeatureDisableEXT,
11562}
11563
11564#[derive(Clone, Copy)]
11565#[repr(C)]
11566pub struct VkValidationFlagsEXT {
11567    pub sType: VkStructureType,
11568    pub pNext: *const c_void,
11569    pub disabledValidationCheckCount: u32,
11570    pub pDisabledValidationChecks: *const VkValidationCheckEXT,
11571}
11572
11573#[derive(Clone, Copy)]
11574#[repr(C)]
11575pub struct VkVertexInputAttributeDescription {
11576    pub location: u32,
11577    pub binding: u32,
11578    pub format: VkFormat,
11579    pub offset: u32,
11580}
11581
11582#[derive(Clone, Copy)]
11583#[repr(C)]
11584pub struct VkVertexInputAttributeDescription2EXT {
11585    pub sType: VkStructureType,
11586    pub pNext: *mut c_void,
11587    pub location: u32,
11588    pub binding: u32,
11589    pub format: VkFormat,
11590    pub offset: u32,
11591}
11592
11593#[derive(Clone, Copy)]
11594#[repr(C)]
11595pub struct VkVertexInputBindingDescription {
11596    pub binding: u32,
11597    pub stride: u32,
11598    pub inputRate: VkVertexInputRate,
11599}
11600
11601#[derive(Clone, Copy)]
11602#[repr(C)]
11603pub struct VkVertexInputBindingDescription2EXT {
11604    pub sType: VkStructureType,
11605    pub pNext: *mut c_void,
11606    pub binding: u32,
11607    pub stride: u32,
11608    pub inputRate: VkVertexInputRate,
11609    pub divisor: u32,
11610}
11611
11612#[derive(Clone, Copy)]
11613#[repr(C)]
11614pub struct VkVertexInputBindingDivisorDescription {
11615    pub binding: u32,
11616    pub divisor: u32,
11617}
11618
11619#[derive(Clone, Copy)]
11620#[repr(C)]
11621pub struct VkVideoBeginCodingInfoKHR {
11622    pub sType: VkStructureType,
11623    pub pNext: *const c_void,
11624    pub flags: VkVideoBeginCodingFlagsKHR,
11625    pub videoSession: VkVideoSessionKHR,
11626    pub videoSessionParameters: VkVideoSessionParametersKHR,
11627    pub referenceSlotCount: u32,
11628    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
11629}
11630
11631#[derive(Clone, Copy)]
11632#[repr(C)]
11633pub struct VkVideoCapabilitiesKHR {
11634    pub sType: VkStructureType,
11635    pub pNext: *mut c_void,
11636    pub flags: VkVideoCapabilityFlagsKHR,
11637    pub minBitstreamBufferOffsetAlignment: VkDeviceSize,
11638    pub minBitstreamBufferSizeAlignment: VkDeviceSize,
11639    pub pictureAccessGranularity: VkExtent2D,
11640    pub minCodedExtent: VkExtent2D,
11641    pub maxCodedExtent: VkExtent2D,
11642    pub maxDpbSlots: u32,
11643    pub maxActiveReferencePictures: u32,
11644    pub stdHeaderVersion: VkExtensionProperties,
11645}
11646
11647#[derive(Clone, Copy)]
11648#[repr(C)]
11649pub struct VkVideoCodingControlInfoKHR {
11650    pub sType: VkStructureType,
11651    pub pNext: *const c_void,
11652    pub flags: VkVideoCodingControlFlagsKHR,
11653}
11654
11655#[derive(Clone, Copy)]
11656#[repr(C)]
11657pub struct VkVideoDecodeAV1CapabilitiesKHR {
11658    pub sType: VkStructureType,
11659    pub pNext: *mut c_void,
11660    pub maxLevel: StdVideoAV1Level,
11661}
11662
11663#[derive(Clone, Copy)]
11664#[repr(C)]
11665pub struct VkVideoDecodeAV1DpbSlotInfoKHR {
11666    pub sType: VkStructureType,
11667    pub pNext: *const c_void,
11668    pub pStdReferenceInfo: *const StdVideoDecodeAV1ReferenceInfo,
11669}
11670
11671#[derive(Clone, Copy)]
11672#[repr(C)]
11673pub struct VkVideoDecodeAV1InlineSessionParametersInfoKHR {
11674    pub sType: VkStructureType,
11675    pub pNext: *const c_void,
11676    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
11677}
11678
11679#[derive(Clone, Copy)]
11680#[repr(C)]
11681pub struct VkVideoDecodeAV1PictureInfoKHR {
11682    pub sType: VkStructureType,
11683    pub pNext: *const c_void,
11684    pub pStdPictureInfo: *const StdVideoDecodeAV1PictureInfo,
11685    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
11686    pub frameHeaderOffset: u32,
11687    pub tileCount: u32,
11688    pub pTileOffsets: *const u32,
11689    pub pTileSizes: *const u32,
11690}
11691
11692#[derive(Clone, Copy)]
11693#[repr(C)]
11694pub struct VkVideoDecodeAV1ProfileInfoKHR {
11695    pub sType: VkStructureType,
11696    pub pNext: *const c_void,
11697    pub stdProfile: StdVideoAV1Profile,
11698    pub filmGrainSupport: VkBool32,
11699}
11700
11701#[derive(Clone, Copy)]
11702#[repr(C)]
11703pub struct VkVideoDecodeAV1SessionParametersCreateInfoKHR {
11704    pub sType: VkStructureType,
11705    pub pNext: *const c_void,
11706    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
11707}
11708
11709#[derive(Clone, Copy)]
11710#[repr(C)]
11711pub struct VkVideoDecodeCapabilitiesKHR {
11712    pub sType: VkStructureType,
11713    pub pNext: *mut c_void,
11714    pub flags: VkVideoDecodeCapabilityFlagsKHR,
11715}
11716
11717#[derive(Clone, Copy)]
11718#[repr(C)]
11719pub struct VkVideoDecodeH264CapabilitiesKHR {
11720    pub sType: VkStructureType,
11721    pub pNext: *mut c_void,
11722    pub maxLevelIdc: StdVideoH264LevelIdc,
11723    pub fieldOffsetGranularity: VkOffset2D,
11724}
11725
11726#[derive(Clone, Copy)]
11727#[repr(C)]
11728pub struct VkVideoDecodeH264DpbSlotInfoKHR {
11729    pub sType: VkStructureType,
11730    pub pNext: *const c_void,
11731    pub pStdReferenceInfo: *const StdVideoDecodeH264ReferenceInfo,
11732}
11733
11734#[derive(Clone, Copy)]
11735#[repr(C)]
11736pub struct VkVideoDecodeH264InlineSessionParametersInfoKHR {
11737    pub sType: VkStructureType,
11738    pub pNext: *const c_void,
11739    pub pStdSPS: *const StdVideoH264SequenceParameterSet,
11740    pub pStdPPS: *const StdVideoH264PictureParameterSet,
11741}
11742
11743#[derive(Clone, Copy)]
11744#[repr(C)]
11745pub struct VkVideoDecodeH264PictureInfoKHR {
11746    pub sType: VkStructureType,
11747    pub pNext: *const c_void,
11748    pub pStdPictureInfo: *const StdVideoDecodeH264PictureInfo,
11749    pub sliceCount: u32,
11750    pub pSliceOffsets: *const u32,
11751}
11752
11753#[derive(Clone, Copy)]
11754#[repr(C)]
11755pub struct VkVideoDecodeH264ProfileInfoKHR {
11756    pub sType: VkStructureType,
11757    pub pNext: *const c_void,
11758    pub stdProfileIdc: StdVideoH264ProfileIdc,
11759    pub pictureLayout: VkVideoDecodeH264PictureLayoutFlagBitsKHR,
11760}
11761
11762#[derive(Clone, Copy)]
11763#[repr(C)]
11764pub struct VkVideoDecodeH264SessionParametersAddInfoKHR {
11765    pub sType: VkStructureType,
11766    pub pNext: *const c_void,
11767    pub stdSPSCount: u32,
11768    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
11769    pub stdPPSCount: u32,
11770    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
11771}
11772
11773#[derive(Clone, Copy)]
11774#[repr(C)]
11775pub struct VkVideoDecodeH264SessionParametersCreateInfoKHR {
11776    pub sType: VkStructureType,
11777    pub pNext: *const c_void,
11778    pub maxStdSPSCount: u32,
11779    pub maxStdPPSCount: u32,
11780    pub pParametersAddInfo: *const VkVideoDecodeH264SessionParametersAddInfoKHR,
11781}
11782
11783#[derive(Clone, Copy)]
11784#[repr(C)]
11785pub struct VkVideoDecodeH265CapabilitiesKHR {
11786    pub sType: VkStructureType,
11787    pub pNext: *mut c_void,
11788    pub maxLevelIdc: StdVideoH265LevelIdc,
11789}
11790
11791#[derive(Clone, Copy)]
11792#[repr(C)]
11793pub struct VkVideoDecodeH265DpbSlotInfoKHR {
11794    pub sType: VkStructureType,
11795    pub pNext: *const c_void,
11796    pub pStdReferenceInfo: *const StdVideoDecodeH265ReferenceInfo,
11797}
11798
11799#[derive(Clone, Copy)]
11800#[repr(C)]
11801pub struct VkVideoDecodeH265InlineSessionParametersInfoKHR {
11802    pub sType: VkStructureType,
11803    pub pNext: *const c_void,
11804    pub pStdVPS: *const StdVideoH265VideoParameterSet,
11805    pub pStdSPS: *const StdVideoH265SequenceParameterSet,
11806    pub pStdPPS: *const StdVideoH265PictureParameterSet,
11807}
11808
11809#[derive(Clone, Copy)]
11810#[repr(C)]
11811pub struct VkVideoDecodeH265PictureInfoKHR {
11812    pub sType: VkStructureType,
11813    pub pNext: *const c_void,
11814    pub pStdPictureInfo: *const StdVideoDecodeH265PictureInfo,
11815    pub sliceSegmentCount: u32,
11816    pub pSliceSegmentOffsets: *const u32,
11817}
11818
11819#[derive(Clone, Copy)]
11820#[repr(C)]
11821pub struct VkVideoDecodeH265ProfileInfoKHR {
11822    pub sType: VkStructureType,
11823    pub pNext: *const c_void,
11824    pub stdProfileIdc: StdVideoH265ProfileIdc,
11825}
11826
11827#[derive(Clone, Copy)]
11828#[repr(C)]
11829pub struct VkVideoDecodeH265SessionParametersAddInfoKHR {
11830    pub sType: VkStructureType,
11831    pub pNext: *const c_void,
11832    pub stdVPSCount: u32,
11833    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
11834    pub stdSPSCount: u32,
11835    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
11836    pub stdPPSCount: u32,
11837    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
11838}
11839
11840#[derive(Clone, Copy)]
11841#[repr(C)]
11842pub struct VkVideoDecodeH265SessionParametersCreateInfoKHR {
11843    pub sType: VkStructureType,
11844    pub pNext: *const c_void,
11845    pub maxStdVPSCount: u32,
11846    pub maxStdSPSCount: u32,
11847    pub maxStdPPSCount: u32,
11848    pub pParametersAddInfo: *const VkVideoDecodeH265SessionParametersAddInfoKHR,
11849}
11850
11851#[derive(Clone, Copy)]
11852#[repr(C)]
11853pub struct VkVideoDecodeInfoKHR {
11854    pub sType: VkStructureType,
11855    pub pNext: *const c_void,
11856    pub flags: VkVideoDecodeFlagsKHR,
11857    pub srcBuffer: VkBuffer,
11858    pub srcBufferOffset: VkDeviceSize,
11859    pub srcBufferRange: VkDeviceSize,
11860    pub dstPictureResource: VkVideoPictureResourceInfoKHR,
11861    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
11862    pub referenceSlotCount: u32,
11863    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
11864}
11865
11866#[derive(Clone, Copy)]
11867#[repr(C)]
11868pub struct VkVideoDecodeUsageInfoKHR {
11869    pub sType: VkStructureType,
11870    pub pNext: *const c_void,
11871    pub videoUsageHints: VkVideoDecodeUsageFlagsKHR,
11872}
11873
11874#[derive(Clone, Copy)]
11875#[repr(C)]
11876pub struct VkVideoDecodeVP9CapabilitiesKHR {
11877    pub sType: VkStructureType,
11878    pub pNext: *mut c_void,
11879    pub maxLevel: StdVideoVP9Level,
11880}
11881
11882#[derive(Clone, Copy)]
11883#[repr(C)]
11884pub struct VkVideoDecodeVP9PictureInfoKHR {
11885    pub sType: VkStructureType,
11886    pub pNext: *const c_void,
11887    pub pStdPictureInfo: *const StdVideoDecodeVP9PictureInfo,
11888    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR as usize],
11889    pub uncompressedHeaderOffset: u32,
11890    pub compressedHeaderOffset: u32,
11891    pub tilesOffset: u32,
11892}
11893
11894#[derive(Clone, Copy)]
11895#[repr(C)]
11896pub struct VkVideoDecodeVP9ProfileInfoKHR {
11897    pub sType: VkStructureType,
11898    pub pNext: *const c_void,
11899    pub stdProfile: StdVideoVP9Profile,
11900}
11901
11902#[derive(Clone, Copy)]
11903#[repr(C)]
11904pub struct VkVideoEncodeAV1CapabilitiesKHR {
11905    pub sType: VkStructureType,
11906    pub pNext: *mut c_void,
11907    pub flags: VkVideoEncodeAV1CapabilityFlagsKHR,
11908    pub maxLevel: StdVideoAV1Level,
11909    pub codedPictureAlignment: VkExtent2D,
11910    pub maxTiles: VkExtent2D,
11911    pub minTileSize: VkExtent2D,
11912    pub maxTileSize: VkExtent2D,
11913    pub superblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
11914    pub maxSingleReferenceCount: u32,
11915    pub singleReferenceNameMask: u32,
11916    pub maxUnidirectionalCompoundReferenceCount: u32,
11917    pub maxUnidirectionalCompoundGroup1ReferenceCount: u32,
11918    pub unidirectionalCompoundReferenceNameMask: u32,
11919    pub maxBidirectionalCompoundReferenceCount: u32,
11920    pub maxBidirectionalCompoundGroup1ReferenceCount: u32,
11921    pub maxBidirectionalCompoundGroup2ReferenceCount: u32,
11922    pub bidirectionalCompoundReferenceNameMask: u32,
11923    pub maxTemporalLayerCount: u32,
11924    pub maxSpatialLayerCount: u32,
11925    pub maxOperatingPoints: u32,
11926    pub minQIndex: u32,
11927    pub maxQIndex: u32,
11928    pub prefersGopRemainingFrames: VkBool32,
11929    pub requiresGopRemainingFrames: VkBool32,
11930    pub stdSyntaxFlags: VkVideoEncodeAV1StdFlagsKHR,
11931}
11932
11933#[derive(Clone, Copy)]
11934#[repr(C)]
11935pub struct VkVideoEncodeAV1DpbSlotInfoKHR {
11936    pub sType: VkStructureType,
11937    pub pNext: *const c_void,
11938    pub pStdReferenceInfo: *const StdVideoEncodeAV1ReferenceInfo,
11939}
11940
11941#[derive(Clone, Copy)]
11942#[repr(C)]
11943pub struct VkVideoEncodeAV1FrameSizeKHR {
11944    pub intraFrameSize: u32,
11945    pub predictiveFrameSize: u32,
11946    pub bipredictiveFrameSize: u32,
11947}
11948
11949#[derive(Clone, Copy)]
11950#[repr(C)]
11951pub struct VkVideoEncodeAV1GopRemainingFrameInfoKHR {
11952    pub sType: VkStructureType,
11953    pub pNext: *const c_void,
11954    pub useGopRemainingFrames: VkBool32,
11955    pub gopRemainingIntra: u32,
11956    pub gopRemainingPredictive: u32,
11957    pub gopRemainingBipredictive: u32,
11958}
11959
11960#[derive(Clone, Copy)]
11961#[repr(C)]
11962pub struct VkVideoEncodeAV1PictureInfoKHR {
11963    pub sType: VkStructureType,
11964    pub pNext: *const c_void,
11965    pub predictionMode: VkVideoEncodeAV1PredictionModeKHR,
11966    pub rateControlGroup: VkVideoEncodeAV1RateControlGroupKHR,
11967    pub constantQIndex: u32,
11968    pub pStdPictureInfo: *const StdVideoEncodeAV1PictureInfo,
11969    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
11970    pub primaryReferenceCdfOnly: VkBool32,
11971    pub generateObuExtensionHeader: VkBool32,
11972}
11973
11974#[derive(Clone, Copy)]
11975#[repr(C)]
11976pub struct VkVideoEncodeAV1ProfileInfoKHR {
11977    pub sType: VkStructureType,
11978    pub pNext: *const c_void,
11979    pub stdProfile: StdVideoAV1Profile,
11980}
11981
11982#[derive(Clone, Copy)]
11983#[repr(C)]
11984pub struct VkVideoEncodeAV1QIndexKHR {
11985    pub intraQIndex: u32,
11986    pub predictiveQIndex: u32,
11987    pub bipredictiveQIndex: u32,
11988}
11989
11990#[derive(Clone, Copy)]
11991#[repr(C)]
11992pub struct VkVideoEncodeAV1QualityLevelPropertiesKHR {
11993    pub sType: VkStructureType,
11994    pub pNext: *mut c_void,
11995    pub preferredRateControlFlags: VkVideoEncodeAV1RateControlFlagsKHR,
11996    pub preferredGopFrameCount: u32,
11997    pub preferredKeyFramePeriod: u32,
11998    pub preferredConsecutiveBipredictiveFrameCount: u32,
11999    pub preferredTemporalLayerCount: u32,
12000    pub preferredConstantQIndex: VkVideoEncodeAV1QIndexKHR,
12001    pub preferredMaxSingleReferenceCount: u32,
12002    pub preferredSingleReferenceNameMask: u32,
12003    pub preferredMaxUnidirectionalCompoundReferenceCount: u32,
12004    pub preferredMaxUnidirectionalCompoundGroup1ReferenceCount: u32,
12005    pub preferredUnidirectionalCompoundReferenceNameMask: u32,
12006    pub preferredMaxBidirectionalCompoundReferenceCount: u32,
12007    pub preferredMaxBidirectionalCompoundGroup1ReferenceCount: u32,
12008    pub preferredMaxBidirectionalCompoundGroup2ReferenceCount: u32,
12009    pub preferredBidirectionalCompoundReferenceNameMask: u32,
12010}
12011
12012#[derive(Clone, Copy)]
12013#[repr(C)]
12014pub struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR {
12015    pub sType: VkStructureType,
12016    pub pNext: *mut c_void,
12017    pub minQIndexDelta: i32,
12018    pub maxQIndexDelta: i32,
12019}
12020
12021#[derive(Clone, Copy)]
12022#[repr(C)]
12023pub struct VkVideoEncodeAV1RateControlInfoKHR {
12024    pub sType: VkStructureType,
12025    pub pNext: *const c_void,
12026    pub flags: VkVideoEncodeAV1RateControlFlagsKHR,
12027    pub gopFrameCount: u32,
12028    pub keyFramePeriod: u32,
12029    pub consecutiveBipredictiveFrameCount: u32,
12030    pub temporalLayerCount: u32,
12031}
12032
12033#[derive(Clone, Copy)]
12034#[repr(C)]
12035pub struct VkVideoEncodeAV1RateControlLayerInfoKHR {
12036    pub sType: VkStructureType,
12037    pub pNext: *const c_void,
12038    pub useMinQIndex: VkBool32,
12039    pub minQIndex: VkVideoEncodeAV1QIndexKHR,
12040    pub useMaxQIndex: VkBool32,
12041    pub maxQIndex: VkVideoEncodeAV1QIndexKHR,
12042    pub useMaxFrameSize: VkBool32,
12043    pub maxFrameSize: VkVideoEncodeAV1FrameSizeKHR,
12044}
12045
12046#[derive(Clone, Copy)]
12047#[repr(C)]
12048pub struct VkVideoEncodeAV1SessionCreateInfoKHR {
12049    pub sType: VkStructureType,
12050    pub pNext: *const c_void,
12051    pub useMaxLevel: VkBool32,
12052    pub maxLevel: StdVideoAV1Level,
12053}
12054
12055#[derive(Clone, Copy)]
12056#[repr(C)]
12057pub struct VkVideoEncodeAV1SessionParametersCreateInfoKHR {
12058    pub sType: VkStructureType,
12059    pub pNext: *const c_void,
12060    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
12061    pub pStdDecoderModelInfo: *const StdVideoEncodeAV1DecoderModelInfo,
12062    pub stdOperatingPointCount: u32,
12063    pub pStdOperatingPoints: *const StdVideoEncodeAV1OperatingPointInfo,
12064}
12065
12066#[derive(Clone, Copy)]
12067#[repr(C)]
12068pub struct VkVideoEncodeCapabilitiesKHR {
12069    pub sType: VkStructureType,
12070    pub pNext: *mut c_void,
12071    pub flags: VkVideoEncodeCapabilityFlagsKHR,
12072    pub rateControlModes: VkVideoEncodeRateControlModeFlagsKHR,
12073    pub maxRateControlLayers: u32,
12074    pub maxBitrate: u64,
12075    pub maxQualityLevels: u32,
12076    pub encodeInputPictureGranularity: VkExtent2D,
12077    pub supportedEncodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
12078}
12079
12080#[derive(Clone, Copy)]
12081#[repr(C)]
12082pub struct VkVideoEncodeH264CapabilitiesKHR {
12083    pub sType: VkStructureType,
12084    pub pNext: *mut c_void,
12085    pub flags: VkVideoEncodeH264CapabilityFlagsKHR,
12086    pub maxLevelIdc: StdVideoH264LevelIdc,
12087    pub maxSliceCount: u32,
12088    pub maxPPictureL0ReferenceCount: u32,
12089    pub maxBPictureL0ReferenceCount: u32,
12090    pub maxL1ReferenceCount: u32,
12091    pub maxTemporalLayerCount: u32,
12092    pub expectDyadicTemporalLayerPattern: VkBool32,
12093    pub minQp: i32,
12094    pub maxQp: i32,
12095    pub prefersGopRemainingFrames: VkBool32,
12096    pub requiresGopRemainingFrames: VkBool32,
12097    pub stdSyntaxFlags: VkVideoEncodeH264StdFlagsKHR,
12098}
12099
12100#[derive(Clone, Copy)]
12101#[repr(C)]
12102pub struct VkVideoEncodeH264DpbSlotInfoKHR {
12103    pub sType: VkStructureType,
12104    pub pNext: *const c_void,
12105    pub pStdReferenceInfo: *const StdVideoEncodeH264ReferenceInfo,
12106}
12107
12108#[derive(Clone, Copy)]
12109#[repr(C)]
12110pub struct VkVideoEncodeH264FrameSizeKHR {
12111    pub frameISize: u32,
12112    pub framePSize: u32,
12113    pub frameBSize: u32,
12114}
12115
12116#[derive(Clone, Copy)]
12117#[repr(C)]
12118pub struct VkVideoEncodeH264GopRemainingFrameInfoKHR {
12119    pub sType: VkStructureType,
12120    pub pNext: *const c_void,
12121    pub useGopRemainingFrames: VkBool32,
12122    pub gopRemainingI: u32,
12123    pub gopRemainingP: u32,
12124    pub gopRemainingB: u32,
12125}
12126
12127#[derive(Clone, Copy)]
12128#[repr(C)]
12129pub struct VkVideoEncodeH264NaluSliceInfoKHR {
12130    pub sType: VkStructureType,
12131    pub pNext: *const c_void,
12132    pub constantQp: i32,
12133    pub pStdSliceHeader: *const StdVideoEncodeH264SliceHeader,
12134}
12135
12136#[derive(Clone, Copy)]
12137#[repr(C)]
12138pub struct VkVideoEncodeH264PictureInfoKHR {
12139    pub sType: VkStructureType,
12140    pub pNext: *const c_void,
12141    pub naluSliceEntryCount: u32,
12142    pub pNaluSliceEntries: *const VkVideoEncodeH264NaluSliceInfoKHR,
12143    pub pStdPictureInfo: *const StdVideoEncodeH264PictureInfo,
12144    pub generatePrefixNalu: VkBool32,
12145}
12146
12147#[derive(Clone, Copy)]
12148#[repr(C)]
12149pub struct VkVideoEncodeH264ProfileInfoKHR {
12150    pub sType: VkStructureType,
12151    pub pNext: *const c_void,
12152    pub stdProfileIdc: StdVideoH264ProfileIdc,
12153}
12154
12155#[derive(Clone, Copy)]
12156#[repr(C)]
12157pub struct VkVideoEncodeH264QpKHR {
12158    pub qpI: i32,
12159    pub qpP: i32,
12160    pub qpB: i32,
12161}
12162
12163#[derive(Clone, Copy)]
12164#[repr(C)]
12165pub struct VkVideoEncodeH264QualityLevelPropertiesKHR {
12166    pub sType: VkStructureType,
12167    pub pNext: *mut c_void,
12168    pub preferredRateControlFlags: VkVideoEncodeH264RateControlFlagsKHR,
12169    pub preferredGopFrameCount: u32,
12170    pub preferredIdrPeriod: u32,
12171    pub preferredConsecutiveBFrameCount: u32,
12172    pub preferredTemporalLayerCount: u32,
12173    pub preferredConstantQp: VkVideoEncodeH264QpKHR,
12174    pub preferredMaxL0ReferenceCount: u32,
12175    pub preferredMaxL1ReferenceCount: u32,
12176    pub preferredStdEntropyCodingModeFlag: VkBool32,
12177}
12178
12179#[derive(Clone, Copy)]
12180#[repr(C)]
12181pub struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR {
12182    pub sType: VkStructureType,
12183    pub pNext: *mut c_void,
12184    pub minQpDelta: i32,
12185    pub maxQpDelta: i32,
12186}
12187
12188#[derive(Clone, Copy)]
12189#[repr(C)]
12190pub struct VkVideoEncodeH264RateControlInfoKHR {
12191    pub sType: VkStructureType,
12192    pub pNext: *const c_void,
12193    pub flags: VkVideoEncodeH264RateControlFlagsKHR,
12194    pub gopFrameCount: u32,
12195    pub idrPeriod: u32,
12196    pub consecutiveBFrameCount: u32,
12197    pub temporalLayerCount: u32,
12198}
12199
12200#[derive(Clone, Copy)]
12201#[repr(C)]
12202pub struct VkVideoEncodeH264RateControlLayerInfoKHR {
12203    pub sType: VkStructureType,
12204    pub pNext: *const c_void,
12205    pub useMinQp: VkBool32,
12206    pub minQp: VkVideoEncodeH264QpKHR,
12207    pub useMaxQp: VkBool32,
12208    pub maxQp: VkVideoEncodeH264QpKHR,
12209    pub useMaxFrameSize: VkBool32,
12210    pub maxFrameSize: VkVideoEncodeH264FrameSizeKHR,
12211}
12212
12213#[derive(Clone, Copy)]
12214#[repr(C)]
12215pub struct VkVideoEncodeH264SessionCreateInfoKHR {
12216    pub sType: VkStructureType,
12217    pub pNext: *const c_void,
12218    pub useMaxLevelIdc: VkBool32,
12219    pub maxLevelIdc: StdVideoH264LevelIdc,
12220}
12221
12222#[derive(Clone, Copy)]
12223#[repr(C)]
12224pub struct VkVideoEncodeH264SessionParametersAddInfoKHR {
12225    pub sType: VkStructureType,
12226    pub pNext: *const c_void,
12227    pub stdSPSCount: u32,
12228    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
12229    pub stdPPSCount: u32,
12230    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
12231}
12232
12233#[derive(Clone, Copy)]
12234#[repr(C)]
12235pub struct VkVideoEncodeH264SessionParametersCreateInfoKHR {
12236    pub sType: VkStructureType,
12237    pub pNext: *const c_void,
12238    pub maxStdSPSCount: u32,
12239    pub maxStdPPSCount: u32,
12240    pub pParametersAddInfo: *const VkVideoEncodeH264SessionParametersAddInfoKHR,
12241}
12242
12243#[derive(Clone, Copy)]
12244#[repr(C)]
12245pub struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR {
12246    pub sType: VkStructureType,
12247    pub pNext: *mut c_void,
12248    pub hasStdSPSOverrides: VkBool32,
12249    pub hasStdPPSOverrides: VkBool32,
12250}
12251
12252#[derive(Clone, Copy)]
12253#[repr(C)]
12254pub struct VkVideoEncodeH264SessionParametersGetInfoKHR {
12255    pub sType: VkStructureType,
12256    pub pNext: *const c_void,
12257    pub writeStdSPS: VkBool32,
12258    pub writeStdPPS: VkBool32,
12259    pub stdSPSId: u32,
12260    pub stdPPSId: u32,
12261}
12262
12263#[derive(Clone, Copy)]
12264#[repr(C)]
12265pub struct VkVideoEncodeH265CapabilitiesKHR {
12266    pub sType: VkStructureType,
12267    pub pNext: *mut c_void,
12268    pub flags: VkVideoEncodeH265CapabilityFlagsKHR,
12269    pub maxLevelIdc: StdVideoH265LevelIdc,
12270    pub maxSliceSegmentCount: u32,
12271    pub maxTiles: VkExtent2D,
12272    pub ctbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
12273    pub transformBlockSizes: VkVideoEncodeH265TransformBlockSizeFlagsKHR,
12274    pub maxPPictureL0ReferenceCount: u32,
12275    pub maxBPictureL0ReferenceCount: u32,
12276    pub maxL1ReferenceCount: u32,
12277    pub maxSubLayerCount: u32,
12278    pub expectDyadicTemporalSubLayerPattern: VkBool32,
12279    pub minQp: i32,
12280    pub maxQp: i32,
12281    pub prefersGopRemainingFrames: VkBool32,
12282    pub requiresGopRemainingFrames: VkBool32,
12283    pub stdSyntaxFlags: VkVideoEncodeH265StdFlagsKHR,
12284}
12285
12286#[derive(Clone, Copy)]
12287#[repr(C)]
12288pub struct VkVideoEncodeH265DpbSlotInfoKHR {
12289    pub sType: VkStructureType,
12290    pub pNext: *const c_void,
12291    pub pStdReferenceInfo: *const StdVideoEncodeH265ReferenceInfo,
12292}
12293
12294#[derive(Clone, Copy)]
12295#[repr(C)]
12296pub struct VkVideoEncodeH265FrameSizeKHR {
12297    pub frameISize: u32,
12298    pub framePSize: u32,
12299    pub frameBSize: u32,
12300}
12301
12302#[derive(Clone, Copy)]
12303#[repr(C)]
12304pub struct VkVideoEncodeH265GopRemainingFrameInfoKHR {
12305    pub sType: VkStructureType,
12306    pub pNext: *const c_void,
12307    pub useGopRemainingFrames: VkBool32,
12308    pub gopRemainingI: u32,
12309    pub gopRemainingP: u32,
12310    pub gopRemainingB: u32,
12311}
12312
12313#[derive(Clone, Copy)]
12314#[repr(C)]
12315pub struct VkVideoEncodeH265NaluSliceSegmentInfoKHR {
12316    pub sType: VkStructureType,
12317    pub pNext: *const c_void,
12318    pub constantQp: i32,
12319    pub pStdSliceSegmentHeader: *const StdVideoEncodeH265SliceSegmentHeader,
12320}
12321
12322#[derive(Clone, Copy)]
12323#[repr(C)]
12324pub struct VkVideoEncodeH265PictureInfoKHR {
12325    pub sType: VkStructureType,
12326    pub pNext: *const c_void,
12327    pub naluSliceSegmentEntryCount: u32,
12328    pub pNaluSliceSegmentEntries: *const VkVideoEncodeH265NaluSliceSegmentInfoKHR,
12329    pub pStdPictureInfo: *const StdVideoEncodeH265PictureInfo,
12330}
12331
12332#[derive(Clone, Copy)]
12333#[repr(C)]
12334pub struct VkVideoEncodeH265ProfileInfoKHR {
12335    pub sType: VkStructureType,
12336    pub pNext: *const c_void,
12337    pub stdProfileIdc: StdVideoH265ProfileIdc,
12338}
12339
12340#[derive(Clone, Copy)]
12341#[repr(C)]
12342pub struct VkVideoEncodeH265QpKHR {
12343    pub qpI: i32,
12344    pub qpP: i32,
12345    pub qpB: i32,
12346}
12347
12348#[derive(Clone, Copy)]
12349#[repr(C)]
12350pub struct VkVideoEncodeH265QualityLevelPropertiesKHR {
12351    pub sType: VkStructureType,
12352    pub pNext: *mut c_void,
12353    pub preferredRateControlFlags: VkVideoEncodeH265RateControlFlagsKHR,
12354    pub preferredGopFrameCount: u32,
12355    pub preferredIdrPeriod: u32,
12356    pub preferredConsecutiveBFrameCount: u32,
12357    pub preferredSubLayerCount: u32,
12358    pub preferredConstantQp: VkVideoEncodeH265QpKHR,
12359    pub preferredMaxL0ReferenceCount: u32,
12360    pub preferredMaxL1ReferenceCount: u32,
12361}
12362
12363#[derive(Clone, Copy)]
12364#[repr(C)]
12365pub struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR {
12366    pub sType: VkStructureType,
12367    pub pNext: *mut c_void,
12368    pub minQpDelta: i32,
12369    pub maxQpDelta: i32,
12370}
12371
12372#[derive(Clone, Copy)]
12373#[repr(C)]
12374pub struct VkVideoEncodeH265RateControlInfoKHR {
12375    pub sType: VkStructureType,
12376    pub pNext: *const c_void,
12377    pub flags: VkVideoEncodeH265RateControlFlagsKHR,
12378    pub gopFrameCount: u32,
12379    pub idrPeriod: u32,
12380    pub consecutiveBFrameCount: u32,
12381    pub subLayerCount: u32,
12382}
12383
12384#[derive(Clone, Copy)]
12385#[repr(C)]
12386pub struct VkVideoEncodeH265RateControlLayerInfoKHR {
12387    pub sType: VkStructureType,
12388    pub pNext: *const c_void,
12389    pub useMinQp: VkBool32,
12390    pub minQp: VkVideoEncodeH265QpKHR,
12391    pub useMaxQp: VkBool32,
12392    pub maxQp: VkVideoEncodeH265QpKHR,
12393    pub useMaxFrameSize: VkBool32,
12394    pub maxFrameSize: VkVideoEncodeH265FrameSizeKHR,
12395}
12396
12397#[derive(Clone, Copy)]
12398#[repr(C)]
12399pub struct VkVideoEncodeH265SessionCreateInfoKHR {
12400    pub sType: VkStructureType,
12401    pub pNext: *const c_void,
12402    pub useMaxLevelIdc: VkBool32,
12403    pub maxLevelIdc: StdVideoH265LevelIdc,
12404}
12405
12406#[derive(Clone, Copy)]
12407#[repr(C)]
12408pub struct VkVideoEncodeH265SessionParametersAddInfoKHR {
12409    pub sType: VkStructureType,
12410    pub pNext: *const c_void,
12411    pub stdVPSCount: u32,
12412    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
12413    pub stdSPSCount: u32,
12414    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
12415    pub stdPPSCount: u32,
12416    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
12417}
12418
12419#[derive(Clone, Copy)]
12420#[repr(C)]
12421pub struct VkVideoEncodeH265SessionParametersCreateInfoKHR {
12422    pub sType: VkStructureType,
12423    pub pNext: *const c_void,
12424    pub maxStdVPSCount: u32,
12425    pub maxStdSPSCount: u32,
12426    pub maxStdPPSCount: u32,
12427    pub pParametersAddInfo: *const VkVideoEncodeH265SessionParametersAddInfoKHR,
12428}
12429
12430#[derive(Clone, Copy)]
12431#[repr(C)]
12432pub struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR {
12433    pub sType: VkStructureType,
12434    pub pNext: *mut c_void,
12435    pub hasStdVPSOverrides: VkBool32,
12436    pub hasStdSPSOverrides: VkBool32,
12437    pub hasStdPPSOverrides: VkBool32,
12438}
12439
12440#[derive(Clone, Copy)]
12441#[repr(C)]
12442pub struct VkVideoEncodeH265SessionParametersGetInfoKHR {
12443    pub sType: VkStructureType,
12444    pub pNext: *const c_void,
12445    pub writeStdVPS: VkBool32,
12446    pub writeStdSPS: VkBool32,
12447    pub writeStdPPS: VkBool32,
12448    pub stdVPSId: u32,
12449    pub stdSPSId: u32,
12450    pub stdPPSId: u32,
12451}
12452
12453#[derive(Clone, Copy)]
12454#[repr(C)]
12455pub struct VkVideoEncodeInfoKHR {
12456    pub sType: VkStructureType,
12457    pub pNext: *const c_void,
12458    pub flags: VkVideoEncodeFlagsKHR,
12459    pub dstBuffer: VkBuffer,
12460    pub dstBufferOffset: VkDeviceSize,
12461    pub dstBufferRange: VkDeviceSize,
12462    pub srcPictureResource: VkVideoPictureResourceInfoKHR,
12463    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
12464    pub referenceSlotCount: u32,
12465    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
12466    pub precedingExternallyEncodedBytes: u32,
12467}
12468
12469#[derive(Clone, Copy)]
12470#[repr(C)]
12471pub struct VkVideoEncodeIntraRefreshCapabilitiesKHR {
12472    pub sType: VkStructureType,
12473    pub pNext: *mut c_void,
12474    pub intraRefreshModes: VkVideoEncodeIntraRefreshModeFlagsKHR,
12475    pub maxIntraRefreshCycleDuration: u32,
12476    pub maxIntraRefreshActiveReferencePictures: u32,
12477    pub partitionIndependentIntraRefreshRegions: VkBool32,
12478    pub nonRectangularIntraRefreshRegions: VkBool32,
12479}
12480
12481#[derive(Clone, Copy)]
12482#[repr(C)]
12483pub struct VkVideoEncodeIntraRefreshInfoKHR {
12484    pub sType: VkStructureType,
12485    pub pNext: *const c_void,
12486    pub intraRefreshCycleDuration: u32,
12487    pub intraRefreshIndex: u32,
12488}
12489
12490#[derive(Clone, Copy)]
12491#[repr(C)]
12492pub struct VkVideoEncodeProfileRgbConversionInfoVALVE {
12493    pub sType: VkStructureType,
12494    pub pNext: *const c_void,
12495    pub performEncodeRgbConversion: VkBool32,
12496}
12497
12498#[derive(Clone, Copy)]
12499#[repr(C)]
12500pub struct VkVideoEncodeQualityLevelInfoKHR {
12501    pub sType: VkStructureType,
12502    pub pNext: *const c_void,
12503    pub qualityLevel: u32,
12504}
12505
12506#[derive(Clone, Copy)]
12507#[repr(C)]
12508pub struct VkVideoEncodeQualityLevelPropertiesKHR {
12509    pub sType: VkStructureType,
12510    pub pNext: *mut c_void,
12511    pub preferredRateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
12512    pub preferredRateControlLayerCount: u32,
12513}
12514
12515#[derive(Clone, Copy)]
12516#[repr(C)]
12517pub struct VkVideoEncodeQuantizationMapCapabilitiesKHR {
12518    pub sType: VkStructureType,
12519    pub pNext: *mut c_void,
12520    pub maxQuantizationMapExtent: VkExtent2D,
12521}
12522
12523#[derive(Clone, Copy)]
12524#[repr(C)]
12525pub struct VkVideoEncodeQuantizationMapInfoKHR {
12526    pub sType: VkStructureType,
12527    pub pNext: *const c_void,
12528    pub quantizationMap: VkImageView,
12529    pub quantizationMapExtent: VkExtent2D,
12530}
12531
12532#[derive(Clone, Copy)]
12533#[repr(C)]
12534pub struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
12535    pub sType: VkStructureType,
12536    pub pNext: *const c_void,
12537    pub quantizationMapTexelSize: VkExtent2D,
12538}
12539
12540#[derive(Clone, Copy)]
12541#[repr(C)]
12542pub struct VkVideoEncodeRateControlInfoKHR {
12543    pub sType: VkStructureType,
12544    pub pNext: *const c_void,
12545    pub flags: VkVideoEncodeRateControlFlagsKHR,
12546    pub rateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
12547    pub layerCount: u32,
12548    pub pLayers: *const VkVideoEncodeRateControlLayerInfoKHR,
12549    pub virtualBufferSizeInMs: u32,
12550    pub initialVirtualBufferSizeInMs: u32,
12551}
12552
12553#[derive(Clone, Copy)]
12554#[repr(C)]
12555pub struct VkVideoEncodeRateControlLayerInfoKHR {
12556    pub sType: VkStructureType,
12557    pub pNext: *const c_void,
12558    pub averageBitrate: u64,
12559    pub maxBitrate: u64,
12560    pub frameRateNumerator: u32,
12561    pub frameRateDenominator: u32,
12562}
12563
12564#[derive(Clone, Copy)]
12565#[repr(C)]
12566pub struct VkVideoEncodeRgbConversionCapabilitiesVALVE {
12567    pub sType: VkStructureType,
12568    pub pNext: *mut c_void,
12569    pub rgbModels: VkVideoEncodeRgbModelConversionFlagsVALVE,
12570    pub rgbRanges: VkVideoEncodeRgbRangeCompressionFlagsVALVE,
12571    pub xChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
12572    pub yChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
12573}
12574
12575#[derive(Clone, Copy)]
12576#[repr(C)]
12577pub struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR {
12578    pub sType: VkStructureType,
12579    pub pNext: *const c_void,
12580    pub intraRefreshMode: VkVideoEncodeIntraRefreshModeFlagBitsKHR,
12581}
12582
12583#[derive(Clone, Copy)]
12584#[repr(C)]
12585pub struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
12586    pub sType: VkStructureType,
12587    pub pNext: *mut c_void,
12588    pub hasOverrides: VkBool32,
12589}
12590
12591#[derive(Clone, Copy)]
12592#[repr(C)]
12593pub struct VkVideoEncodeSessionParametersGetInfoKHR {
12594    pub sType: VkStructureType,
12595    pub pNext: *const c_void,
12596    pub videoSessionParameters: VkVideoSessionParametersKHR,
12597}
12598
12599#[derive(Clone, Copy)]
12600#[repr(C)]
12601pub struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE {
12602    pub sType: VkStructureType,
12603    pub pNext: *const c_void,
12604    pub rgbModel: VkVideoEncodeRgbModelConversionFlagBitsVALVE,
12605    pub rgbRange: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE,
12606    pub xChromaOffset: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE,
12607    pub yChromaOffset: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE,
12608}
12609
12610#[derive(Clone, Copy)]
12611#[repr(C)]
12612pub struct VkVideoEncodeUsageInfoKHR {
12613    pub sType: VkStructureType,
12614    pub pNext: *const c_void,
12615    pub videoUsageHints: VkVideoEncodeUsageFlagsKHR,
12616    pub videoContentHints: VkVideoEncodeContentFlagsKHR,
12617    pub tuningMode: VkVideoEncodeTuningModeKHR,
12618}
12619
12620#[derive(Clone, Copy)]
12621#[repr(C)]
12622pub struct VkVideoEndCodingInfoKHR {
12623    pub sType: VkStructureType,
12624    pub pNext: *const c_void,
12625    pub flags: VkVideoEndCodingFlagsKHR,
12626}
12627
12628#[derive(Clone, Copy)]
12629#[repr(C)]
12630pub struct VkVideoFormatAV1QuantizationMapPropertiesKHR {
12631    pub sType: VkStructureType,
12632    pub pNext: *mut c_void,
12633    pub compatibleSuperblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
12634}
12635
12636#[derive(Clone, Copy)]
12637#[repr(C)]
12638pub struct VkVideoFormatH265QuantizationMapPropertiesKHR {
12639    pub sType: VkStructureType,
12640    pub pNext: *mut c_void,
12641    pub compatibleCtbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
12642}
12643
12644#[derive(Clone, Copy)]
12645#[repr(C)]
12646pub struct VkVideoFormatPropertiesKHR {
12647    pub sType: VkStructureType,
12648    pub pNext: *mut c_void,
12649    pub format: VkFormat,
12650    pub componentMapping: VkComponentMapping,
12651    pub imageCreateFlags: VkImageCreateFlags,
12652    pub imageType: VkImageType,
12653    pub imageTiling: VkImageTiling,
12654    pub imageUsageFlags: VkImageUsageFlags,
12655}
12656
12657#[derive(Clone, Copy)]
12658#[repr(C)]
12659pub struct VkVideoFormatQuantizationMapPropertiesKHR {
12660    pub sType: VkStructureType,
12661    pub pNext: *mut c_void,
12662    pub quantizationMapTexelSize: VkExtent2D,
12663}
12664
12665#[derive(Clone, Copy)]
12666#[repr(C)]
12667pub struct VkVideoInlineQueryInfoKHR {
12668    pub sType: VkStructureType,
12669    pub pNext: *const c_void,
12670    pub queryPool: VkQueryPool,
12671    pub firstQuery: u32,
12672    pub queryCount: u32,
12673}
12674
12675#[derive(Clone, Copy)]
12676#[repr(C)]
12677pub struct VkVideoPictureResourceInfoKHR {
12678    pub sType: VkStructureType,
12679    pub pNext: *const c_void,
12680    pub codedOffset: VkOffset2D,
12681    pub codedExtent: VkExtent2D,
12682    pub baseArrayLayer: u32,
12683    pub imageViewBinding: VkImageView,
12684}
12685
12686#[derive(Clone, Copy)]
12687#[repr(C)]
12688pub struct VkVideoProfileInfoKHR {
12689    pub sType: VkStructureType,
12690    pub pNext: *const c_void,
12691    pub videoCodecOperation: VkVideoCodecOperationFlagBitsKHR,
12692    pub chromaSubsampling: VkVideoChromaSubsamplingFlagsKHR,
12693    pub lumaBitDepth: VkVideoComponentBitDepthFlagsKHR,
12694    pub chromaBitDepth: VkVideoComponentBitDepthFlagsKHR,
12695}
12696
12697#[derive(Clone, Copy)]
12698#[repr(C)]
12699pub struct VkVideoProfileListInfoKHR {
12700    pub sType: VkStructureType,
12701    pub pNext: *const c_void,
12702    pub profileCount: u32,
12703    pub pProfiles: *const VkVideoProfileInfoKHR,
12704}
12705
12706#[derive(Clone, Copy)]
12707#[repr(C)]
12708pub struct VkVideoReferenceIntraRefreshInfoKHR {
12709    pub sType: VkStructureType,
12710    pub pNext: *const c_void,
12711    pub dirtyIntraRefreshRegions: u32,
12712}
12713
12714#[derive(Clone, Copy)]
12715#[repr(C)]
12716pub struct VkVideoReferenceSlotInfoKHR {
12717    pub sType: VkStructureType,
12718    pub pNext: *const c_void,
12719    pub slotIndex: i32,
12720    pub pPictureResource: *const VkVideoPictureResourceInfoKHR,
12721}
12722
12723#[derive(Clone, Copy)]
12724#[repr(C)]
12725pub struct VkVideoSessionCreateInfoKHR {
12726    pub sType: VkStructureType,
12727    pub pNext: *const c_void,
12728    pub queueFamilyIndex: u32,
12729    pub flags: VkVideoSessionCreateFlagsKHR,
12730    pub pVideoProfile: *const VkVideoProfileInfoKHR,
12731    pub pictureFormat: VkFormat,
12732    pub maxCodedExtent: VkExtent2D,
12733    pub referencePictureFormat: VkFormat,
12734    pub maxDpbSlots: u32,
12735    pub maxActiveReferencePictures: u32,
12736    pub pStdHeaderVersion: *const VkExtensionProperties,
12737}
12738
12739#[repr(C)]
12740pub struct VkVideoSessionKHR_T {
12741    _data: (),
12742    _marker: PhantomData<(*mut u8, PhantomPinned)>,
12743}
12744
12745#[derive(Clone, Copy)]
12746#[repr(C)]
12747pub struct VkVideoSessionMemoryRequirementsKHR {
12748    pub sType: VkStructureType,
12749    pub pNext: *mut c_void,
12750    pub memoryBindIndex: u32,
12751    pub memoryRequirements: VkMemoryRequirements,
12752}
12753
12754#[derive(Clone, Copy)]
12755#[repr(C)]
12756pub struct VkVideoSessionParametersCreateInfoKHR {
12757    pub sType: VkStructureType,
12758    pub pNext: *const c_void,
12759    pub flags: VkVideoSessionParametersCreateFlagsKHR,
12760    pub videoSessionParametersTemplate: VkVideoSessionParametersKHR,
12761    pub videoSession: VkVideoSessionKHR,
12762}
12763
12764#[repr(C)]
12765pub struct VkVideoSessionParametersKHR_T {
12766    _data: (),
12767    _marker: PhantomData<(*mut u8, PhantomPinned)>,
12768}
12769
12770#[derive(Clone, Copy)]
12771#[repr(C)]
12772pub struct VkVideoSessionParametersUpdateInfoKHR {
12773    pub sType: VkStructureType,
12774    pub pNext: *const c_void,
12775    pub updateSequenceCount: u32,
12776}
12777
12778#[derive(Clone, Copy)]
12779#[repr(C)]
12780pub struct VkViewport {
12781    pub x: f32,
12782    pub y: f32,
12783    pub width: f32,
12784    pub height: f32,
12785    pub minDepth: f32,
12786    pub maxDepth: f32,
12787}
12788
12789#[derive(Clone, Copy)]
12790#[repr(C)]
12791pub struct VkViewportSwizzleNV {
12792    pub x: VkViewportCoordinateSwizzleNV,
12793    pub y: VkViewportCoordinateSwizzleNV,
12794    pub z: VkViewportCoordinateSwizzleNV,
12795    pub w: VkViewportCoordinateSwizzleNV,
12796}
12797
12798#[derive(Clone, Copy)]
12799#[repr(C)]
12800pub struct VkViewportWScalingNV {
12801    pub xcoeff: f32,
12802    pub ycoeff: f32,
12803}
12804
12805#[derive(Clone, Copy)]
12806#[repr(C)]
12807pub struct VkWriteDescriptorSet {
12808    pub sType: VkStructureType,
12809    pub pNext: *const c_void,
12810    pub dstSet: VkDescriptorSet,
12811    pub dstBinding: u32,
12812    pub dstArrayElement: u32,
12813    pub descriptorCount: u32,
12814    pub descriptorType: VkDescriptorType,
12815    pub pImageInfo: *const VkDescriptorImageInfo,
12816    pub pBufferInfo: *const VkDescriptorBufferInfo,
12817    pub pTexelBufferView: *const VkBufferView,
12818}
12819
12820#[derive(Clone, Copy)]
12821#[repr(C)]
12822pub struct VkWriteDescriptorSetAccelerationStructureKHR {
12823    pub sType: VkStructureType,
12824    pub pNext: *const c_void,
12825    pub accelerationStructureCount: u32,
12826    pub pAccelerationStructures: *const VkAccelerationStructureKHR,
12827}
12828
12829#[derive(Clone, Copy)]
12830#[repr(C)]
12831pub struct VkWriteDescriptorSetAccelerationStructureNV {
12832    pub sType: VkStructureType,
12833    pub pNext: *const c_void,
12834    pub accelerationStructureCount: u32,
12835    pub pAccelerationStructures: *const VkAccelerationStructureNV,
12836}
12837
12838#[derive(Clone, Copy)]
12839#[repr(C)]
12840pub struct VkWriteDescriptorSetInlineUniformBlock {
12841    pub sType: VkStructureType,
12842    pub pNext: *const c_void,
12843    pub dataSize: u32,
12844    pub pData: *const c_void,
12845}
12846
12847#[derive(Clone, Copy)]
12848#[repr(C)]
12849pub struct VkWriteDescriptorSetPartitionedAccelerationStructureNV {
12850    pub sType: VkStructureType,
12851    pub pNext: *mut c_void,
12852    pub accelerationStructureCount: u32,
12853    pub pAccelerationStructures: *const VkDeviceAddress,
12854}
12855
12856#[derive(Clone, Copy)]
12857#[repr(C)]
12858pub struct VkWriteDescriptorSetTensorARM {
12859    pub sType: VkStructureType,
12860    pub pNext: *const c_void,
12861    pub tensorViewCount: u32,
12862    pub pTensorViews: *const VkTensorViewARM,
12863}
12864
12865#[derive(Clone, Copy)]
12866#[repr(C)]
12867pub struct VkWriteIndirectExecutionSetPipelineEXT {
12868    pub sType: VkStructureType,
12869    pub pNext: *const c_void,
12870    pub index: u32,
12871    pub pipeline: VkPipeline,
12872}
12873
12874#[derive(Clone, Copy)]
12875#[repr(C)]
12876pub struct VkWriteIndirectExecutionSetShaderEXT {
12877    pub sType: VkStructureType,
12878    pub pNext: *const c_void,
12879    pub index: u32,
12880    pub shader: VkShaderEXT,
12881}
12882
12883#[derive(Clone, Copy)]
12884#[repr(C)]
12885pub struct VkXYColorEXT {
12886    pub x: f32,
12887    pub y: f32,
12888}
12889
12890pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = 1;
12891pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR: VkAccelerationStructureBuildTypeKHR = 0;
12892pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = 2;
12893pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = 0;
12894pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = 1;
12895pub const VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkAccelerationStructureCreateFlagBitsKHR = 1 << 3;
12896pub const VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkAccelerationStructureCreateFlagBitsKHR = 1 << 0;
12897pub const VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV: VkAccelerationStructureCreateFlagBitsKHR = 1 << 2;
12898pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 1;
12899pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 0;
12900pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 2;
12901pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = 1;
12902pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = 2;
12903pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV: VkAccelerationStructureMotionInstanceTypeNV = 0;
12904pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR: VkAccelerationStructureTypeKHR = 1;
12905pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;
12906pub const VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR: VkAccelerationStructureTypeKHR = 2;
12907pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR: VkAccelerationStructureTypeKHR = 0;
12908pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR;
12909pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 21;
12910pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR;
12911pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 22;
12912pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
12913pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 7;
12914pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT;
12915pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlagBits2 = 1 << 19;
12916pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2 = 1 << 8;
12917pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
12918pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 17;
12919pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT;
12920pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 18;
12921pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT;
12922pub const VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 20;
12923pub const VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM: VkAccessFlagBits2 = 1 << 47;
12924pub const VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM: VkAccessFlagBits2 = 1 << 48;
12925pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 9;
12926pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
12927pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2 = 1 << 10;
12928pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
12929pub const VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 41;
12930pub const VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 24;
12931pub const VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 23;
12932pub const VK_ACCESS_2_HOST_READ_BIT: VkAccessFlagBits2 = 1 << 13;
12933pub const VK_ACCESS_2_HOST_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_HOST_READ_BIT;
12934pub const VK_ACCESS_2_HOST_WRITE_BIT: VkAccessFlagBits2 = 1 << 14;
12935pub const VK_ACCESS_2_HOST_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_HOST_WRITE_BIT;
12936pub const VK_ACCESS_2_INDEX_READ_BIT: VkAccessFlagBits2 = 1 << 1;
12937pub const VK_ACCESS_2_INDEX_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INDEX_READ_BIT;
12938pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits2 = 1 << 0;
12939pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
12940pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 4;
12941pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT;
12942pub const VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI: VkAccessFlagBits2 = 1 << 39;
12943pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 55;
12944pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 56;
12945pub const VK_ACCESS_2_MEMORY_READ_BIT: VkAccessFlagBits2 = 1 << 15;
12946pub const VK_ACCESS_2_MEMORY_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_MEMORY_READ_BIT;
12947pub const VK_ACCESS_2_MEMORY_WRITE_BIT: VkAccessFlagBits2 = 1 << 16;
12948pub const VK_ACCESS_2_MEMORY_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_MEMORY_WRITE_BIT;
12949pub const VK_ACCESS_2_MICROMAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 44;
12950pub const VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 45;
12951pub const VK_ACCESS_2_NONE: VkAccessFlagBits2 = 0;
12952pub const VK_ACCESS_2_NONE_KHR: VkAccessFlagBits2 = VK_ACCESS_2_NONE;
12953pub const VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV: VkAccessFlagBits2 = 1 << 42;
12954pub const VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV: VkAccessFlagBits2 = 1 << 43;
12955pub const VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 58;
12956pub const VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 57;
12957pub const VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 40;
12958pub const VK_ACCESS_2_SHADER_READ_BIT: VkAccessFlagBits2 = 1 << 5;
12959pub const VK_ACCESS_2_SHADER_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_READ_BIT;
12960pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT: VkAccessFlagBits2 = 1 << 32;
12961pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
12962pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT: VkAccessFlagBits2 = 1 << 33;
12963pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
12964pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT: VkAccessFlagBits2 = 1 << 34;
12965pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
12966pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM: VkAccessFlagBits2 = 1 << 51;
12967pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM: VkAccessFlagBits2 = 1 << 52;
12968pub const VK_ACCESS_2_SHADER_WRITE_BIT: VkAccessFlagBits2 = 1 << 6;
12969pub const VK_ACCESS_2_SHADER_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_WRITE_BIT;
12970pub const VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
12971pub const VK_ACCESS_2_TRANSFER_READ_BIT: VkAccessFlagBits2 = 1 << 11;
12972pub const VK_ACCESS_2_TRANSFER_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_TRANSFER_READ_BIT;
12973pub const VK_ACCESS_2_TRANSFER_WRITE_BIT: VkAccessFlagBits2 = 1 << 12;
12974pub const VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_TRANSFER_WRITE_BIT;
12975pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 26;
12976pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 27;
12977pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 25;
12978pub const VK_ACCESS_2_UNIFORM_READ_BIT: VkAccessFlagBits2 = 1 << 3;
12979pub const VK_ACCESS_2_UNIFORM_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_UNIFORM_READ_BIT;
12980pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits2 = 1 << 2;
12981pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT;
12982pub const VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 35;
12983pub const VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 36;
12984pub const VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 37;
12985pub const VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 38;
12986pub const VK_ACCESS_3_NONE_KHR: VkAccessFlagBits3KHR = 0;
12987pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlagBits = 1 << 21;
12988pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
12989pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlagBits = 1 << 22;
12990pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlagBits = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
12991pub const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 7;
12992pub const VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlagBits = 1 << 19;
12993pub const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 1 << 8;
12994pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlagBits = 1 << 17;
12995pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT;
12996pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 18;
12997pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlagBits = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT;
12998pub const VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlagBits = 1 << 20;
12999pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 9;
13000pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 1 << 10;
13001pub const VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlagBits = 1 << 24;
13002pub const VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits = 1 << 23;
13003pub const VK_ACCESS_HOST_READ_BIT: VkAccessFlagBits = 1 << 13;
13004pub const VK_ACCESS_HOST_WRITE_BIT: VkAccessFlagBits = 1 << 14;
13005pub const VK_ACCESS_INDEX_READ_BIT: VkAccessFlagBits = 1 << 1;
13006pub const VK_ACCESS_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits = 1 << 0;
13007pub const VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 4;
13008pub const VK_ACCESS_MEMORY_READ_BIT: VkAccessFlagBits = 1 << 15;
13009pub const VK_ACCESS_MEMORY_WRITE_BIT: VkAccessFlagBits = 1 << 16;
13010pub const VK_ACCESS_NONE: VkAccessFlagBits = 0;
13011pub const VK_ACCESS_NONE_KHR: VkAccessFlagBits = VK_ACCESS_NONE;
13012pub const VK_ACCESS_SHADER_READ_BIT: VkAccessFlagBits = 1 << 5;
13013pub const VK_ACCESS_SHADER_WRITE_BIT: VkAccessFlagBits = 1 << 6;
13014pub const VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
13015pub const VK_ACCESS_TRANSFER_READ_BIT: VkAccessFlagBits = 1 << 11;
13016pub const VK_ACCESS_TRANSFER_WRITE_BIT: VkAccessFlagBits = 1 << 12;
13017pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlagBits = 1 << 26;
13018pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 27;
13019pub const VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 25;
13020pub const VK_ACCESS_UNIFORM_READ_BIT: VkAccessFlagBits = 1 << 3;
13021pub const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits = 1 << 2;
13022pub const VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 0;
13023pub const VK_ADDRESS_COPY_PROTECTED_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 2;
13024pub const VK_ADDRESS_COPY_SPARSE_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 1;
13025pub const VK_AMD_ANTI_LAG_EXTENSION_NAME: &CStr = c"VK_AMD_anti_lag";
13026pub const VK_AMD_ANTI_LAG_SPEC_VERSION: u32 = 1;
13027pub const VK_AMD_BUFFER_MARKER_EXTENSION_NAME: &CStr = c"VK_AMD_buffer_marker";
13028pub const VK_AMD_BUFFER_MARKER_SPEC_VERSION: u32 = 1;
13029pub const VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME: &CStr = c"VK_AMD_device_coherent_memory";
13030pub const VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION: u32 = 1;
13031pub const VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME: &CStr = c"VK_AMD_display_native_hdr";
13032pub const VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION: u32 = 1;
13033pub const VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME: &CStr = c"VK_AMD_draw_indirect_count";
13034pub const VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION: u32 = 2;
13035pub const VK_AMD_GCN_SHADER_EXTENSION_NAME: &CStr = c"VK_AMD_gcn_shader";
13036pub const VK_AMD_GCN_SHADER_SPEC_VERSION: u32 = 1;
13037pub const VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME: &CStr = c"VK_AMD_gpu_shader_half_float";
13038pub const VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION: u32 = 2;
13039pub const VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME: &CStr = c"VK_AMD_gpu_shader_int16";
13040pub const VK_AMD_GPU_SHADER_INT16_SPEC_VERSION: u32 = 2;
13041pub const VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME: &CStr = c"VK_AMD_memory_overallocation_behavior";
13042pub const VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION: u32 = 1;
13043pub const VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME: &CStr = c"VK_AMD_mixed_attachment_samples";
13044pub const VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION: u32 = 1;
13045pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME: &CStr = c"VK_AMD_negative_viewport_height";
13046pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION: u32 = 1;
13047pub const VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME: &CStr = c"VK_AMD_pipeline_compiler_control";
13048pub const VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION: u32 = 1;
13049pub const VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME: &CStr = c"VK_AMD_rasterization_order";
13050pub const VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION: u32 = 1;
13051pub const VK_AMD_SHADER_BALLOT_EXTENSION_NAME: &CStr = c"VK_AMD_shader_ballot";
13052pub const VK_AMD_SHADER_BALLOT_SPEC_VERSION: u32 = 1;
13053pub const VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_AMD_shader_core_properties2";
13054pub const VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION: u32 = 1;
13055pub const VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_AMD_shader_core_properties";
13056pub const VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION: u32 = 2;
13057pub const VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME: &CStr = c"VK_AMD_shader_early_and_late_fragment_tests";
13058pub const VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION: u32 = 1;
13059pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME: &CStr = c"VK_AMD_shader_explicit_vertex_parameter";
13060pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION: u32 = 1;
13061pub const VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME: &CStr = c"VK_AMD_shader_fragment_mask";
13062pub const VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION: u32 = 1;
13063pub const VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME: &CStr = c"VK_AMD_shader_image_load_store_lod";
13064pub const VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION: u32 = 1;
13065pub const VK_AMD_SHADER_INFO_EXTENSION_NAME: &CStr = c"VK_AMD_shader_info";
13066pub const VK_AMD_SHADER_INFO_SPEC_VERSION: u32 = 1;
13067pub const VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME: &CStr = c"VK_AMD_shader_trinary_minmax";
13068pub const VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION: u32 = 1;
13069pub const VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME: &CStr = c"VK_AMD_texture_gather_bias_lod";
13070pub const VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION: u32 = 1;
13071pub const VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD: VkAntiLagModeAMD = 0;
13072pub const VK_ANTI_LAG_MODE_OFF_AMD: VkAntiLagModeAMD = 2;
13073pub const VK_ANTI_LAG_MODE_ON_AMD: VkAntiLagModeAMD = 1;
13074pub const VK_ANTI_LAG_STAGE_INPUT_AMD: VkAntiLagStageAMD = 0;
13075pub const VK_ANTI_LAG_STAGE_PRESENT_AMD: VkAntiLagStageAMD = 1;
13076pub const VK_API_VERSION_1_0: u32 = VK_MAKE_API_VERSION(0, 1, 0, 0);
13077pub const VK_API_VERSION_1_1: u32 = VK_MAKE_API_VERSION(0, 1, 1, 0);
13078pub const VK_API_VERSION_1_2: u32 = VK_MAKE_API_VERSION(0, 1, 2, 0);
13079pub const VK_API_VERSION_1_3: u32 = VK_MAKE_API_VERSION(0, 1, 3, 0);
13080pub const VK_API_VERSION_1_4: u32 = VK_MAKE_API_VERSION(0, 1, 4, 0);
13081pub const VK_ARM_DATA_GRAPH_EXTENSION_NAME: &CStr = c"VK_ARM_data_graph";
13082pub const VK_ARM_DATA_GRAPH_SPEC_VERSION: u32 = 1;
13083pub const VK_ARM_FORMAT_PACK_EXTENSION_NAME: &CStr = c"VK_ARM_format_pack";
13084pub const VK_ARM_FORMAT_PACK_SPEC_VERSION: u32 = 1;
13085pub const VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME: &CStr = c"VK_ARM_performance_counters_by_region";
13086pub const VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION: u32 = 1;
13087pub const VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME: &CStr = c"VK_ARM_pipeline_opacity_micromap";
13088pub const VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION: u32 = 1;
13089pub const VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME: &CStr = c"VK_ARM_rasterization_order_attachment_access";
13090pub const VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION: u32 = 1;
13091pub const VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME: &CStr = c"VK_ARM_render_pass_striped";
13092pub const VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION: u32 = 1;
13093pub const VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME: &CStr = c"VK_ARM_scheduling_controls";
13094pub const VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION: u32 = 1;
13095pub const VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME: &CStr = c"VK_ARM_shader_core_builtins";
13096pub const VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION: u32 = 2;
13097pub const VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_ARM_shader_core_properties";
13098pub const VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION: u32 = 1;
13099pub const VK_ARM_TENSORS_EXTENSION_NAME: &CStr = c"VK_ARM_tensors";
13100pub const VK_ARM_TENSORS_SPEC_VERSION: u32 = 1;
13101pub const VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: VkAttachmentDescriptionFlagBits = 1 << 0;
13102pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlagBits = 1 << 2;
13103pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlagBits = 1 << 1;
13104pub const VK_ATTACHMENT_LOAD_OP_CLEAR: VkAttachmentLoadOp = 1;
13105pub const VK_ATTACHMENT_LOAD_OP_DONT_CARE: VkAttachmentLoadOp = 2;
13106pub const VK_ATTACHMENT_LOAD_OP_LOAD: VkAttachmentLoadOp = 0;
13107pub const VK_ATTACHMENT_LOAD_OP_NONE: VkAttachmentLoadOp = 1000400000;
13108pub const VK_ATTACHMENT_LOAD_OP_NONE_EXT: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;
13109pub const VK_ATTACHMENT_LOAD_OP_NONE_KHR: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;
13110pub const VK_ATTACHMENT_STORE_OP_DONT_CARE: VkAttachmentStoreOp = 1;
13111pub const VK_ATTACHMENT_STORE_OP_NONE: VkAttachmentStoreOp = 1000301000;
13112pub const VK_ATTACHMENT_STORE_OP_NONE_EXT: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
13113pub const VK_ATTACHMENT_STORE_OP_NONE_KHR: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
13114pub const VK_ATTACHMENT_STORE_OP_NONE_QCOM: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
13115pub const VK_ATTACHMENT_STORE_OP_STORE: VkAttachmentStoreOp = 0;
13116pub const VK_ATTACHMENT_UNUSED: u32 = !0;
13117pub const VK_BLEND_FACTOR_CONSTANT_ALPHA: VkBlendFactor = 12;
13118pub const VK_BLEND_FACTOR_CONSTANT_COLOR: VkBlendFactor = 10;
13119pub const VK_BLEND_FACTOR_DST_ALPHA: VkBlendFactor = 8;
13120pub const VK_BLEND_FACTOR_DST_COLOR: VkBlendFactor = 4;
13121pub const VK_BLEND_FACTOR_ONE: VkBlendFactor = 1;
13122pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: VkBlendFactor = 13;
13123pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: VkBlendFactor = 11;
13124pub const VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: VkBlendFactor = 9;
13125pub const VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR: VkBlendFactor = 5;
13126pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: VkBlendFactor = 18;
13127pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: VkBlendFactor = 16;
13128pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: VkBlendFactor = 7;
13129pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: VkBlendFactor = 3;
13130pub const VK_BLEND_FACTOR_SRC1_ALPHA: VkBlendFactor = 17;
13131pub const VK_BLEND_FACTOR_SRC1_COLOR: VkBlendFactor = 15;
13132pub const VK_BLEND_FACTOR_SRC_ALPHA: VkBlendFactor = 6;
13133pub const VK_BLEND_FACTOR_SRC_ALPHA_SATURATE: VkBlendFactor = 14;
13134pub const VK_BLEND_FACTOR_SRC_COLOR: VkBlendFactor = 2;
13135pub const VK_BLEND_FACTOR_ZERO: VkBlendFactor = 0;
13136pub const VK_BLEND_OP_ADD: VkBlendOp = 0;
13137pub const VK_BLEND_OP_BLUE_EXT: VkBlendOp = 1000148045;
13138pub const VK_BLEND_OP_COLORBURN_EXT: VkBlendOp = 1000148018;
13139pub const VK_BLEND_OP_COLORDODGE_EXT: VkBlendOp = 1000148017;
13140pub const VK_BLEND_OP_CONTRAST_EXT: VkBlendOp = 1000148041;
13141pub const VK_BLEND_OP_DARKEN_EXT: VkBlendOp = 1000148015;
13142pub const VK_BLEND_OP_DIFFERENCE_EXT: VkBlendOp = 1000148021;
13143pub const VK_BLEND_OP_DST_ATOP_EXT: VkBlendOp = 1000148010;
13144pub const VK_BLEND_OP_DST_EXT: VkBlendOp = 1000148002;
13145pub const VK_BLEND_OP_DST_IN_EXT: VkBlendOp = 1000148006;
13146pub const VK_BLEND_OP_DST_OUT_EXT: VkBlendOp = 1000148008;
13147pub const VK_BLEND_OP_DST_OVER_EXT: VkBlendOp = 1000148004;
13148pub const VK_BLEND_OP_EXCLUSION_EXT: VkBlendOp = 1000148022;
13149pub const VK_BLEND_OP_GREEN_EXT: VkBlendOp = 1000148044;
13150pub const VK_BLEND_OP_HARDLIGHT_EXT: VkBlendOp = 1000148019;
13151pub const VK_BLEND_OP_HARDMIX_EXT: VkBlendOp = 1000148030;
13152pub const VK_BLEND_OP_HSL_COLOR_EXT: VkBlendOp = 1000148033;
13153pub const VK_BLEND_OP_HSL_HUE_EXT: VkBlendOp = 1000148031;
13154pub const VK_BLEND_OP_HSL_LUMINOSITY_EXT: VkBlendOp = 1000148034;
13155pub const VK_BLEND_OP_HSL_SATURATION_EXT: VkBlendOp = 1000148032;
13156pub const VK_BLEND_OP_INVERT_EXT: VkBlendOp = 1000148023;
13157pub const VK_BLEND_OP_INVERT_OVG_EXT: VkBlendOp = 1000148042;
13158pub const VK_BLEND_OP_INVERT_RGB_EXT: VkBlendOp = 1000148024;
13159pub const VK_BLEND_OP_LIGHTEN_EXT: VkBlendOp = 1000148016;
13160pub const VK_BLEND_OP_LINEARBURN_EXT: VkBlendOp = 1000148026;
13161pub const VK_BLEND_OP_LINEARDODGE_EXT: VkBlendOp = 1000148025;
13162pub const VK_BLEND_OP_LINEARLIGHT_EXT: VkBlendOp = 1000148028;
13163pub const VK_BLEND_OP_MAX: VkBlendOp = 4;
13164pub const VK_BLEND_OP_MIN: VkBlendOp = 3;
13165pub const VK_BLEND_OP_MINUS_CLAMPED_EXT: VkBlendOp = 1000148040;
13166pub const VK_BLEND_OP_MINUS_EXT: VkBlendOp = 1000148039;
13167pub const VK_BLEND_OP_MULTIPLY_EXT: VkBlendOp = 1000148012;
13168pub const VK_BLEND_OP_OVERLAY_EXT: VkBlendOp = 1000148014;
13169pub const VK_BLEND_OP_PINLIGHT_EXT: VkBlendOp = 1000148029;
13170pub const VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT: VkBlendOp = 1000148037;
13171pub const VK_BLEND_OP_PLUS_CLAMPED_EXT: VkBlendOp = 1000148036;
13172pub const VK_BLEND_OP_PLUS_DARKER_EXT: VkBlendOp = 1000148038;
13173pub const VK_BLEND_OP_PLUS_EXT: VkBlendOp = 1000148035;
13174pub const VK_BLEND_OP_RED_EXT: VkBlendOp = 1000148043;
13175pub const VK_BLEND_OP_REVERSE_SUBTRACT: VkBlendOp = 2;
13176pub const VK_BLEND_OP_SCREEN_EXT: VkBlendOp = 1000148013;
13177pub const VK_BLEND_OP_SOFTLIGHT_EXT: VkBlendOp = 1000148020;
13178pub const VK_BLEND_OP_SRC_ATOP_EXT: VkBlendOp = 1000148009;
13179pub const VK_BLEND_OP_SRC_EXT: VkBlendOp = 1000148001;
13180pub const VK_BLEND_OP_SRC_IN_EXT: VkBlendOp = 1000148005;
13181pub const VK_BLEND_OP_SRC_OUT_EXT: VkBlendOp = 1000148007;
13182pub const VK_BLEND_OP_SRC_OVER_EXT: VkBlendOp = 1000148003;
13183pub const VK_BLEND_OP_SUBTRACT: VkBlendOp = 1;
13184pub const VK_BLEND_OP_VIVIDLIGHT_EXT: VkBlendOp = 1000148027;
13185pub const VK_BLEND_OP_XOR_EXT: VkBlendOp = 1000148011;
13186pub const VK_BLEND_OP_ZERO_EXT: VkBlendOp = 1000148000;
13187pub const VK_BLEND_OVERLAP_CONJOINT_EXT: VkBlendOverlapEXT = 2;
13188pub const VK_BLEND_OVERLAP_DISJOINT_EXT: VkBlendOverlapEXT = 1;
13189pub const VK_BLEND_OVERLAP_UNCORRELATED_EXT: VkBlendOverlapEXT = 0;
13190pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM: VkBlockMatchWindowCompareModeQCOM = 1;
13191pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM: VkBlockMatchWindowCompareModeQCOM = 0;
13192pub const VK_BORDER_COLOR_FLOAT_CUSTOM_EXT: VkBorderColor = 1000287003;
13193pub const VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: VkBorderColor = 2;
13194pub const VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: VkBorderColor = 4;
13195pub const VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: VkBorderColor = 0;
13196pub const VK_BORDER_COLOR_INT_CUSTOM_EXT: VkBorderColor = 1000287004;
13197pub const VK_BORDER_COLOR_INT_OPAQUE_BLACK: VkBorderColor = 3;
13198pub const VK_BORDER_COLOR_INT_OPAQUE_WHITE: VkBorderColor = 5;
13199pub const VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: VkBorderColor = 1;
13200pub const VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlagBits = 1 << 5;
13201pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkBufferCreateFlagBits = 1 << 4;
13202pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlagBits = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
13203pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkBufferCreateFlagBits = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
13204pub const VK_BUFFER_CREATE_PROTECTED_BIT: VkBufferCreateFlagBits = 1 << 3;
13205pub const VK_BUFFER_CREATE_SPARSE_ALIASED_BIT: VkBufferCreateFlagBits = 1 << 2;
13206pub const VK_BUFFER_CREATE_SPARSE_BINDING_BIT: VkBufferCreateFlagBits = 1 << 0;
13207pub const VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT: VkBufferCreateFlagBits = 1 << 1;
13208pub const VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkBufferCreateFlagBits = 1 << 6;
13209pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 19;
13210pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 20;
13211pub const VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 9;
13212pub const VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM: VkBufferUsageFlagBits2 = 1 << 29;
13213pub const VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 28;
13214pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 6;
13215pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT;
13216pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 8;
13217pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT;
13218pub const VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 32;
13219pub const VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 23;
13220pub const VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 24;
13221pub const VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 31;
13222pub const VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 26;
13223pub const VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR;
13224pub const VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 22;
13225pub const VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 21;
13226pub const VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 10;
13227pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlagBits2 = 1 << 17;
13228pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT;
13229pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 5;
13230pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT;
13231pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 3;
13232pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT;
13233pub const VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlagBits2 = 1 << 27;
13234pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT: VkBufferUsageFlagBits2 = 1 << 1;
13235pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_TRANSFER_DST_BIT;
13236pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT: VkBufferUsageFlagBits2 = 1 << 0;
13237pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT;
13238pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 11;
13239pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 12;
13240pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 4;
13241pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT;
13242pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 2;
13243pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT;
13244pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 7;
13245pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT;
13246pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 14;
13247pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 13;
13248pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 15;
13249pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 16;
13250pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlagBits = 1 << 19;
13251pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlagBits = 1 << 20;
13252pub const VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlagBits = 1 << 9;
13253pub const VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT: VkBufferUsageFlagBits = 1 << 28;
13254pub const VK_BUFFER_USAGE_INDEX_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 6;
13255pub const VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 8;
13256pub const VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlagBits = 1 << 23;
13257pub const VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlagBits = 1 << 24;
13258pub const VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 26;
13259pub const VK_BUFFER_USAGE_RAY_TRACING_BIT_NV: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR;
13260pub const VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 22;
13261pub const VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 21;
13262pub const VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlagBits = 1 << 10;
13263pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlagBits = 1 << 17;
13264pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
13265pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
13266pub const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 5;
13267pub const VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 3;
13268pub const VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlagBits = 1 << 27;
13269pub const VK_BUFFER_USAGE_TRANSFER_DST_BIT: VkBufferUsageFlagBits = 1 << 1;
13270pub const VK_BUFFER_USAGE_TRANSFER_SRC_BIT: VkBufferUsageFlagBits = 1 << 0;
13271pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 11;
13272pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 12;
13273pub const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 4;
13274pub const VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 2;
13275pub const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 7;
13276pub const VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlagBits = 1 << 14;
13277pub const VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlagBits = 1 << 13;
13278pub const VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlagBits = 1 << 15;
13279pub const VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlagBits = 1 << 16;
13280pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = 1 << 12;
13281pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 1;
13282pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR;
13283pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 11;
13284pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR;
13285pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 7;
13286pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT;
13287pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 8;
13288pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT;
13289pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 6;
13290pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT;
13291pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 0;
13292pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR;
13293pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 4;
13294pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR;
13295pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR: VkBuildAccelerationStructureModeKHR = 0;
13296pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR: VkBuildAccelerationStructureModeKHR = 1;
13297pub const VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = 1 << 5;
13298pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 3;
13299pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR;
13300pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 2;
13301pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR;
13302pub const VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 2;
13303pub const VK_BUILD_MICROMAP_MODE_BUILD_EXT: VkBuildMicromapModeEXT = 0;
13304pub const VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 1;
13305pub const VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 0;
13306pub const VK_CHROMA_LOCATION_COSITED_EVEN: VkChromaLocation = 0;
13307pub const VK_CHROMA_LOCATION_COSITED_EVEN_KHR: VkChromaLocation = VK_CHROMA_LOCATION_COSITED_EVEN;
13308pub const VK_CHROMA_LOCATION_MIDPOINT: VkChromaLocation = 1;
13309pub const VK_CHROMA_LOCATION_MIDPOINT_KHR: VkChromaLocation = VK_CHROMA_LOCATION_MIDPOINT;
13310pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 2;
13311pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 0;
13312pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 3;
13313pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 1;
13314pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 4;
13315pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 5;
13316pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 0;
13317pub const VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV: VkClusterAccelerationStructureClusterFlagBitsNV = 1 << 0;
13318pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 0;
13319pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 1;
13320pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 2;
13321pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 1;
13322pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 2;
13323pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 0;
13324pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV: VkClusterAccelerationStructureOpModeNV = 2;
13325pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = 1;
13326pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = 0;
13327pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureOpTypeNV = 1;
13328pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = 2;
13329pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureOpTypeNV = 3;
13330pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV: VkClusterAccelerationStructureOpTypeNV = 5;
13331pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = 4;
13332pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV: VkClusterAccelerationStructureOpTypeNV = 0;
13333pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureTypeNV = 0;
13334pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureTypeNV = 1;
13335pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureTypeNV = 2;
13336pub const VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV: VkCoarseSampleOrderTypeNV = 1;
13337pub const VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV: VkCoarseSampleOrderTypeNV = 0;
13338pub const VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV: VkCoarseSampleOrderTypeNV = 2;
13339pub const VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV: VkCoarseSampleOrderTypeNV = 3;
13340pub const VK_COLORSPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
13341pub const VK_COLOR_COMPONENT_A_BIT: VkColorComponentFlagBits = 1 << 3;
13342pub const VK_COLOR_COMPONENT_B_BIT: VkColorComponentFlagBits = 1 << 2;
13343pub const VK_COLOR_COMPONENT_G_BIT: VkColorComponentFlagBits = 1 << 1;
13344pub const VK_COLOR_COMPONENT_R_BIT: VkColorComponentFlagBits = 1 << 0;
13345pub const VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT: VkColorSpaceKHR = 1000104011;
13346pub const VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT: VkColorSpaceKHR = 1000104012;
13347pub const VK_COLOR_SPACE_BT2020_LINEAR_EXT: VkColorSpaceKHR = 1000104007;
13348pub const VK_COLOR_SPACE_BT709_LINEAR_EXT: VkColorSpaceKHR = 1000104005;
13349pub const VK_COLOR_SPACE_BT709_NONLINEAR_EXT: VkColorSpaceKHR = 1000104006;
13350pub const VK_COLOR_SPACE_DCI_P3_LINEAR_EXT: VkColorSpaceKHR = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT;
13351pub const VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT: VkColorSpaceKHR = 1000104004;
13352pub const VK_COLOR_SPACE_DISPLAY_NATIVE_AMD: VkColorSpaceKHR = 1000213000;
13353pub const VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT: VkColorSpaceKHR = 1000104003;
13354pub const VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT: VkColorSpaceKHR = 1000104001;
13355pub const VK_COLOR_SPACE_DOLBYVISION_EXT: VkColorSpaceKHR = 1000104009;
13356pub const VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT: VkColorSpaceKHR = 1000104002;
13357pub const VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT: VkColorSpaceKHR = 1000104014;
13358pub const VK_COLOR_SPACE_HDR10_HLG_EXT: VkColorSpaceKHR = 1000104010;
13359pub const VK_COLOR_SPACE_HDR10_ST2084_EXT: VkColorSpaceKHR = 1000104008;
13360pub const VK_COLOR_SPACE_PASS_THROUGH_EXT: VkColorSpaceKHR = 1000104013;
13361pub const VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = 0;
13362pub const VK_COMMAND_BUFFER_LEVEL_PRIMARY: VkCommandBufferLevel = 0;
13363pub const VK_COMMAND_BUFFER_LEVEL_SECONDARY: VkCommandBufferLevel = 1;
13364pub const VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: VkCommandBufferResetFlagBits = 1 << 0;
13365pub const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: VkCommandBufferUsageFlagBits = 1 << 0;
13366pub const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: VkCommandBufferUsageFlagBits = 1 << 1;
13367pub const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: VkCommandBufferUsageFlagBits = 1 << 2;
13368pub const VK_COMMAND_POOL_CREATE_PROTECTED_BIT: VkCommandPoolCreateFlagBits = 1 << 2;
13369pub const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: VkCommandPoolCreateFlagBits = 1 << 1;
13370pub const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT: VkCommandPoolCreateFlagBits = 1 << 0;
13371pub const VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: VkCommandPoolResetFlagBits = 1 << 0;
13372pub const VK_COMPARE_OP_ALWAYS: VkCompareOp = 7;
13373pub const VK_COMPARE_OP_EQUAL: VkCompareOp = 2;
13374pub const VK_COMPARE_OP_GREATER: VkCompareOp = 4;
13375pub const VK_COMPARE_OP_GREATER_OR_EQUAL: VkCompareOp = 6;
13376pub const VK_COMPARE_OP_LESS: VkCompareOp = 1;
13377pub const VK_COMPARE_OP_LESS_OR_EQUAL: VkCompareOp = 3;
13378pub const VK_COMPARE_OP_NEVER: VkCompareOp = 0;
13379pub const VK_COMPARE_OP_NOT_EQUAL: VkCompareOp = 5;
13380pub const VK_COMPONENT_SWIZZLE_A: VkComponentSwizzle = 6;
13381pub const VK_COMPONENT_SWIZZLE_B: VkComponentSwizzle = 5;
13382pub const VK_COMPONENT_SWIZZLE_G: VkComponentSwizzle = 4;
13383pub const VK_COMPONENT_SWIZZLE_IDENTITY: VkComponentSwizzle = 0;
13384pub const VK_COMPONENT_SWIZZLE_ONE: VkComponentSwizzle = 2;
13385pub const VK_COMPONENT_SWIZZLE_R: VkComponentSwizzle = 3;
13386pub const VK_COMPONENT_SWIZZLE_ZERO: VkComponentSwizzle = 1;
13387pub const VK_COMPONENT_TYPE_BFLOAT16_KHR: VkComponentTypeKHR = 1000141000;
13388pub const VK_COMPONENT_TYPE_FLOAT16_KHR: VkComponentTypeKHR = 0;
13389pub const VK_COMPONENT_TYPE_FLOAT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT16_KHR;
13390pub const VK_COMPONENT_TYPE_FLOAT32_KHR: VkComponentTypeKHR = 1;
13391pub const VK_COMPONENT_TYPE_FLOAT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT32_KHR;
13392pub const VK_COMPONENT_TYPE_FLOAT64_KHR: VkComponentTypeKHR = 2;
13393pub const VK_COMPONENT_TYPE_FLOAT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT64_KHR;
13394pub const VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT: VkComponentTypeKHR = 1000491002;
13395pub const VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT: VkComponentTypeKHR = 1000491003;
13396pub const VK_COMPONENT_TYPE_FLOAT_E4M3_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT;
13397pub const VK_COMPONENT_TYPE_FLOAT_E5M2_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT;
13398pub const VK_COMPONENT_TYPE_SINT16_KHR: VkComponentTypeKHR = 4;
13399pub const VK_COMPONENT_TYPE_SINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT16_KHR;
13400pub const VK_COMPONENT_TYPE_SINT32_KHR: VkComponentTypeKHR = 5;
13401pub const VK_COMPONENT_TYPE_SINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT32_KHR;
13402pub const VK_COMPONENT_TYPE_SINT64_KHR: VkComponentTypeKHR = 6;
13403pub const VK_COMPONENT_TYPE_SINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT64_KHR;
13404pub const VK_COMPONENT_TYPE_SINT8_KHR: VkComponentTypeKHR = 3;
13405pub const VK_COMPONENT_TYPE_SINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT8_KHR;
13406pub const VK_COMPONENT_TYPE_SINT8_PACKED_NV: VkComponentTypeKHR = 1000491000;
13407pub const VK_COMPONENT_TYPE_UINT16_KHR: VkComponentTypeKHR = 8;
13408pub const VK_COMPONENT_TYPE_UINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT16_KHR;
13409pub const VK_COMPONENT_TYPE_UINT32_KHR: VkComponentTypeKHR = 9;
13410pub const VK_COMPONENT_TYPE_UINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT32_KHR;
13411pub const VK_COMPONENT_TYPE_UINT64_KHR: VkComponentTypeKHR = 10;
13412pub const VK_COMPONENT_TYPE_UINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT64_KHR;
13413pub const VK_COMPONENT_TYPE_UINT8_KHR: VkComponentTypeKHR = 7;
13414pub const VK_COMPONENT_TYPE_UINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT8_KHR;
13415pub const VK_COMPONENT_TYPE_UINT8_PACKED_NV: VkComponentTypeKHR = 1000491001;
13416pub const VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 3;
13417pub const VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 0;
13418pub const VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 2;
13419pub const VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 1;
13420pub const VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV: f32 = 0.75;
13421pub const VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV: f32 = 0.25;
13422pub const VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV: f32 = 0.50;
13423pub const VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT: VkConditionalRenderingFlagBitsEXT = 1 << 0;
13424pub const VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: VkConservativeRasterizationModeEXT = 0;
13425pub const VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT: VkConservativeRasterizationModeEXT = 1;
13426pub const VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: VkConservativeRasterizationModeEXT = 2;
13427pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = 1;
13428pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = 2;
13429pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = 0;
13430pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = 3;
13431pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR: VkCopyAccelerationStructureModeKHR = 0;
13432pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR;
13433pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR: VkCopyAccelerationStructureModeKHR = 1;
13434pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR;
13435pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = 3;
13436pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = 2;
13437pub const VK_COPY_MICROMAP_MODE_CLONE_EXT: VkCopyMicromapModeEXT = 0;
13438pub const VK_COPY_MICROMAP_MODE_COMPACT_EXT: VkCopyMicromapModeEXT = 3;
13439pub const VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT: VkCopyMicromapModeEXT = 2;
13440pub const VK_COPY_MICROMAP_MODE_SERIALIZE_EXT: VkCopyMicromapModeEXT = 1;
13441pub const VK_COVERAGE_MODULATION_MODE_ALPHA_NV: VkCoverageModulationModeNV = 2;
13442pub const VK_COVERAGE_MODULATION_MODE_NONE_NV: VkCoverageModulationModeNV = 0;
13443pub const VK_COVERAGE_MODULATION_MODE_RGBA_NV: VkCoverageModulationModeNV = 3;
13444pub const VK_COVERAGE_MODULATION_MODE_RGB_NV: VkCoverageModulationModeNV = 1;
13445pub const VK_COVERAGE_REDUCTION_MODE_MERGE_NV: VkCoverageReductionModeNV = 0;
13446pub const VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV: VkCoverageReductionModeNV = 1;
13447pub const VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM: VkCubicFilterWeightsQCOM = 2;
13448pub const VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM: VkCubicFilterWeightsQCOM = 0;
13449pub const VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM: VkCubicFilterWeightsQCOM = 3;
13450pub const VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM: VkCubicFilterWeightsQCOM = 1;
13451pub const VK_CULL_MODE_BACK_BIT: VkCullModeFlagBits = 1 << 1;
13452pub const VK_CULL_MODE_FRONT_AND_BACK: VkCullModeFlagBits = 0x00000003;
13453pub const VK_CULL_MODE_FRONT_BIT: VkCullModeFlagBits = 1 << 0;
13454pub const VK_CULL_MODE_NONE: VkCullModeFlagBits = 0;
13455pub const VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM: VkDataGraphModelCacheTypeQCOM = 0;
13456pub const VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM: u32 = 3;
13457pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM: VkDataGraphPipelinePropertyARM = 0;
13458pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM: VkDataGraphPipelinePropertyARM = 1;
13459pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM: VkDataGraphPipelineSessionBindPointARM = 0;
13460pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM: VkDataGraphPipelineSessionBindPointTypeARM = 0;
13461pub const VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM: VkDataGraphPipelineSessionCreateFlagBitsARM = 1 << 0;
13462pub const VK_DEBUG_REPORT_DEBUG_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 4;
13463pub const VK_DEBUG_REPORT_ERROR_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 3;
13464pub const VK_DEBUG_REPORT_INFORMATION_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 0;
13465pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT: VkDebugReportObjectTypeEXT = 1000150000;
13466pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: VkDebugReportObjectTypeEXT = 1000165000;
13467pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: VkDebugReportObjectTypeEXT = 9;
13468pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: VkDebugReportObjectTypeEXT = 13;
13469pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: VkDebugReportObjectTypeEXT = 6;
13470pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: VkDebugReportObjectTypeEXT = 25;
13471pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT: VkDebugReportObjectTypeEXT = 1000029001;
13472pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT: VkDebugReportObjectTypeEXT = 1000029000;
13473pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: VkDebugReportObjectTypeEXT = 28;
13474pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT;
13475pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: VkDebugReportObjectTypeEXT = 22;
13476pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: VkDebugReportObjectTypeEXT = 23;
13477pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 20;
13478pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: VkDebugReportObjectTypeEXT = 1000085000;
13479pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT;
13480pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: VkDebugReportObjectTypeEXT = 3;
13481pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: VkDebugReportObjectTypeEXT = 8;
13482pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: VkDebugReportObjectTypeEXT = 29;
13483pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: VkDebugReportObjectTypeEXT = 30;
13484pub const VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: VkDebugReportObjectTypeEXT = 11;
13485pub const VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: VkDebugReportObjectTypeEXT = 7;
13486pub const VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: VkDebugReportObjectTypeEXT = 24;
13487pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: VkDebugReportObjectTypeEXT = 10;
13488pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: VkDebugReportObjectTypeEXT = 14;
13489pub const VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: VkDebugReportObjectTypeEXT = 1;
13490pub const VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: VkDebugReportObjectTypeEXT = 2;
13491pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: VkDebugReportObjectTypeEXT = 16;
13492pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: VkDebugReportObjectTypeEXT = 19;
13493pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 17;
13494pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: VkDebugReportObjectTypeEXT = 12;
13495pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: VkDebugReportObjectTypeEXT = 4;
13496pub const VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: VkDebugReportObjectTypeEXT = 18;
13497pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: VkDebugReportObjectTypeEXT = 21;
13498pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: VkDebugReportObjectTypeEXT = 1000156000;
13499pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT;
13500pub const VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: VkDebugReportObjectTypeEXT = 5;
13501pub const VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: VkDebugReportObjectTypeEXT = 15;
13502pub const VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: VkDebugReportObjectTypeEXT = 26;
13503pub const VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: VkDebugReportObjectTypeEXT = 27;
13504pub const VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: VkDebugReportObjectTypeEXT = 0;
13505pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT;
13506pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: VkDebugReportObjectTypeEXT = 33;
13507pub const VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 2;
13508pub const VK_DEBUG_REPORT_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 1;
13509pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 12;
13510pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 4;
13511pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 0;
13512pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 8;
13513pub const VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 3;
13514pub const VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 0;
13515pub const VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 2;
13516pub const VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 1;
13517pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR: VkDefaultVertexAttributeValueKHR = 1;
13518pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR: VkDefaultVertexAttributeValueKHR = 0;
13519pub const VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR: VkDependencyFlagBits = 1 << 6;
13520pub const VK_DEPENDENCY_BY_REGION_BIT: VkDependencyFlagBits = 1 << 0;
13521pub const VK_DEPENDENCY_DEVICE_GROUP_BIT: VkDependencyFlagBits = 1 << 2;
13522pub const VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR: VkDependencyFlagBits = VK_DEPENDENCY_DEVICE_GROUP_BIT;
13523pub const VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT: VkDependencyFlagBits = 1 << 3;
13524pub const VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR: VkDependencyFlagBits = 1 << 5;
13525pub const VK_DEPENDENCY_VIEW_LOCAL_BIT: VkDependencyFlagBits = 1 << 1;
13526pub const VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR: VkDependencyFlagBits = VK_DEPENDENCY_VIEW_LOCAL_BIT;
13527pub const VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT: VkDepthBiasRepresentationEXT = 2;
13528pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT: VkDepthBiasRepresentationEXT = 1;
13529pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT: VkDepthBiasRepresentationEXT = 0;
13530pub const VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: VkDepthClampModeEXT = 1;
13531pub const VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: VkDepthClampModeEXT = 0;
13532pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT: VkDescriptorBindingFlagBits = 1 << 2;
13533pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
13534pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT: VkDescriptorBindingFlagBits = 1 << 0;
13535pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT;
13536pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT: VkDescriptorBindingFlagBits = 1 << 1;
13537pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT;
13538pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT: VkDescriptorBindingFlagBits = 1 << 3;
13539pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT;
13540pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT: VkDescriptorMappingSourceEXT = 0;
13541pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT: VkDescriptorMappingSourceEXT = 3;
13542pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT: VkDescriptorMappingSourceEXT = 2;
13543pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT: VkDescriptorMappingSourceEXT = 1;
13544pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT: VkDescriptorMappingSourceEXT = 8;
13545pub const VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT: VkDescriptorMappingSourceEXT = 7;
13546pub const VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT: VkDescriptorMappingSourceEXT = 6;
13547pub const VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT: VkDescriptorMappingSourceEXT = 5;
13548pub const VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT: VkDescriptorMappingSourceEXT = 4;
13549pub const VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT: VkDescriptorMappingSourceEXT = 10;
13550pub const VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT: VkDescriptorMappingSourceEXT = 9;
13551pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV: VkDescriptorPoolCreateFlagBits = 1 << 4;
13552pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV: VkDescriptorPoolCreateFlagBits = 1 << 3;
13553pub const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: VkDescriptorPoolCreateFlagBits = 1 << 0;
13554pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT: VkDescriptorPoolCreateFlagBits = 1 << 2;
13555pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE: VkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT;
13556pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT: VkDescriptorPoolCreateFlagBits = 1 << 1;
13557pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;
13558pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 4;
13559pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 5;
13560pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 2;
13561pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT;
13562pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV: VkDescriptorSetLayoutCreateFlagBits = 1 << 7;
13563pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV: VkDescriptorSetLayoutCreateFlagBits = 1 << 6;
13564pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT: VkDescriptorSetLayoutCreateFlagBits = 1 << 0;
13565pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT;
13566pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT: VkDescriptorSetLayoutCreateFlagBits = 1 << 1;
13567pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT;
13568pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: VkDescriptorType = 1000150000;
13569pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: VkDescriptorType = 1000165000;
13570pub const VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: VkDescriptorType = 1000440001;
13571pub const VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: VkDescriptorType = 1;
13572pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: VkDescriptorType = 1000138000;
13573pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT: VkDescriptorType = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK;
13574pub const VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: VkDescriptorType = 10;
13575pub const VK_DESCRIPTOR_TYPE_MUTABLE_EXT: VkDescriptorType = 1000351000;
13576pub const VK_DESCRIPTOR_TYPE_MUTABLE_VALVE: VkDescriptorType = VK_DESCRIPTOR_TYPE_MUTABLE_EXT;
13577pub const VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkDescriptorType = 1000570000;
13578pub const VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: VkDescriptorType = 2;
13579pub const VK_DESCRIPTOR_TYPE_SAMPLER: VkDescriptorType = 0;
13580pub const VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: VkDescriptorType = 1000440000;
13581pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: VkDescriptorType = 7;
13582pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: VkDescriptorType = 9;
13583pub const VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: VkDescriptorType = 3;
13584pub const VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: VkDescriptorType = 5;
13585pub const VK_DESCRIPTOR_TYPE_TENSOR_ARM: VkDescriptorType = 1000460000;
13586pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: VkDescriptorType = 6;
13587pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: VkDescriptorType = 8;
13588pub const VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: VkDescriptorType = 4;
13589pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: VkDescriptorUpdateTemplateType = 0;
13590pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET;
13591pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS: VkDescriptorUpdateTemplateType = 1;
13592pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS;
13593pub const VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT: VkDeviceAddressBindingFlagBitsEXT = 1 << 0;
13594pub const VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT: VkDeviceAddressBindingTypeEXT = 0;
13595pub const VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT: VkDeviceAddressBindingTypeEXT = 1;
13596pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 2;
13597pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 1;
13598pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 0;
13599pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 3;
13600pub const VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: VkDeviceEventTypeEXT = 0;
13601pub const VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 3;
13602pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT: VkDeviceFaultAddressTypeEXT = 6;
13603pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 5;
13604pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT: VkDeviceFaultAddressTypeEXT = 4;
13605pub const VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT: VkDeviceFaultAddressTypeEXT = 0;
13606pub const VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 1;
13607pub const VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 2;
13608pub const VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT: VkDeviceFaultVendorBinaryHeaderVersionEXT = 1;
13609pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 0;
13610pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 3;
13611pub const VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 1;
13612pub const VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 2;
13613pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT: VkDeviceMemoryReportEventTypeEXT = 0;
13614pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT: VkDeviceMemoryReportEventTypeEXT = 4;
13615pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT: VkDeviceMemoryReportEventTypeEXT = 1;
13616pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = 2;
13617pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = 3;
13618pub const VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR: VkDeviceQueueCreateFlagBits = 1 << 2;
13619pub const VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT: VkDeviceQueueCreateFlagBits = 1 << 0;
13620pub const VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = 0;
13621pub const VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = 1;
13622pub const VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: VkDiscardRectangleModeEXT = 1;
13623pub const VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: VkDiscardRectangleModeEXT = 0;
13624pub const VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: VkDisplayEventTypeEXT = 0;
13625pub const VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 1;
13626pub const VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 0;
13627pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 2;
13628pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 3;
13629pub const VK_DISPLAY_POWER_STATE_OFF_EXT: VkDisplayPowerStateEXT = 0;
13630pub const VK_DISPLAY_POWER_STATE_ON_EXT: VkDisplayPowerStateEXT = 2;
13631pub const VK_DISPLAY_POWER_STATE_SUSPEND_EXT: VkDisplayPowerStateEXT = 1;
13632pub const VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV: VkDisplaySurfaceStereoTypeNV = 2;
13633pub const VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV: VkDisplaySurfaceStereoTypeNV = 3;
13634pub const VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV: VkDisplaySurfaceStereoTypeNV = 0;
13635pub const VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV: VkDisplaySurfaceStereoTypeNV = 1;
13636pub const VK_DRIVER_ID_AMD_OPEN_SOURCE: VkDriverId = 2;
13637pub const VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR: VkDriverId = VK_DRIVER_ID_AMD_OPEN_SOURCE;
13638pub const VK_DRIVER_ID_AMD_PROPRIETARY: VkDriverId = 1;
13639pub const VK_DRIVER_ID_AMD_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_AMD_PROPRIETARY;
13640pub const VK_DRIVER_ID_ARM_PROPRIETARY: VkDriverId = 9;
13641pub const VK_DRIVER_ID_ARM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_ARM_PROPRIETARY;
13642pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY: VkDriverId = 12;
13643pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_BROADCOM_PROPRIETARY;
13644pub const VK_DRIVER_ID_COREAVI_PROPRIETARY: VkDriverId = 15;
13645pub const VK_DRIVER_ID_GGP_PROPRIETARY: VkDriverId = 11;
13646pub const VK_DRIVER_ID_GGP_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_GGP_PROPRIETARY;
13647pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER: VkDriverId = 10;
13648pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR: VkDriverId = VK_DRIVER_ID_GOOGLE_SWIFTSHADER;
13649pub const VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA: VkDriverId = 25;
13650pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY: VkDriverId = 7;
13651pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_IMAGINATION_PROPRIETARY;
13652pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA: VkDriverId = 6;
13653pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR: VkDriverId = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
13654pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS: VkDriverId = 5;
13655pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR: VkDriverId = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
13656pub const VK_DRIVER_ID_JUICE_PROPRIETARY: VkDriverId = 16;
13657pub const VK_DRIVER_ID_MESA_DOZEN: VkDriverId = 23;
13658pub const VK_DRIVER_ID_MESA_HONEYKRISP: VkDriverId = 26;
13659pub const VK_DRIVER_ID_MESA_KOSMICKRISP: VkDriverId = 28;
13660pub const VK_DRIVER_ID_MESA_LLVMPIPE: VkDriverId = 13;
13661pub const VK_DRIVER_ID_MESA_NVK: VkDriverId = 24;
13662pub const VK_DRIVER_ID_MESA_PANVK: VkDriverId = 20;
13663pub const VK_DRIVER_ID_MESA_RADV: VkDriverId = 3;
13664pub const VK_DRIVER_ID_MESA_RADV_KHR: VkDriverId = VK_DRIVER_ID_MESA_RADV;
13665pub const VK_DRIVER_ID_MESA_TURNIP: VkDriverId = 18;
13666pub const VK_DRIVER_ID_MESA_V3DV: VkDriverId = 19;
13667pub const VK_DRIVER_ID_MESA_VENUS: VkDriverId = 22;
13668pub const VK_DRIVER_ID_MOLTENVK: VkDriverId = 14;
13669pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY: VkDriverId = 4;
13670pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_NVIDIA_PROPRIETARY;
13671pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY: VkDriverId = 8;
13672pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
13673pub const VK_DRIVER_ID_SAMSUNG_PROPRIETARY: VkDriverId = 21;
13674pub const VK_DRIVER_ID_VERISILICON_PROPRIETARY: VkDriverId = 17;
13675pub const VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN: VkDriverId = 27;
13676pub const VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT: VkDynamicState = 1000455007;
13677pub const VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT: VkDynamicState = 1000455008;
13678pub const VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: VkDynamicState = 1000524000;
13679pub const VK_DYNAMIC_STATE_BLEND_CONSTANTS: VkDynamicState = 4;
13680pub const VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT: VkDynamicState = 1000455018;
13681pub const VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT: VkDynamicState = 1000455010;
13682pub const VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT: VkDynamicState = 1000455011;
13683pub const VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT: VkDynamicState = 1000381000;
13684pub const VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT: VkDynamicState = 1000455012;
13685pub const VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT: VkDynamicState = 1000455014;
13686pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV: VkDynamicState = 1000455027;
13687pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV: VkDynamicState = 1000455028;
13688pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV: VkDynamicState = 1000455029;
13689pub const VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV: VkDynamicState = 1000455032;
13690pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV: VkDynamicState = 1000455025;
13691pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV: VkDynamicState = 1000455026;
13692pub const VK_DYNAMIC_STATE_CULL_MODE: VkDynamicState = 1000267000;
13693pub const VK_DYNAMIC_STATE_CULL_MODE_EXT: VkDynamicState = VK_DYNAMIC_STATE_CULL_MODE;
13694pub const VK_DYNAMIC_STATE_DEPTH_BIAS: VkDynamicState = 3;
13695pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE: VkDynamicState = 1000377002;
13696pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE;
13697pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS: VkDynamicState = 5;
13698pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE: VkDynamicState = 1000267009;
13699pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE;
13700pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT: VkDynamicState = 1000455003;
13701pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: VkDynamicState = 1000582000;
13702pub const VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT: VkDynamicState = 1000455016;
13703pub const VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: VkDynamicState = 1000455022;
13704pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP: VkDynamicState = 1000267008;
13705pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP;
13706pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE: VkDynamicState = 1000267006;
13707pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE;
13708pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE: VkDynamicState = 1000267007;
13709pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE;
13710pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT: VkDynamicState = 1000099001;
13711pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT: VkDynamicState = 1000099000;
13712pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT: VkDynamicState = 1000099002;
13713pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV: VkDynamicState = 1000205000;
13714pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV: VkDynamicState = 1000205001;
13715pub const VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: VkDynamicState = 1000455015;
13716pub const VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR: VkDynamicState = 1000226000;
13717pub const VK_DYNAMIC_STATE_FRONT_FACE: VkDynamicState = 1000267001;
13718pub const VK_DYNAMIC_STATE_FRONT_FACE_EXT: VkDynamicState = VK_DYNAMIC_STATE_FRONT_FACE;
13719pub const VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT: VkDynamicState = 1000455020;
13720pub const VK_DYNAMIC_STATE_LINE_STIPPLE: VkDynamicState = 1000259000;
13721pub const VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT: VkDynamicState = 1000455021;
13722pub const VK_DYNAMIC_STATE_LINE_STIPPLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
13723pub const VK_DYNAMIC_STATE_LINE_STIPPLE_KHR: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
13724pub const VK_DYNAMIC_STATE_LINE_WIDTH: VkDynamicState = 2;
13725pub const VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT: VkDynamicState = 1000455009;
13726pub const VK_DYNAMIC_STATE_LOGIC_OP_EXT: VkDynamicState = 1000377003;
13727pub const VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT: VkDynamicState = 1000377000;
13728pub const VK_DYNAMIC_STATE_POLYGON_MODE_EXT: VkDynamicState = 1000455004;
13729pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE: VkDynamicState = 1000377004;
13730pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE;
13731pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY: VkDynamicState = 1000267002;
13732pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY;
13733pub const VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT: VkDynamicState = 1000455019;
13734pub const VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT: VkDynamicState = 1000455005;
13735pub const VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT: VkDynamicState = 1000455013;
13736pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE: VkDynamicState = 1000377001;
13737pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE;
13738pub const VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR: VkDynamicState = 1000347000;
13739pub const VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: VkDynamicState = 1000455031;
13740pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT: VkDynamicState = 1000455017;
13741pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT: VkDynamicState = 1000143000;
13742pub const VK_DYNAMIC_STATE_SAMPLE_MASK_EXT: VkDynamicState = 1000455006;
13743pub const VK_DYNAMIC_STATE_SCISSOR: VkDynamicState = 1;
13744pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT: VkDynamicState = 1000267004;
13745pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT;
13746pub const VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV: VkDynamicState = 1000455030;
13747pub const VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: VkDynamicState = 6;
13748pub const VK_DYNAMIC_STATE_STENCIL_OP: VkDynamicState = 1000267011;
13749pub const VK_DYNAMIC_STATE_STENCIL_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_OP;
13750pub const VK_DYNAMIC_STATE_STENCIL_REFERENCE: VkDynamicState = 8;
13751pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE: VkDynamicState = 1000267010;
13752pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE;
13753pub const VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: VkDynamicState = 7;
13754pub const VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT: VkDynamicState = 1000455002;
13755pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE: VkDynamicState = 1000267005;
13756pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT: VkDynamicState = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE;
13757pub const VK_DYNAMIC_STATE_VERTEX_INPUT_EXT: VkDynamicState = 1000352000;
13758pub const VK_DYNAMIC_STATE_VIEWPORT: VkDynamicState = 0;
13759pub const VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV: VkDynamicState = 1000164006;
13760pub const VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV: VkDynamicState = 1000164004;
13761pub const VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV: VkDynamicState = 1000455024;
13762pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT: VkDynamicState = 1000267003;
13763pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT;
13764pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV: VkDynamicState = 1000455023;
13765pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV: VkDynamicState = 1000087000;
13766pub const VK_ERROR_COMPRESSION_EXHAUSTED_EXT: VkResult = -1000338000;
13767pub const VK_ERROR_DEVICE_LOST: VkResult = -4;
13768pub const VK_ERROR_EXTENSION_NOT_PRESENT: VkResult = -7;
13769pub const VK_ERROR_FEATURE_NOT_PRESENT: VkResult = -8;
13770pub const VK_ERROR_FORMAT_NOT_SUPPORTED: VkResult = -11;
13771pub const VK_ERROR_FRAGMENTATION: VkResult = -1000161000;
13772pub const VK_ERROR_FRAGMENTATION_EXT: VkResult = VK_ERROR_FRAGMENTATION;
13773pub const VK_ERROR_FRAGMENTED_POOL: VkResult = -12;
13774pub const VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: VkResult = -1000023000;
13775pub const VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: VkResult = -1000003001;
13776pub const VK_ERROR_INCOMPATIBLE_DRIVER: VkResult = -9;
13777pub const VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = VK_INCOMPATIBLE_SHADER_BINARY_EXT;
13778pub const VK_ERROR_INITIALIZATION_FAILED: VkResult = -3;
13779pub const VK_ERROR_INVALID_DEVICE_ADDRESS_EXT: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
13780pub const VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: VkResult = -1000158000;
13781pub const VK_ERROR_INVALID_EXTERNAL_HANDLE: VkResult = -1000072003;
13782pub const VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR: VkResult = VK_ERROR_INVALID_EXTERNAL_HANDLE;
13783pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: VkResult = -1000257000;
13784pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
13785pub const VK_ERROR_INVALID_SHADER_NV: VkResult = -1000012000;
13786pub const VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: VkResult = -1000299000;
13787pub const VK_ERROR_LAYER_NOT_PRESENT: VkResult = -6;
13788pub const VK_ERROR_MEMORY_MAP_FAILED: VkResult = -5;
13789pub const VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: VkResult = -1000000001;
13790pub const VK_ERROR_NOT_ENOUGH_SPACE_KHR: VkResult = -1000483000;
13791pub const VK_ERROR_NOT_PERMITTED: VkResult = -1000174001;
13792pub const VK_ERROR_NOT_PERMITTED_EXT: VkResult = VK_ERROR_NOT_PERMITTED;
13793pub const VK_ERROR_NOT_PERMITTED_KHR: VkResult = VK_ERROR_NOT_PERMITTED;
13794pub const VK_ERROR_OUT_OF_DATE_KHR: VkResult = -1000001004;
13795pub const VK_ERROR_OUT_OF_DEVICE_MEMORY: VkResult = -2;
13796pub const VK_ERROR_OUT_OF_HOST_MEMORY: VkResult = -1;
13797pub const VK_ERROR_OUT_OF_POOL_MEMORY: VkResult = -1000069000;
13798pub const VK_ERROR_OUT_OF_POOL_MEMORY_KHR: VkResult = VK_ERROR_OUT_OF_POOL_MEMORY;
13799pub const VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
13800pub const VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT: VkResult = -1000208000;
13801pub const VK_ERROR_SURFACE_LOST_KHR: VkResult = -1000000000;
13802pub const VK_ERROR_TOO_MANY_OBJECTS: VkResult = -10;
13803pub const VK_ERROR_UNKNOWN: VkResult = -13;
13804pub const VK_ERROR_VALIDATION_FAILED: VkResult = -1000011001;
13805pub const VK_ERROR_VALIDATION_FAILED_EXT: VkResult = VK_ERROR_VALIDATION_FAILED;
13806pub const VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: VkResult = -1000023001;
13807pub const VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: VkResult = -1000023004;
13808pub const VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: VkResult = -1000023003;
13809pub const VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: VkResult = -1000023002;
13810pub const VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: VkResult = -1000023005;
13811pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT: VkEventCreateFlagBits = 1 << 0;
13812pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR: VkEventCreateFlagBits = VK_EVENT_CREATE_DEVICE_ONLY_BIT;
13813pub const VK_EVENT_RESET: VkResult = 4;
13814pub const VK_EVENT_SET: VkResult = 3;
13815pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT: VkExternalFenceFeatureFlagBits = 1 << 0;
13816pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT;
13817pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT: VkExternalFenceFeatureFlagBits = 1 << 1;
13818pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT;
13819pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 0;
13820pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT;
13821pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 1;
13822pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
13823pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 2;
13824pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
13825pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 3;
13826pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
13827pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT: VkExternalMemoryFeatureFlagBits = 1 << 0;
13828pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT;
13829pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 0;
13830pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT: VkExternalMemoryFeatureFlagBits = 1 << 1;
13831pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
13832pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 1;
13833pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT: VkExternalMemoryFeatureFlagBits = 1 << 2;
13834pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
13835pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 2;
13836pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 2;
13837pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 3;
13838pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 3;
13839pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT;
13840pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 4;
13841pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT;
13842pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 5;
13843pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT;
13844pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 6;
13845pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT;
13846pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 9;
13847pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 7;
13848pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 8;
13849pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 0;
13850pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
13851pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 1;
13852pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
13853pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 0;
13854pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 2;
13855pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
13856pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 1;
13857pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV: VkExternalMemoryHandleTypeFlagBits = 1 << 12;
13858pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBits = 1 << 0;
13859pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBits = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT;
13860pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBits = 1 << 1;
13861pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBits = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
13862pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
13863pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 3;
13864pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
13865pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 0;
13866pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
13867pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 1;
13868pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
13869pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 2;
13870pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
13871pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 4;
13872pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
13873pub const VK_EXT_4444_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_4444_formats";
13874pub const VK_EXT_4444_FORMATS_SPEC_VERSION: u32 = 1;
13875pub const VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME: &CStr = c"VK_EXT_acquire_drm_display";
13876pub const VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION: u32 = 1;
13877pub const VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME: &CStr = c"VK_EXT_astc_decode_mode";
13878pub const VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION: u32 = 1;
13879pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_attachment_feedback_loop_dynamic_state";
13880pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION: u32 = 1;
13881pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME: &CStr = c"VK_EXT_attachment_feedback_loop_layout";
13882pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION: u32 = 2;
13883pub const VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME: &CStr = c"VK_EXT_blend_operation_advanced";
13884pub const VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION: u32 = 2;
13885pub const VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME: &CStr = c"VK_EXT_border_color_swizzle";
13886pub const VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION: u32 = 1;
13887pub const VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME: &CStr = c"VK_EXT_buffer_device_address";
13888pub const VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION: u32 = 2;
13889pub const VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME: &CStr = c"VK_EXT_calibrated_timestamps";
13890pub const VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION: u32 = 2;
13891pub const VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME: &CStr = c"VK_EXT_color_write_enable";
13892pub const VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION: u32 = 1;
13893pub const VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME: &CStr = c"VK_EXT_conditional_rendering";
13894pub const VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION: u32 = 2;
13895pub const VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_EXT_conservative_rasterization";
13896pub const VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION: u32 = 1;
13897pub const VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME: &CStr = c"VK_EXT_custom_border_color";
13898pub const VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION: u32 = 12;
13899pub const VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME: &CStr = c"VK_EXT_custom_resolve";
13900pub const VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION: u32 = 1;
13901pub const VK_EXT_DEBUG_MARKER_EXTENSION_NAME: &CStr = c"VK_EXT_debug_marker";
13902pub const VK_EXT_DEBUG_MARKER_SPEC_VERSION: u32 = 4;
13903pub const VK_EXT_DEBUG_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_debug_report";
13904pub const VK_EXT_DEBUG_REPORT_SPEC_VERSION: u32 = 10;
13905pub const VK_EXT_DEBUG_UTILS_EXTENSION_NAME: &CStr = c"VK_EXT_debug_utils";
13906pub const VK_EXT_DEBUG_UTILS_SPEC_VERSION: u32 = 2;
13907pub const VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_bias_control";
13908pub const VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION: u32 = 1;
13909pub const VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clamp_control";
13910pub const VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION: u32 = 1;
13911pub const VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clamp_zero_one";
13912pub const VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION: u32 = 1;
13913pub const VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clip_control";
13914pub const VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION: u32 = 1;
13915pub const VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clip_enable";
13916pub const VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION: u32 = 1;
13917pub const VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME: &CStr = c"VK_EXT_depth_range_unrestricted";
13918pub const VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION: u32 = 1;
13919pub const VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_buffer";
13920pub const VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION: u32 = 1;
13921pub const VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_heap";
13922pub const VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION: u32 = 1;
13923pub const VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_indexing";
13924pub const VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION: u32 = 2;
13925pub const VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_device_address_binding_report";
13926pub const VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION: u32 = 1;
13927pub const VK_EXT_DEVICE_FAULT_EXTENSION_NAME: &CStr = c"VK_EXT_device_fault";
13928pub const VK_EXT_DEVICE_FAULT_SPEC_VERSION: u32 = 2;
13929pub const VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: &CStr = c"VK_EXT_device_generated_commands";
13930pub const VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: u32 = 1;
13931pub const VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_device_memory_report";
13932pub const VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION: u32 = 2;
13933pub const VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME: &CStr = c"VK_EXT_direct_mode_display";
13934pub const VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION: u32 = 1;
13935pub const VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME: &CStr = c"VK_EXT_discard_rectangles";
13936pub const VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION: u32 = 2;
13937pub const VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_display_control";
13938pub const VK_EXT_DISPLAY_CONTROL_SPEC_VERSION: u32 = 1;
13939pub const VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME: &CStr = c"VK_EXT_display_surface_counter";
13940pub const VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION: u32 = 1;
13941pub const VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME: &CStr = c"VK_EXT_dynamic_rendering_unused_attachments";
13942pub const VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION: u32 = 1;
13943pub const VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state2";
13944pub const VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION: u32 = 1;
13945pub const VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state3";
13946pub const VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION: u32 = 2;
13947pub const VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state";
13948pub const VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION: u32 = 1;
13949pub const VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_acquire_unmodified";
13950pub const VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION: u32 = 1;
13951pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_dma_buf";
13952pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION: u32 = 1;
13953pub const VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_host";
13954pub const VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION: u32 = 1;
13955pub const VK_EXT_FILTER_CUBIC_EXTENSION_NAME: &CStr = c"VK_EXT_filter_cubic";
13956pub const VK_EXT_FILTER_CUBIC_SPEC_VERSION: u32 = 3;
13957pub const VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map2";
13958pub const VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION: u32 = 1;
13959pub const VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map";
13960pub const VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map_offset";
13961pub const VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION: u32 = 1;
13962pub const VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION: u32 = 3;
13963pub const VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_shader_interlock";
13964pub const VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION: u32 = 1;
13965pub const VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME: &CStr = c"VK_EXT_frame_boundary";
13966pub const VK_EXT_FRAME_BOUNDARY_SPEC_VERSION: u32 = 1;
13967pub const VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME: &CStr = c"VK_EXT_global_priority";
13968pub const VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME: &CStr = c"VK_EXT_global_priority_query";
13969pub const VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION: u32 = 1;
13970pub const VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION: u32 = 2;
13971pub const VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME: &CStr = c"VK_EXT_graphics_pipeline_library";
13972pub const VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION: u32 = 1;
13973pub const VK_EXT_HDR_METADATA_EXTENSION_NAME: &CStr = c"VK_EXT_hdr_metadata";
13974pub const VK_EXT_HDR_METADATA_SPEC_VERSION: u32 = 3;
13975pub const VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME: &CStr = c"VK_EXT_headless_surface";
13976pub const VK_EXT_HEADLESS_SURFACE_SPEC_VERSION: u32 = 1;
13977pub const VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME: &CStr = c"VK_EXT_host_image_copy";
13978pub const VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION: u32 = 1;
13979pub const VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME: &CStr = c"VK_EXT_host_query_reset";
13980pub const VK_EXT_HOST_QUERY_RESET_SPEC_VERSION: u32 = 1;
13981pub const VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME: &CStr = c"VK_EXT_image_2d_view_of_3d";
13982pub const VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION: u32 = 1;
13983pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_image_compression_control";
13984pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION: u32 = 1;
13985pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_EXT_image_compression_control_swapchain";
13986pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION: u32 = 1;
13987pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME: &CStr = c"VK_EXT_image_drm_format_modifier";
13988pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION: u32 = 2;
13989pub const VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_image_robustness";
13990pub const VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
13991pub const VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME: &CStr = c"VK_EXT_image_sliced_view_of_3d";
13992pub const VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION: u32 = 1;
13993pub const VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME: &CStr = c"VK_EXT_image_view_min_lod";
13994pub const VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION: u32 = 1;
13995pub const VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME: &CStr = c"VK_EXT_index_type_uint8";
13996pub const VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION: u32 = 1;
13997pub const VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME: &CStr = c"VK_EXT_inline_uniform_block";
13998pub const VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION: u32 = 1;
13999pub const VK_EXT_LAYER_SETTINGS_EXTENSION_NAME: &CStr = c"VK_EXT_layer_settings";
14000pub const VK_EXT_LAYER_SETTINGS_SPEC_VERSION: u32 = 2;
14001pub const VK_EXT_LEGACY_DITHERING_EXTENSION_NAME: &CStr = c"VK_EXT_legacy_dithering";
14002pub const VK_EXT_LEGACY_DITHERING_SPEC_VERSION: u32 = 2;
14003pub const VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME: &CStr = c"VK_EXT_legacy_vertex_attributes";
14004pub const VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION: u32 = 1;
14005pub const VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_EXT_line_rasterization";
14006pub const VK_EXT_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
14007pub const VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME: &CStr = c"VK_EXT_load_store_op_none";
14008pub const VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION: u32 = 1;
14009pub const VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME: &CStr = c"VK_EXT_map_memory_placed";
14010pub const VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION: u32 = 1;
14011pub const VK_EXT_MEMORY_BUDGET_EXTENSION_NAME: &CStr = c"VK_EXT_memory_budget";
14012pub const VK_EXT_MEMORY_BUDGET_SPEC_VERSION: u32 = 1;
14013pub const VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME: &CStr = c"VK_EXT_memory_decompression";
14014pub const VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION: u32 = 1;
14015pub const VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME: &CStr = c"VK_EXT_memory_priority";
14016pub const VK_EXT_MEMORY_PRIORITY_SPEC_VERSION: u32 = 1;
14017pub const VK_EXT_MESH_SHADER_EXTENSION_NAME: &CStr = c"VK_EXT_mesh_shader";
14018pub const VK_EXT_MESH_SHADER_SPEC_VERSION: u32 = 1;
14019pub const VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME: &CStr = c"VK_EXT_multisampled_render_to_single_sampled";
14020pub const VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION: u32 = 1;
14021pub const VK_EXT_MULTI_DRAW_EXTENSION_NAME: &CStr = c"VK_EXT_multi_draw";
14022pub const VK_EXT_MULTI_DRAW_SPEC_VERSION: u32 = 1;
14023pub const VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME: &CStr = c"VK_EXT_mutable_descriptor_type";
14024pub const VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION: u32 = 1;
14025pub const VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME: &CStr = c"VK_EXT_nested_command_buffer";
14026pub const VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION: u32 = 1;
14027pub const VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME: &CStr = c"VK_EXT_non_seamless_cube_map";
14028pub const VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION: u32 = 1;
14029pub const VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME: &CStr = c"VK_EXT_opacity_micromap";
14030pub const VK_EXT_OPACITY_MICROMAP_SPEC_VERSION: u32 = 2;
14031pub const VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_EXT_pageable_device_local_memory";
14032pub const VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION: u32 = 1;
14033pub const VK_EXT_PCI_BUS_INFO_EXTENSION_NAME: &CStr = c"VK_EXT_pci_bus_info";
14034pub const VK_EXT_PCI_BUS_INFO_SPEC_VERSION: u32 = 2;
14035pub const VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME: &CStr = c"VK_EXT_physical_device_drm";
14036pub const VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION: u32 = 1;
14037pub const VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_creation_cache_control";
14038pub const VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION: u32 = 3;
14039pub const VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_creation_feedback";
14040pub const VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION: u32 = 1;
14041pub const VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_library_group_handles";
14042pub const VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION: u32 = 1;
14043pub const VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_properties";
14044pub const VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION: u32 = 1;
14045pub const VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_protected_access";
14046pub const VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION: u32 = 1;
14047pub const VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_robustness";
14048pub const VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
14049pub const VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME: &CStr = c"VK_EXT_post_depth_coverage";
14050pub const VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION: u32 = 1;
14051pub const VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME: &CStr = c"VK_EXT_present_mode_fifo_latest_ready";
14052pub const VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION: u32 = 1;
14053pub const VK_EXT_PRESENT_TIMING_EXTENSION_NAME: &CStr = c"VK_EXT_present_timing";
14054pub const VK_EXT_PRESENT_TIMING_SPEC_VERSION: u32 = 3;
14055pub const VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME: &CStr = c"VK_EXT_primitives_generated_query";
14056pub const VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION: u32 = 1;
14057pub const VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME: &CStr = c"VK_EXT_primitive_topology_list_restart";
14058pub const VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION: u32 = 1;
14059pub const VK_EXT_PRIVATE_DATA_EXTENSION_NAME: &CStr = c"VK_EXT_private_data";
14060pub const VK_EXT_PRIVATE_DATA_SPEC_VERSION: u32 = 1;
14061pub const VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME: &CStr = c"VK_EXT_provoking_vertex";
14062pub const VK_EXT_PROVOKING_VERTEX_SPEC_VERSION: u32 = 1;
14063pub const VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME: &CStr = c"VK_EXT_queue_family_foreign";
14064pub const VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION: u32 = 1;
14065pub const VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME: &CStr = c"VK_EXT_rasterization_order_attachment_access";
14066pub const VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION: u32 = 1;
14067pub const VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME: &CStr = c"VK_EXT_ray_tracing_invocation_reorder";
14068pub const VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION: u32 = 1;
14069pub const VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_rgba10x6_formats";
14070pub const VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION: u32 = 1;
14071pub const VK_EXT_ROBUSTNESS_2_EXTENSION_NAME: &CStr = c"VK_EXT_robustness2";
14072pub const VK_EXT_ROBUSTNESS_2_SPEC_VERSION: u32 = 1;
14073pub const VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME: &CStr = c"VK_EXT_sampler_filter_minmax";
14074pub const VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION: u32 = 2;
14075pub const VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME: &CStr = c"VK_EXT_sample_locations";
14076pub const VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION: u32 = 1;
14077pub const VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME: &CStr = c"VK_EXT_scalar_block_layout";
14078pub const VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION: u32 = 1;
14079pub const VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME: &CStr = c"VK_EXT_separate_stencil_usage";
14080pub const VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION: u32 = 1;
14081pub const VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME: &CStr = c"VK_EXT_shader_64bit_indexing";
14082pub const VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION: u32 = 1;
14083pub const VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME: &CStr = c"VK_EXT_shader_atomic_float2";
14084pub const VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION: u32 = 1;
14085pub const VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_atomic_float";
14086pub const VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION: u32 = 1;
14087pub const VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME: &CStr = c"VK_EXT_shader_demote_to_helper_invocation";
14088pub const VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION: u32 = 1;
14089pub const VK_EXT_SHADER_FLOAT8_EXTENSION_NAME: &CStr = c"VK_EXT_shader_float8";
14090pub const VK_EXT_SHADER_FLOAT8_SPEC_VERSION: u32 = 1;
14091pub const VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME: &CStr = c"VK_EXT_shader_image_atomic_int64";
14092pub const VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION: u32 = 1;
14093pub const VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME: &CStr = c"VK_EXT_shader_long_vector";
14094pub const VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION: u32 = 1;
14095pub const VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME: &CStr = c"VK_EXT_shader_module_identifier";
14096pub const VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION: u32 = 1;
14097pub const VK_EXT_SHADER_OBJECT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_object";
14098pub const VK_EXT_SHADER_OBJECT_SPEC_VERSION: u32 = 1;
14099pub const VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME: &CStr = c"VK_EXT_shader_replicated_composites";
14100pub const VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION: u32 = 1;
14101pub const VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_stencil_export";
14102pub const VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION: u32 = 1;
14103pub const VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_ballot";
14104pub const VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION: u32 = 1;
14105pub const VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_partitioned";
14106pub const VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION: u32 = 1;
14107pub const VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_vote";
14108pub const VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION: u32 = 1;
14109pub const VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME: &CStr = c"VK_EXT_shader_tile_image";
14110pub const VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION: u32 = 1;
14111pub const VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME: &CStr = c"VK_EXT_shader_uniform_buffer_unsized_array";
14112pub const VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION: u32 = 1;
14113pub const VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME: &CStr = c"VK_EXT_shader_viewport_index_layer";
14114pub const VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION: u32 = 1;
14115pub const VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_subgroup_size_control";
14116pub const VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION: u32 = 2;
14117pub const VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_subpass_merge_feedback";
14118pub const VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION: u32 = 2;
14119pub const VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_EXT_surface_maintenance1";
14120pub const VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
14121pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME: &CStr = c"VK_EXT_swapchain_colorspace";
14122pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION: u32 = 5;
14123pub const VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_EXT_swapchain_maintenance1";
14124pub const VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
14125pub const VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME: &CStr = c"VK_EXT_texel_buffer_alignment";
14126pub const VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION: u32 = 1;
14127pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME: &CStr = c"VK_EXT_texture_compression_astc_3d";
14128pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION: u32 = 1;
14129pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME: &CStr = c"VK_EXT_texture_compression_astc_hdr";
14130pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION: u32 = 1;
14131pub const VK_EXT_TOOLING_INFO_EXTENSION_NAME: &CStr = c"VK_EXT_tooling_info";
14132pub const VK_EXT_TOOLING_INFO_SPEC_VERSION: u32 = 1;
14133pub const VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_transform_feedback";
14134pub const VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION: u32 = 1;
14135pub const VK_EXT_VALIDATION_CACHE_EXTENSION_NAME: &CStr = c"VK_EXT_validation_cache";
14136pub const VK_EXT_VALIDATION_CACHE_SPEC_VERSION: u32 = 1;
14137pub const VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME: &CStr = c"VK_EXT_validation_features";
14138pub const VK_EXT_VALIDATION_FEATURES_SPEC_VERSION: u32 = 6;
14139pub const VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME: &CStr = c"VK_EXT_validation_flags";
14140pub const VK_EXT_VALIDATION_FLAGS_SPEC_VERSION: u32 = 3;
14141pub const VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_attribute_divisor";
14142pub const VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION: u32 = 3;
14143pub const VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_attribute_robustness";
14144pub const VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
14145pub const VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_input_dynamic_state";
14146pub const VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION: u32 = 2;
14147pub const VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_ycbcr_2plane_444_formats";
14148pub const VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION: u32 = 1;
14149pub const VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME: &CStr = c"VK_EXT_ycbcr_image_arrays";
14150pub const VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION: u32 = 1;
14151pub const VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME: &CStr = c"VK_EXT_zero_initialize_device_memory";
14152pub const VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION: u32 = 1;
14153pub const VK_FALSE: u32 = 0;
14154pub const VK_FENCE_CREATE_SIGNALED_BIT: VkFenceCreateFlagBits = 1 << 0;
14155pub const VK_FENCE_IMPORT_TEMPORARY_BIT: VkFenceImportFlagBits = 1 << 0;
14156pub const VK_FENCE_IMPORT_TEMPORARY_BIT_KHR: VkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT;
14157pub const VK_FILTER_CUBIC_EXT: VkFilter = 1000015000;
14158pub const VK_FILTER_CUBIC_IMG: VkFilter = VK_FILTER_CUBIC_EXT;
14159pub const VK_FILTER_LINEAR: VkFilter = 1;
14160pub const VK_FILTER_NEAREST: VkFilter = 0;
14161pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16: VkFormat = 1000470000;
14162pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_A1B5G5R5_UNORM_PACK16;
14163pub const VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormat = 8;
14164pub const VK_FORMAT_A2B10G10R10_SINT_PACK32: VkFormat = 69;
14165pub const VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormat = 65;
14166pub const VK_FORMAT_A2B10G10R10_SSCALED_PACK32: VkFormat = 67;
14167pub const VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormat = 68;
14168pub const VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormat = 64;
14169pub const VK_FORMAT_A2B10G10R10_USCALED_PACK32: VkFormat = 66;
14170pub const VK_FORMAT_A2R10G10B10_SINT_PACK32: VkFormat = 63;
14171pub const VK_FORMAT_A2R10G10B10_SNORM_PACK32: VkFormat = 59;
14172pub const VK_FORMAT_A2R10G10B10_SSCALED_PACK32: VkFormat = 61;
14173pub const VK_FORMAT_A2R10G10B10_UINT_PACK32: VkFormat = 62;
14174pub const VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormat = 58;
14175pub const VK_FORMAT_A2R10G10B10_USCALED_PACK32: VkFormat = 60;
14176pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16: VkFormat = 1000340001;
14177pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4B4G4R4_UNORM_PACK16;
14178pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16: VkFormat = 1000340000;
14179pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4R4G4B4_UNORM_PACK16;
14180pub const VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormat = 56;
14181pub const VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormat = 52;
14182pub const VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormat = 57;
14183pub const VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormat = 54;
14184pub const VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormat = 55;
14185pub const VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormat = 51;
14186pub const VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormat = 53;
14187pub const VK_FORMAT_A8_UNORM: VkFormat = 1000470001;
14188pub const VK_FORMAT_A8_UNORM_KHR: VkFormat = VK_FORMAT_A8_UNORM;
14189pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: VkFormat = 1000066011;
14190pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK;
14191pub const VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormat = 180;
14192pub const VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormat = 179;
14193pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: VkFormat = 1000066008;
14194pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK;
14195pub const VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormat = 174;
14196pub const VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormat = 173;
14197pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: VkFormat = 1000066009;
14198pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK;
14199pub const VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormat = 176;
14200pub const VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormat = 175;
14201pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: VkFormat = 1000066010;
14202pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK;
14203pub const VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormat = 178;
14204pub const VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormat = 177;
14205pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: VkFormat = 1000066012;
14206pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK;
14207pub const VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormat = 182;
14208pub const VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormat = 181;
14209pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: VkFormat = 1000066013;
14210pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK;
14211pub const VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormat = 184;
14212pub const VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormat = 183;
14213pub const VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288002;
14214pub const VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: VkFormat = 1000288001;
14215pub const VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: VkFormat = 1000288000;
14216pub const VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288005;
14217pub const VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: VkFormat = 1000288004;
14218pub const VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: VkFormat = 1000288003;
14219pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: VkFormat = 1000066000;
14220pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK;
14221pub const VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormat = 158;
14222pub const VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormat = 157;
14223pub const VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288008;
14224pub const VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: VkFormat = 1000288007;
14225pub const VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: VkFormat = 1000288006;
14226pub const VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288011;
14227pub const VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: VkFormat = 1000288010;
14228pub const VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: VkFormat = 1000288009;
14229pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: VkFormat = 1000066001;
14230pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK;
14231pub const VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormat = 160;
14232pub const VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormat = 159;
14233pub const VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288014;
14234pub const VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: VkFormat = 1000288013;
14235pub const VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: VkFormat = 1000288012;
14236pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: VkFormat = 1000066002;
14237pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK;
14238pub const VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormat = 162;
14239pub const VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormat = 161;
14240pub const VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288017;
14241pub const VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: VkFormat = 1000288016;
14242pub const VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: VkFormat = 1000288015;
14243pub const VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288020;
14244pub const VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: VkFormat = 1000288019;
14245pub const VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: VkFormat = 1000288018;
14246pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: VkFormat = 1000066003;
14247pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK;
14248pub const VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormat = 164;
14249pub const VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormat = 163;
14250pub const VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288023;
14251pub const VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: VkFormat = 1000288022;
14252pub const VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: VkFormat = 1000288021;
14253pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: VkFormat = 1000066004;
14254pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK;
14255pub const VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormat = 166;
14256pub const VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormat = 165;
14257pub const VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288026;
14258pub const VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: VkFormat = 1000288025;
14259pub const VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: VkFormat = 1000288024;
14260pub const VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT: VkFormat = 1000288029;
14261pub const VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: VkFormat = 1000288028;
14262pub const VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: VkFormat = 1000288027;
14263pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: VkFormat = 1000066005;
14264pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK;
14265pub const VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormat = 168;
14266pub const VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormat = 167;
14267pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: VkFormat = 1000066006;
14268pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK;
14269pub const VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormat = 170;
14270pub const VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormat = 169;
14271pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: VkFormat = 1000066007;
14272pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK;
14273pub const VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormat = 172;
14274pub const VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormat = 171;
14275pub const VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormat = 122;
14276pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: VkFormat = 1000156011;
14277pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
14278pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: VkFormat = 1000156021;
14279pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
14280pub const VK_FORMAT_B16G16R16G16_422_UNORM: VkFormat = 1000156028;
14281pub const VK_FORMAT_B16G16R16G16_422_UNORM_KHR: VkFormat = VK_FORMAT_B16G16R16G16_422_UNORM;
14282pub const VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormat = 3;
14283pub const VK_FORMAT_B5G5R5A1_UNORM_PACK16: VkFormat = 7;
14284pub const VK_FORMAT_B5G6R5_UNORM_PACK16: VkFormat = 5;
14285pub const VK_FORMAT_B8G8R8A8_SINT: VkFormat = 49;
14286pub const VK_FORMAT_B8G8R8A8_SNORM: VkFormat = 45;
14287pub const VK_FORMAT_B8G8R8A8_SRGB: VkFormat = 50;
14288pub const VK_FORMAT_B8G8R8A8_SSCALED: VkFormat = 47;
14289pub const VK_FORMAT_B8G8R8A8_UINT: VkFormat = 48;
14290pub const VK_FORMAT_B8G8R8A8_UNORM: VkFormat = 44;
14291pub const VK_FORMAT_B8G8R8A8_USCALED: VkFormat = 46;
14292pub const VK_FORMAT_B8G8R8G8_422_UNORM: VkFormat = 1000156001;
14293pub const VK_FORMAT_B8G8R8G8_422_UNORM_KHR: VkFormat = VK_FORMAT_B8G8R8G8_422_UNORM;
14294pub const VK_FORMAT_B8G8R8_SINT: VkFormat = 35;
14295pub const VK_FORMAT_B8G8R8_SNORM: VkFormat = 31;
14296pub const VK_FORMAT_B8G8R8_SRGB: VkFormat = 36;
14297pub const VK_FORMAT_B8G8R8_SSCALED: VkFormat = 33;
14298pub const VK_FORMAT_B8G8R8_UINT: VkFormat = 34;
14299pub const VK_FORMAT_B8G8R8_UNORM: VkFormat = 30;
14300pub const VK_FORMAT_B8G8R8_USCALED: VkFormat = 32;
14301pub const VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormat = 134;
14302pub const VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormat = 133;
14303pub const VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormat = 132;
14304pub const VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormat = 131;
14305pub const VK_FORMAT_BC2_SRGB_BLOCK: VkFormat = 136;
14306pub const VK_FORMAT_BC2_UNORM_BLOCK: VkFormat = 135;
14307pub const VK_FORMAT_BC3_SRGB_BLOCK: VkFormat = 138;
14308pub const VK_FORMAT_BC3_UNORM_BLOCK: VkFormat = 137;
14309pub const VK_FORMAT_BC4_SNORM_BLOCK: VkFormat = 140;
14310pub const VK_FORMAT_BC4_UNORM_BLOCK: VkFormat = 139;
14311pub const VK_FORMAT_BC5_SNORM_BLOCK: VkFormat = 142;
14312pub const VK_FORMAT_BC5_UNORM_BLOCK: VkFormat = 141;
14313pub const VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormat = 144;
14314pub const VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormat = 143;
14315pub const VK_FORMAT_BC7_SRGB_BLOCK: VkFormat = 146;
14316pub const VK_FORMAT_BC7_UNORM_BLOCK: VkFormat = 145;
14317pub const VK_FORMAT_D16_UNORM: VkFormat = 124;
14318pub const VK_FORMAT_D16_UNORM_S8_UINT: VkFormat = 128;
14319pub const VK_FORMAT_D24_UNORM_S8_UINT: VkFormat = 129;
14320pub const VK_FORMAT_D32_SFLOAT: VkFormat = 126;
14321pub const VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormat = 130;
14322pub const VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormat = 123;
14323pub const VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormat = 156;
14324pub const VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormat = 155;
14325pub const VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormat = 154;
14326pub const VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormat = 153;
14327pub const VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormat = 150;
14328pub const VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormat = 149;
14329pub const VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormat = 152;
14330pub const VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormat = 151;
14331pub const VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormat = 148;
14332pub const VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormat = 147;
14333pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 51;
14334pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 29;
14335pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT: VkFormatFeatureFlagBits2 = 1 << 11;
14336pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
14337pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT: VkFormatFeatureFlagBits2 = 1 << 10;
14338pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
14339pub const VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 36;
14340pub const VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 37;
14341pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlagBits2 = 1 << 7;
14342pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
14343pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlagBits2 = 1 << 8;
14344pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
14345pub const VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 59;
14346pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits2 = 1 << 23;
14347pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT;
14348pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 52;
14349pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 53;
14350pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlagBits2 = 1 << 9;
14351pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
14352pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT: VkFormatFeatureFlagBits2 = 1 << 22;
14353pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_DISJOINT_BIT;
14354pub const VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlagBits2 = 1 << 24;
14355pub const VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 30;
14356pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT: VkFormatFeatureFlagBits2 = 1 << 46;
14357pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT;
14358pub const VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 38;
14359pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits2 = 1 << 17;
14360pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT;
14361pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 42;
14362pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 40;
14363pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 41;
14364pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT: VkFormatFeatureFlagBits2 = 1 << 0;
14365pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
14366pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT: VkFormatFeatureFlagBits2 = 1 << 33;
14367pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
14368pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT: VkFormatFeatureFlagBits2 = 1 << 13;
14369pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT;
14370pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlagBits2 = 1 << 12;
14371pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
14372pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlagBits2 = 1 << 16;
14373pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
14374pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlagBits2 = 1 << 20;
14375pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT;
14376pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlagBits2 = 1 << 21;
14377pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT;
14378pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlagBits2 = 1 << 18;
14379pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
14380pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlagBits2 = 1 << 19;
14381pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT;
14382pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 54;
14383pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 55;
14384pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlagBits2 = 1 << 2;
14385pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
14386pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT: VkFormatFeatureFlagBits2 = 1 << 1;
14387pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
14388pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT: VkFormatFeatureFlagBits2 = 1 << 31;
14389pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT;
14390pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlagBits2 = 1 << 5;
14391pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
14392pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 4;
14393pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
14394pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT: VkFormatFeatureFlagBits2 = 1 << 32;
14395pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
14396pub const VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 48;
14397pub const VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 43;
14398pub const VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 39;
14399pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT: VkFormatFeatureFlagBits2 = 1 << 15;
14400pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
14401pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT: VkFormatFeatureFlagBits2 = 1 << 14;
14402pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT;
14403pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 3;
14404pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
14405pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 6;
14406pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
14407pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 26;
14408pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 25;
14409pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 28;
14410pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 50;
14411pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 27;
14412pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 49;
14413pub const VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 34;
14414pub const VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 35;
14415pub const VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits = 1 << 29;
14416pub const VK_FORMAT_FEATURE_BLIT_DST_BIT: VkFormatFeatureFlagBits = 1 << 11;
14417pub const VK_FORMAT_FEATURE_BLIT_SRC_BIT: VkFormatFeatureFlagBits = 1 << 10;
14418pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 1 << 7;
14419pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlagBits = 1 << 8;
14420pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 1 << 23;
14421pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
14422pub const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 1 << 9;
14423pub const VK_FORMAT_FEATURE_DISJOINT_BIT: VkFormatFeatureFlagBits = 1 << 22;
14424pub const VK_FORMAT_FEATURE_DISJOINT_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_DISJOINT_BIT;
14425pub const VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlagBits = 1 << 24;
14426pub const VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 30;
14427pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 1 << 17;
14428pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT;
14429pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT: VkFormatFeatureFlagBits = 1 << 0;
14430pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlagBits = 1 << 13;
14431pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
14432pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlagBits = 1 << 12;
14433pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlagBits = 1 << 16;
14434pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
14435pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlagBits = 1 << 20;
14436pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT;
14437pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlagBits = 1 << 21;
14438pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT;
14439pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlagBits = 1 << 18;
14440pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
14441pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlagBits = 1 << 19;
14442pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT;
14443pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlagBits = 1 << 2;
14444pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT: VkFormatFeatureFlagBits = 1 << 1;
14445pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlagBits = 1 << 5;
14446pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 4;
14447pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT: VkFormatFeatureFlagBits = 1 << 15;
14448pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
14449pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT: VkFormatFeatureFlagBits = 1 << 14;
14450pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
14451pub const VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 3;
14452pub const VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 6;
14453pub const VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlagBits = 1 << 26;
14454pub const VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 25;
14455pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlagBits = 1 << 28;
14456pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 27;
14457pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: VkFormat = 1000156010;
14458pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
14459pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156013;
14460pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
14461pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156015;
14462pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
14463pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: VkFormat = 1000330001;
14464pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16;
14465pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156012;
14466pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
14467pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156014;
14468pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
14469pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156016;
14470pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
14471pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: VkFormat = 1000156020;
14472pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
14473pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156023;
14474pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
14475pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156025;
14476pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
14477pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: VkFormat = 1000330002;
14478pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16;
14479pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156022;
14480pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
14481pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156024;
14482pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
14483pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156026;
14484pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
14485pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: VkFormat = 1000609012;
14486pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: VkFormat = 1000609013;
14487pub const VK_FORMAT_G16B16G16R16_422_UNORM: VkFormat = 1000156027;
14488pub const VK_FORMAT_G16B16G16R16_422_UNORM_KHR: VkFormat = VK_FORMAT_G16B16G16R16_422_UNORM;
14489pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: VkFormat = 1000156030;
14490pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM;
14491pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: VkFormat = 1000156032;
14492pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM;
14493pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: VkFormat = 1000330003;
14494pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM;
14495pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: VkFormat = 1000156029;
14496pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM;
14497pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: VkFormat = 1000156031;
14498pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM;
14499pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: VkFormat = 1000156033;
14500pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM;
14501pub const VK_FORMAT_G8B8G8R8_422_UNORM: VkFormat = 1000156000;
14502pub const VK_FORMAT_G8B8G8R8_422_UNORM_KHR: VkFormat = VK_FORMAT_G8B8G8R8_422_UNORM;
14503pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: VkFormat = 1000156003;
14504pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
14505pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: VkFormat = 1000156005;
14506pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM;
14507pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: VkFormat = 1000330000;
14508pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM;
14509pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: VkFormat = 1000156002;
14510pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
14511pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: VkFormat = 1000156004;
14512pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM;
14513pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: VkFormat = 1000156006;
14514pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM;
14515pub const VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054004;
14516pub const VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054000;
14517pub const VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054005;
14518pub const VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054001;
14519pub const VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054006;
14520pub const VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054002;
14521pub const VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054007;
14522pub const VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054003;
14523pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: VkFormat = 1000609002;
14524pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: VkFormat = 1000156009;
14525pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
14526pub const VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: VkFormat = 1000609001;
14527pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16: VkFormat = 1000156008;
14528pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
14529pub const VK_FORMAT_R10X6_UINT_PACK16_ARM: VkFormat = 1000609000;
14530pub const VK_FORMAT_R10X6_UNORM_PACK16: VkFormat = 1000156007;
14531pub const VK_FORMAT_R10X6_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R10X6_UNORM_PACK16;
14532pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: VkFormat = 1000609005;
14533pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: VkFormat = 1000156019;
14534pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
14535pub const VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: VkFormat = 1000609004;
14536pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16: VkFormat = 1000156018;
14537pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
14538pub const VK_FORMAT_R12X4_UINT_PACK16_ARM: VkFormat = 1000609003;
14539pub const VK_FORMAT_R12X4_UNORM_PACK16: VkFormat = 1000156017;
14540pub const VK_FORMAT_R12X4_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R12X4_UNORM_PACK16;
14541pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: VkFormat = 1000609008;
14542pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: VkFormat = 1000609011;
14543pub const VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: VkFormat = 1000609007;
14544pub const VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: VkFormat = 1000609010;
14545pub const VK_FORMAT_R14X2_UINT_PACK16_ARM: VkFormat = 1000609006;
14546pub const VK_FORMAT_R14X2_UNORM_PACK16_ARM: VkFormat = 1000609009;
14547pub const VK_FORMAT_R16G16B16A16_SFLOAT: VkFormat = 97;
14548pub const VK_FORMAT_R16G16B16A16_SINT: VkFormat = 96;
14549pub const VK_FORMAT_R16G16B16A16_SNORM: VkFormat = 92;
14550pub const VK_FORMAT_R16G16B16A16_SSCALED: VkFormat = 94;
14551pub const VK_FORMAT_R16G16B16A16_UINT: VkFormat = 95;
14552pub const VK_FORMAT_R16G16B16A16_UNORM: VkFormat = 91;
14553pub const VK_FORMAT_R16G16B16A16_USCALED: VkFormat = 93;
14554pub const VK_FORMAT_R16G16B16_SFLOAT: VkFormat = 90;
14555pub const VK_FORMAT_R16G16B16_SINT: VkFormat = 89;
14556pub const VK_FORMAT_R16G16B16_SNORM: VkFormat = 85;
14557pub const VK_FORMAT_R16G16B16_SSCALED: VkFormat = 87;
14558pub const VK_FORMAT_R16G16B16_UINT: VkFormat = 88;
14559pub const VK_FORMAT_R16G16B16_UNORM: VkFormat = 84;
14560pub const VK_FORMAT_R16G16B16_USCALED: VkFormat = 86;
14561pub const VK_FORMAT_R16G16_S10_5_NV: VkFormat = VK_FORMAT_R16G16_SFIXED5_NV;
14562pub const VK_FORMAT_R16G16_SFIXED5_NV: VkFormat = 1000464000;
14563pub const VK_FORMAT_R16G16_SFLOAT: VkFormat = 83;
14564pub const VK_FORMAT_R16G16_SINT: VkFormat = 82;
14565pub const VK_FORMAT_R16G16_SNORM: VkFormat = 78;
14566pub const VK_FORMAT_R16G16_SSCALED: VkFormat = 80;
14567pub const VK_FORMAT_R16G16_UINT: VkFormat = 81;
14568pub const VK_FORMAT_R16G16_UNORM: VkFormat = 77;
14569pub const VK_FORMAT_R16G16_USCALED: VkFormat = 79;
14570pub const VK_FORMAT_R16_SFLOAT: VkFormat = 76;
14571pub const VK_FORMAT_R16_SINT: VkFormat = 75;
14572pub const VK_FORMAT_R16_SNORM: VkFormat = 71;
14573pub const VK_FORMAT_R16_SSCALED: VkFormat = 73;
14574pub const VK_FORMAT_R16_UINT: VkFormat = 74;
14575pub const VK_FORMAT_R16_UNORM: VkFormat = 70;
14576pub const VK_FORMAT_R16_USCALED: VkFormat = 72;
14577pub const VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = 109;
14578pub const VK_FORMAT_R32G32B32A32_SINT: VkFormat = 108;
14579pub const VK_FORMAT_R32G32B32A32_UINT: VkFormat = 107;
14580pub const VK_FORMAT_R32G32B32_SFLOAT: VkFormat = 106;
14581pub const VK_FORMAT_R32G32B32_SINT: VkFormat = 105;
14582pub const VK_FORMAT_R32G32B32_UINT: VkFormat = 104;
14583pub const VK_FORMAT_R32G32_SFLOAT: VkFormat = 103;
14584pub const VK_FORMAT_R32G32_SINT: VkFormat = 102;
14585pub const VK_FORMAT_R32G32_UINT: VkFormat = 101;
14586pub const VK_FORMAT_R32_SFLOAT: VkFormat = 100;
14587pub const VK_FORMAT_R32_SINT: VkFormat = 99;
14588pub const VK_FORMAT_R32_UINT: VkFormat = 98;
14589pub const VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormat = 2;
14590pub const VK_FORMAT_R4G4_UNORM_PACK8: VkFormat = 1;
14591pub const VK_FORMAT_R5G5B5A1_UNORM_PACK16: VkFormat = 6;
14592pub const VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormat = 4;
14593pub const VK_FORMAT_R64G64B64A64_SFLOAT: VkFormat = 121;
14594pub const VK_FORMAT_R64G64B64A64_SINT: VkFormat = 120;
14595pub const VK_FORMAT_R64G64B64A64_UINT: VkFormat = 119;
14596pub const VK_FORMAT_R64G64B64_SFLOAT: VkFormat = 118;
14597pub const VK_FORMAT_R64G64B64_SINT: VkFormat = 117;
14598pub const VK_FORMAT_R64G64B64_UINT: VkFormat = 116;
14599pub const VK_FORMAT_R64G64_SFLOAT: VkFormat = 115;
14600pub const VK_FORMAT_R64G64_SINT: VkFormat = 114;
14601pub const VK_FORMAT_R64G64_UINT: VkFormat = 113;
14602pub const VK_FORMAT_R64_SFLOAT: VkFormat = 112;
14603pub const VK_FORMAT_R64_SINT: VkFormat = 111;
14604pub const VK_FORMAT_R64_UINT: VkFormat = 110;
14605pub const VK_FORMAT_R8G8B8A8_SINT: VkFormat = 42;
14606pub const VK_FORMAT_R8G8B8A8_SNORM: VkFormat = 38;
14607pub const VK_FORMAT_R8G8B8A8_SRGB: VkFormat = 43;
14608pub const VK_FORMAT_R8G8B8A8_SSCALED: VkFormat = 40;
14609pub const VK_FORMAT_R8G8B8A8_UINT: VkFormat = 41;
14610pub const VK_FORMAT_R8G8B8A8_UNORM: VkFormat = 37;
14611pub const VK_FORMAT_R8G8B8A8_USCALED: VkFormat = 39;
14612pub const VK_FORMAT_R8G8B8_SINT: VkFormat = 28;
14613pub const VK_FORMAT_R8G8B8_SNORM: VkFormat = 24;
14614pub const VK_FORMAT_R8G8B8_SRGB: VkFormat = 29;
14615pub const VK_FORMAT_R8G8B8_SSCALED: VkFormat = 26;
14616pub const VK_FORMAT_R8G8B8_UINT: VkFormat = 27;
14617pub const VK_FORMAT_R8G8B8_UNORM: VkFormat = 23;
14618pub const VK_FORMAT_R8G8B8_USCALED: VkFormat = 25;
14619pub const VK_FORMAT_R8G8_SINT: VkFormat = 21;
14620pub const VK_FORMAT_R8G8_SNORM: VkFormat = 17;
14621pub const VK_FORMAT_R8G8_SRGB: VkFormat = 22;
14622pub const VK_FORMAT_R8G8_SSCALED: VkFormat = 19;
14623pub const VK_FORMAT_R8G8_UINT: VkFormat = 20;
14624pub const VK_FORMAT_R8G8_UNORM: VkFormat = 16;
14625pub const VK_FORMAT_R8G8_USCALED: VkFormat = 18;
14626pub const VK_FORMAT_R8_BOOL_ARM: VkFormat = 1000460000;
14627pub const VK_FORMAT_R8_SINT: VkFormat = 14;
14628pub const VK_FORMAT_R8_SNORM: VkFormat = 10;
14629pub const VK_FORMAT_R8_SRGB: VkFormat = 15;
14630pub const VK_FORMAT_R8_SSCALED: VkFormat = 12;
14631pub const VK_FORMAT_R8_UINT: VkFormat = 13;
14632pub const VK_FORMAT_R8_UNORM: VkFormat = 9;
14633pub const VK_FORMAT_R8_USCALED: VkFormat = 11;
14634pub const VK_FORMAT_S8_UINT: VkFormat = 127;
14635pub const VK_FORMAT_UNDEFINED: VkFormat = 0;
14636pub const VK_FORMAT_X8_D24_UNORM_PACK32: VkFormat = 125;
14637pub const VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 14;
14638pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV: VkFragmentShadingRateNV = 1;
14639pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV: VkFragmentShadingRateNV = 4;
14640pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV: VkFragmentShadingRateNV = 5;
14641pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV: VkFragmentShadingRateNV = 6;
14642pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV: VkFragmentShadingRateNV = 9;
14643pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV: VkFragmentShadingRateNV = 10;
14644pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV: VkFragmentShadingRateNV = 0;
14645pub const VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 11;
14646pub const VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 12;
14647pub const VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 13;
14648pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR: VkFragmentShadingRateCombinerOpKHR = 0;
14649pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR: VkFragmentShadingRateCombinerOpKHR = 3;
14650pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR: VkFragmentShadingRateCombinerOpKHR = 2;
14651pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR: VkFragmentShadingRateCombinerOpKHR = 4;
14652pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR: VkFragmentShadingRateCombinerOpKHR = 1;
14653pub const VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV: VkFragmentShadingRateNV = 15;
14654pub const VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV: VkFragmentShadingRateTypeNV = 1;
14655pub const VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV: VkFragmentShadingRateTypeNV = 0;
14656pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT: VkFramebufferCreateFlagBits = 1 << 0;
14657pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR: VkFramebufferCreateFlagBits = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT;
14658pub const VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT: VkFrameBoundaryFlagBitsEXT = 1 << 0;
14659pub const VK_FRONT_FACE_CLOCKWISE: VkFrontFace = 1;
14660pub const VK_FRONT_FACE_COUNTER_CLOCKWISE: VkFrontFace = 0;
14661pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkGeometryInstanceFlagBitsKHR = 1 << 5;
14662pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT;
14663pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 3;
14664pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR;
14665pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT: VkGeometryInstanceFlagBitsKHR = 1 << 4;
14666pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT;
14667pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 2;
14668pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR;
14669pub const VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR;
14670pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 0;
14671pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 1;
14672pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR;
14673pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR;
14674pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR: VkGeometryFlagBitsKHR = 1 << 1;
14675pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV: VkGeometryFlagBitsKHR = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR;
14676pub const VK_GEOMETRY_OPAQUE_BIT_KHR: VkGeometryFlagBitsKHR = 1 << 0;
14677pub const VK_GEOMETRY_OPAQUE_BIT_NV: VkGeometryFlagBitsKHR = VK_GEOMETRY_OPAQUE_BIT_KHR;
14678pub const VK_GEOMETRY_TYPE_AABBS_KHR: VkGeometryTypeKHR = 1;
14679pub const VK_GEOMETRY_TYPE_AABBS_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_AABBS_KHR;
14680pub const VK_GEOMETRY_TYPE_INSTANCES_KHR: VkGeometryTypeKHR = 2;
14681pub const VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV: VkGeometryTypeKHR = 1000429005;
14682pub const VK_GEOMETRY_TYPE_SPHERES_NV: VkGeometryTypeKHR = 1000429004;
14683pub const VK_GEOMETRY_TYPE_TRIANGLES_KHR: VkGeometryTypeKHR = 0;
14684pub const VK_GEOMETRY_TYPE_TRIANGLES_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
14685pub const VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME: &CStr = c"VK_GOOGLE_decorate_string";
14686pub const VK_GOOGLE_DECORATE_STRING_SPEC_VERSION: u32 = 1;
14687pub const VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME: &CStr = c"VK_GOOGLE_display_timing";
14688pub const VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION: u32 = 1;
14689pub const VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME: &CStr = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME;
14690pub const VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION: u32 = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION;
14691pub const VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME: &CStr = c"VK_GOOGLE_hlsl_functionality1";
14692pub const VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION: u32 = 1;
14693pub const VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME: &CStr = c"VK_GOOGLE_surfaceless_query";
14694pub const VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION: u32 = 2;
14695pub const VK_GOOGLE_USER_TYPE_EXTENSION_NAME: &CStr = c"VK_GOOGLE_user_type";
14696pub const VK_GOOGLE_USER_TYPE_SPEC_VERSION: u32 = 1;
14697pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 3;
14698pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 2;
14699pub const VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 1;
14700pub const VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 0;
14701pub const VK_HEADER_VERSION: u32 = 341;
14702pub const VK_HEADER_VERSION_COMPLETE: u32 = VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION);
14703pub const VK_HOST_IMAGE_COPY_MEMCPY: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
14704pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT: VkHostImageCopyFlagBits = 1 << 0;
14705pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
14706pub const VK_HOST_IMAGE_COPY_MEMCPY_EXT: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
14707pub const VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME: &CStr = c"VK_HUAWEI_cluster_culling_shader";
14708pub const VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION: u32 = 3;
14709pub const VK_HUAWEI_HDR_VIVID_EXTENSION_NAME: &CStr = c"VK_HUAWEI_hdr_vivid";
14710pub const VK_HUAWEI_HDR_VIVID_SPEC_VERSION: u32 = 1;
14711pub const VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME: &CStr = c"VK_HUAWEI_invocation_mask";
14712pub const VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION: u32 = 1;
14713pub const VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME: &CStr = c"VK_HUAWEI_subpass_shading";
14714pub const VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION: u32 = 3;
14715pub const VK_IMAGE_ASPECT_COLOR_BIT: VkImageAspectFlagBits = 1 << 0;
14716pub const VK_IMAGE_ASPECT_DEPTH_BIT: VkImageAspectFlagBits = 1 << 1;
14717pub const VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT: VkImageAspectFlagBits = 1 << 7;
14718pub const VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT: VkImageAspectFlagBits = 1 << 8;
14719pub const VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT: VkImageAspectFlagBits = 1 << 9;
14720pub const VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT: VkImageAspectFlagBits = 1 << 10;
14721pub const VK_IMAGE_ASPECT_METADATA_BIT: VkImageAspectFlagBits = 1 << 3;
14722pub const VK_IMAGE_ASPECT_NONE: VkImageAspectFlagBits = 0;
14723pub const VK_IMAGE_ASPECT_NONE_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_NONE;
14724pub const VK_IMAGE_ASPECT_PLANE_0_BIT: VkImageAspectFlagBits = 1 << 4;
14725pub const VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_0_BIT;
14726pub const VK_IMAGE_ASPECT_PLANE_1_BIT: VkImageAspectFlagBits = 1 << 5;
14727pub const VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_1_BIT;
14728pub const VK_IMAGE_ASPECT_PLANE_2_BIT: VkImageAspectFlagBits = 1 << 6;
14729pub const VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_2_BIT;
14730pub const VK_IMAGE_ASPECT_STENCIL_BIT: VkImageAspectFlagBits = 1 << 2;
14731pub const VK_IMAGE_COMPRESSION_DEFAULT_EXT: VkImageCompressionFlagBitsEXT = 0;
14732pub const VK_IMAGE_COMPRESSION_DISABLED_EXT: VkImageCompressionFlagBitsEXT = 1 << 2;
14733pub const VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 9;
14734pub const VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 10;
14735pub const VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 11;
14736pub const VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 12;
14737pub const VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 13;
14738pub const VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 14;
14739pub const VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 15;
14740pub const VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 16;
14741pub const VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 17;
14742pub const VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 18;
14743pub const VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 0;
14744pub const VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 19;
14745pub const VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 20;
14746pub const VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 21;
14747pub const VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 22;
14748pub const VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 23;
14749pub const VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 1;
14750pub const VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 2;
14751pub const VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 3;
14752pub const VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 4;
14753pub const VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 5;
14754pub const VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 6;
14755pub const VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 7;
14756pub const VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 8;
14757pub const VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT: VkImageCompressionFlagBitsEXT = 1 << 0;
14758pub const VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT: VkImageCompressionFlagBitsEXT = 1 << 1;
14759pub const VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT: VkImageCompressionFixedRateFlagBitsEXT = 0;
14760pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 5;
14761pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
14762pub const VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT: VkImageCreateFlagBits = 1 << 17;
14763pub const VK_IMAGE_CREATE_ALIAS_BIT: VkImageCreateFlagBits = 1 << 10;
14764pub const VK_IMAGE_CREATE_ALIAS_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_ALIAS_BIT;
14765pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 7;
14766pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT;
14767pub const VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV: VkImageCreateFlagBits = 1 << 13;
14768pub const VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 4;
14769pub const VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageCreateFlagBits = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT;
14770pub const VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT: VkImageCreateFlagBits = 1 << 16;
14771pub const VK_IMAGE_CREATE_DISJOINT_BIT: VkImageCreateFlagBits = 1 << 9;
14772pub const VK_IMAGE_CREATE_DISJOINT_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_DISJOINT_BIT;
14773pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT: VkImageCreateFlagBits = 1 << 8;
14774pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
14775pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT: VkImageCreateFlagBits = 1 << 15;
14776pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: VkImageCreateFlagBits = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT;
14777pub const VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: VkImageCreateFlagBits = 1 << 18;
14778pub const VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT: VkImageCreateFlagBits = 1 << 3;
14779pub const VK_IMAGE_CREATE_PROTECTED_BIT: VkImageCreateFlagBits = 1 << 11;
14780pub const VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT: VkImageCreateFlagBits = 1 << 12;
14781pub const VK_IMAGE_CREATE_SPARSE_ALIASED_BIT: VkImageCreateFlagBits = 1 << 2;
14782pub const VK_IMAGE_CREATE_SPARSE_BINDING_BIT: VkImageCreateFlagBits = 1 << 0;
14783pub const VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT: VkImageCreateFlagBits = 1 << 1;
14784pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT: VkImageCreateFlagBits = 1 << 6;
14785pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT;
14786pub const VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT: VkImageCreateFlagBits = 1 << 14;
14787pub const VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkImageCreateFlagBits = 1 << 20;
14788pub const VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: VkImageLayout = 1000339000;
14789pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: VkImageLayout = 1000314001;
14790pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL;
14791pub const VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = 2;
14792pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241000;
14793pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
14794pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000117001;
14795pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
14796pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL: VkImageLayout = 1000241001;
14797pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
14798pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000117000;
14799pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
14800pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 3;
14801pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 4;
14802pub const VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: VkImageLayout = 1000218000;
14803pub const VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = 1000164003;
14804pub const VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = 1;
14805pub const VK_IMAGE_LAYOUT_PREINITIALIZED: VkImageLayout = 8;
14806pub const VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = 1000001002;
14807pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL: VkImageLayout = 1000314000;
14808pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL;
14809pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ: VkImageLayout = 1000232000;
14810pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR: VkImageLayout = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ;
14811pub const VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = 5;
14812pub const VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV: VkImageLayout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
14813pub const VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: VkImageLayout = 1000111000;
14814pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241002;
14815pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
14816pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000241003;
14817pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL;
14818pub const VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM: VkImageLayout = 1000460000;
14819pub const VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = 7;
14820pub const VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = 6;
14821pub const VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = 0;
14822pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR: VkImageLayout = 1000024002;
14823pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR: VkImageLayout = 1000024000;
14824pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR: VkImageLayout = 1000024001;
14825pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR: VkImageLayout = 1000299002;
14826pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR: VkImageLayout = 1000299000;
14827pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR: VkImageLayout = 1000553000;
14828pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR: VkImageLayout = 1000299001;
14829pub const VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT: VkImageLayout = 1000620000;
14830pub const VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: VkImageTiling = 1000158000;
14831pub const VK_IMAGE_TILING_LINEAR: VkImageTiling = 1;
14832pub const VK_IMAGE_TILING_OPTIMAL: VkImageTiling = 0;
14833pub const VK_IMAGE_TYPE_1D: VkImageType = 0;
14834pub const VK_IMAGE_TYPE_2D: VkImageType = 1;
14835pub const VK_IMAGE_TYPE_3D: VkImageType = 2;
14836pub const VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkImageUsageFlagBits = 1 << 19;
14837pub const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 4;
14838pub const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 5;
14839pub const VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkImageUsageFlagBits = 1 << 9;
14840pub const VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkImageUsageFlagBits = 1 << 8;
14841pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT: VkImageUsageFlagBits = 1 << 22;
14842pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT: VkImageUsageFlagBits = VK_IMAGE_USAGE_HOST_TRANSFER_BIT;
14843pub const VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 7;
14844pub const VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI: VkImageUsageFlagBits = 1 << 18;
14845pub const VK_IMAGE_USAGE_SAMPLED_BIT: VkImageUsageFlagBits = 1 << 2;
14846pub const VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM: VkImageUsageFlagBits = 1 << 21;
14847pub const VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM: VkImageUsageFlagBits = 1 << 20;
14848pub const VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV: VkImageUsageFlagBits = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
14849pub const VK_IMAGE_USAGE_STORAGE_BIT: VkImageUsageFlagBits = 1 << 3;
14850pub const VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM: VkImageUsageFlagBits = 1 << 23;
14851pub const VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM: VkImageUsageFlagBits = 1 << 27;
14852pub const VK_IMAGE_USAGE_TRANSFER_DST_BIT: VkImageUsageFlagBits = 1 << 1;
14853pub const VK_IMAGE_USAGE_TRANSFER_SRC_BIT: VkImageUsageFlagBits = 1 << 0;
14854pub const VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 6;
14855pub const VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR: VkImageUsageFlagBits = 1 << 12;
14856pub const VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkImageUsageFlagBits = 1 << 10;
14857pub const VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkImageUsageFlagBits = 1 << 11;
14858pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR: VkImageUsageFlagBits = 1 << 15;
14859pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkImageUsageFlagBits = 1 << 13;
14860pub const VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkImageUsageFlagBits = 1 << 26;
14861pub const VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkImageUsageFlagBits = 1 << 25;
14862pub const VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkImageUsageFlagBits = 1 << 14;
14863pub const VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageViewCreateFlagBits = 1 << 2;
14864pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT: VkImageViewCreateFlagBits = 1 << 1;
14865pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT: VkImageViewCreateFlagBits = 1 << 0;
14866pub const VK_IMAGE_VIEW_TYPE_1D: VkImageViewType = 0;
14867pub const VK_IMAGE_VIEW_TYPE_1D_ARRAY: VkImageViewType = 4;
14868pub const VK_IMAGE_VIEW_TYPE_2D: VkImageViewType = 1;
14869pub const VK_IMAGE_VIEW_TYPE_2D_ARRAY: VkImageViewType = 5;
14870pub const VK_IMAGE_VIEW_TYPE_3D: VkImageViewType = 2;
14871pub const VK_IMAGE_VIEW_TYPE_CUBE: VkImageViewType = 3;
14872pub const VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: VkImageViewType = 6;
14873pub const VK_IMG_FILTER_CUBIC_EXTENSION_NAME: &CStr = c"VK_IMG_filter_cubic";
14874pub const VK_IMG_FILTER_CUBIC_SPEC_VERSION: u32 = 1;
14875pub const VK_IMG_FORMAT_PVRTC_EXTENSION_NAME: &CStr = c"VK_IMG_format_pvrtc";
14876pub const VK_IMG_FORMAT_PVRTC_SPEC_VERSION: u32 = 1;
14877pub const VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_IMG_relaxed_line_rasterization";
14878pub const VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
14879pub const VK_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = 1000482000;
14880pub const VK_INCOMPLETE: VkResult = 5;
14881pub const VK_INDEX_TYPE_NONE_KHR: VkIndexType = 1000165000;
14882pub const VK_INDEX_TYPE_NONE_NV: VkIndexType = VK_INDEX_TYPE_NONE_KHR;
14883pub const VK_INDEX_TYPE_UINT16: VkIndexType = 0;
14884pub const VK_INDEX_TYPE_UINT32: VkIndexType = 1;
14885pub const VK_INDEX_TYPE_UINT8: VkIndexType = 1000265000;
14886pub const VK_INDEX_TYPE_UINT8_EXT: VkIndexType = VK_INDEX_TYPE_UINT8;
14887pub const VK_INDEX_TYPE_UINT8_KHR: VkIndexType = VK_INDEX_TYPE_UINT8;
14888pub const VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagBitsEXT = 1 << 1;
14889pub const VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagBitsEXT = 1 << 0;
14890pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: VkIndirectCommandsLayoutUsageFlagBitsEXT = 1 << 0;
14891pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 0;
14892pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 1;
14893pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: VkIndirectCommandsLayoutUsageFlagBitsEXT = 1 << 1;
14894pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 2;
14895pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: VkIndirectCommandsTokenTypeEXT = 9;
14896pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV: VkIndirectCommandsTokenTypeNV = 1000428004;
14897pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 8;
14898pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: VkIndirectCommandsTokenTypeEXT = 6;
14899pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 7;
14900pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: VkIndirectCommandsTokenTypeEXT = 5;
14901pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV: VkIndirectCommandsTokenTypeNV = 5;
14902pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 1000328001;
14903pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: VkIndirectCommandsTokenTypeEXT = 1000202003;
14904pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: VkIndirectCommandsTokenTypeEXT = 1000328000;
14905pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV: VkIndirectCommandsTokenTypeNV = 1000328000;
14906pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: VkIndirectCommandsTokenTypeEXT = 1000202002;
14907pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV: VkIndirectCommandsTokenTypeNV = 6;
14908pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV: VkIndirectCommandsTokenTypeNV = 7;
14909pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: VkIndirectCommandsTokenTypeEXT = 0;
14910pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = 3;
14911pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = 2;
14912pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV: VkIndirectCommandsTokenTypeNV = 1000428003;
14913pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: VkIndirectCommandsTokenTypeEXT = 1;
14914pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV: VkIndirectCommandsTokenTypeNV = 4;
14915pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT: VkIndirectCommandsTokenTypeEXT = 1000135000;
14916pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV: VkIndirectCommandsTokenTypeNV = 1000135000;
14917pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT: VkIndirectCommandsTokenTypeEXT = 1000135001;
14918pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: VkIndirectCommandsTokenTypeEXT = 2;
14919pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV: VkIndirectCommandsTokenTypeNV = 0;
14920pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV: VkIndirectCommandsTokenTypeNV = 1;
14921pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: VkIndirectCommandsTokenTypeEXT = 1000386004;
14922pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = 4;
14923pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = 3;
14924pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: VkIndirectExecutionSetInfoTypeEXT = 0;
14925pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: VkIndirectExecutionSetInfoTypeEXT = 1;
14926pub const VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV: VkIndirectStateFlagBitsNV = 1 << 0;
14927pub const VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR: VkInstanceCreateFlagBits = 1 << 0;
14928pub const VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME: &CStr = c"VK_INTEL_performance_query";
14929pub const VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION: u32 = 2;
14930pub const VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME: &CStr = c"VK_INTEL_shader_integer_functions2";
14931pub const VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION: u32 = 1;
14932pub const VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE: VkInternalAllocationType = 0;
14933pub const VK_KHR_16BIT_STORAGE_EXTENSION_NAME: &CStr = c"VK_KHR_16bit_storage";
14934pub const VK_KHR_16BIT_STORAGE_SPEC_VERSION: u32 = 1;
14935pub const VK_KHR_8BIT_STORAGE_EXTENSION_NAME: &CStr = c"VK_KHR_8bit_storage";
14936pub const VK_KHR_8BIT_STORAGE_SPEC_VERSION: u32 = 1;
14937pub const VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_KHR_acceleration_structure";
14938pub const VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 13;
14939pub const VK_KHR_BIND_MEMORY_2_EXTENSION_NAME: &CStr = c"VK_KHR_bind_memory2";
14940pub const VK_KHR_BIND_MEMORY_2_SPEC_VERSION: u32 = 1;
14941pub const VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME: &CStr = c"VK_KHR_buffer_device_address";
14942pub const VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION: u32 = 1;
14943pub const VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME: &CStr = c"VK_KHR_calibrated_timestamps";
14944pub const VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION: u32 = 1;
14945pub const VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME: &CStr = c"VK_KHR_compute_shader_derivatives";
14946pub const VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION: u32 = 1;
14947pub const VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME: &CStr = c"VK_KHR_cooperative_matrix";
14948pub const VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION: u32 = 2;
14949pub const VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME: &CStr = c"VK_KHR_copy_commands2";
14950pub const VK_KHR_COPY_COMMANDS_2_SPEC_VERSION: u32 = 1;
14951pub const VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME: &CStr = c"VK_KHR_copy_memory_indirect";
14952pub const VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION: u32 = 1;
14953pub const VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME: &CStr = c"VK_KHR_create_renderpass2";
14954pub const VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION: u32 = 1;
14955pub const VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME: &CStr = c"VK_KHR_dedicated_allocation";
14956pub const VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION: u32 = 3;
14957pub const VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME: &CStr = c"VK_KHR_deferred_host_operations";
14958pub const VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION: u32 = 4;
14959pub const VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME: &CStr = c"VK_KHR_depth_clamp_zero_one";
14960pub const VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION: u32 = 1;
14961pub const VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME: &CStr = c"VK_KHR_depth_stencil_resolve";
14962pub const VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION: u32 = 1;
14963pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME: &CStr = c"VK_KHR_descriptor_update_template";
14964pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION: u32 = 1;
14965pub const VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME: &CStr = c"VK_KHR_device_group_creation";
14966pub const VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION: u32 = 1;
14967pub const VK_KHR_DEVICE_GROUP_EXTENSION_NAME: &CStr = c"VK_KHR_device_group";
14968pub const VK_KHR_DEVICE_GROUP_SPEC_VERSION: u32 = 4;
14969pub const VK_KHR_DISPLAY_EXTENSION_NAME: &CStr = c"VK_KHR_display";
14970pub const VK_KHR_DISPLAY_SPEC_VERSION: u32 = 23;
14971pub const VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_KHR_display_swapchain";
14972pub const VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION: u32 = 10;
14973pub const VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME: &CStr = c"VK_KHR_draw_indirect_count";
14974pub const VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION: u32 = 1;
14975pub const VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_KHR_driver_properties";
14976pub const VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION: u32 = 1;
14977pub const VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME: &CStr = c"VK_KHR_dynamic_rendering";
14978pub const VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME: &CStr = c"VK_KHR_dynamic_rendering_local_read";
14979pub const VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION: u32 = 1;
14980pub const VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION: u32 = 1;
14981pub const VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence_capabilities";
14982pub const VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION: u32 = 1;
14983pub const VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence";
14984pub const VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence_fd";
14985pub const VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION: u32 = 1;
14986pub const VK_KHR_EXTERNAL_FENCE_SPEC_VERSION: u32 = 1;
14987pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory_capabilities";
14988pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: u32 = 1;
14989pub const VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory";
14990pub const VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory_fd";
14991pub const VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION: u32 = 1;
14992pub const VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION: u32 = 1;
14993pub const VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore_capabilities";
14994pub const VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION: u32 = 1;
14995pub const VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore";
14996pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore_fd";
14997pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION: u32 = 1;
14998pub const VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION: u32 = 1;
14999pub const VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME: &CStr = c"VK_KHR_format_feature_flags2";
15000pub const VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION: u32 = 2;
15001pub const VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME: &CStr = c"VK_KHR_fragment_shader_barycentric";
15002pub const VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION: u32 = 1;
15003pub const VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME: &CStr = c"VK_KHR_fragment_shading_rate";
15004pub const VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION: u32 = 2;
15005pub const VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_display_properties2";
15006pub const VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION: u32 = 1;
15007pub const VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_memory_requirements2";
15008pub const VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION: u32 = 1;
15009pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_physical_device_properties2";
15010pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION: u32 = 2;
15011pub const VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_surface_capabilities2";
15012pub const VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION: u32 = 1;
15013pub const VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME: &CStr = c"VK_KHR_global_priority";
15014pub const VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION: u32 = 1;
15015pub const VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME: &CStr = c"VK_KHR_imageless_framebuffer";
15016pub const VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION: u32 = 1;
15017pub const VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME: &CStr = c"VK_KHR_image_format_list";
15018pub const VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION: u32 = 1;
15019pub const VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME: &CStr = c"VK_KHR_incremental_present";
15020pub const VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION: u32 = 2;
15021pub const VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME: &CStr = c"VK_KHR_index_type_uint8";
15022pub const VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION: u32 = 1;
15023pub const VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME: &CStr = c"VK_KHR_internally_synchronized_queues";
15024pub const VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION: u32 = 1;
15025pub const VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_KHR_line_rasterization";
15026pub const VK_KHR_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
15027pub const VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME: &CStr = c"VK_KHR_load_store_op_none";
15028pub const VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION: u32 = 1;
15029pub const VK_KHR_MAINTENANCE1_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_1_EXTENSION_NAME;
15030pub const VK_KHR_MAINTENANCE1_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_1_SPEC_VERSION;
15031pub const VK_KHR_MAINTENANCE2_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_2_EXTENSION_NAME;
15032pub const VK_KHR_MAINTENANCE2_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_2_SPEC_VERSION;
15033pub const VK_KHR_MAINTENANCE3_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_3_EXTENSION_NAME;
15034pub const VK_KHR_MAINTENANCE3_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_3_SPEC_VERSION;
15035pub const VK_KHR_MAINTENANCE_10_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance10";
15036pub const VK_KHR_MAINTENANCE_10_SPEC_VERSION: u32 = 1;
15037pub const VK_KHR_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance1";
15038pub const VK_KHR_MAINTENANCE_1_SPEC_VERSION: u32 = 2;
15039pub const VK_KHR_MAINTENANCE_2_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance2";
15040pub const VK_KHR_MAINTENANCE_2_SPEC_VERSION: u32 = 1;
15041pub const VK_KHR_MAINTENANCE_3_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance3";
15042pub const VK_KHR_MAINTENANCE_3_SPEC_VERSION: u32 = 1;
15043pub const VK_KHR_MAINTENANCE_4_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance4";
15044pub const VK_KHR_MAINTENANCE_4_SPEC_VERSION: u32 = 2;
15045pub const VK_KHR_MAINTENANCE_5_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance5";
15046pub const VK_KHR_MAINTENANCE_5_SPEC_VERSION: u32 = 1;
15047pub const VK_KHR_MAINTENANCE_6_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance6";
15048pub const VK_KHR_MAINTENANCE_6_SPEC_VERSION: u32 = 1;
15049pub const VK_KHR_MAINTENANCE_7_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance7";
15050pub const VK_KHR_MAINTENANCE_7_SPEC_VERSION: u32 = 1;
15051pub const VK_KHR_MAINTENANCE_8_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance8";
15052pub const VK_KHR_MAINTENANCE_8_SPEC_VERSION: u32 = 1;
15053pub const VK_KHR_MAINTENANCE_9_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance9";
15054pub const VK_KHR_MAINTENANCE_9_SPEC_VERSION: u32 = 1;
15055pub const VK_KHR_MAP_MEMORY_2_EXTENSION_NAME: &CStr = c"VK_KHR_map_memory2";
15056pub const VK_KHR_MAP_MEMORY_2_SPEC_VERSION: u32 = 1;
15057pub const VK_KHR_MULTIVIEW_EXTENSION_NAME: &CStr = c"VK_KHR_multiview";
15058pub const VK_KHR_MULTIVIEW_SPEC_VERSION: u32 = 1;
15059pub const VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME: &CStr = c"VK_KHR_performance_query";
15060pub const VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION: u32 = 1;
15061pub const VK_KHR_PIPELINE_BINARY_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_binary";
15062pub const VK_KHR_PIPELINE_BINARY_SPEC_VERSION: u32 = 1;
15063pub const VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_executable_properties";
15064pub const VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION: u32 = 1;
15065pub const VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_library";
15066pub const VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION: u32 = 1;
15067pub const VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME: &CStr = c"VK_KHR_portability_enumeration";
15068pub const VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION: u32 = 1;
15069pub const VK_KHR_PRESENT_ID_2_EXTENSION_NAME: &CStr = c"VK_KHR_present_id2";
15070pub const VK_KHR_PRESENT_ID_2_SPEC_VERSION: u32 = 1;
15071pub const VK_KHR_PRESENT_ID_EXTENSION_NAME: &CStr = c"VK_KHR_present_id";
15072pub const VK_KHR_PRESENT_ID_SPEC_VERSION: u32 = 1;
15073pub const VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME: &CStr = c"VK_KHR_present_mode_fifo_latest_ready";
15074pub const VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION: u32 = 1;
15075pub const VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME: &CStr = c"VK_KHR_present_wait2";
15076pub const VK_KHR_PRESENT_WAIT_2_SPEC_VERSION: u32 = 1;
15077pub const VK_KHR_PRESENT_WAIT_EXTENSION_NAME: &CStr = c"VK_KHR_present_wait";
15078pub const VK_KHR_PRESENT_WAIT_SPEC_VERSION: u32 = 1;
15079pub const VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME: &CStr = c"VK_KHR_push_descriptor";
15080pub const VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION: u32 = 2;
15081pub const VK_KHR_RAY_QUERY_EXTENSION_NAME: &CStr = c"VK_KHR_ray_query";
15082pub const VK_KHR_RAY_QUERY_SPEC_VERSION: u32 = 1;
15083pub const VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_maintenance1";
15084pub const VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15085pub const VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_pipeline";
15086pub const VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION: u32 = 1;
15087pub const VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_position_fetch";
15088pub const VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION: u32 = 1;
15089pub const VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_relaxed_block_layout";
15090pub const VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION: u32 = 1;
15091pub const VK_KHR_ROBUSTNESS_2_EXTENSION_NAME: &CStr = c"VK_KHR_robustness2";
15092pub const VK_KHR_ROBUSTNESS_2_SPEC_VERSION: u32 = 1;
15093pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME: &CStr = c"VK_KHR_sampler_mirror_clamp_to_edge";
15094pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION: u32 = 3;
15095pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME: &CStr = c"VK_KHR_sampler_ycbcr_conversion";
15096pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION: u32 = 14;
15097pub const VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME: &CStr = c"VK_KHR_separate_depth_stencil_layouts";
15098pub const VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION: u32 = 1;
15099pub const VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME: &CStr = c"VK_KHR_shader_atomic_int64";
15100pub const VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION: u32 = 1;
15101pub const VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME: &CStr = c"VK_KHR_shader_bfloat16";
15102pub const VK_KHR_SHADER_BFLOAT16_SPEC_VERSION: u32 = 1;
15103pub const VK_KHR_SHADER_CLOCK_EXTENSION_NAME: &CStr = c"VK_KHR_shader_clock";
15104pub const VK_KHR_SHADER_CLOCK_SPEC_VERSION: u32 = 1;
15105pub const VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_draw_parameters";
15106pub const VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION: u32 = 1;
15107pub const VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME: &CStr = c"VK_KHR_shader_expect_assume";
15108pub const VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION: u32 = 1;
15109pub const VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float16_int8";
15110pub const VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION: u32 = 1;
15111pub const VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float_controls2";
15112pub const VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION: u32 = 1;
15113pub const VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float_controls";
15114pub const VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION: u32 = 4;
15115pub const VK_KHR_SHADER_FMA_EXTENSION_NAME: &CStr = c"VK_KHR_shader_fma";
15116pub const VK_KHR_SHADER_FMA_SPEC_VERSION: u32 = 1;
15117pub const VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME: &CStr = c"VK_KHR_shader_integer_dot_product";
15118pub const VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION: u32 = 1;
15119pub const VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME: &CStr = c"VK_KHR_shader_maximal_reconvergence";
15120pub const VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION: u32 = 1;
15121pub const VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME: &CStr = c"VK_KHR_shader_non_semantic_info";
15122pub const VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION: u32 = 1;
15123pub const VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME: &CStr = c"VK_KHR_shader_quad_control";
15124pub const VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION: u32 = 1;
15125pub const VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME: &CStr = c"VK_KHR_shader_relaxed_extended_instruction";
15126pub const VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION: u32 = 1;
15127pub const VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_extended_types";
15128pub const VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION: u32 = 1;
15129pub const VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_rotate";
15130pub const VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION: u32 = 2;
15131pub const VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_uniform_control_flow";
15132pub const VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION: u32 = 1;
15133pub const VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME: &CStr = c"VK_KHR_shader_terminate_invocation";
15134pub const VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION: u32 = 1;
15135pub const VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_untyped_pointers";
15136pub const VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION: u32 = 1;
15137pub const VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME: &CStr = c"VK_KHR_shared_presentable_image";
15138pub const VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION: u32 = 1;
15139pub const VK_KHR_SPIRV_1_4_EXTENSION_NAME: &CStr = c"VK_KHR_spirv_1_4";
15140pub const VK_KHR_SPIRV_1_4_SPEC_VERSION: u32 = 1;
15141pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME: &CStr = c"VK_KHR_storage_buffer_storage_class";
15142pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION: u32 = 1;
15143pub const VK_KHR_SURFACE_EXTENSION_NAME: &CStr = c"VK_KHR_surface";
15144pub const VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_surface_maintenance1";
15145pub const VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15146pub const VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_surface_protected_capabilities";
15147pub const VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION: u32 = 1;
15148pub const VK_KHR_SURFACE_SPEC_VERSION: u32 = 25;
15149pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain";
15150pub const VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain_maintenance1";
15151pub const VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15152pub const VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain_mutable_format";
15153pub const VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION: u32 = 1;
15154pub const VK_KHR_SWAPCHAIN_SPEC_VERSION: u32 = 70;
15155pub const VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME: &CStr = c"VK_KHR_synchronization2";
15156pub const VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION: u32 = 1;
15157pub const VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME: &CStr = c"VK_KHR_timeline_semaphore";
15158pub const VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION: u32 = 2;
15159pub const VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME: &CStr = c"VK_KHR_unified_image_layouts";
15160pub const VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION: u32 = 1;
15161pub const VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_uniform_buffer_standard_layout";
15162pub const VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION: u32 = 1;
15163pub const VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME: &CStr = c"VK_KHR_variable_pointers";
15164pub const VK_KHR_VARIABLE_POINTERS_SPEC_VERSION: u32 = 1;
15165pub const VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME: &CStr = c"VK_KHR_vertex_attribute_divisor";
15166pub const VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION: u32 = 1;
15167pub const VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_av1";
15168pub const VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION: u32 = 1;
15169pub const VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_h264";
15170pub const VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION: u32 = 9;
15171pub const VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_h265";
15172pub const VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION: u32 = 8;
15173pub const VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_queue";
15174pub const VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION: u32 = 8;
15175pub const VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_vp9";
15176pub const VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION: u32 = 1;
15177pub const VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_av1";
15178pub const VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION: u32 = 1;
15179pub const VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_h264";
15180pub const VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION: u32 = 14;
15181pub const VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_h265";
15182pub const VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION: u32 = 14;
15183pub const VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_intra_refresh";
15184pub const VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION: u32 = 1;
15185pub const VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_quantization_map";
15186pub const VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION: u32 = 2;
15187pub const VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_queue";
15188pub const VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION: u32 = 12;
15189pub const VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_video_maintenance1";
15190pub const VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15191pub const VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME: &CStr = c"VK_KHR_video_maintenance2";
15192pub const VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION: u32 = 1;
15193pub const VK_KHR_VIDEO_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_queue";
15194pub const VK_KHR_VIDEO_QUEUE_SPEC_VERSION: u32 = 8;
15195pub const VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME: &CStr = c"VK_KHR_vulkan_memory_model";
15196pub const VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION: u32 = 3;
15197pub const VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_workgroup_memory_explicit_layout";
15198pub const VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION: u32 = 1;
15199pub const VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME: &CStr = c"VK_KHR_zero_initialize_workgroup_memory";
15200pub const VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION: u32 = 1;
15201pub const VK_LATENCY_MARKER_INPUT_SAMPLE_NV: VkLatencyMarkerNV = 6;
15202pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV: VkLatencyMarkerNV = 11;
15203pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV: VkLatencyMarkerNV = 10;
15204pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = 9;
15205pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = 8;
15206pub const VK_LATENCY_MARKER_PRESENT_END_NV: VkLatencyMarkerNV = 5;
15207pub const VK_LATENCY_MARKER_PRESENT_START_NV: VkLatencyMarkerNV = 4;
15208pub const VK_LATENCY_MARKER_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = 3;
15209pub const VK_LATENCY_MARKER_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = 2;
15210pub const VK_LATENCY_MARKER_SIMULATION_END_NV: VkLatencyMarkerNV = 1;
15211pub const VK_LATENCY_MARKER_SIMULATION_START_NV: VkLatencyMarkerNV = 0;
15212pub const VK_LATENCY_MARKER_TRIGGER_FLASH_NV: VkLatencyMarkerNV = 7;
15213pub const VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT: VkLayeredDriverUnderlyingApiMSFT = 1;
15214pub const VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT: VkLayeredDriverUnderlyingApiMSFT = 0;
15215pub const VK_LAYER_SETTING_TYPE_BOOL32_EXT: VkLayerSettingTypeEXT = 0;
15216pub const VK_LAYER_SETTING_TYPE_FLOAT32_EXT: VkLayerSettingTypeEXT = 5;
15217pub const VK_LAYER_SETTING_TYPE_FLOAT64_EXT: VkLayerSettingTypeEXT = 6;
15218pub const VK_LAYER_SETTING_TYPE_INT32_EXT: VkLayerSettingTypeEXT = 1;
15219pub const VK_LAYER_SETTING_TYPE_INT64_EXT: VkLayerSettingTypeEXT = 2;
15220pub const VK_LAYER_SETTING_TYPE_STRING_EXT: VkLayerSettingTypeEXT = 7;
15221pub const VK_LAYER_SETTING_TYPE_UINT32_EXT: VkLayerSettingTypeEXT = 3;
15222pub const VK_LAYER_SETTING_TYPE_UINT64_EXT: VkLayerSettingTypeEXT = 4;
15223pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM: VkLineRasterizationMode = 2;
15224pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
15225pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
15226pub const VK_LINE_RASTERIZATION_MODE_DEFAULT: VkLineRasterizationMode = 0;
15227pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
15228pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
15229pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR: VkLineRasterizationMode = 1;
15230pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
15231pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
15232pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH: VkLineRasterizationMode = 3;
15233pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;
15234pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;
15235pub const VK_LOD_CLAMP_NONE: f32 = 1000.0;
15236pub const VK_LOGIC_OP_AND: VkLogicOp = 1;
15237pub const VK_LOGIC_OP_AND_INVERTED: VkLogicOp = 4;
15238pub const VK_LOGIC_OP_AND_REVERSE: VkLogicOp = 2;
15239pub const VK_LOGIC_OP_CLEAR: VkLogicOp = 0;
15240pub const VK_LOGIC_OP_COPY: VkLogicOp = 3;
15241pub const VK_LOGIC_OP_COPY_INVERTED: VkLogicOp = 12;
15242pub const VK_LOGIC_OP_EQUIVALENT: VkLogicOp = 9;
15243pub const VK_LOGIC_OP_INVERT: VkLogicOp = 10;
15244pub const VK_LOGIC_OP_NAND: VkLogicOp = 14;
15245pub const VK_LOGIC_OP_NOR: VkLogicOp = 8;
15246pub const VK_LOGIC_OP_NO_OP: VkLogicOp = 5;
15247pub const VK_LOGIC_OP_OR: VkLogicOp = 7;
15248pub const VK_LOGIC_OP_OR_INVERTED: VkLogicOp = 13;
15249pub const VK_LOGIC_OP_OR_REVERSE: VkLogicOp = 11;
15250pub const VK_LOGIC_OP_SET: VkLogicOp = 15;
15251pub const VK_LOGIC_OP_XOR: VkLogicOp = 6;
15252pub const VK_LUID_SIZE: u32 = 8;
15253pub const VK_LUID_SIZE_KHR: u32 = VK_LUID_SIZE;
15254pub const VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME: &CStr = c"VK_LUNARG_direct_driver_loading";
15255pub const VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION: u32 = 1;
15256pub const VK_MAX_DESCRIPTION_SIZE: u32 = 256;
15257pub const VK_MAX_DEVICE_GROUP_SIZE: u32 = 32;
15258pub const VK_MAX_DEVICE_GROUP_SIZE_KHR: u32 = VK_MAX_DEVICE_GROUP_SIZE;
15259pub const VK_MAX_DRIVER_INFO_SIZE: u32 = 256;
15260pub const VK_MAX_DRIVER_INFO_SIZE_KHR: u32 = VK_MAX_DRIVER_INFO_SIZE;
15261pub const VK_MAX_DRIVER_NAME_SIZE: u32 = 256;
15262pub const VK_MAX_DRIVER_NAME_SIZE_KHR: u32 = VK_MAX_DRIVER_NAME_SIZE;
15263pub const VK_MAX_EXTENSION_NAME_SIZE: u32 = 256;
15264pub const VK_MAX_GLOBAL_PRIORITY_SIZE: u32 = 16;
15265pub const VK_MAX_GLOBAL_PRIORITY_SIZE_EXT: u32 = VK_MAX_GLOBAL_PRIORITY_SIZE;
15266pub const VK_MAX_GLOBAL_PRIORITY_SIZE_KHR: u32 = VK_MAX_GLOBAL_PRIORITY_SIZE;
15267pub const VK_MAX_MEMORY_HEAPS: u32 = 16;
15268pub const VK_MAX_MEMORY_TYPES: u32 = 32;
15269pub const VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM: u32 = 128;
15270pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: u32 = 256;
15271pub const VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR: u32 = 32;
15272pub const VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: u32 = 32;
15273pub const VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR: u32 = 7;
15274pub const VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR: u32 = 3;
15275pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT: VkMemoryAllocateFlagBits = 1 << 1;
15276pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
15277pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkMemoryAllocateFlagBits = 1 << 2;
15278pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
15279pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT: VkMemoryAllocateFlagBits = 1 << 0;
15280pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT;
15281pub const VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT: VkMemoryAllocateFlagBits = 1 << 3;
15282pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT: VkMemoryDecompressionMethodFlagBitsEXT = 1 << 0;
15283pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV: VkMemoryDecompressionMethodFlagBitsEXT = VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT;
15284pub const VK_MEMORY_HEAP_DEVICE_LOCAL_BIT: VkMemoryHeapFlagBits = 1 << 0;
15285pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT: VkMemoryHeapFlagBits = 1 << 1;
15286pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR: VkMemoryHeapFlagBits = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT;
15287pub const VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM: VkMemoryHeapFlagBits = 1 << 3;
15288pub const VK_MEMORY_MAP_PLACED_BIT_EXT: VkMemoryMapFlagBits = 1 << 0;
15289pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = 1;
15290pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD: VkMemoryOverallocationBehaviorAMD = 0;
15291pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = 2;
15292pub const VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD: VkMemoryPropertyFlagBits = 1 << 6;
15293pub const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT: VkMemoryPropertyFlagBits = 1 << 0;
15294pub const VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD: VkMemoryPropertyFlagBits = 1 << 7;
15295pub const VK_MEMORY_PROPERTY_HOST_CACHED_BIT: VkMemoryPropertyFlagBits = 1 << 3;
15296pub const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT: VkMemoryPropertyFlagBits = 1 << 2;
15297pub const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT: VkMemoryPropertyFlagBits = 1 << 1;
15298pub const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: VkMemoryPropertyFlagBits = 1 << 4;
15299pub const VK_MEMORY_PROPERTY_PROTECTED_BIT: VkMemoryPropertyFlagBits = 1 << 5;
15300pub const VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV: VkMemoryPropertyFlagBits = 1 << 8;
15301pub const VK_MEMORY_UNMAP_RESERVE_BIT_EXT: VkMemoryUnmapFlagBits = 1 << 0;
15302pub const VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME: &CStr = c"VK_MESA_image_alignment_control";
15303pub const VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION: u32 = 1;
15304pub const VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkMicromapCreateFlagBitsEXT = 1 << 0;
15305pub const VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT: VkMicromapTypeEXT = 0;
15306pub const VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME: &CStr = c"VK_MSFT_layered_driver";
15307pub const VK_MSFT_LAYERED_DRIVER_SPEC_VERSION: u32 = 1;
15308pub const VK_NOT_READY: VkResult = 1;
15309pub const VK_NVX_BINARY_IMPORT_EXTENSION_NAME: &CStr = c"VK_NVX_binary_import";
15310pub const VK_NVX_BINARY_IMPORT_SPEC_VERSION: u32 = 2;
15311pub const VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME: &CStr = c"VK_NVX_image_view_handle";
15312pub const VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION: u32 = 4;
15313pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME: &CStr = c"VK_NVX_multiview_per_view_attributes";
15314pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION: u32 = 1;
15315pub const VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME: &CStr = c"VK_NV_clip_space_w_scaling";
15316pub const VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION: u32 = 1;
15317pub const VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_NV_cluster_acceleration_structure";
15318pub const VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 4;
15319pub const VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME: &CStr = c"VK_NV_command_buffer_inheritance";
15320pub const VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION: u32 = 1;
15321pub const VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME: &CStr = c"VK_NV_compute_occupancy_priority";
15322pub const VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION: u32 = 1;
15323pub const VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME: &CStr = c"VK_NV_compute_shader_derivatives";
15324pub const VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION: u32 = 1;
15325pub const VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_matrix2";
15326pub const VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION: u32 = 1;
15327pub const VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_matrix";
15328pub const VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION: u32 = 1;
15329pub const VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_vector";
15330pub const VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION: u32 = 4;
15331pub const VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME: &CStr = c"VK_NV_copy_memory_indirect";
15332pub const VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION: u32 = 1;
15333pub const VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME: &CStr = c"VK_NV_corner_sampled_image";
15334pub const VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION: u32 = 2;
15335pub const VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME: &CStr = c"VK_NV_coverage_reduction_mode";
15336pub const VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION: u32 = 1;
15337pub const VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME: &CStr = c"VK_NV_dedicated_allocation";
15338pub const VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME: &CStr = c"VK_NV_dedicated_allocation_image_aliasing";
15339pub const VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION: u32 = 1;
15340pub const VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION: u32 = 1;
15341pub const VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME: &CStr = c"VK_NV_descriptor_pool_overallocation";
15342pub const VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION: u32 = 1;
15343pub const VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME: &CStr = c"VK_NV_device_diagnostics_config";
15344pub const VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION: u32 = 2;
15345pub const VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME: &CStr = c"VK_NV_device_diagnostic_checkpoints";
15346pub const VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION: u32 = 2;
15347pub const VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME: &CStr = c"VK_NV_device_generated_commands_compute";
15348pub const VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION: u32 = 2;
15349pub const VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: &CStr = c"VK_NV_device_generated_commands";
15350pub const VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: u32 = 3;
15351pub const VK_NV_DISPLAY_STEREO_EXTENSION_NAME: &CStr = c"VK_NV_display_stereo";
15352pub const VK_NV_DISPLAY_STEREO_SPEC_VERSION: u32 = 1;
15353pub const VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME: &CStr = c"VK_NV_extended_sparse_address_space";
15354pub const VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION: u32 = 1;
15355pub const VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME: &CStr = c"VK_NV_external_compute_queue";
15356pub const VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION: u32 = 1;
15357pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_NV_external_memory_capabilities";
15358pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: u32 = 1;
15359pub const VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_NV_external_memory";
15360pub const VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME: &CStr = c"VK_NV_external_memory_rdma";
15361pub const VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION: u32 = 1;
15362pub const VK_NV_EXTERNAL_MEMORY_SPEC_VERSION: u32 = 1;
15363pub const VK_NV_FILL_RECTANGLE_EXTENSION_NAME: &CStr = c"VK_NV_fill_rectangle";
15364pub const VK_NV_FILL_RECTANGLE_SPEC_VERSION: u32 = 1;
15365pub const VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME: &CStr = c"VK_NV_fragment_coverage_to_color";
15366pub const VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION: u32 = 1;
15367pub const VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME: &CStr = c"VK_NV_fragment_shader_barycentric";
15368pub const VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION: u32 = 1;
15369pub const VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME: &CStr = c"VK_NV_fragment_shading_rate_enums";
15370pub const VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION: u32 = 1;
15371pub const VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME: &CStr = c"VK_NV_framebuffer_mixed_samples";
15372pub const VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION: u32 = 1;
15373pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME: &CStr = c"VK_NV_geometry_shader_passthrough";
15374pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION: u32 = 1;
15375pub const VK_NV_GLSL_SHADER_EXTENSION_NAME: &CStr = c"VK_NV_glsl_shader";
15376pub const VK_NV_GLSL_SHADER_SPEC_VERSION: u32 = 1;
15377pub const VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME: &CStr = c"VK_NV_inherited_viewport_scissor";
15378pub const VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION: u32 = 1;
15379pub const VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME: &CStr = c"VK_NV_linear_color_attachment";
15380pub const VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION: u32 = 1;
15381pub const VK_NV_LOW_LATENCY_2_EXTENSION_NAME: &CStr = c"VK_NV_low_latency2";
15382pub const VK_NV_LOW_LATENCY_2_SPEC_VERSION: u32 = 2;
15383pub const VK_NV_LOW_LATENCY_EXTENSION_NAME: &CStr = c"VK_NV_low_latency";
15384pub const VK_NV_LOW_LATENCY_SPEC_VERSION: u32 = 1;
15385pub const VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME: &CStr = c"VK_NV_memory_decompression";
15386pub const VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION: u32 = 1;
15387pub const VK_NV_MESH_SHADER_EXTENSION_NAME: &CStr = c"VK_NV_mesh_shader";
15388pub const VK_NV_MESH_SHADER_SPEC_VERSION: u32 = 1;
15389pub const VK_NV_OPTICAL_FLOW_EXTENSION_NAME: &CStr = c"VK_NV_optical_flow";
15390pub const VK_NV_OPTICAL_FLOW_SPEC_VERSION: u32 = 1;
15391pub const VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_NV_partitioned_acceleration_structure";
15392pub const VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 1;
15393pub const VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME: &CStr = c"VK_NV_per_stage_descriptor_set";
15394pub const VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION: u32 = 1;
15395pub const VK_NV_PRESENT_BARRIER_EXTENSION_NAME: &CStr = c"VK_NV_present_barrier";
15396pub const VK_NV_PRESENT_BARRIER_SPEC_VERSION: u32 = 1;
15397pub const VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME: &CStr = c"VK_NV_push_constant_bank";
15398pub const VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION: u32 = 1;
15399pub const VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME: &CStr = c"VK_NV_raw_access_chains";
15400pub const VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION: u32 = 1;
15401pub const VK_NV_RAY_TRACING_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing";
15402pub const VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_invocation_reorder";
15403pub const VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION: u32 = 1;
15404pub const VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_linear_swept_spheres";
15405pub const VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION: u32 = 1;
15406pub const VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_motion_blur";
15407pub const VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION: u32 = 1;
15408pub const VK_NV_RAY_TRACING_SPEC_VERSION: u32 = 3;
15409pub const VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_validation";
15410pub const VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION: u32 = 1;
15411pub const VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME: &CStr = c"VK_NV_representative_fragment_test";
15412pub const VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION: u32 = 2;
15413pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME: &CStr = c"VK_NV_sample_mask_override_coverage";
15414pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION: u32 = 1;
15415pub const VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME: &CStr = c"VK_NV_scissor_exclusive";
15416pub const VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION: u32 = 2;
15417pub const VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME: &CStr = c"VK_NV_shader_atomic_float16_vector";
15418pub const VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION: u32 = 1;
15419pub const VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME: &CStr = c"VK_NV_shader_image_footprint";
15420pub const VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION: u32 = 2;
15421pub const VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME: &CStr = c"VK_NV_shader_sm_builtins";
15422pub const VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION: u32 = 1;
15423pub const VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME: &CStr = c"VK_NV_shader_subgroup_partitioned";
15424pub const VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION: u32 = 1;
15425pub const VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME: &CStr = c"VK_NV_shading_rate_image";
15426pub const VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION: u32 = 3;
15427pub const VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME: &CStr = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME;
15428pub const VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION: u32 = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION;
15429pub const VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME: &CStr = c"VK_NV_viewport_array2";
15430pub const VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION: u32 = 1;
15431pub const VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME: &CStr = c"VK_NV_viewport_swizzle";
15432pub const VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION: u32 = 1;
15433pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: VkObjectType = 1000150000;
15434pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV: VkObjectType = 1000165000;
15435pub const VK_OBJECT_TYPE_BUFFER: VkObjectType = 9;
15436pub const VK_OBJECT_TYPE_BUFFER_VIEW: VkObjectType = 13;
15437pub const VK_OBJECT_TYPE_COMMAND_BUFFER: VkObjectType = 6;
15438pub const VK_OBJECT_TYPE_COMMAND_POOL: VkObjectType = 25;
15439pub const VK_OBJECT_TYPE_CU_FUNCTION_NVX: VkObjectType = 1000029001;
15440pub const VK_OBJECT_TYPE_CU_MODULE_NVX: VkObjectType = 1000029000;
15441pub const VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM: VkObjectType = 1000507000;
15442pub const VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: VkObjectType = 1000011000;
15443pub const VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: VkObjectType = 1000128000;
15444pub const VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR: VkObjectType = 1000268000;
15445pub const VK_OBJECT_TYPE_DESCRIPTOR_POOL: VkObjectType = 22;
15446pub const VK_OBJECT_TYPE_DESCRIPTOR_SET: VkObjectType = 23;
15447pub const VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: VkObjectType = 20;
15448pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: VkObjectType = 1000085000;
15449pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
15450pub const VK_OBJECT_TYPE_DEVICE: VkObjectType = 3;
15451pub const VK_OBJECT_TYPE_DEVICE_MEMORY: VkObjectType = 8;
15452pub const VK_OBJECT_TYPE_DISPLAY_KHR: VkObjectType = 1000002000;
15453pub const VK_OBJECT_TYPE_DISPLAY_MODE_KHR: VkObjectType = 1000002001;
15454pub const VK_OBJECT_TYPE_EVENT: VkObjectType = 11;
15455pub const VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV: VkObjectType = 1000556000;
15456pub const VK_OBJECT_TYPE_FENCE: VkObjectType = 7;
15457pub const VK_OBJECT_TYPE_FRAMEBUFFER: VkObjectType = 24;
15458pub const VK_OBJECT_TYPE_IMAGE: VkObjectType = 10;
15459pub const VK_OBJECT_TYPE_IMAGE_VIEW: VkObjectType = 14;
15460pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: VkObjectType = 1000572000;
15461pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: VkObjectType = 1000277000;
15462pub const VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: VkObjectType = 1000572001;
15463pub const VK_OBJECT_TYPE_INSTANCE: VkObjectType = 1;
15464pub const VK_OBJECT_TYPE_MICROMAP_EXT: VkObjectType = 1000396000;
15465pub const VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: VkObjectType = 1000464000;
15466pub const VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: VkObjectType = 1000210000;
15467pub const VK_OBJECT_TYPE_PHYSICAL_DEVICE: VkObjectType = 2;
15468pub const VK_OBJECT_TYPE_PIPELINE: VkObjectType = 19;
15469pub const VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: VkObjectType = 1000483000;
15470pub const VK_OBJECT_TYPE_PIPELINE_CACHE: VkObjectType = 16;
15471pub const VK_OBJECT_TYPE_PIPELINE_LAYOUT: VkObjectType = 17;
15472pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT: VkObjectType = 1000295000;
15473pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT: VkObjectType = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT;
15474pub const VK_OBJECT_TYPE_QUERY_POOL: VkObjectType = 12;
15475pub const VK_OBJECT_TYPE_QUEUE: VkObjectType = 4;
15476pub const VK_OBJECT_TYPE_RENDER_PASS: VkObjectType = 18;
15477pub const VK_OBJECT_TYPE_SAMPLER: VkObjectType = 21;
15478pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: VkObjectType = 1000156000;
15479pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR: VkObjectType = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
15480pub const VK_OBJECT_TYPE_SEMAPHORE: VkObjectType = 5;
15481pub const VK_OBJECT_TYPE_SHADER_EXT: VkObjectType = 1000482000;
15482pub const VK_OBJECT_TYPE_SHADER_MODULE: VkObjectType = 15;
15483pub const VK_OBJECT_TYPE_SURFACE_KHR: VkObjectType = 1000000000;
15484pub const VK_OBJECT_TYPE_SWAPCHAIN_KHR: VkObjectType = 1000001000;
15485pub const VK_OBJECT_TYPE_TENSOR_ARM: VkObjectType = 1000460000;
15486pub const VK_OBJECT_TYPE_TENSOR_VIEW_ARM: VkObjectType = 1000460001;
15487pub const VK_OBJECT_TYPE_UNKNOWN: VkObjectType = 0;
15488pub const VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkObjectType = 1000160000;
15489pub const VK_OBJECT_TYPE_VIDEO_SESSION_KHR: VkObjectType = 1000023000;
15490pub const VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR: VkObjectType = 1000023001;
15491pub const VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT: VkOpacityMicromapFormatEXT = 1;
15492pub const VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT: VkOpacityMicromapFormatEXT = 2;
15493pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: VkOpacityMicromapSpecialIndexEXT = -5;
15494pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = -2;
15495pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = -1;
15496pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = -4;
15497pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = -3;
15498pub const VK_OPERATION_DEFERRED_KHR: VkResult = 1000268002;
15499pub const VK_OPERATION_NOT_DEFERRED_KHR: VkResult = 1000268003;
15500pub const VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV: VkOpticalFlowExecuteFlagBitsNV = 1 << 0;
15501pub const VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 0;
15502pub const VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 1;
15503pub const VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 2;
15504pub const VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 3;
15505pub const VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV: VkOpticalFlowGridSizeFlagBitsNV = 0;
15506pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV: VkOpticalFlowPerformanceLevelNV = 3;
15507pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV: VkOpticalFlowPerformanceLevelNV = 2;
15508pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV: VkOpticalFlowPerformanceLevelNV = 1;
15509pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV: VkOpticalFlowPerformanceLevelNV = 0;
15510pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV: VkOpticalFlowSessionBindingPointNV = 7;
15511pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = 5;
15512pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV: VkOpticalFlowSessionBindingPointNV = 6;
15513pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = 4;
15514pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV: VkOpticalFlowSessionBindingPointNV = 8;
15515pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV: VkOpticalFlowSessionBindingPointNV = 3;
15516pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV: VkOpticalFlowSessionBindingPointNV = 1;
15517pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV: VkOpticalFlowSessionBindingPointNV = 2;
15518pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV: VkOpticalFlowSessionBindingPointNV = 0;
15519pub const VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 3;
15520pub const VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 4;
15521pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 1;
15522pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 2;
15523pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 0;
15524pub const VK_OPTICAL_FLOW_USAGE_COST_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 3;
15525pub const VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 4;
15526pub const VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 2;
15527pub const VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 0;
15528pub const VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 1;
15529pub const VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV: VkOpticalFlowUsageFlagBitsNV = 0;
15530pub const VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV: VkOutOfBandQueueTypeNV = 1;
15531pub const VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV: VkOutOfBandQueueTypeNV = 0;
15532pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 4;
15533pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 3;
15534pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 2;
15535pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 0;
15536pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 1;
15537pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = 1;
15538pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = 0;
15539pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV: VkPartitionedAccelerationStructureOpTypeNV = 2;
15540pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV: u32 = !0;
15541pub const VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT: VkPastPresentationTimingFlagBitsEXT = 1 << 1;
15542pub const VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT: VkPastPresentationTimingFlagBitsEXT = 1 << 0;
15543pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT: VkPeerMemoryFeatureFlagBits = 1 << 1;
15544pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT;
15545pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT: VkPeerMemoryFeatureFlagBits = 1 << 0;
15546pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT;
15547pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT: VkPeerMemoryFeatureFlagBits = 1 << 3;
15548pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;
15549pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT: VkPeerMemoryFeatureFlagBits = 1 << 2;
15550pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT;
15551pub const VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL: VkPerformanceConfigurationTypeINTEL = 0;
15552pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = 1 << 1;
15553pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR;
15554pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = 1 << 0;
15555pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR;
15556pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = 0;
15557pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = 2;
15558pub const VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = 1;
15559pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR: VkPerformanceCounterStorageKHR = 4;
15560pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR: VkPerformanceCounterStorageKHR = 5;
15561pub const VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR: VkPerformanceCounterStorageKHR = 0;
15562pub const VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR: VkPerformanceCounterStorageKHR = 1;
15563pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR: VkPerformanceCounterStorageKHR = 2;
15564pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR: VkPerformanceCounterStorageKHR = 3;
15565pub const VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR: VkPerformanceCounterUnitKHR = 8;
15566pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR: VkPerformanceCounterUnitKHR = 3;
15567pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR: VkPerformanceCounterUnitKHR = 4;
15568pub const VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR: VkPerformanceCounterUnitKHR = 10;
15569pub const VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR: VkPerformanceCounterUnitKHR = 0;
15570pub const VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR: VkPerformanceCounterUnitKHR = 9;
15571pub const VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR: VkPerformanceCounterUnitKHR = 5;
15572pub const VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR: VkPerformanceCounterUnitKHR = 2;
15573pub const VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR: VkPerformanceCounterUnitKHR = 1;
15574pub const VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR: VkPerformanceCounterUnitKHR = 7;
15575pub const VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR: VkPerformanceCounterUnitKHR = 6;
15576pub const VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL: VkPerformanceOverrideTypeINTEL = 1;
15577pub const VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL: VkPerformanceOverrideTypeINTEL = 0;
15578pub const VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL: VkPerformanceParameterTypeINTEL = 0;
15579pub const VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL: VkPerformanceParameterTypeINTEL = 1;
15580pub const VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL: VkPerformanceValueTypeINTEL = 3;
15581pub const VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL: VkPerformanceValueTypeINTEL = 2;
15582pub const VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL: VkPerformanceValueTypeINTEL = 4;
15583pub const VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL: VkPerformanceValueTypeINTEL = 0;
15584pub const VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL: VkPerformanceValueTypeINTEL = 1;
15585pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = 1000629001;
15586pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = 1000629000;
15587pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM: VkPhysicalDeviceDataGraphOperationTypeARM = 0;
15588pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 1000629001;
15589pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 0;
15590pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 1000629000;
15591pub const VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR: VkPhysicalDeviceLayeredApiKHR = 1;
15592pub const VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR: VkPhysicalDeviceLayeredApiKHR = 2;
15593pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR: VkPhysicalDeviceLayeredApiKHR = 4;
15594pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR: VkPhysicalDeviceLayeredApiKHR = 3;
15595pub const VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR: VkPhysicalDeviceLayeredApiKHR = 0;
15596pub const VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM: VkPhysicalDeviceSchedulingControlsFlagBitsARM = 1 << 0;
15597pub const VK_PHYSICAL_DEVICE_TYPE_CPU: VkPhysicalDeviceType = 4;
15598pub const VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: VkPhysicalDeviceType = 2;
15599pub const VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: VkPhysicalDeviceType = 1;
15600pub const VK_PHYSICAL_DEVICE_TYPE_OTHER: VkPhysicalDeviceType = 0;
15601pub const VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: VkPhysicalDeviceType = 3;
15602pub const VK_PIPELINE_BINARY_MISSING_KHR: VkResult = 1000483000;
15603pub const VK_PIPELINE_BIND_POINT_COMPUTE: VkPipelineBindPoint = 1;
15604pub const VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM: VkPipelineBindPoint = 1000507000;
15605pub const VK_PIPELINE_BIND_POINT_GRAPHICS: VkPipelineBindPoint = 0;
15606pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: VkPipelineBindPoint = 1000165000;
15607pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_NV: VkPipelineBindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
15608pub const VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI: VkPipelineBindPoint = 1000369003;
15609pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT: VkPipelineCacheCreateFlagBits = 1 << 0;
15610pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT: VkPipelineCacheCreateFlagBits = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT;
15611pub const VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR: VkPipelineCacheCreateFlagBits = 1 << 3;
15612pub const VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM: VkPipelineCacheHeaderVersion = 1000629000;
15613pub const VK_PIPELINE_CACHE_HEADER_VERSION_ONE: VkPipelineCacheHeaderVersion = 1;
15614pub const VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM: VkPipelineColorBlendStateCreateFlagBits = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT;
15615pub const VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT: VkPipelineColorBlendStateCreateFlagBits = 1 << 0;
15616pub const VK_PIPELINE_COMPILE_REQUIRED: VkResult = 1000297000;
15617pub const VK_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
15618pub const VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 43;
15619pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlagBits2 = 1 << 1;
15620pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT;
15621pub const VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 31;
15622pub const VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 7;
15623pub const VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 6;
15624pub const VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 25;
15625pub const VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 5;
15626pub const VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 26;
15627pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT: VkPipelineCreateFlagBits2 = 1 << 2;
15628pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DERIVATIVE_BIT;
15629pub const VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 29;
15630pub const VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 36;
15631pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlagBits2 = 1 << 0;
15632pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT;
15633pub const VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM: VkPipelineCreateFlagBits2 = 1 << 37;
15634pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT: VkPipelineCreateFlagBits2 = 1 << 4;
15635pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT;
15636pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlagBits2 = 1 << 9;
15637pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT;
15638pub const VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 34;
15639pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlagBits2 = 1 << 8;
15640pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
15641pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 38;
15642pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 18;
15643pub const VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 11;
15644pub const VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 10;
15645pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlagBits2 = 1 << 27;
15646pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT;
15647pub const VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkPipelineCreateFlagBits2 = 1 << 40;
15648pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlagBits2 = 1 << 30;
15649pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT;
15650pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 20;
15651pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 33;
15652pub const VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 28;
15653pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 14;
15654pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 15;
15655pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 17;
15656pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 16;
15657pub const VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 24;
15658pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 19;
15659pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 13;
15660pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR;
15661pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 12;
15662pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 22;
15663pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 21;
15664pub const VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 23;
15665pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlagBits2 = 1 << 3;
15666pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
15667pub const VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlagBits = 1 << 1;
15668pub const VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 7;
15669pub const VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 6;
15670pub const VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 25;
15671pub const VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlagBits = 1 << 5;
15672pub const VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 26;
15673pub const VK_PIPELINE_CREATE_DERIVATIVE_BIT: VkPipelineCreateFlagBits = 1 << 2;
15674pub const VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlagBits = 1 << 29;
15675pub const VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlagBits = 1 << 0;
15676pub const VK_PIPELINE_CREATE_DISPATCH_BASE: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
15677pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT: VkPipelineCreateFlagBits = 1 << 4;
15678pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
15679pub const VK_PIPELINE_CREATE_DISPATCH_BASE_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
15680pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlagBits = 1 << 9;
15681pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT;
15682pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlagBits = 1 << 8;
15683pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
15684pub const VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlagBits = 1 << 18;
15685pub const VK_PIPELINE_CREATE_LIBRARY_BIT_KHR: VkPipelineCreateFlagBits = 1 << 11;
15686pub const VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlagBits = 1 << 10;
15687pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlagBits = 1 << 27;
15688pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT;
15689pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlagBits = 1 << 30;
15690pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT;
15691pub const VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlagBits = 1 << 20;
15692pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 14;
15693pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 15;
15694pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 17;
15695pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 16;
15696pub const VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 24;
15697pub const VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlagBits = 1 << 19;
15698pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 13;
15699pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlagBits = 1 << 12;
15700pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits = 1 << 22;
15701pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits = 1 << 21;
15702pub const VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlagBits = 1 << 23;
15703pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlagBits = 1 << 3;
15704pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
15705pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 1;
15706pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT;
15707pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 2;
15708pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT;
15709pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 0;
15710pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT;
15711pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: VkPipelineDepthStencilStateCreateFlagBits = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT;
15712pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: VkPipelineDepthStencilStateCreateFlagBits = 1 << 0;
15713pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: VkPipelineDepthStencilStateCreateFlagBits = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT;
15714pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: VkPipelineDepthStencilStateCreateFlagBits = 1 << 1;
15715pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR: VkPipelineExecutableStatisticFormatKHR = 0;
15716pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR: VkPipelineExecutableStatisticFormatKHR = 3;
15717pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR: VkPipelineExecutableStatisticFormatKHR = 1;
15718pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR: VkPipelineExecutableStatisticFormatKHR = 2;
15719pub const VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT: VkPipelineLayoutCreateFlagBits = 1 << 1;
15720pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT;
15721pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
15722pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessBufferBehavior = 0;
15723pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT;
15724pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED: VkPipelineRobustnessBufferBehavior = 1;
15725pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED;
15726pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS: VkPipelineRobustnessBufferBehavior = 2;
15727pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2: VkPipelineRobustnessBufferBehavior = 3;
15728pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2;
15729pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS;
15730pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessImageBehavior = 0;
15731pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT;
15732pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED: VkPipelineRobustnessImageBehavior = 1;
15733pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED;
15734pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS: VkPipelineRobustnessImageBehavior = 2;
15735pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2: VkPipelineRobustnessImageBehavior = 3;
15736pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2;
15737pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS;
15738pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT: VkPipelineShaderStageCreateFlagBits = 1 << 0;
15739pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkPipelineShaderStageCreateFlagBits = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT;
15740pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT: VkPipelineShaderStageCreateFlagBits = 1 << 1;
15741pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkPipelineShaderStageCreateFlagBits = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT;
15742pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 25;
15743pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
15744pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 28;
15745pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT: VkPipelineStageFlagBits2 = 1 << 16;
15746pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
15747pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits2 = 1 << 15;
15748pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
15749pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT: VkPipelineStageFlagBits2 = 1 << 12;
15750pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
15751pub const VK_PIPELINE_STAGE_2_BLIT_BIT: VkPipelineStageFlagBits2 = 1 << 34;
15752pub const VK_PIPELINE_STAGE_2_BLIT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_BLIT_BIT;
15753pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits2 = 1 << 13;
15754pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT;
15755pub const VK_PIPELINE_STAGE_2_CLEAR_BIT: VkPipelineStageFlagBits2 = 1 << 35;
15756pub const VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_CLEAR_BIT;
15757pub const VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 41;
15758pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits2 = 1 << 10;
15759pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
15760pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 17;
15761pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT;
15762pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 11;
15763pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
15764pub const VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 18;
15765pub const VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV: VkPipelineStageFlagBits2 = 1 << 44;
15766pub const VK_PIPELINE_STAGE_2_COPY_BIT: VkPipelineStageFlagBits2 = 1 << 32;
15767pub const VK_PIPELINE_STAGE_2_COPY_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COPY_BIT;
15768pub const VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 46;
15769pub const VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM: VkPipelineStageFlagBits2 = 1 << 42;
15770pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits2 = 1 << 1;
15771pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
15772pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2 = 1 << 8;
15773pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT;
15774pub const VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 23;
15775pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 7;
15776pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
15777pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 22;
15778pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 6;
15779pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT;
15780pub const VK_PIPELINE_STAGE_2_HOST_BIT: VkPipelineStageFlagBits2 = 1 << 14;
15781pub const VK_PIPELINE_STAGE_2_HOST_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_HOST_BIT;
15782pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 36;
15783pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT;
15784pub const VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 40;
15785pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2 = 1 << 9;
15786pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;
15787pub const VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 45;
15788pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 20;
15789pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT;
15790pub const VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 30;
15791pub const VK_PIPELINE_STAGE_2_NONE: VkPipelineStageFlagBits2 = 0;
15792pub const VK_PIPELINE_STAGE_2_NONE_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_NONE;
15793pub const VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV: VkPipelineStageFlagBits2 = 1 << 29;
15794pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT: VkPipelineStageFlagBits2 = 1 << 38;
15795pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT;
15796pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 21;
15797pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR;
15798pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT: VkPipelineStageFlagBits2 = 1 << 33;
15799pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_RESOLVE_BIT;
15800pub const VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
15801pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 39;
15802pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI;
15803pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 19;
15804pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT;
15805pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 4;
15806pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT;
15807pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 5;
15808pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT;
15809pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits2 = 1 << 0;
15810pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;
15811pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
15812pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
15813pub const VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 24;
15814pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 37;
15815pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT;
15816pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 2;
15817pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT;
15818pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 3;
15819pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT;
15820pub const VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 26;
15821pub const VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 27;
15822pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlagBits = 1 << 25;
15823pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
15824pub const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT: VkPipelineStageFlagBits = 1 << 16;
15825pub const VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits = 1 << 15;
15826pub const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits = 1 << 13;
15827pub const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits = 1 << 10;
15828pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlagBits = 1 << 17;
15829pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT;
15830pub const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits = 1 << 11;
15831pub const VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlagBits = 1 << 18;
15832pub const VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits = 1 << 1;
15833pub const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 1 << 8;
15834pub const VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlagBits = 1 << 23;
15835pub const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits = 1 << 7;
15836pub const VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlagBits = 1 << 22;
15837pub const VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits = 1 << 6;
15838pub const VK_PIPELINE_STAGE_HOST_BIT: VkPipelineStageFlagBits = 1 << 14;
15839pub const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 1 << 9;
15840pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT: VkPipelineStageFlagBits = 1 << 20;
15841pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
15842pub const VK_PIPELINE_STAGE_NONE: VkPipelineStageFlagBits = 0;
15843pub const VK_PIPELINE_STAGE_NONE_KHR: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_NONE;
15844pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlagBits = 1 << 21;
15845pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
15846pub const VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
15847pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT: VkPipelineStageFlagBits = 1 << 19;
15848pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT;
15849pub const VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits = 1 << 4;
15850pub const VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits = 1 << 5;
15851pub const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits = 1 << 0;
15852pub const VK_PIPELINE_STAGE_TRANSFER_BIT: VkPipelineStageFlagBits = 1 << 12;
15853pub const VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlagBits = 1 << 24;
15854pub const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: VkPipelineStageFlagBits = 1 << 2;
15855pub const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: VkPipelineStageFlagBits = 1 << 3;
15856pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: VkPointClippingBehavior = 0;
15857pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
15858pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: VkPointClippingBehavior = 1;
15859pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY;
15860pub const VK_POLYGON_MODE_FILL: VkPolygonMode = 0;
15861pub const VK_POLYGON_MODE_FILL_RECTANGLE_NV: VkPolygonMode = 1000153000;
15862pub const VK_POLYGON_MODE_LINE: VkPolygonMode = 1;
15863pub const VK_POLYGON_MODE_POINT: VkPolygonMode = 2;
15864pub const VK_PRESENT_GRAVITY_CENTERED_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR;
15865pub const VK_PRESENT_GRAVITY_CENTERED_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 2;
15866pub const VK_PRESENT_GRAVITY_MAX_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_MAX_BIT_KHR;
15867pub const VK_PRESENT_GRAVITY_MAX_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 1;
15868pub const VK_PRESENT_GRAVITY_MIN_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_MIN_BIT_KHR;
15869pub const VK_PRESENT_GRAVITY_MIN_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 0;
15870pub const VK_PRESENT_MODE_FIFO_KHR: VkPresentModeKHR = 2;
15871pub const VK_PRESENT_MODE_FIFO_LATEST_READY_EXT: VkPresentModeKHR = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR;
15872pub const VK_PRESENT_MODE_FIFO_LATEST_READY_KHR: VkPresentModeKHR = 1000361000;
15873pub const VK_PRESENT_MODE_FIFO_RELAXED_KHR: VkPresentModeKHR = 3;
15874pub const VK_PRESENT_MODE_IMMEDIATE_KHR: VkPresentModeKHR = 0;
15875pub const VK_PRESENT_MODE_MAILBOX_KHR: VkPresentModeKHR = 1;
15876pub const VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR: VkPresentModeKHR = 1000111001;
15877pub const VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR: VkPresentModeKHR = 1000111000;
15878pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR;
15879pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 1;
15880pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR;
15881pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 0;
15882pub const VK_PRESENT_SCALING_STRETCH_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_STRETCH_BIT_KHR;
15883pub const VK_PRESENT_SCALING_STRETCH_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 2;
15884pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 2;
15885pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 3;
15886pub const VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 0;
15887pub const VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 1;
15888pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT: VkPresentTimingInfoFlagBitsEXT = 1 << 1;
15889pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT: VkPresentTimingInfoFlagBitsEXT = 1 << 0;
15890pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST: VkPrimitiveTopology = 1;
15891pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 6;
15892pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: VkPrimitiveTopology = 2;
15893pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 7;
15894pub const VK_PRIMITIVE_TOPOLOGY_PATCH_LIST: VkPrimitiveTopology = 10;
15895pub const VK_PRIMITIVE_TOPOLOGY_POINT_LIST: VkPrimitiveTopology = 0;
15896pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN: VkPrimitiveTopology = 5;
15897pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: VkPrimitiveTopology = 3;
15898pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 8;
15899pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: VkPrimitiveTopology = 4;
15900pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 9;
15901pub const VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT: VkProvokingVertexModeEXT = 0;
15902pub const VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT: VkProvokingVertexModeEXT = 1;
15903pub const VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME: &CStr = c"VK_QCOM_data_graph_model";
15904pub const VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION: u32 = 1;
15905pub const VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME: &CStr = c"VK_QCOM_filter_cubic_clamp";
15906pub const VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION: u32 = 1;
15907pub const VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME: &CStr = c"VK_QCOM_filter_cubic_weights";
15908pub const VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION: u32 = 1;
15909pub const VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME: &CStr = c"VK_QCOM_fragment_density_map_offset";
15910pub const VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION: u32 = 3;
15911pub const VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME: &CStr = c"VK_QCOM_image_processing2";
15912pub const VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION: u32 = 1;
15913pub const VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME: &CStr = c"VK_QCOM_image_processing";
15914pub const VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION: u32 = 1;
15915pub const VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME: &CStr = c"VK_QCOM_multiview_per_view_render_areas";
15916pub const VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION: u32 = 1;
15917pub const VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME: &CStr = c"VK_QCOM_multiview_per_view_viewports";
15918pub const VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION: u32 = 1;
15919pub const VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_shader_resolve";
15920pub const VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION: u32 = 4;
15921pub const VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_store_ops";
15922pub const VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION: u32 = 2;
15923pub const VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_transform";
15924pub const VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION: u32 = 5;
15925pub const VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME: &CStr = c"VK_QCOM_rotated_copy_commands";
15926pub const VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION: u32 = 2;
15927pub const VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_memory_heap";
15928pub const VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION: u32 = 1;
15929pub const VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_properties";
15930pub const VK_QCOM_TILE_PROPERTIES_SPEC_VERSION: u32 = 1;
15931pub const VK_QCOM_TILE_SHADING_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_shading";
15932pub const VK_QCOM_TILE_SHADING_SPEC_VERSION: u32 = 2;
15933pub const VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME: &CStr = c"VK_QCOM_ycbcr_degamma";
15934pub const VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION: u32 = 1;
15935pub const VK_QUERY_CONTROL_PRECISE_BIT: VkQueryControlFlagBits = 1 << 0;
15936pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 5;
15937pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 6;
15938pub const VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI: VkQueryPipelineStatisticFlagBits = 1 << 13;
15939pub const VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 10;
15940pub const VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 7;
15941pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 3;
15942pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 4;
15943pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 1;
15944pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 0;
15945pub const VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlagBits = 1 << 12;
15946pub const VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlagBits = 1 << 11;
15947pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 8;
15948pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 9;
15949pub const VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 2;
15950pub const VK_QUERY_POOL_CREATE_RESET_BIT_KHR: VkQueryPoolCreateFlagBits = 1 << 0;
15951pub const VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL: VkQueryPoolSamplingModeINTEL = 0;
15952pub const VK_QUERY_RESULT_64_BIT: VkQueryResultFlagBits = 1 << 0;
15953pub const VK_QUERY_RESULT_PARTIAL_BIT: VkQueryResultFlagBits = 1 << 3;
15954pub const VK_QUERY_RESULT_STATUS_COMPLETE_KHR: VkQueryResultStatusKHR = 1;
15955pub const VK_QUERY_RESULT_STATUS_ERROR_KHR: VkQueryResultStatusKHR = -1;
15956pub const VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR: VkQueryResultStatusKHR = -1000299000;
15957pub const VK_QUERY_RESULT_STATUS_NOT_READY_KHR: VkQueryResultStatusKHR = 0;
15958pub const VK_QUERY_RESULT_WAIT_BIT: VkQueryResultFlagBits = 1 << 1;
15959pub const VK_QUERY_RESULT_WITH_AVAILABILITY_BIT: VkQueryResultFlagBits = 1 << 2;
15960pub const VK_QUERY_RESULT_WITH_STATUS_BIT_KHR: VkQueryResultFlagBits = 1 << 4;
15961pub const VK_QUERY_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR;
15962pub const VK_QUERY_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR;
15963pub const VK_QUERY_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR;
15964pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: VkQueryType = 1000150000;
15965pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: VkQueryType = 1000165000;
15966pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: VkQueryType = 1000386000;
15967pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: VkQueryType = 1000150001;
15968pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR: VkQueryType = 1000386001;
15969pub const VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT: VkQueryType = 1000328000;
15970pub const VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT: VkQueryType = 1000396001;
15971pub const VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT: VkQueryType = 1000396000;
15972pub const VK_QUERY_TYPE_OCCLUSION: VkQueryType = 0;
15973pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL: VkQueryType = 1000210000;
15974pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR: VkQueryType = 1000116000;
15975pub const VK_QUERY_TYPE_PIPELINE_STATISTICS: VkQueryType = 1;
15976pub const VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT: VkQueryType = 1000382000;
15977pub const VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR: VkQueryType = 1000023000;
15978pub const VK_QUERY_TYPE_TIMESTAMP: VkQueryType = 2;
15979pub const VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT: VkQueryType = 1000028004;
15980pub const VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR: VkQueryType = 1000299000;
15981pub const VK_QUEUE_COMPUTE_BIT: VkQueueFlagBits = 1 << 1;
15982pub const VK_QUEUE_DATA_GRAPH_BIT_ARM: VkQueueFlagBits = 1 << 10;
15983pub const VK_QUEUE_FAMILY_EXTERNAL: u32 = !1;
15984pub const VK_QUEUE_FAMILY_EXTERNAL_KHR: u32 = VK_QUEUE_FAMILY_EXTERNAL;
15985pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = !2;
15986pub const VK_QUEUE_FAMILY_IGNORED: u32 = !0;
15987pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH: VkQueueGlobalPriority = 512;
15988pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
15989pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
15990pub const VK_QUEUE_GLOBAL_PRIORITY_LOW: VkQueueGlobalPriority = 128;
15991pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
15992pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
15993pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM: VkQueueGlobalPriority = 256;
15994pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
15995pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
15996pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME: VkQueueGlobalPriority = 1024;
15997pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;
15998pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;
15999pub const VK_QUEUE_GRAPHICS_BIT: VkQueueFlagBits = 1 << 0;
16000pub const VK_QUEUE_OPTICAL_FLOW_BIT_NV: VkQueueFlagBits = 1 << 8;
16001pub const VK_QUEUE_PROTECTED_BIT: VkQueueFlagBits = 1 << 4;
16002pub const VK_QUEUE_SPARSE_BINDING_BIT: VkQueueFlagBits = 1 << 3;
16003pub const VK_QUEUE_TRANSFER_BIT: VkQueueFlagBits = 1 << 2;
16004pub const VK_QUEUE_VIDEO_DECODE_BIT_KHR: VkQueueFlagBits = 1 << 5;
16005pub const VK_QUEUE_VIDEO_ENCODE_BIT_KHR: VkQueueFlagBits = 1 << 6;
16006pub const VK_RASTERIZATION_ORDER_RELAXED_AMD: VkRasterizationOrderAMD = 1;
16007pub const VK_RASTERIZATION_ORDER_STRICT_AMD: VkRasterizationOrderAMD = 0;
16008pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT: VkRayTracingInvocationReorderModeEXT = 0;
16009pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT;
16010pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT: VkRayTracingInvocationReorderModeEXT = 1;
16011pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT;
16012pub const VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV: VkRayTracingLssIndexingModeNV = 0;
16013pub const VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV: VkRayTracingLssIndexingModeNV = 1;
16014pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV: VkRayTracingLssPrimitiveEndCapsModeNV = 1;
16015pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV: VkRayTracingLssPrimitiveEndCapsModeNV = 0;
16016pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR: VkRayTracingShaderGroupTypeKHR = 0;
16017pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
16018pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = 2;
16019pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR;
16020pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = 1;
16021pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
16022pub const VK_REMAINING_3D_SLICES_EXT: u32 = !0;
16023pub const VK_REMAINING_ARRAY_LAYERS: u32 = !0;
16024pub const VK_REMAINING_MIP_LEVELS: u32 = !0;
16025pub const VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 0;
16026pub const VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 2;
16027pub const VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 1;
16028pub const VK_RENDERING_CONTENTS_INLINE_BIT_EXT: VkRenderingFlagBits = VK_RENDERING_CONTENTS_INLINE_BIT_KHR;
16029pub const VK_RENDERING_CONTENTS_INLINE_BIT_KHR: VkRenderingFlagBits = 1 << 4;
16030pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT: VkRenderingFlagBits = 1 << 0;
16031pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT;
16032pub const VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT: VkRenderingFlagBits = 1 << 7;
16033pub const VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT: VkRenderingFlagBits = 1 << 3;
16034pub const VK_RENDERING_FRAGMENT_REGION_BIT_EXT: VkRenderingFlagBits = 1 << 6;
16035pub const VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR: VkRenderingFlagBits = 1 << 8;
16036pub const VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderingFlagBits = 1 << 5;
16037pub const VK_RENDERING_RESUMING_BIT: VkRenderingFlagBits = 1 << 2;
16038pub const VK_RENDERING_RESUMING_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_RESUMING_BIT;
16039pub const VK_RENDERING_SUSPENDING_BIT: VkRenderingFlagBits = 1 << 1;
16040pub const VK_RENDERING_SUSPENDING_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_SUSPENDING_BIT;
16041pub const VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderPassCreateFlagBits = 1 << 2;
16042pub const VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM: VkRenderPassCreateFlagBits = 1 << 1;
16043pub const VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagBitsKHR = 1 << 1;
16044pub const VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagBitsKHR = 1 << 0;
16045pub const VK_RESOLVE_MODE_AVERAGE_BIT: VkResolveModeFlagBits = 1 << 1;
16046pub const VK_RESOLVE_MODE_AVERAGE_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_AVERAGE_BIT;
16047pub const VK_RESOLVE_MODE_CUSTOM_BIT_EXT: VkResolveModeFlagBits = 1 << 5;
16048pub const VK_RESOLVE_MODE_MAX_BIT: VkResolveModeFlagBits = 1 << 3;
16049pub const VK_RESOLVE_MODE_MAX_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_MAX_BIT;
16050pub const VK_RESOLVE_MODE_MIN_BIT: VkResolveModeFlagBits = 1 << 2;
16051pub const VK_RESOLVE_MODE_MIN_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_MIN_BIT;
16052pub const VK_RESOLVE_MODE_NONE: VkResolveModeFlagBits = 0;
16053pub const VK_RESOLVE_MODE_NONE_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_NONE;
16054pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT: VkResolveModeFlagBits = 1 << 0;
16055pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
16056pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: VkSamplerAddressMode = 3;
16057pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: VkSamplerAddressMode = 2;
16058pub const VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: VkSamplerAddressMode = 1;
16059pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: VkSamplerAddressMode = 4;
16060pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR: VkSamplerAddressMode = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
16061pub const VK_SAMPLER_ADDRESS_MODE_REPEAT: VkSamplerAddressMode = 0;
16062pub const VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkSamplerCreateFlagBits = 1 << 3;
16063pub const VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM: VkSamplerCreateFlagBits = 1 << 4;
16064pub const VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT: VkSamplerCreateFlagBits = 1 << 2;
16065pub const VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT: VkSamplerCreateFlagBits = 1 << 0;
16066pub const VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT: VkSamplerCreateFlagBits = 1 << 1;
16067pub const VK_SAMPLER_MIPMAP_MODE_LINEAR: VkSamplerMipmapMode = 1;
16068pub const VK_SAMPLER_MIPMAP_MODE_NEAREST: VkSamplerMipmapMode = 0;
16069pub const VK_SAMPLER_REDUCTION_MODE_MAX: VkSamplerReductionMode = 2;
16070pub const VK_SAMPLER_REDUCTION_MODE_MAX_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MAX;
16071pub const VK_SAMPLER_REDUCTION_MODE_MIN: VkSamplerReductionMode = 1;
16072pub const VK_SAMPLER_REDUCTION_MODE_MIN_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MIN;
16073pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE: VkSamplerReductionMode = 0;
16074pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
16075pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM: VkSamplerReductionMode = 1000521000;
16076pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: VkSamplerYcbcrModelConversion = 0;
16077pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
16078pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: VkSamplerYcbcrModelConversion = 4;
16079pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020;
16080pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: VkSamplerYcbcrModelConversion = 3;
16081pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
16082pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: VkSamplerYcbcrModelConversion = 2;
16083pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709;
16084pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: VkSamplerYcbcrModelConversion = 1;
16085pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY;
16086pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL: VkSamplerYcbcrRange = 0;
16087pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
16088pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW: VkSamplerYcbcrRange = 1;
16089pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW;
16090pub const VK_SAMPLE_COUNT_16_BIT: VkSampleCountFlagBits = 1 << 4;
16091pub const VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlagBits = 1 << 0;
16092pub const VK_SAMPLE_COUNT_2_BIT: VkSampleCountFlagBits = 1 << 1;
16093pub const VK_SAMPLE_COUNT_32_BIT: VkSampleCountFlagBits = 1 << 5;
16094pub const VK_SAMPLE_COUNT_4_BIT: VkSampleCountFlagBits = 1 << 2;
16095pub const VK_SAMPLE_COUNT_64_BIT: VkSampleCountFlagBits = 1 << 6;
16096pub const VK_SAMPLE_COUNT_8_BIT: VkSampleCountFlagBits = 1 << 3;
16097pub const VK_SCOPE_DEVICE_KHR: VkScopeKHR = 1;
16098pub const VK_SCOPE_DEVICE_NV: VkScopeKHR = VK_SCOPE_DEVICE_KHR;
16099pub const VK_SCOPE_QUEUE_FAMILY_KHR: VkScopeKHR = 5;
16100pub const VK_SCOPE_QUEUE_FAMILY_NV: VkScopeKHR = VK_SCOPE_QUEUE_FAMILY_KHR;
16101pub const VK_SCOPE_SUBGROUP_KHR: VkScopeKHR = 3;
16102pub const VK_SCOPE_SUBGROUP_NV: VkScopeKHR = VK_SCOPE_SUBGROUP_KHR;
16103pub const VK_SCOPE_WORKGROUP_KHR: VkScopeKHR = 2;
16104pub const VK_SCOPE_WORKGROUP_NV: VkScopeKHR = VK_SCOPE_WORKGROUP_KHR;
16105pub const VK_SEC_AMIGO_PROFILING_EXTENSION_NAME: &CStr = c"VK_SEC_amigo_profiling";
16106pub const VK_SEC_AMIGO_PROFILING_SPEC_VERSION: u32 = 1;
16107pub const VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME: &CStr = c"VK_SEC_pipeline_cache_incremental_mode";
16108pub const VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION: u32 = 1;
16109pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT: VkSemaphoreImportFlagBits = 1 << 0;
16110pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR: VkSemaphoreImportFlagBits = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT;
16111pub const VK_SEMAPHORE_TYPE_BINARY: VkSemaphoreType = 0;
16112pub const VK_SEMAPHORE_TYPE_BINARY_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_BINARY;
16113pub const VK_SEMAPHORE_TYPE_TIMELINE: VkSemaphoreType = 1;
16114pub const VK_SEMAPHORE_TYPE_TIMELINE_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
16115pub const VK_SEMAPHORE_WAIT_ANY_BIT: VkSemaphoreWaitFlagBits = 1 << 0;
16116pub const VK_SEMAPHORE_WAIT_ANY_BIT_KHR: VkSemaphoreWaitFlagBits = VK_SEMAPHORE_WAIT_ANY_BIT;
16117pub const VK_SHADER_CODE_TYPE_BINARY_EXT: VkShaderCodeTypeEXT = 0;
16118pub const VK_SHADER_CODE_TYPE_SPIRV_EXT: VkShaderCodeTypeEXT = 1;
16119pub const VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 15;
16120pub const VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 1;
16121pub const VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 10;
16122pub const VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 4;
16123pub const VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 6;
16124pub const VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 5;
16125pub const VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 7;
16126pub const VK_SHADER_CREATE_LINK_STAGE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 0;
16127pub const VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 3;
16128pub const VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 2;
16129pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY: VkShaderFloatControlsIndependence = 0;
16130pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY;
16131pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL: VkShaderFloatControlsIndependence = 1;
16132pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
16133pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE: VkShaderFloatControlsIndependence = 2;
16134pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;
16135pub const VK_SHADER_GROUP_SHADER_ANY_HIT_KHR: VkShaderGroupShaderKHR = 2;
16136pub const VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR: VkShaderGroupShaderKHR = 1;
16137pub const VK_SHADER_GROUP_SHADER_GENERAL_KHR: VkShaderGroupShaderKHR = 0;
16138pub const VK_SHADER_GROUP_SHADER_INTERSECTION_KHR: VkShaderGroupShaderKHR = 3;
16139pub const VK_SHADER_INFO_TYPE_BINARY_AMD: VkShaderInfoTypeAMD = 1;
16140pub const VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD: VkShaderInfoTypeAMD = 2;
16141pub const VK_SHADER_INFO_TYPE_STATISTICS_AMD: VkShaderInfoTypeAMD = 0;
16142pub const VK_SHADER_STAGE_ALL: VkShaderStageFlagBits = 0x7FFFFFFF;
16143pub const VK_SHADER_STAGE_ALL_GRAPHICS: VkShaderStageFlagBits = 0x0000001F;
16144pub const VK_SHADER_STAGE_ANY_HIT_BIT_KHR: VkShaderStageFlagBits = 1 << 9;
16145pub const VK_SHADER_STAGE_ANY_HIT_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
16146pub const VK_SHADER_STAGE_CALLABLE_BIT_KHR: VkShaderStageFlagBits = 1 << 13;
16147pub const VK_SHADER_STAGE_CALLABLE_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_CALLABLE_BIT_KHR;
16148pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: VkShaderStageFlagBits = 1 << 10;
16149pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
16150pub const VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI: VkShaderStageFlagBits = 1 << 19;
16151pub const VK_SHADER_STAGE_COMPUTE_BIT: VkShaderStageFlagBits = 1 << 5;
16152pub const VK_SHADER_STAGE_FRAGMENT_BIT: VkShaderStageFlagBits = 1 << 4;
16153pub const VK_SHADER_STAGE_GEOMETRY_BIT: VkShaderStageFlagBits = 1 << 3;
16154pub const VK_SHADER_STAGE_INTERSECTION_BIT_KHR: VkShaderStageFlagBits = 1 << 12;
16155pub const VK_SHADER_STAGE_INTERSECTION_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
16156pub const VK_SHADER_STAGE_MESH_BIT_EXT: VkShaderStageFlagBits = 1 << 7;
16157pub const VK_SHADER_STAGE_MESH_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_MESH_BIT_EXT;
16158pub const VK_SHADER_STAGE_MISS_BIT_KHR: VkShaderStageFlagBits = 1 << 11;
16159pub const VK_SHADER_STAGE_MISS_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_MISS_BIT_KHR;
16160pub const VK_SHADER_STAGE_RAYGEN_BIT_KHR: VkShaderStageFlagBits = 1 << 8;
16161pub const VK_SHADER_STAGE_RAYGEN_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
16162pub const VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI: VkShaderStageFlagBits = 1 << 14;
16163pub const VK_SHADER_STAGE_TASK_BIT_EXT: VkShaderStageFlagBits = 1 << 6;
16164pub const VK_SHADER_STAGE_TASK_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_TASK_BIT_EXT;
16165pub const VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: VkShaderStageFlagBits = 1 << 1;
16166pub const VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: VkShaderStageFlagBits = 1 << 2;
16167pub const VK_SHADER_STAGE_VERTEX_BIT: VkShaderStageFlagBits = 1 << 0;
16168pub const VK_SHADER_UNUSED_KHR: u32 = !0;
16169pub const VK_SHADER_UNUSED_NV: u32 = VK_SHADER_UNUSED_KHR;
16170pub const VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 1;
16171pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 7;
16172pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV: VkShadingRatePaletteEntryNV = 6;
16173pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 8;
16174pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV: VkShadingRatePaletteEntryNV = 10;
16175pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 9;
16176pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV: VkShadingRatePaletteEntryNV = 11;
16177pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 5;
16178pub const VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 4;
16179pub const VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 3;
16180pub const VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 2;
16181pub const VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV: VkShadingRatePaletteEntryNV = 0;
16182pub const VK_SHARING_MODE_CONCURRENT: VkSharingMode = 1;
16183pub const VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = 0;
16184pub const VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: VkSparseImageFormatFlagBits = 1 << 1;
16185pub const VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: VkSparseImageFormatFlagBits = 1 << 2;
16186pub const VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: VkSparseImageFormatFlagBits = 1 << 0;
16187pub const VK_SPARSE_MEMORY_BIND_METADATA_BIT: VkSparseMemoryBindFlagBits = 1 << 0;
16188pub const VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 8;
16189pub const VK_SPIRV_RESOURCE_TYPE_ALL_EXT: VkSpirvResourceTypeFlagBitsEXT = 0x7FFFFFFF;
16190pub const VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 4;
16191pub const VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 2;
16192pub const VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 6;
16193pub const VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 3;
16194pub const VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 7;
16195pub const VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 1;
16196pub const VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 0;
16197pub const VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM: VkSpirvResourceTypeFlagBitsEXT = 1 << 9;
16198pub const VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 5;
16199pub const VK_STENCIL_FACE_BACK_BIT: VkStencilFaceFlagBits = 1 << 1;
16200pub const VK_STENCIL_FACE_FRONT_AND_BACK: VkStencilFaceFlagBits = 0x00000003;
16201pub const VK_STENCIL_FACE_FRONT_BIT: VkStencilFaceFlagBits = 1 << 0;
16202pub const VK_STENCIL_FRONT_AND_BACK: VkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_AND_BACK;
16203pub const VK_STENCIL_OP_DECREMENT_AND_CLAMP: VkStencilOp = 4;
16204pub const VK_STENCIL_OP_DECREMENT_AND_WRAP: VkStencilOp = 7;
16205pub const VK_STENCIL_OP_INCREMENT_AND_CLAMP: VkStencilOp = 3;
16206pub const VK_STENCIL_OP_INCREMENT_AND_WRAP: VkStencilOp = 6;
16207pub const VK_STENCIL_OP_INVERT: VkStencilOp = 5;
16208pub const VK_STENCIL_OP_KEEP: VkStencilOp = 0;
16209pub const VK_STENCIL_OP_REPLACE: VkStencilOp = 2;
16210pub const VK_STENCIL_OP_ZERO: VkStencilOp = 1;
16211pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: VkStructureType = 1000150000;
16212pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: VkStructureType = 1000150020;
16213pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316009;
16214pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: VkStructureType = 1000150017;
16215pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = 1000165001;
16216pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: VkStructureType = 1000150002;
16217pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: VkStructureType = 1000150003;
16218pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: VkStructureType = 1000150004;
16219pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: VkStructureType = 1000150006;
16220pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: VkStructureType = 1000429009;
16221pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: VkStructureType = 1000327000;
16222pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: VkStructureType = 1000429010;
16223pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: VkStructureType = 1000150005;
16224pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = 1000165012;
16225pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = 1000165008;
16226pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: VkStructureType = 1000327002;
16227pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: VkStructureType = 1000396009;
16228pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: VkStructureType = 1000150009;
16229pub const VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: VkStructureType = 1000060010;
16230pub const VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: VkStructureType = 1000116004;
16231pub const VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: VkStructureType = 1000485001;
16232pub const VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: VkStructureType = 1000476001;
16233pub const VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: VkStructureType = 1000476002;
16234pub const VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = 0;
16235pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: VkStructureType = 1000109000;
16236pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
16237pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: VkStructureType = 1000241002;
16238pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
16239pub const VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: VkStructureType = 1000527001;
16240pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: VkStructureType = 1000109001;
16241pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
16242pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: VkStructureType = 1000241001;
16243pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
16244pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: VkStructureType = 1000044008;
16245pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
16246pub const VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: VkStructureType = 1000628001;
16247pub const VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: VkStructureType = 1000165006;
16248pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060013;
16249pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
16250pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: VkStructureType = 1000157000;
16251pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO;
16252pub const VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: VkStructureType = 1000507005;
16253pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: VkStructureType = 1000545008;
16254pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: VkStructureType = 1000545003;
16255pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO;
16256pub const VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT: VkStructureType = 1000135003;
16257pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060014;
16258pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
16259pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: VkStructureType = 1000157001;
16260pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
16261pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: VkStructureType = 1000060009;
16262pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: VkStructureType = 1000156002;
16263pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
16264pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: VkStructureType = 1000545002;
16265pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS;
16266pub const VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: VkStructureType = 7;
16267pub const VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: VkStructureType = 1000460002;
16268pub const VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: VkStructureType = 1000023004;
16269pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: VkStructureType = 1000519002;
16270pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: VkStructureType = 1000337004;
16271pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2;
16272pub const VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316005;
16273pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2: VkStructureType = 1000337006;
16274pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COPY_2;
16275pub const VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = 12;
16276pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: VkStructureType = 1000244002;
16277pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: VkStructureType = 1000244001;
16278pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
16279pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
16280pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: VkStructureType = 1000337009;
16281pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2;
16282pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = 44;
16283pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: VkStructureType = 1000314001;
16284pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2;
16285pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146000;
16286pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
16287pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: VkStructureType = 1000257002;
16288pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
16289pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: VkStructureType = 1000470006;
16290pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO;
16291pub const VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: VkStructureType = 13;
16292pub const VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = 1000570004;
16293pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR;
16294pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: VkStructureType = 1000184000;
16295pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: VkStructureType = 1000314009;
16296pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: VkStructureType = 1000206000;
16297pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: VkStructureType = 1000569002;
16298pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: VkStructureType = 1000569006;
16299pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: VkStructureType = 1000569005;
16300pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: VkStructureType = 1000569004;
16301pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: VkStructureType = 1000569003;
16302pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = 40;
16303pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 42;
16304pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: VkStructureType = 1000081000;
16305pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT: VkStructureType = 1000135010;
16306pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: VkStructureType = 41;
16307pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: VkStructureType = 1000044004;
16308pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
16309pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: VkStructureType = 1000282000;
16310pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: VkStructureType = 1000278001;
16311pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: VkStructureType = 1000314006;
16312pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
16313pub const VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = 39;
16314pub const VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: VkStructureType = 1000645000;
16315pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = 29;
16316pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: VkStructureType = 1000428001;
16317pub const VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: VkStructureType = 1000081002;
16318pub const VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: VkStructureType = 1000491004;
16319pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: VkStructureType = 1000593001;
16320pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = 1000506001;
16321pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = 1000249001;
16322pub const VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = 1000491002;
16323pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = 1000150010;
16324pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: VkStructureType = 1000150011;
16325pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: VkStructureType = 1000337000;
16326pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2;
16327pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: VkStructureType = 1000337002;
16328pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2;
16329pub const VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: VkStructureType = 1000333000;
16330pub const VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: VkStructureType = 36;
16331pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: VkStructureType = 1000337001;
16332pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2;
16333pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: VkStructureType = 1000337003;
16334pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2;
16335pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: VkStructureType = 1000270007;
16336pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO;
16337pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: VkStructureType = 1000270004;
16338pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO;
16339pub const VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: VkStructureType = 1000549002;
16340pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = 1000150012;
16341pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: VkStructureType = 1000549003;
16342pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: VkStructureType = 1000270005;
16343pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO;
16344pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: VkStructureType = 1000396004;
16345pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: VkStructureType = 1000396002;
16346pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: VkStructureType = 1000396003;
16347pub const VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: VkStructureType = 1000460011;
16348pub const VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: VkStructureType = 1000628002;
16349pub const VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: VkStructureType = 1000029001;
16350pub const VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: VkStructureType = 1000029002;
16351pub const VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: VkStructureType = 1000029000;
16352pub const VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: VkStructureType = 1000029004;
16353pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: VkStructureType = 1000629001;
16354pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: VkStructureType = 1000507010;
16355pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: VkStructureType = 1000507003;
16356pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: VkStructureType = 1000507015;
16357pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: VkStructureType = 1000507000;
16358pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: VkStructureType = 1000507014;
16359pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: VkStructureType = 1000507013;
16360pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: VkStructureType = 1000507009;
16361pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: VkStructureType = 1000507008;
16362pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: VkStructureType = 1000507002;
16363pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: VkStructureType = 1000507011;
16364pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: VkStructureType = 1000507012;
16365pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: VkStructureType = 1000507001;
16366pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = 1000507004;
16367pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: VkStructureType = 1000507007;
16368pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: VkStructureType = 1000507016;
16369pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: VkStructureType = 1000022002;
16370pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: VkStructureType = 1000022000;
16371pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: VkStructureType = 1000022001;
16372pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: VkStructureType = 1000011000;
16373pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
16374pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: VkStructureType = 1000128002;
16375pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: VkStructureType = 1000128003;
16376pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: VkStructureType = 1000128004;
16377pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: VkStructureType = 1000128000;
16378pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: VkStructureType = 1000128001;
16379pub const VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: VkStructureType = 1000550002;
16380pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: VkStructureType = 1000026001;
16381pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: VkStructureType = 1000026000;
16382pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000026002;
16383pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO: VkStructureType = 1000314003;
16384pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
16385pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: VkStructureType = 1000283001;
16386pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: VkStructureType = 1000283002;
16387pub const VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: VkStructureType = 1000316003;
16388pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: VkStructureType = 1000316011;
16389pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: VkStructureType = 1000316012;
16390pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: VkStructureType = 1000316004;
16391pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: VkStructureType = 1000460020;
16392pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = 33;
16393pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: VkStructureType = 1000138003;
16394pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
16395pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = 34;
16396pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT: VkStructureType = 1000135005;
16397pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: VkStructureType = 1000420001;
16398pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: VkStructureType = 1000161000;
16399pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
16400pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = 32;
16401pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: VkStructureType = 1000420002;
16402pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: VkStructureType = 1000168001;
16403pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT;
16404pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: VkStructureType = 1000161003;
16405pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
16406pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: VkStructureType = 1000161004;
16407pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
16408pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: VkStructureType = 1000085000;
16409pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
16410pub const VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: VkStructureType = 1000354001;
16411pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: VkStructureType = 1000413002;
16412pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS;
16413pub const VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = 3;
16414pub const VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: VkStructureType = 1000284001;
16415pub const VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: VkStructureType = 1000300001;
16416pub const VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: VkStructureType = 1000091001;
16417pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: VkStructureType = 1000341001;
16418pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: VkStructureType = 1000341002;
16419pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: VkStructureType = 1000060006;
16420pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
16421pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 1000060004;
16422pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
16423pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: VkStructureType = 1000070001;
16424pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
16425pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: VkStructureType = 1000060007;
16426pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: VkStructureType = 1000060011;
16427pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: VkStructureType = 1000060003;
16428pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
16429pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: VkStructureType = 1000060005;
16430pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
16431pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060012;
16432pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: VkStructureType = 1000413003;
16433pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS;
16434pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: VkStructureType = 1000470004;
16435pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO;
16436pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: VkStructureType = 1000257004;
16437pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
16438pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: VkStructureType = 1000189000;
16439pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: VkStructureType = 1000284002;
16440pub const VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: VkStructureType = 1000483008;
16441pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: VkStructureType = 1000295001;
16442pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
16443pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = 2;
16444pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: VkStructureType = 1000174000;
16445pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
16446pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
16447pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: VkStructureType = 1000145003;
16448pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: VkStructureType = 1000417000;
16449pub const VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: VkStructureType = 1000460010;
16450pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: VkStructureType = 1000459000;
16451pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: VkStructureType = 1000459001;
16452pub const VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: VkStructureType = 1000309005;
16453pub const VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: VkStructureType = 1000091002;
16454pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: VkStructureType = 1000002000;
16455pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: VkStructureType = 1000121002;
16456pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: VkStructureType = 1000551001;
16457pub const VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: VkStructureType = 1000213000;
16458pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: VkStructureType = 1000121004;
16459pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: VkStructureType = 1000121003;
16460pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: VkStructureType = 1000121001;
16461pub const VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: VkStructureType = 1000091000;
16462pub const VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: VkStructureType = 1000003000;
16463pub const VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: VkStructureType = 1000121000;
16464pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000002001;
16465pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: VkStructureType = 1000551000;
16466pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: VkStructureType = 1000158006;
16467pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: VkStructureType = 1000158000;
16468pub const VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: VkStructureType = 10;
16469pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: VkStructureType = 1000113000;
16470pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
16471pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = 1000072002;
16472pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
16473pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000056001;
16474pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = 1000077000;
16475pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
16476pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: VkStructureType = 1000071003;
16477pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES;
16478pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: VkStructureType = 1000556001;
16479pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: VkStructureType = 1000556002;
16480pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: VkStructureType = 1000556000;
16481pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: VkStructureType = 1000112001;
16482pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES;
16483pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000071001;
16484pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
16485pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: VkStructureType = 1000453000;
16486pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: VkStructureType = 1000072000;
16487pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
16488pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = 1000072001;
16489pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
16490pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: VkStructureType = 1000056000;
16491pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: VkStructureType = 1000460017;
16492pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: VkStructureType = 1000076001;
16493pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES;
16494pub const VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460016;
16495pub const VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: VkStructureType = 8;
16496pub const VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: VkStructureType = 1000115001;
16497pub const VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: VkStructureType = 1000170001;
16498pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = 1000059002;
16499pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
16500pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: VkStructureType = 1000360000;
16501pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
16502pub const VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = 1000226000;
16503pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: VkStructureType = 1000108001;
16504pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
16505pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: VkStructureType = 1000108002;
16506pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
16507pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: VkStructureType = 37;
16508pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: VkStructureType = 1000250002;
16509pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: VkStructureType = 1000375001;
16510pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: VkStructureType = 1000460023;
16511pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: VkStructureType = 1000572004;
16512pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: VkStructureType = 1000277005;
16513pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: VkStructureType = 1000572002;
16514pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = 1000277006;
16515pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: VkStructureType = 1000572013;
16516pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: VkStructureType = 1000572014;
16517pub const VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: VkStructureType = 1000165005;
16518pub const VK_STRUCTURE_TYPE_GEOMETRY_NV: VkStructureType = 1000165003;
16519pub const VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: VkStructureType = 1000165004;
16520pub const VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: VkStructureType = 1000505003;
16521pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = 28;
16522pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: VkStructureType = 1000320002;
16523pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: VkStructureType = 1000277002;
16524pub const VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = 1000277001;
16525pub const VK_STRUCTURE_TYPE_HDR_METADATA_EXT: VkStructureType = 1000105000;
16526pub const VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: VkStructureType = 1000590001;
16527pub const VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: VkStructureType = 1000256000;
16528pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: VkStructureType = 1000270009;
16529pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY;
16530pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: VkStructureType = 1000270006;
16531pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO;
16532pub const VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: VkStructureType = 1000575002;
16533pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2: VkStructureType = 1000337008;
16534pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2;
16535pub const VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316006;
16536pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: VkStructureType = 1000338001;
16537pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: VkStructureType = 1000338004;
16538pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2: VkStructureType = 1000337007;
16539pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_COPY_2;
16540pub const VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = 14;
16541pub const VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT: VkStructureType = 1000135001;
16542pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: VkStructureType = 1000158004;
16543pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: VkStructureType = 1000158003;
16544pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = 1000158005;
16545pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: VkStructureType = 1000147000;
16546pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
16547pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059003;
16548pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
16549pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = 45;
16550pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: VkStructureType = 1000314002;
16551pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
16552pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146001;
16553pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
16554pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: VkStructureType = 1000156003;
16555pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
16556pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: VkStructureType = 1000337010;
16557pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2;
16558pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146002;
16559pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
16560pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: VkStructureType = 1000246000;
16561pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
16562pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: VkStructureType = 1000338003;
16563pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
16564pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
16565pub const VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060008;
16566pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: VkStructureType = 1000270003;
16567pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY;
16568pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: VkStructureType = 1000030001;
16569pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: VkStructureType = 1000067000;
16570pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316007;
16571pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = 15;
16572pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: VkStructureType = 1000030000;
16573pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: VkStructureType = 1000391001;
16574pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: VkStructureType = 1000440002;
16575pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: VkStructureType = 1000418001;
16576pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: VkStructureType = 1000117002;
16577pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
16578pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: VkStructureType = 1000115000;
16579pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: VkStructureType = 1000074000;
16580pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: VkStructureType = 1000178000;
16581pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: VkStructureType = 1000079000;
16582pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: VkStructureType = 1000572006;
16583pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: VkStructureType = 1000277004;
16584pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV: VkStructureType = 1000135012;
16585pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: VkStructureType = 1000572007;
16586pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: VkStructureType = 1000277003;
16587pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: VkStructureType = 1000572003;
16588pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: VkStructureType = 1000572010;
16589pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: VkStructureType = 1000572011;
16590pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: VkStructureType = 1000572012;
16591pub const VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: VkStructureType = 1000210001;
16592pub const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = 1;
16593pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: VkStructureType = 1000505001;
16594pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: VkStructureType = 1000505000;
16595pub const VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: VkStructureType = 1000505005;
16596pub const VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: VkStructureType = 1000505008;
16597pub const VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: VkStructureType = 1000505004;
16598pub const VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: VkStructureType = 1000496000;
16599pub const VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: VkStructureType = 48;
16600pub const VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: VkStructureType = 47;
16601pub const VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = 6;
16602pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: VkStructureType = 1000060000;
16603pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
16604pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = 5;
16605pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = 46;
16606pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: VkStructureType = 1000314000;
16607pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
16608pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: VkStructureType = 1000574002;
16609pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = 1000127001;
16610pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
16611pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: VkStructureType = 1000460014;
16612pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: VkStructureType = 1000127000;
16613pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
16614pub const VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: VkStructureType = 1000074001;
16615pub const VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = 1000074002;
16616pub const VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: VkStructureType = 1000371000;
16617pub const VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: VkStructureType = 1000178001;
16618pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: VkStructureType = 1000271000;
16619pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO;
16620pub const VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: VkStructureType = 1000272002;
16621pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: VkStructureType = 1000257003;
16622pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
16623pub const VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: VkStructureType = 1000238001;
16624pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146003;
16625pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
16626pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: VkStructureType = 1000270002;
16627pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY;
16628pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: VkStructureType = 1000271001;
16629pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO;
16630pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: VkStructureType = 1000396000;
16631pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: VkStructureType = 1000396008;
16632pub const VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: VkStructureType = 1000396007;
16633pub const VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: VkStructureType = 1000396001;
16634pub const VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: VkStructureType = 1000376002;
16635pub const VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: VkStructureType = 1000143004;
16636pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: VkStructureType = 1000044009;
16637pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: VkStructureType = 1000510001;
16638pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: VkStructureType = 1000351002;
16639pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: VkStructureType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
16640pub const VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: VkStructureType = 1000135007;
16641pub const VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: VkStructureType = 1000316010;
16642pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: VkStructureType = 1000464005;
16643pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: VkStructureType = 1000464002;
16644pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: VkStructureType = 1000464003;
16645pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: VkStructureType = 1000464004;
16646pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: VkStructureType = 1000464010;
16647pub const VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: VkStructureType = 1000505006;
16648pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: VkStructureType = 1000570005;
16649pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: VkStructureType = 1000570003;
16650pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: VkStructureType = 1000208007;
16651pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: VkStructureType = 1000208005;
16652pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: VkStructureType = 1000208006;
16653pub const VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: VkStructureType = 1000210005;
16654pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: VkStructureType = 1000605002;
16655pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: VkStructureType = 1000605003;
16656pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: VkStructureType = 1000116006;
16657pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: VkStructureType = 1000116005;
16658pub const VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: VkStructureType = 1000210002;
16659pub const VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: VkStructureType = 1000210004;
16660pub const VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: VkStructureType = 1000116003;
16661pub const VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: VkStructureType = 1000210003;
16662pub const VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: VkStructureType = 1000309003;
16663pub const VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: VkStructureType = 1000309004;
16664pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = 1000083000;
16665pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
16666pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: VkStructureType = 1000340000;
16667pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: VkStructureType = 1000177000;
16668pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
16669pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: VkStructureType = 1000150013;
16670pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: VkStructureType = 1000150014;
16671pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: VkStructureType = 1000354000;
16672pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: VkStructureType = 1000485000;
16673pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: VkStructureType = 1000476000;
16674pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: VkStructureType = 1000067001;
16675pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000524000;
16676pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: VkStructureType = 1000339000;
16677pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: VkStructureType = 1000148000;
16678pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: VkStructureType = 1000148001;
16679pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: VkStructureType = 1000411000;
16680pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
16681pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: VkStructureType = 1000257000;
16682pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: VkStructureType = 1000244000;
16683pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
16684pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = 1000569000;
16685pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = 1000569001;
16686pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: VkStructureType = 1000404000;
16687pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: VkStructureType = 1000404001;
16688pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: VkStructureType = 1000404002;
16689pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: VkStructureType = 1000229000;
16690pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: VkStructureType = 1000381000;
16691pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: VkStructureType = 1000559000;
16692pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: VkStructureType = 1000645001;
16693pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: VkStructureType = 1000201000;
16694pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
16695pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: VkStructureType = 1000511000;
16696pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: VkStructureType = 1000081001;
16697pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = 1000101000;
16698pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: VkStructureType = 1000593000;
16699pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: VkStructureType = 1000593002;
16700pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: VkStructureType = 1000506000;
16701pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: VkStructureType = 1000249000;
16702pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = 1000506002;
16703pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = 1000249002;
16704pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: VkStructureType = 1000491000;
16705pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = 1000491001;
16706pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: VkStructureType = 1000549000;
16707pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: VkStructureType = 1000426000;
16708pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: VkStructureType = 1000426001;
16709pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
16710pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: VkStructureType = 1000050000;
16711pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: VkStructureType = 1000250000;
16712pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: VkStructureType = 1000521000;
16713pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: VkStructureType = 1000519001;
16714pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: VkStructureType = 1000287002;
16715pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: VkStructureType = 1000287001;
16716pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: VkStructureType = 1000628000;
16717pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: VkStructureType = 1000507006;
16718pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: VkStructureType = 1000629000;
16719pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: VkStructureType = 1000240000;
16720pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: VkStructureType = 1000283000;
16721pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: VkStructureType = 1000582000;
16722pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
16723pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: VkStructureType = 1000421000;
16724pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: VkStructureType = 1000355000;
16725pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: VkStructureType = 1000102000;
16726pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: VkStructureType = 1000199000;
16727pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
16728pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = 1000316001;
16729pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: VkStructureType = 1000316002;
16730pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: VkStructureType = 1000316000;
16731pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: VkStructureType = 1000460018;
16732pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460019;
16733pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: VkStructureType = 1000135009;
16734pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT: VkStructureType = 1000135008;
16735pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM: VkStructureType = 1000135014;
16736pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: VkStructureType = 1000161001;
16737pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
16738pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: VkStructureType = 1000161002;
16739pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
16740pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: VkStructureType = 1000546000;
16741pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: VkStructureType = 1000420000;
16742pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: VkStructureType = 1000428000;
16743pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: VkStructureType = 1000572000;
16744pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: VkStructureType = 1000277007;
16745pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: VkStructureType = 1000572001;
16746pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: VkStructureType = 1000277000;
16747pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: VkStructureType = 1000284000;
16748pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: VkStructureType = 1000300000;
16749pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: VkStructureType = 1000099000;
16750pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: VkStructureType = 1000196000;
16751pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
16752pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: VkStructureType = 1000353000;
16753pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: VkStructureType = 1000044003;
16754pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
16755pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: VkStructureType = 1000232000;
16756pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
16757pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: VkStructureType = 1000499000;
16758pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: VkStructureType = 1000205002;
16759pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: VkStructureType = 1000377000;
16760pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: VkStructureType = 1000455000;
16761pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: VkStructureType = 1000455001;
16762pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000267000;
16763pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: VkStructureType = 1000492000;
16764pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: VkStructureType = 1000492001;
16765pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: VkStructureType = 1000071002;
16766pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
16767pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: VkStructureType = 1000556003;
16768pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: VkStructureType = 1000112000;
16769pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
16770pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: VkStructureType = 1000071000;
16771pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
16772pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: VkStructureType = 1000178002;
16773pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: VkStructureType = 1000371001;
16774pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: VkStructureType = 1000076000;
16775pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
16776pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: VkStructureType = 1000460015;
16777pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: VkStructureType = 1000341000;
16778pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = 1000059000;
16779pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
16780pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
16781pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: VkStructureType = 1000197000;
16782pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
16783pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: VkStructureType = 1000609000;
16784pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: VkStructureType = 1000332000;
16785pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: VkStructureType = 1000332001;
16786pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: VkStructureType = 1000218000;
16787pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: VkStructureType = 1000611000;
16788pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: VkStructureType = 1000611001;
16789pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: VkStructureType = 1000425000;
16790pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
16791pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: VkStructureType = 1000425001;
16792pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
16793pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = 1000218001;
16794pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: VkStructureType = 1000203000;
16795pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
16796pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: VkStructureType = 1000322000;
16797pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: VkStructureType = 1000251000;
16798pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: VkStructureType = 1000326001;
16799pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: VkStructureType = 1000326000;
16800pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: VkStructureType = 1000226003;
16801pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: VkStructureType = 1000226004;
16802pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: VkStructureType = 1000226002;
16803pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: VkStructureType = 1000375000;
16804pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: VkStructureType = 1000388000;
16805pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
16806pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
16807pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: VkStructureType = 1000320000;
16808pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: VkStructureType = 1000320001;
16809pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: VkStructureType = 1000070000;
16810pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
16811pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: VkStructureType = 1000590000;
16812pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: VkStructureType = 1000270000;
16813pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
16814pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: VkStructureType = 1000270001;
16815pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
16816pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: VkStructureType = 1000261000;
16817pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
16818pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: VkStructureType = 1000071004;
16819pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
16820pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: VkStructureType = 1000108000;
16821pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
16822pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: VkStructureType = 1000393000;
16823pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: VkStructureType = 1000575000;
16824pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: VkStructureType = 1000575001;
16825pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: VkStructureType = 1000338000;
16826pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: VkStructureType = 1000437000;
16827pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: VkStructureType = 1000158002;
16828pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059004;
16829pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
16830pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: VkStructureType = 1000518000;
16831pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: VkStructureType = 1000518001;
16832pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: VkStructureType = 1000440000;
16833pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: VkStructureType = 1000440001;
16834pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: VkStructureType = 1000335000;
16835pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
16836pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: VkStructureType = 1000418000;
16837pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: VkStructureType = 1000170000;
16838pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: VkStructureType = 1000391000;
16839pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: VkStructureType = 1000265000;
16840pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
16841pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
16842pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: VkStructureType = 1000278000;
16843pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: VkStructureType = 1000138000;
16844pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
16845pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: VkStructureType = 1000138001;
16846pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
16847pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: VkStructureType = 1000504000;
16848pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: VkStructureType = 1000370000;
16849pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: VkStructureType = 1000562003;
16850pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: VkStructureType = 1000562002;
16851pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: VkStructureType = 1000562004;
16852pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: VkStructureType = 1000530000;
16853pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: VkStructureType = 1000465000;
16854pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: VkStructureType = 1000495000;
16855pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: VkStructureType = 1000495001;
16856pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: VkStructureType = 1000430000;
16857pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: VkStructureType = 1000259000;
16858pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
16859pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
16860pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: VkStructureType = 1000259002;
16861pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
16862pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
16863pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: VkStructureType = 1000630000;
16864pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: VkStructureType = 1000630001;
16865pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: VkStructureType = 1000168000;
16866pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
16867pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: VkStructureType = 1000413000;
16868pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
16869pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: VkStructureType = 1000413001;
16870pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
16871pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: VkStructureType = 1000470000;
16872pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
16873pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: VkStructureType = 1000470001;
16874pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
16875pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: VkStructureType = 1000545000;
16876pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
16877pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: VkStructureType = 1000545001;
16878pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
16879pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: VkStructureType = 1000562000;
16880pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: VkStructureType = 1000562001;
16881pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: VkStructureType = 1000574000;
16882pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: VkStructureType = 1000584000;
16883pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: VkStructureType = 1000584001;
16884pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: VkStructureType = 1000272000;
16885pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: VkStructureType = 1000272001;
16886pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: VkStructureType = 1000237000;
16887pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: VkStructureType = 1000427000;
16888pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT;
16889pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: VkStructureType = 1000427001;
16890pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT;
16891pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: VkStructureType = 1000238000;
16892pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: VkStructureType = 1000059006;
16893pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
16894pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: VkStructureType = 1000328000;
16895pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: VkStructureType = 1000202000;
16896pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: VkStructureType = 1000328001;
16897pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: VkStructureType = 1000202001;
16898pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: VkStructureType = 1000376000;
16899pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: VkStructureType = 1000053001;
16900pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
16901pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: VkStructureType = 1000097000;
16902pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: VkStructureType = 1000510000;
16903pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: VkStructureType = 1000488000;
16904pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: VkStructureType = 1000053002;
16905pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
16906pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: VkStructureType = 1000392000;
16907pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: VkStructureType = 1000392001;
16908pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: VkStructureType = 1000351000;
16909pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
16910pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: VkStructureType = 1000451000;
16911pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: VkStructureType = 1000451001;
16912pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: VkStructureType = 1000422000;
16913pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: VkStructureType = 1000396005;
16914pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: VkStructureType = 1000396006;
16915pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: VkStructureType = 1000464000;
16916pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: VkStructureType = 1000464001;
16917pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: VkStructureType = 1000412000;
16918pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = 1000570000;
16919pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = 1000570001;
16920pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: VkStructureType = 1000212000;
16921pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: VkStructureType = 1000605000;
16922pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: VkStructureType = 1000605001;
16923pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: VkStructureType = 1000116000;
16924pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: VkStructureType = 1000116001;
16925pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: VkStructureType = 1000516000;
16926pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: VkStructureType = 1000483000;
16927pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: VkStructureType = 1000483004;
16928pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: VkStructureType = 1000637000;
16929pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: VkStructureType = 1000297000;
16930pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
16931pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: VkStructureType = 1000269000;
16932pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: VkStructureType = 1000498000;
16933pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: VkStructureType = 1000596000;
16934pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: VkStructureType = 1000372001;
16935pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: VkStructureType = 1000466000;
16936pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
16937pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: VkStructureType = 1000068001;
16938pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
16939pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: VkStructureType = 1000068002;
16940pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
16941pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: VkStructureType = 1000117000;
16942pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
16943pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: VkStructureType = 1000292000;
16944pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: VkStructureType = 1000479002;
16945pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: VkStructureType = 1000294001;
16946pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR;
16947pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: VkStructureType = 1000361000;
16948pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: VkStructureType = 1000208000;
16949pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: VkStructureType = 1000480001;
16950pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: VkStructureType = 1000248000;
16951pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: VkStructureType = 1000382000;
16952pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: VkStructureType = 1000356000;
16953pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: VkStructureType = 1000295000;
16954pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
16955pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = 1000059001;
16956pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
16957pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: VkStructureType = 1000145001;
16958pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: VkStructureType = 1000145002;
16959pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: VkStructureType = 1000254000;
16960pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: VkStructureType = 1000254002;
16961pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: VkStructureType = 1000580001;
16962pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV: VkStructureType = 1000580002;
16963pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: VkStructureType = 1000080000;
16964pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
16965pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: VkStructureType = 1000507019;
16966pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
16967pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: VkStructureType = 1000342000;
16968pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: VkStructureType = 1000555000;
16969pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: VkStructureType = 1000348013;
16970pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: VkStructureType = 1000581000;
16971pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: VkStructureType = 1000490000;
16972pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: VkStructureType = 1000581001;
16973pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: VkStructureType = 1000490001;
16974pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: VkStructureType = 1000429008;
16975pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000386000;
16976pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: VkStructureType = 1000327001;
16977pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: VkStructureType = 1000347000;
16978pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: VkStructureType = 1000347001;
16979pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: VkStructureType = 1000481000;
16980pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: VkStructureType = 1000165009;
16981pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: VkStructureType = 1000568000;
16982pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: VkStructureType = 1000110000;
16983pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: VkStructureType = 1000424000;
16984pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: VkStructureType = 1000424001;
16985pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: VkStructureType = 1000166000;
16986pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: VkStructureType = 1000344000;
16987pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
16988pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: VkStructureType = 1000286000;
16989pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
16990pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: VkStructureType = 1000286001;
16991pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: VkStructureType = 1000130000;
16992pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
16993pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: VkStructureType = 1000156004;
16994pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
16995pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: VkStructureType = 1000143003;
16996pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: VkStructureType = 1000221000;
16997pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
16998pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: VkStructureType = 1000417001;
16999pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: VkStructureType = 1000417002;
17000pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: VkStructureType = 1000241000;
17001pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
17002pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: VkStructureType = 1000627000;
17003pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: VkStructureType = 1000563000;
17004pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: VkStructureType = 1000273000;
17005pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: VkStructureType = 1000260000;
17006pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: VkStructureType = 1000180000;
17007pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
17008pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: VkStructureType = 1000141000;
17009pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: VkStructureType = 1000181000;
17010pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: VkStructureType = 1000497000;
17011pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: VkStructureType = 1000497001;
17012pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: VkStructureType = 1000227000;
17013pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: VkStructureType = 1000185000;
17014pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: VkStructureType = 1000415000;
17015pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: VkStructureType = 1000276000;
17016pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES;
17017pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: VkStructureType = 1000063000;
17018pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
17019pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: VkStructureType = 1000321000;
17020pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: VkStructureType = 1000544000;
17021pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
17022pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: VkStructureType = 1000082000;
17023pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
17024pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: VkStructureType = 1000567000;
17025pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: VkStructureType = 1000528000;
17026pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
17027pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: VkStructureType = 1000579000;
17028pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: VkStructureType = 1000234000;
17029pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: VkStructureType = 1000204000;
17030pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: VkStructureType = 1000280000;
17031pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
17032pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: VkStructureType = 1000280001;
17033pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
17034pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: VkStructureType = 1000209000;
17035pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: VkStructureType = 1000635000;
17036pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: VkStructureType = 1000635001;
17037pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: VkStructureType = 1000434000;
17038pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: VkStructureType = 1000462000;
17039pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: VkStructureType = 1000462001;
17040pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: VkStructureType = 1000482000;
17041pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: VkStructureType = 1000482001;
17042pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: VkStructureType = 1000235000;
17043pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: VkStructureType = 1000558000;
17044pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: VkStructureType = 1000564000;
17045pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: VkStructureType = 1000154000;
17046pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: VkStructureType = 1000154001;
17047pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: VkStructureType = 1000175000;
17048pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
17049pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: VkStructureType = 1000662000;
17050pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: VkStructureType = 1000416000;
17051pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
17052pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: VkStructureType = 1000323000;
17053pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: VkStructureType = 1000215000;
17054pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
17055pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: VkStructureType = 1000395000;
17056pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: VkStructureType = 1000395001;
17057pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: VkStructureType = 1000642000;
17058pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: VkStructureType = 1000387000;
17059pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: VkStructureType = 1000164001;
17060pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: VkStructureType = 1000164002;
17061pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059008;
17062pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
17063pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: VkStructureType = 1000094000;
17064pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: VkStructureType = 1000225002;
17065pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
17066pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: VkStructureType = 1000225000;
17067pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
17068pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: VkStructureType = 1000458000;
17069pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: VkStructureType = 1000369001;
17070pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: VkStructureType = 1000369002;
17071pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: VkStructureType = 1000119000;
17072pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
17073pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000275000;
17074pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: VkStructureType = 1000314007;
17075pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
17076pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: VkStructureType = 1000460009;
17077pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460004;
17078pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: VkStructureType = 1000281000;
17079pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: VkStructureType = 1000281001;
17080pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
17081pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: VkStructureType = 1000288000;
17082pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: VkStructureType = 1000066000;
17083pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
17084pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: VkStructureType = 1000547000;
17085pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: VkStructureType = 1000547001;
17086pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: VkStructureType = 1000484000;
17087pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: VkStructureType = 1000309000;
17088pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: VkStructureType = 1000309001;
17089pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: VkStructureType = 1000207000;
17090pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
17091pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: VkStructureType = 1000207001;
17092pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
17093pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: VkStructureType = 1000245000;
17094pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES;
17095pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: VkStructureType = 1000028000;
17096pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: VkStructureType = 1000028001;
17097pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: VkStructureType = 1000527000;
17098pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: VkStructureType = 1000253000;
17099pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
17100pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: VkStructureType = 1000120000;
17101pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
17102pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
17103pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
17104pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: VkStructureType = 1000190002;
17105pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
17106pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
17107pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: VkStructureType = 1000525000;
17108pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: VkStructureType = 1000190000;
17109pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
17110pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: VkStructureType = 1000608000;
17111pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000352000;
17112pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: VkStructureType = 1000514000;
17113pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: VkStructureType = 1000513004;
17114pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: VkStructureType = 1000552004;
17115pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = 1000299006;
17116pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: VkStructureType = 1000553009;
17117pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: VkStructureType = 1000390000;
17118pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: VkStructureType = 1000023014;
17119pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000515000;
17120pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: VkStructureType = 1000586000;
17121pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: VkStructureType = 49;
17122pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: VkStructureType = 50;
17123pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: VkStructureType = 51;
17124pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: VkStructureType = 52;
17125pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: VkStructureType = 53;
17126pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: VkStructureType = 54;
17127pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: VkStructureType = 55;
17128pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: VkStructureType = 56;
17129pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: VkStructureType = 1000211000;
17130pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
17131pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: VkStructureType = 1000336000;
17132pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: VkStructureType = 1000330000;
17133pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: VkStructureType = 1000520000;
17134pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: VkStructureType = 1000252000;
17135pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: VkStructureType = 1000620000;
17136pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: VkStructureType = 1000325000;
17137pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
17138pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: VkStructureType = 1000483001;
17139pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: VkStructureType = 1000483006;
17140pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: VkStructureType = 1000483009;
17141pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: VkStructureType = 1000483002;
17142pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: VkStructureType = 1000483003;
17143pub const VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: VkStructureType = 17;
17144pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: VkStructureType = 1000148002;
17145pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = 26;
17146pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: VkStructureType = 1000381001;
17147pub const VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: VkStructureType = 1000183000;
17148pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: VkStructureType = 1000152000;
17149pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: VkStructureType = 1000250001;
17150pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: VkStructureType = 1000149000;
17151pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: VkStructureType = 1000470005;
17152pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
17153pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: VkStructureType = 1000483007;
17154pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: VkStructureType = 1000192000;
17155pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
17156pub const VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = 25;
17157pub const VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: VkStructureType = 1000099001;
17158pub const VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = 27;
17159pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: VkStructureType = 1000269003;
17160pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: VkStructureType = 1000269005;
17161pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: VkStructureType = 1000269002;
17162pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: VkStructureType = 1000269004;
17163pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: VkStructureType = 1000611002;
17164pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: VkStructureType = 1000326002;
17165pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: VkStructureType = 1000226001;
17166pub const VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: VkStructureType = 1000428002;
17167pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
17168pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: VkStructureType = 1000269001;
17169pub const VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = 20;
17170pub const VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = 30;
17171pub const VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: VkStructureType = 1000290000;
17172pub const VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = 24;
17173pub const VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: VkStructureType = 1000372000;
17174pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: VkStructureType = 1000101001;
17175pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: VkStructureType = 1000102001;
17176pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: VkStructureType = 1000259001;
17177pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
17178pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
17179pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: VkStructureType = 1000254001;
17180pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = 23;
17181pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: VkStructureType = 1000018000;
17182pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: VkStructureType = 1000028002;
17183pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: VkStructureType = 1000044002;
17184pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
17185pub const VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: VkStructureType = 1000166001;
17186pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: VkStructureType = 1000068000;
17187pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
17188pub const VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: VkStructureType = 1000143002;
17189pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = 18;
17190pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: VkStructureType = 1000462002;
17191pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: VkStructureType = 1000225001;
17192pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
17193pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: VkStructureType = 1000117003;
17194pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
17195pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: VkStructureType = 21;
17196pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: VkStructureType = 1000190001;
17197pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
17198pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
17199pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = 19;
17200pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: VkStructureType = 1000164005;
17201pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: VkStructureType = 1000582001;
17202pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: VkStructureType = 1000355001;
17203pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: VkStructureType = 1000205000;
17204pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: VkStructureType = 1000164000;
17205pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = 22;
17206pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: VkStructureType = 1000098000;
17207pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: VkStructureType = 1000087000;
17208pub const VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: VkStructureType = 1000479001;
17209pub const VK_STRUCTURE_TYPE_PRESENT_ID_KHR: VkStructureType = 1000294000;
17210pub const VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = 1000001001;
17211pub const VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: VkStructureType = 1000084000;
17212pub const VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: VkStructureType = 1000092000;
17213pub const VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: VkStructureType = 1000208003;
17214pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: VkStructureType = 1000208004;
17215pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: VkStructureType = 1000208008;
17216pub const VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: VkStructureType = 1000480002;
17217pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: VkStructureType = 1000295002;
17218pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO;
17219pub const VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: VkStructureType = 1000145000;
17220pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: VkStructureType = 1000545004;
17221pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO;
17222pub const VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV: VkStructureType = 1000580000;
17223pub const VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT: VkStructureType = 1000135004;
17224pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: VkStructureType = 1000545005;
17225pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO;
17226pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: VkStructureType = 1000545006;
17227pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO;
17228pub const VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: VkStructureType = 1000310000;
17229pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = 11;
17230pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
17231pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: VkStructureType = 1000116002;
17232pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: VkStructureType = 1000210000;
17233pub const VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: VkStructureType = 1000299005;
17234pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: VkStructureType = 1000314008;
17235pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: VkStructureType = 1000206001;
17236pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: VkStructureType = 1000507017;
17237pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: VkStructureType = 1000507018;
17238pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: VkStructureType = 1000388001;
17239pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
17240pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
17241pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: VkStructureType = 1000584002;
17242pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: VkStructureType = 1000059005;
17243pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
17244pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: VkStructureType = 1000023016;
17245pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: VkStructureType = 1000023012;
17246pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = 1000569007;
17247pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: VkStructureType = 1000150015;
17248pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: VkStructureType = 1000165000;
17249pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: VkStructureType = 1000150018;
17250pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: VkStructureType = 1000150016;
17251pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = 1000165011;
17252pub const VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: VkStructureType = 1000483005;
17253pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR;
17254pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: VkStructureType = 1000275005;
17255pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: VkStructureType = 1000470003;
17256pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO;
17257pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: VkStructureType = 1000630002;
17258pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: VkStructureType = 1000044001;
17259pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
17260pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: VkStructureType = 1000232001;
17261pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
17262pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR;
17263pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: VkStructureType = 1000619003;
17264pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: VkStructureType = 1000044007;
17265pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = 1000044006;
17266pub const VK_STRUCTURE_TYPE_RENDERING_INFO: VkStructureType = 1000044000;
17267pub const VK_STRUCTURE_TYPE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INFO;
17268pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: VkStructureType = 1000232002;
17269pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
17270pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: VkStructureType = 1000108003;
17271pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
17272pub const VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: VkStructureType = 43;
17273pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: VkStructureType = 38;
17274pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: VkStructureType = 1000109004;
17275pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2;
17276pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: VkStructureType = 1000458001;
17277pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = 1000458002;
17278pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: VkStructureType = 1000218002;
17279pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: VkStructureType = 1000425002;
17280pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: VkStructureType = 1000117001;
17281pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
17282pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: VkStructureType = 1000053000;
17283pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
17284pub const VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: VkStructureType = 1000605004;
17285pub const VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: VkStructureType = 1000143001;
17286pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: VkStructureType = 1000424002;
17287pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: VkStructureType = 1000424003;
17288pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: VkStructureType = 1000424004;
17289pub const VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: VkStructureType = 1000458003;
17290pub const VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: VkStructureType = 1000309002;
17291pub const VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: VkStructureType = 1000282001;
17292pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: VkStructureType = 1000337005;
17293pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2;
17294pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: VkStructureType = 1000630004;
17295pub const VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT: VkStructureType = 1000135002;
17296pub const VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: VkStructureType = 1000518002;
17297pub const VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: VkStructureType = 1000411001;
17298pub const VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316008;
17299pub const VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = 31;
17300pub const VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: VkStructureType = 1000519000;
17301pub const VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: VkStructureType = 1000287000;
17302pub const VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT: VkStructureType = 1000135011;
17303pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: VkStructureType = 1000130001;
17304pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
17305pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: VkStructureType = 1000156000;
17306pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
17307pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000156005;
17308pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
17309pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: VkStructureType = 1000156001;
17310pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
17311pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: VkStructureType = 1000520001;
17312pub const VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: VkStructureType = 1000143000;
17313pub const VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = 9;
17314pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = 1000079001;
17315pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: VkStructureType = 1000207005;
17316pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO;
17317pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000314005;
17318pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
17319pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: VkStructureType = 1000207002;
17320pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
17321pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: VkStructureType = 1000207004;
17322pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
17323pub const VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: VkStructureType = 1000545007;
17324pub const VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: VkStructureType = 1000505002;
17325pub const VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: VkStructureType = 1000482002;
17326pub const VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT: VkStructureType = 1000135006;
17327pub const VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = 16;
17328pub const VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: VkStructureType = 1000462003;
17329pub const VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160001;
17330pub const VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
17331pub const VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: VkStructureType = 1000111000;
17332pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059007;
17333pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
17334pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146004;
17335pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
17336pub const VK_STRUCTURE_TYPE_SUBMIT_INFO: VkStructureType = 4;
17337pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2: VkStructureType = 1000314004;
17338pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
17339pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: VkStructureType = 1000109005;
17340pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO;
17341pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: VkStructureType = 1000109003;
17342pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
17343pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: VkStructureType = 1000109002;
17344pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2;
17345pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: VkStructureType = 1000199001;
17346pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
17347pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO: VkStructureType = 1000109006;
17348pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO;
17349pub const VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT;
17350pub const VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: VkStructureType = 1000376001;
17351pub const VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: VkStructureType = 1000369000;
17352pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: VkStructureType = 1000270008;
17353pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
17354pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: VkStructureType = 1000338002;
17355pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
17356pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
17357pub const VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT: VkStructureType = 1000135013;
17358pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
17359pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: VkStructureType = 1000090000;
17360pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: VkStructureType = 1000119001;
17361pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: VkStructureType = 1000292001;
17362pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: VkStructureType = 1000479000;
17363pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: VkStructureType = 1000480000;
17364pub const VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: VkStructureType = 1000119002;
17365pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR;
17366pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: VkStructureType = 1000274002;
17367pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR;
17368pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: VkStructureType = 1000274000;
17369pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
17370pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: VkStructureType = 1000274001;
17371pub const VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: VkStructureType = 1000239000;
17372pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = 1000208009;
17373pub const VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: VkStructureType = 1000091003;
17374pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000001000;
17375pub const VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: VkStructureType = 1000213001;
17376pub const VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: VkStructureType = 1000505007;
17377pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: VkStructureType = 1000292002;
17378pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR;
17379pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: VkStructureType = 1000275001;
17380pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR;
17381pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: VkStructureType = 1000275002;
17382pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR;
17383pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: VkStructureType = 1000275003;
17384pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR;
17385pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: VkStructureType = 1000275004;
17386pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: VkStructureType = 1000208002;
17387pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: VkStructureType = 1000208001;
17388pub const VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = 1000460021;
17389pub const VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: VkStructureType = 1000460012;
17390pub const VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: VkStructureType = 1000460000;
17391pub const VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: VkStructureType = 1000460013;
17392pub const VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: VkStructureType = 1000460006;
17393pub const VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: VkStructureType = 1000460005;
17394pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: VkStructureType = 1000460008;
17395pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = 1000460007;
17396pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = 1000460022;
17397pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: VkStructureType = 1000460001;
17398pub const VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: VkStructureType = 1000135000;
17399pub const VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: VkStructureType = 1000041000;
17400pub const VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: VkStructureType = 1000547003;
17401pub const VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: VkStructureType = 1000547002;
17402pub const VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: VkStructureType = 1000547004;
17403pub const VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: VkStructureType = 1000484001;
17404pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000207003;
17405pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
17406pub const VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160000;
17407pub const VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: VkStructureType = 1000247000;
17408pub const VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: VkStructureType = 1000061000;
17409pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: VkStructureType = 1000352002;
17410pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: VkStructureType = 1000352001;
17411pub const VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: VkStructureType = 1000023008;
17412pub const VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: VkStructureType = 1000023001;
17413pub const VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: VkStructureType = 1000023010;
17414pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: VkStructureType = 1000512000;
17415pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = 1000512005;
17416pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586003;
17417pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: VkStructureType = 1000512001;
17418pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: VkStructureType = 1000512003;
17419pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000512004;
17420pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: VkStructureType = 1000024001;
17421pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: VkStructureType = 1000040000;
17422pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = 1000040006;
17423pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586001;
17424pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: VkStructureType = 1000040001;
17425pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: VkStructureType = 1000040003;
17426pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000040005;
17427pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000040004;
17428pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: VkStructureType = 1000187000;
17429pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = 1000187005;
17430pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586002;
17431pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: VkStructureType = 1000187004;
17432pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: VkStructureType = 1000187003;
17433pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000187002;
17434pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000187001;
17435pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: VkStructureType = 1000024000;
17436pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: VkStructureType = 1000024002;
17437pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: VkStructureType = 1000514001;
17438pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: VkStructureType = 1000514002;
17439pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: VkStructureType = 1000514003;
17440pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: VkStructureType = 1000513000;
17441pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = 1000513003;
17442pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000513010;
17443pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: VkStructureType = 1000513002;
17444pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: VkStructureType = 1000513005;
17445pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000513008;
17446pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553007;
17447pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: VkStructureType = 1000513006;
17448pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000513007;
17449pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: VkStructureType = 1000513009;
17450pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000513001;
17451pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: VkStructureType = 1000299003;
17452pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: VkStructureType = 1000038000;
17453pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = 1000038004;
17454pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000038006;
17455pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: VkStructureType = 1000038005;
17456pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: VkStructureType = 1000038003;
17457pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: VkStructureType = 1000038007;
17458pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000038011;
17459pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553003;
17460pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: VkStructureType = 1000038008;
17461pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000038009;
17462pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: VkStructureType = 1000038010;
17463pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000038002;
17464pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000038001;
17465pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000038013;
17466pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000038012;
17467pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: VkStructureType = 1000039000;
17468pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = 1000039004;
17469pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000039006;
17470pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: VkStructureType = 1000039005;
17471pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: VkStructureType = 1000039003;
17472pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: VkStructureType = 1000039007;
17473pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000039012;
17474pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553004;
17475pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: VkStructureType = 1000039009;
17476pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000039010;
17477pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: VkStructureType = 1000039011;
17478pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000039002;
17479pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000039001;
17480pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000039014;
17481pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000039013;
17482pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: VkStructureType = 1000299000;
17483pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: VkStructureType = 1000552000;
17484pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: VkStructureType = 1000552002;
17485pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: VkStructureType = 1000390002;
17486pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = 1000299008;
17487pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000299007;
17488pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553000;
17489pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: VkStructureType = 1000553002;
17490pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000553005;
17491pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: VkStructureType = 1000299001;
17492pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000299002;
17493pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: VkStructureType = 1000390001;
17494pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: VkStructureType = 1000552001;
17495pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000299010;
17496pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000299009;
17497pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: VkStructureType = 1000390003;
17498pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: VkStructureType = 1000299004;
17499pub const VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: VkStructureType = 1000023009;
17500pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553008;
17501pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553006;
17502pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: VkStructureType = 1000023015;
17503pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553001;
17504pub const VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: VkStructureType = 1000515001;
17505pub const VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: VkStructureType = 1000023002;
17506pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: VkStructureType = 1000023000;
17507pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: VkStructureType = 1000023013;
17508pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: VkStructureType = 1000552003;
17509pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: VkStructureType = 1000023011;
17510pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: VkStructureType = 1000023005;
17511pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: VkStructureType = 1000023003;
17512pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000023006;
17513pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: VkStructureType = 1000023007;
17514pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = 35;
17515pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: VkStructureType = 1000150007;
17516pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: VkStructureType = 1000165007;
17517pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: VkStructureType = 1000138002;
17518pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
17519pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkStructureType = 1000570002;
17520pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: VkStructureType = 1000460003;
17521pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: VkStructureType = 1000572008;
17522pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: VkStructureType = 1000572009;
17523pub const VK_SUBGROUP_FEATURE_ARITHMETIC_BIT: VkSubgroupFeatureFlagBits = 1 << 2;
17524pub const VK_SUBGROUP_FEATURE_BALLOT_BIT: VkSubgroupFeatureFlagBits = 1 << 3;
17525pub const VK_SUBGROUP_FEATURE_BASIC_BIT: VkSubgroupFeatureFlagBits = 1 << 0;
17526pub const VK_SUBGROUP_FEATURE_CLUSTERED_BIT: VkSubgroupFeatureFlagBits = 1 << 6;
17527pub const VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT: VkSubgroupFeatureFlagBits = 1 << 8;
17528pub const VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT;
17529pub const VK_SUBGROUP_FEATURE_QUAD_BIT: VkSubgroupFeatureFlagBits = 1 << 7;
17530pub const VK_SUBGROUP_FEATURE_ROTATE_BIT: VkSubgroupFeatureFlagBits = 1 << 9;
17531pub const VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_ROTATE_BIT;
17532pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT: VkSubgroupFeatureFlagBits = 1 << 10;
17533pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT;
17534pub const VK_SUBGROUP_FEATURE_SHUFFLE_BIT: VkSubgroupFeatureFlagBits = 1 << 4;
17535pub const VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: VkSubgroupFeatureFlagBits = 1 << 5;
17536pub const VK_SUBGROUP_FEATURE_VOTE_BIT: VkSubgroupFeatureFlagBits = 1 << 1;
17537pub const VK_SUBMIT_PROTECTED_BIT: VkSubmitFlagBits = 1 << 0;
17538pub const VK_SUBMIT_PROTECTED_BIT_KHR: VkSubmitFlagBits = VK_SUBMIT_PROTECTED_BIT;
17539pub const VK_SUBOPTIMAL_KHR: VkResult = 1000001003;
17540pub const VK_SUBPASS_CONTENTS_INLINE: VkSubpassContents = 0;
17541pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT: VkSubpassContents = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR;
17542pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR: VkSubpassContents = 1000451000;
17543pub const VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: VkSubpassContents = 1;
17544pub const VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 3;
17545pub const VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 7;
17546pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 2;
17547pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT;
17548pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX: VkSubpassDescriptionFlagBits = 1 << 0;
17549pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX: VkSubpassDescriptionFlagBits = 1 << 1;
17550pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT;
17551pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 4;
17552pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT;
17553pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 5;
17554pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT;
17555pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 6;
17556pub const VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT;
17557pub const VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM: VkSubpassDescriptionFlagBits = 1 << 8;
17558pub const VK_SUBPASS_EXTERNAL: u32 = !0;
17559pub const VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT: VkSubpassMergeStatusEXT = 1;
17560pub const VK_SUBPASS_MERGE_STATUS_MERGED_EXT: VkSubpassMergeStatusEXT = 0;
17561pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT: VkSubpassMergeStatusEXT = 5;
17562pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT: VkSubpassMergeStatusEXT = 6;
17563pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT: VkSubpassMergeStatusEXT = 10;
17564pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT: VkSubpassMergeStatusEXT = 7;
17565pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT: VkSubpassMergeStatusEXT = 9;
17566pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT: VkSubpassMergeStatusEXT = 11;
17567pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT: VkSubpassMergeStatusEXT = 3;
17568pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT: VkSubpassMergeStatusEXT = 2;
17569pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT: VkSubpassMergeStatusEXT = 12;
17570pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT: VkSubpassMergeStatusEXT = 8;
17571pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT: VkSubpassMergeStatusEXT = 13;
17572pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT: VkSubpassMergeStatusEXT = 4;
17573pub const VK_SUCCESS: VkResult = 0;
17574pub const VK_SURFACE_COUNTER_VBLANK_BIT_EXT: VkSurfaceCounterFlagBitsEXT = 1 << 0;
17575pub const VK_SURFACE_COUNTER_VBLANK_EXT: VkSurfaceCounterFlagBitsEXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT;
17576pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 4;
17577pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 6;
17578pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 7;
17579pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 5;
17580pub const VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 0;
17581pub const VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 8;
17582pub const VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 2;
17583pub const VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 3;
17584pub const VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 1;
17585pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT: VkSwapchainCreateFlagBitsKHR = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR;
17586pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 3;
17587pub const VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 2;
17588pub const VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 6;
17589pub const VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT: VkSwapchainCreateFlagBitsKHR = 1 << 9;
17590pub const VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 7;
17591pub const VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 1;
17592pub const VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 0;
17593pub const VK_SYSTEM_ALLOCATION_SCOPE_CACHE: VkSystemAllocationScope = 2;
17594pub const VK_SYSTEM_ALLOCATION_SCOPE_COMMAND: VkSystemAllocationScope = 0;
17595pub const VK_SYSTEM_ALLOCATION_SCOPE_DEVICE: VkSystemAllocationScope = 3;
17596pub const VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE: VkSystemAllocationScope = 4;
17597pub const VK_SYSTEM_ALLOCATION_SCOPE_OBJECT: VkSystemAllocationScope = 1;
17598pub const VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 2;
17599pub const VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 3;
17600pub const VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 0;
17601pub const VK_TENSOR_CREATE_PROTECTED_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 1;
17602pub const VK_TENSOR_TILING_LINEAR_ARM: VkTensorTilingARM = 1;
17603pub const VK_TENSOR_TILING_OPTIMAL_ARM: VkTensorTilingARM = 0;
17604pub const VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 5;
17605pub const VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 4;
17606pub const VK_TENSOR_USAGE_SHADER_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 1;
17607pub const VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 3;
17608pub const VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 2;
17609pub const VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorViewCreateFlagBitsARM = 1 << 0;
17610pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT: VkTessellationDomainOrigin = 1;
17611pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT;
17612pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT: VkTessellationDomainOrigin = 0;
17613pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT;
17614pub const VK_THREAD_DONE_KHR: VkResult = 1000268001;
17615pub const VK_THREAD_IDLE_KHR: VkResult = 1000268000;
17616pub const VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM: VkTileShadingRenderPassFlagBitsQCOM = 1 << 0;
17617pub const VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM: VkTileShadingRenderPassFlagBitsQCOM = 1 << 1;
17618pub const VK_TIMEOUT: VkResult = 2;
17619pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR;
17620pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR: VkTimeDomainKHR = 1;
17621pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR;
17622pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR: VkTimeDomainKHR = 2;
17623pub const VK_TIME_DOMAIN_DEVICE_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_DEVICE_KHR;
17624pub const VK_TIME_DOMAIN_DEVICE_KHR: VkTimeDomainKHR = 0;
17625pub const VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT: VkTimeDomainKHR = 1000208000;
17626pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR;
17627pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: VkTimeDomainKHR = 3;
17628pub const VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT: VkTimeDomainKHR = 1000208001;
17629pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT: VkToolPurposeFlagBits = 1 << 3;
17630pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT;
17631pub const VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT: VkToolPurposeFlagBits = 1 << 6;
17632pub const VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT: VkToolPurposeFlagBits = 1 << 5;
17633pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT: VkToolPurposeFlagBits = 1 << 4;
17634pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT;
17635pub const VK_TOOL_PURPOSE_PROFILING_BIT: VkToolPurposeFlagBits = 1 << 1;
17636pub const VK_TOOL_PURPOSE_PROFILING_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_PROFILING_BIT;
17637pub const VK_TOOL_PURPOSE_TRACING_BIT: VkToolPurposeFlagBits = 1 << 2;
17638pub const VK_TOOL_PURPOSE_TRACING_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_TRACING_BIT;
17639pub const VK_TOOL_PURPOSE_VALIDATION_BIT: VkToolPurposeFlagBits = 1 << 0;
17640pub const VK_TOOL_PURPOSE_VALIDATION_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_VALIDATION_BIT;
17641pub const VK_TRUE: u32 = 1;
17642pub const VK_USE_64_BIT_PTR_DEFINES: bool = true;
17643pub const VK_UUID_SIZE: u32 = 16;
17644pub const VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: VkValidationCacheHeaderVersionEXT = 1;
17645pub const VK_VALIDATION_CHECK_ALL_EXT: VkValidationCheckEXT = 0;
17646pub const VK_VALIDATION_CHECK_SHADERS_EXT: VkValidationCheckEXT = 1;
17647pub const VK_VALIDATION_FEATURE_DISABLE_ALL_EXT: VkValidationFeatureDisableEXT = 0;
17648pub const VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT: VkValidationFeatureDisableEXT = 3;
17649pub const VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT: VkValidationFeatureDisableEXT = 5;
17650pub const VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT: VkValidationFeatureDisableEXT = 4;
17651pub const VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT: VkValidationFeatureDisableEXT = 1;
17652pub const VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT: VkValidationFeatureDisableEXT = 7;
17653pub const VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT: VkValidationFeatureDisableEXT = 2;
17654pub const VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT: VkValidationFeatureDisableEXT = 6;
17655pub const VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT: VkValidationFeatureEnableEXT = 2;
17656pub const VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT: VkValidationFeatureEnableEXT = 3;
17657pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT: VkValidationFeatureEnableEXT = 0;
17658pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT: VkValidationFeatureEnableEXT = 1;
17659pub const VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT: VkValidationFeatureEnableEXT = 4;
17660pub const VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME: &CStr = c"VK_VALVE_descriptor_set_host_mapping";
17661pub const VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION: u32 = 1;
17662pub const VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME: &CStr = c"VK_VALVE_fragment_density_map_layered";
17663pub const VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION: u32 = 1;
17664pub const VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME: &CStr = c"VK_VALVE_mutable_descriptor_type";
17665pub const VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION: u32 = 1;
17666pub const VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME: &CStr = c"VK_VALVE_video_encode_rgb_conversion";
17667pub const VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION: u32 = 1;
17668pub const VK_VENDOR_ID_CODEPLAY: VkVendorId = 0x10004;
17669pub const VK_VENDOR_ID_KAZAN: VkVendorId = 0x10003;
17670pub const VK_VENDOR_ID_KHRONOS: VkVendorId = 0x10000;
17671pub const VK_VENDOR_ID_MESA: VkVendorId = 0x10005;
17672pub const VK_VENDOR_ID_MOBILEYE: VkVendorId = 0x10007;
17673pub const VK_VENDOR_ID_POCL: VkVendorId = 0x10006;
17674pub const VK_VENDOR_ID_VIV: VkVendorId = 0x10001;
17675pub const VK_VENDOR_ID_VSI: VkVendorId = 0x10002;
17676pub const VK_VERTEX_INPUT_RATE_INSTANCE: VkVertexInputRate = 1;
17677pub const VK_VERTEX_INPUT_RATE_VERTEX: VkVertexInputRate = 0;
17678pub const VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR: VkVideoCapabilityFlagBitsKHR = 1 << 0;
17679pub const VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR: VkVideoCapabilityFlagBitsKHR = 1 << 1;
17680pub const VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 1;
17681pub const VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 2;
17682pub const VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 3;
17683pub const VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 0;
17684pub const VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 0;
17685pub const VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 2;
17686pub const VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 0;
17687pub const VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 1;
17688pub const VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 3;
17689pub const VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 18;
17690pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 16;
17691pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 17;
17692pub const VK_VIDEO_CODEC_OPERATION_NONE_KHR: VkVideoCodecOperationFlagBitsKHR = 0;
17693pub const VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 2;
17694pub const VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 1;
17695pub const VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 0;
17696pub const VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 2;
17697pub const VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 4;
17698pub const VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 0;
17699pub const VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR: VkVideoComponentBitDepthFlagBitsKHR = 0;
17700pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR: VkVideoDecodeCapabilityFlagBitsKHR = 1 << 0;
17701pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR: VkVideoDecodeCapabilityFlagBitsKHR = 1 << 1;
17702pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 1 << 0;
17703pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 1 << 1;
17704pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 0;
17705pub const VK_VIDEO_DECODE_USAGE_DEFAULT_KHR: VkVideoDecodeUsageFlagBitsKHR = 0;
17706pub const VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 1;
17707pub const VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 2;
17708pub const VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 0;
17709pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 5;
17710pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 3;
17711pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 1;
17712pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 4;
17713pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 0;
17714pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 2;
17715pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = 3;
17716pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR: VkVideoEncodeAV1PredictionModeKHR = 0;
17717pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR: VkVideoEncodeAV1PredictionModeKHR = 1;
17718pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = 2;
17719pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = 2;
17720pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR: VkVideoEncodeAV1RateControlGroupKHR = 0;
17721pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = 1;
17722pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 3;
17723pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 2;
17724pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 0;
17725pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 1;
17726pub const VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 3;
17727pub const VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 2;
17728pub const VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 1;
17729pub const VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 0;
17730pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = 1 << 1;
17731pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = 1 << 0;
17732pub const VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 3;
17733pub const VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 1;
17734pub const VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 0;
17735pub const VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 2;
17736pub const VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 0;
17737pub const VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR: VkVideoEncodeContentFlagBitsKHR = 0;
17738pub const VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 1;
17739pub const VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 2;
17740pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 0;
17741pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 1;
17742pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 2;
17743pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 4;
17744pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 5;
17745pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 10;
17746pub const VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 3;
17747pub const VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 8;
17748pub const VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 0;
17749pub const VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 9;
17750pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 6;
17751pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 7;
17752pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 1;
17753pub const VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 2;
17754pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 0;
17755pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 3;
17756pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 2;
17757pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 1;
17758pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 4;
17759pub const VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 3;
17760pub const VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 14;
17761pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 15;
17762pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 16;
17763pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 17;
17764pub const VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 20;
17765pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 13;
17766pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 10;
17767pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 12;
17768pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 11;
17769pub const VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 5;
17770pub const VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 1;
17771pub const VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 2;
17772pub const VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 4;
17773pub const VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 0;
17774pub const VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 19;
17775pub const VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 9;
17776pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 7;
17777pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 8;
17778pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 6;
17779pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 4;
17780pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 5;
17781pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 11;
17782pub const VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 10;
17783pub const VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 3;
17784pub const VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 0;
17785pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 9;
17786pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 8;
17787pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 6;
17788pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 7;
17789pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 1;
17790pub const VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 2;
17791pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 0;
17792pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 1;
17793pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 2;
17794pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 0;
17795pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 3;
17796pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 2;
17797pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 1;
17798pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 4;
17799pub const VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 14;
17800pub const VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 16;
17801pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 17;
17802pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 18;
17803pub const VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 20;
17804pub const VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 15;
17805pub const VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 5;
17806pub const VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 8;
17807pub const VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 3;
17808pub const VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 12;
17809pub const VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 1;
17810pub const VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 2;
17811pub const VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 0;
17812pub const VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 9;
17813pub const VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 19;
17814pub const VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 4;
17815pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 10;
17816pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 11;
17817pub const VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 13;
17818pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 7;
17819pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 6;
17820pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 2;
17821pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 3;
17822pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 0;
17823pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 1;
17824pub const VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 2;
17825pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 1;
17826pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 3;
17827pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 2;
17828pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 0;
17829pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 0;
17830pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 1;
17831pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 0;
17832pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 0;
17833pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 2;
17834pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = 1 << 0;
17835pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = 1 << 1;
17836pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 0;
17837pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 4;
17838pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 3;
17839pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 2;
17840pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 1;
17841pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = 1 << 0;
17842pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = 1 << 1;
17843pub const VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR: VkVideoEncodeTuningModeKHR = 0;
17844pub const VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR: VkVideoEncodeTuningModeKHR = 1;
17845pub const VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR: VkVideoEncodeTuningModeKHR = 4;
17846pub const VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = 2;
17847pub const VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = 3;
17848pub const VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 3;
17849pub const VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR: VkVideoEncodeUsageFlagBitsKHR = 0;
17850pub const VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 2;
17851pub const VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 1;
17852pub const VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 0;
17853pub const VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 1;
17854pub const VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 0;
17855pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 4;
17856pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 1;
17857pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 3;
17858pub const VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 2;
17859pub const VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 5;
17860pub const VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 0;
17861pub const VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR: VkVideoSessionParametersCreateFlagBitsKHR = 1 << 0;
17862pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: VkViewportCoordinateSwizzleNV = 7;
17863pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: VkViewportCoordinateSwizzleNV = 1;
17864pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV: VkViewportCoordinateSwizzleNV = 3;
17865pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV: VkViewportCoordinateSwizzleNV = 5;
17866pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: VkViewportCoordinateSwizzleNV = 6;
17867pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: VkViewportCoordinateSwizzleNV = 0;
17868pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV: VkViewportCoordinateSwizzleNV = 2;
17869pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV: VkViewportCoordinateSwizzleNV = 4;
17870pub const VK_WHOLE_SIZE: u64 = !0;
17871
17872pub const fn VK_API_VERSION_MAJOR(version: u32) -> u32 {
17873    (version >> 22) & 0x7F
17874}
17875
17876pub const fn VK_API_VERSION_MINOR(version: u32) -> u32 {
17877    (version >> 12) & 0x3FF
17878}
17879
17880pub const fn VK_API_VERSION_PATCH(version: u32) -> u32 {
17881    version & 0xFFF
17882}
17883
17884pub const fn VK_API_VERSION_VARIANT(version: u32) -> u32 {
17885    version >> 29
17886}
17887
17888pub const fn VK_MAKE_API_VERSION(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
17889    (variant << 29) | (major << 22) | (minor << 12) | patch
17890}
17891
17892pub const fn VK_MAKE_VERSION(major: u32, minor: u32, patch: u32) -> u32 {
17893    (major << 22) | (minor << 12) | patch
17894}
17895
17896pub const fn VK_VERSION_MAJOR(version: u32) -> u32 {
17897    version >> 22
17898}
17899
17900pub const fn VK_VERSION_MINOR(version: u32) -> u32 {
17901    (version >> 12) & 0x3FF
17902}
17903
17904pub const fn VK_VERSION_PATCH(version: u32) -> u32 {
17905    version & 0xFFF
17906}
17907
17908unsafe extern "system" {
17909    /// Available if built with `prototypes`.
17910    #[cfg(any(doc, feature = "prototypes"))]
17911    pub fn vkAcquireDrmDisplayEXT(physicalDevice: VkPhysicalDevice, drmFd: i32, display: VkDisplayKHR) -> VkResult;
17912
17913    /// Available if built with `prototypes`.
17914    #[cfg(any(doc, feature = "prototypes"))]
17915    pub fn vkAcquireNextImage2KHR(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut u32) -> VkResult;
17916
17917    /// Available if built with `prototypes`.
17918    #[cfg(any(doc, feature = "prototypes"))]
17919    pub fn vkAcquireNextImageKHR(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult;
17920
17921    /// Available if built with `prototypes`.
17922    #[cfg(any(doc, feature = "prototypes"))]
17923    pub fn vkAcquirePerformanceConfigurationINTEL(device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult;
17924
17925    /// Available if built with `prototypes`.
17926    #[cfg(any(doc, feature = "prototypes"))]
17927    pub fn vkAcquireProfilingLockKHR(device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult;
17928
17929    /// Available if built with `exported-prototypes`.
17930    #[cfg(any(doc, feature = "exported-prototypes"))]
17931    pub fn vkAllocateCommandBuffers(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;
17932
17933    /// Available if built with `exported-prototypes`.
17934    #[cfg(any(doc, feature = "exported-prototypes"))]
17935    pub fn vkAllocateDescriptorSets(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;
17936
17937    /// Available if built with `exported-prototypes`.
17938    #[cfg(any(doc, feature = "exported-prototypes"))]
17939    pub fn vkAllocateMemory(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;
17940
17941    /// Available if built with `prototypes`.
17942    #[cfg(any(doc, feature = "prototypes"))]
17943    pub fn vkAntiLagUpdateAMD(device: VkDevice, pData: *const VkAntiLagDataAMD);
17944
17945    /// Available if built with `exported-prototypes`.
17946    #[cfg(any(doc, feature = "exported-prototypes"))]
17947    pub fn vkBeginCommandBuffer(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;
17948
17949    /// Available if built with `prototypes`.
17950    #[cfg(any(doc, feature = "prototypes"))]
17951    pub fn vkBindAccelerationStructureMemoryNV(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult;
17952
17953    /// Available if built with `exported-prototypes`.
17954    #[cfg(any(doc, feature = "exported-prototypes"))]
17955    pub fn vkBindBufferMemory(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
17956
17957    /// Available if built with `exported-prototypes`.
17958    #[cfg(any(doc, feature = "exported-prototypes"))]
17959    pub fn vkBindBufferMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
17960
17961    /// Available if built with `prototypes`.
17962    #[cfg(any(doc, feature = "prototypes"))]
17963    pub fn vkBindBufferMemory2KHR(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
17964
17965    /// Available if built with `prototypes`.
17966    #[cfg(any(doc, feature = "prototypes"))]
17967    pub fn vkBindDataGraphPipelineSessionMemoryARM(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult;
17968
17969    /// Available if built with `exported-prototypes`.
17970    #[cfg(any(doc, feature = "exported-prototypes"))]
17971    pub fn vkBindImageMemory(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
17972
17973    /// Available if built with `exported-prototypes`.
17974    #[cfg(any(doc, feature = "exported-prototypes"))]
17975    pub fn vkBindImageMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
17976
17977    /// Available if built with `prototypes`.
17978    #[cfg(any(doc, feature = "prototypes"))]
17979    pub fn vkBindImageMemory2KHR(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
17980
17981    /// Available if built with `prototypes`.
17982    #[cfg(any(doc, feature = "prototypes"))]
17983    pub fn vkBindOpticalFlowSessionImageNV(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult;
17984
17985    /// Available if built with `prototypes`.
17986    #[cfg(any(doc, feature = "prototypes"))]
17987    pub fn vkBindTensorMemoryARM(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult;
17988
17989    /// Available if built with `prototypes`.
17990    #[cfg(any(doc, feature = "prototypes"))]
17991    pub fn vkBindVideoSessionMemoryKHR(device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: u32, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult;
17992
17993    /// Available if built with `prototypes`.
17994    #[cfg(any(doc, feature = "prototypes"))]
17995    pub fn vkBuildAccelerationStructuresKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult;
17996
17997    /// Available if built with `prototypes`.
17998    #[cfg(any(doc, feature = "prototypes"))]
17999    pub fn vkBuildMicromapsEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult;
18000
18001    /// Available if built with `prototypes`.
18002    #[cfg(any(doc, feature = "prototypes"))]
18003    pub fn vkCmdBeginConditionalRenderingEXT(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT);
18004
18005    /// Available if built with `prototypes`.
18006    #[cfg(any(doc, feature = "prototypes"))]
18007    pub fn vkCmdBeginCustomResolveEXT(commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT);
18008
18009    /// Available if built with `prototypes`.
18010    #[cfg(any(doc, feature = "prototypes"))]
18011    pub fn vkCmdBeginDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
18012
18013    /// Available if built with `prototypes`.
18014    #[cfg(any(doc, feature = "prototypes"))]
18015    pub fn vkCmdBeginPerTileExecutionQCOM(commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM);
18016
18017    /// Available if built with `exported-prototypes`.
18018    #[cfg(any(doc, feature = "exported-prototypes"))]
18019    pub fn vkCmdBeginQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags);
18020
18021    /// Available if built with `prototypes`.
18022    #[cfg(any(doc, feature = "prototypes"))]
18023    pub fn vkCmdBeginQueryIndexedEXT(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags, index: u32);
18024
18025    /// Available if built with `exported-prototypes`.
18026    #[cfg(any(doc, feature = "exported-prototypes"))]
18027    pub fn vkCmdBeginRenderPass(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents);
18028
18029    /// Available if built with `exported-prototypes`.
18030    #[cfg(any(doc, feature = "exported-prototypes"))]
18031    pub fn vkCmdBeginRenderPass2(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
18032
18033    /// Available if built with `prototypes`.
18034    #[cfg(any(doc, feature = "prototypes"))]
18035    pub fn vkCmdBeginRenderPass2KHR(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
18036
18037    /// Available if built with `exported-prototypes`.
18038    #[cfg(any(doc, feature = "exported-prototypes"))]
18039    pub fn vkCmdBeginRendering(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
18040
18041    /// Available if built with `prototypes`.
18042    #[cfg(any(doc, feature = "prototypes"))]
18043    pub fn vkCmdBeginRenderingKHR(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
18044
18045    /// Available if built with `prototypes`.
18046    #[cfg(any(doc, feature = "prototypes"))]
18047    pub fn vkCmdBeginTransformFeedbackEXT(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
18048
18049    /// Available if built with `prototypes`.
18050    #[cfg(any(doc, feature = "prototypes"))]
18051    pub fn vkCmdBeginVideoCodingKHR(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR);
18052
18053    /// Available if built with `prototypes`.
18054    #[cfg(any(doc, feature = "prototypes"))]
18055    pub fn vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
18056
18057    /// Available if built with `prototypes`.
18058    #[cfg(any(doc, feature = "prototypes"))]
18059    pub fn vkCmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32);
18060
18061    /// Available if built with `prototypes`.
18062    #[cfg(any(doc, feature = "prototypes"))]
18063    pub fn vkCmdBindDescriptorBuffersEXT(commandBuffer: VkCommandBuffer, bufferCount: u32, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT);
18064
18065    /// Available if built with `exported-prototypes`.
18066    #[cfg(any(doc, feature = "exported-prototypes"))]
18067    pub fn vkCmdBindDescriptorSets(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: *const u32);
18068
18069    /// Available if built with `exported-prototypes`.
18070    #[cfg(any(doc, feature = "exported-prototypes"))]
18071    pub fn vkCmdBindDescriptorSets2(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
18072
18073    /// Available if built with `prototypes`.
18074    #[cfg(any(doc, feature = "prototypes"))]
18075    pub fn vkCmdBindDescriptorSets2KHR(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
18076
18077    /// Available if built with `exported-prototypes`.
18078    #[cfg(any(doc, feature = "exported-prototypes"))]
18079    pub fn vkCmdBindIndexBuffer(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType);
18080
18081    /// Available if built with `exported-prototypes`.
18082    #[cfg(any(doc, feature = "exported-prototypes"))]
18083    pub fn vkCmdBindIndexBuffer2(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
18084
18085    /// Available if built with `prototypes`.
18086    #[cfg(any(doc, feature = "prototypes"))]
18087    pub fn vkCmdBindIndexBuffer2KHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
18088
18089    /// Available if built with `prototypes`.
18090    #[cfg(any(doc, feature = "prototypes"))]
18091    pub fn vkCmdBindInvocationMaskHUAWEI(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
18092
18093    /// Available if built with `exported-prototypes`.
18094    #[cfg(any(doc, feature = "exported-prototypes"))]
18095    pub fn vkCmdBindPipeline(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
18096
18097    /// Available if built with `prototypes`.
18098    #[cfg(any(doc, feature = "prototypes"))]
18099    pub fn vkCmdBindPipelineShaderGroupNV(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: u32);
18100
18101    /// Available if built with `prototypes`.
18102    #[cfg(any(doc, feature = "prototypes"))]
18103    pub fn vkCmdBindResourceHeapEXT(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
18104
18105    /// Available if built with `prototypes`.
18106    #[cfg(any(doc, feature = "prototypes"))]
18107    pub fn vkCmdBindSamplerHeapEXT(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
18108
18109    /// Available if built with `prototypes`.
18110    #[cfg(any(doc, feature = "prototypes"))]
18111    pub fn vkCmdBindShadersEXT(commandBuffer: VkCommandBuffer, stageCount: u32, pStages: *const VkShaderStageFlagBits, pShaders: *const VkShaderEXT);
18112
18113    /// Available if built with `prototypes`.
18114    #[cfg(any(doc, feature = "prototypes"))]
18115    pub fn vkCmdBindShadingRateImageNV(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
18116
18117    /// Available if built with `prototypes`.
18118    #[cfg(any(doc, feature = "prototypes"))]
18119    pub fn vkCmdBindTileMemoryQCOM(commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM);
18120
18121    /// Available if built with `prototypes`.
18122    #[cfg(any(doc, feature = "prototypes"))]
18123    pub fn vkCmdBindTransformFeedbackBuffersEXT(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize);
18124
18125    /// Available if built with `exported-prototypes`.
18126    #[cfg(any(doc, feature = "exported-prototypes"))]
18127    pub fn vkCmdBindVertexBuffers(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize);
18128
18129    /// Available if built with `exported-prototypes`.
18130    #[cfg(any(doc, feature = "exported-prototypes"))]
18131    pub fn vkCmdBindVertexBuffers2(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
18132
18133    /// Available if built with `prototypes`.
18134    #[cfg(any(doc, feature = "prototypes"))]
18135    pub fn vkCmdBindVertexBuffers2EXT(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
18136
18137    /// Available if built with `exported-prototypes`.
18138    #[cfg(any(doc, feature = "exported-prototypes"))]
18139    pub fn vkCmdBlitImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filter: VkFilter);
18140
18141    /// Available if built with `exported-prototypes`.
18142    #[cfg(any(doc, feature = "exported-prototypes"))]
18143    pub fn vkCmdBlitImage2(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
18144
18145    /// Available if built with `prototypes`.
18146    #[cfg(any(doc, feature = "prototypes"))]
18147    pub fn vkCmdBlitImage2KHR(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
18148
18149    /// Available if built with `prototypes`.
18150    #[cfg(any(doc, feature = "prototypes"))]
18151    pub fn vkCmdBuildAccelerationStructureNV(commandBuffer: VkCommandBuffer, pInfo: *const VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize);
18152
18153    /// Available if built with `prototypes`.
18154    #[cfg(any(doc, feature = "prototypes"))]
18155    pub fn vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const u32, ppMaxPrimitiveCounts: *const *const u32);
18156
18157    /// Available if built with `prototypes`.
18158    #[cfg(any(doc, feature = "prototypes"))]
18159    pub fn vkCmdBuildAccelerationStructuresKHR(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR);
18160
18161    /// Available if built with `prototypes`.
18162    #[cfg(any(doc, feature = "prototypes"))]
18163    pub fn vkCmdBuildClusterAccelerationStructureIndirectNV(commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV);
18164
18165    /// Available if built with `prototypes`.
18166    #[cfg(any(doc, feature = "prototypes"))]
18167    pub fn vkCmdBuildMicromapsEXT(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT);
18168
18169    /// Available if built with `prototypes`.
18170    #[cfg(any(doc, feature = "prototypes"))]
18171    pub fn vkCmdBuildPartitionedAccelerationStructuresNV(commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV);
18172
18173    /// Available if built with `exported-prototypes`.
18174    #[cfg(any(doc, feature = "exported-prototypes"))]
18175    pub fn vkCmdClearAttachments(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect);
18176
18177    /// Available if built with `exported-prototypes`.
18178    #[cfg(any(doc, feature = "exported-prototypes"))]
18179    pub fn vkCmdClearColorImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
18180
18181    /// Available if built with `exported-prototypes`.
18182    #[cfg(any(doc, feature = "exported-prototypes"))]
18183    pub fn vkCmdClearDepthStencilImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
18184
18185    /// Available if built with `prototypes`.
18186    #[cfg(any(doc, feature = "prototypes"))]
18187    pub fn vkCmdControlVideoCodingKHR(commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR);
18188
18189    /// Available if built with `prototypes`.
18190    #[cfg(any(doc, feature = "prototypes"))]
18191    pub fn vkCmdConvertCooperativeVectorMatrixNV(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV);
18192
18193    /// Available if built with `prototypes`.
18194    #[cfg(any(doc, feature = "prototypes"))]
18195    pub fn vkCmdCopyAccelerationStructureKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR);
18196
18197    /// Available if built with `prototypes`.
18198    #[cfg(any(doc, feature = "prototypes"))]
18199    pub fn vkCmdCopyAccelerationStructureNV(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR);
18200
18201    /// Available if built with `prototypes`.
18202    #[cfg(any(doc, feature = "prototypes"))]
18203    pub fn vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR);
18204
18205    /// Available if built with `exported-prototypes`.
18206    #[cfg(any(doc, feature = "exported-prototypes"))]
18207    pub fn vkCmdCopyBuffer(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy);
18208
18209    /// Available if built with `exported-prototypes`.
18210    #[cfg(any(doc, feature = "exported-prototypes"))]
18211    pub fn vkCmdCopyBuffer2(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
18212
18213    /// Available if built with `prototypes`.
18214    #[cfg(any(doc, feature = "prototypes"))]
18215    pub fn vkCmdCopyBuffer2KHR(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
18216
18217    /// Available if built with `exported-prototypes`.
18218    #[cfg(any(doc, feature = "exported-prototypes"))]
18219    pub fn vkCmdCopyBufferToImage(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy);
18220
18221    /// Available if built with `exported-prototypes`.
18222    #[cfg(any(doc, feature = "exported-prototypes"))]
18223    pub fn vkCmdCopyBufferToImage2(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
18224
18225    /// Available if built with `prototypes`.
18226    #[cfg(any(doc, feature = "prototypes"))]
18227    pub fn vkCmdCopyBufferToImage2KHR(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
18228
18229    /// Available if built with `exported-prototypes`.
18230    #[cfg(any(doc, feature = "exported-prototypes"))]
18231    pub fn vkCmdCopyImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy);
18232
18233    /// Available if built with `exported-prototypes`.
18234    #[cfg(any(doc, feature = "exported-prototypes"))]
18235    pub fn vkCmdCopyImage2(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
18236
18237    /// Available if built with `prototypes`.
18238    #[cfg(any(doc, feature = "prototypes"))]
18239    pub fn vkCmdCopyImage2KHR(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
18240
18241    /// Available if built with `exported-prototypes`.
18242    #[cfg(any(doc, feature = "exported-prototypes"))]
18243    pub fn vkCmdCopyImageToBuffer(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy);
18244
18245    /// Available if built with `exported-prototypes`.
18246    #[cfg(any(doc, feature = "exported-prototypes"))]
18247    pub fn vkCmdCopyImageToBuffer2(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
18248
18249    /// Available if built with `prototypes`.
18250    #[cfg(any(doc, feature = "prototypes"))]
18251    pub fn vkCmdCopyImageToBuffer2KHR(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
18252
18253    /// Available if built with `prototypes`.
18254    #[cfg(any(doc, feature = "prototypes"))]
18255    pub fn vkCmdCopyMemoryIndirectKHR(commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR);
18256
18257    /// Available if built with `prototypes`.
18258    #[cfg(any(doc, feature = "prototypes"))]
18259    pub fn vkCmdCopyMemoryIndirectNV(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32);
18260
18261    /// Available if built with `prototypes`.
18262    #[cfg(any(doc, feature = "prototypes"))]
18263    pub fn vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR);
18264
18265    /// Available if built with `prototypes`.
18266    #[cfg(any(doc, feature = "prototypes"))]
18267    pub fn vkCmdCopyMemoryToImageIndirectKHR(commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR);
18268
18269    /// Available if built with `prototypes`.
18270    #[cfg(any(doc, feature = "prototypes"))]
18271    pub fn vkCmdCopyMemoryToImageIndirectNV(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers);
18272
18273    /// Available if built with `prototypes`.
18274    #[cfg(any(doc, feature = "prototypes"))]
18275    pub fn vkCmdCopyMemoryToMicromapEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT);
18276
18277    /// Available if built with `prototypes`.
18278    #[cfg(any(doc, feature = "prototypes"))]
18279    pub fn vkCmdCopyMicromapEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT);
18280
18281    /// Available if built with `prototypes`.
18282    #[cfg(any(doc, feature = "prototypes"))]
18283    pub fn vkCmdCopyMicromapToMemoryEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT);
18284
18285    /// Available if built with `exported-prototypes`.
18286    #[cfg(any(doc, feature = "exported-prototypes"))]
18287    pub fn vkCmdCopyQueryPoolResults(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags);
18288
18289    /// Available if built with `prototypes`.
18290    #[cfg(any(doc, feature = "prototypes"))]
18291    pub fn vkCmdCopyTensorARM(commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM);
18292
18293    /// Available if built with `prototypes`.
18294    #[cfg(any(doc, feature = "prototypes"))]
18295    pub fn vkCmdCuLaunchKernelNVX(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX);
18296
18297    /// Available if built with `prototypes`.
18298    #[cfg(any(doc, feature = "prototypes"))]
18299    pub fn vkCmdDebugMarkerBeginEXT(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
18300
18301    /// Available if built with `prototypes`.
18302    #[cfg(any(doc, feature = "prototypes"))]
18303    pub fn vkCmdDebugMarkerEndEXT(commandBuffer: VkCommandBuffer);
18304
18305    /// Available if built with `prototypes`.
18306    #[cfg(any(doc, feature = "prototypes"))]
18307    pub fn vkCmdDebugMarkerInsertEXT(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
18308
18309    /// Available if built with `prototypes`.
18310    #[cfg(any(doc, feature = "prototypes"))]
18311    pub fn vkCmdDecodeVideoKHR(commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR);
18312
18313    /// Available if built with `prototypes`.
18314    #[cfg(any(doc, feature = "prototypes"))]
18315    pub fn vkCmdDecompressMemoryEXT(commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT);
18316
18317    /// Available if built with `prototypes`.
18318    #[cfg(any(doc, feature = "prototypes"))]
18319    pub fn vkCmdDecompressMemoryIndirectCountEXT(commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: u32, stride: u32);
18320
18321    /// Available if built with `prototypes`.
18322    #[cfg(any(doc, feature = "prototypes"))]
18323    pub fn vkCmdDecompressMemoryIndirectCountNV(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: u32);
18324
18325    /// Available if built with `prototypes`.
18326    #[cfg(any(doc, feature = "prototypes"))]
18327    pub fn vkCmdDecompressMemoryNV(commandBuffer: VkCommandBuffer, decompressRegionCount: u32, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV);
18328
18329    /// Available if built with `exported-prototypes`.
18330    #[cfg(any(doc, feature = "exported-prototypes"))]
18331    pub fn vkCmdDispatch(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18332
18333    /// Available if built with `exported-prototypes`.
18334    #[cfg(any(doc, feature = "exported-prototypes"))]
18335    pub fn vkCmdDispatchBase(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18336
18337    /// Available if built with `prototypes`.
18338    #[cfg(any(doc, feature = "prototypes"))]
18339    pub fn vkCmdDispatchBaseKHR(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18340
18341    /// Available if built with `prototypes`.
18342    #[cfg(any(doc, feature = "prototypes"))]
18343    pub fn vkCmdDispatchDataGraphARM(commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM);
18344
18345    /// Available if built with `exported-prototypes`.
18346    #[cfg(any(doc, feature = "exported-prototypes"))]
18347    pub fn vkCmdDispatchIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
18348
18349    /// Available if built with `prototypes`.
18350    #[cfg(any(doc, feature = "prototypes"))]
18351    pub fn vkCmdDispatchTileQCOM(commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM);
18352
18353    /// Available if built with `exported-prototypes`.
18354    #[cfg(any(doc, feature = "exported-prototypes"))]
18355    pub fn vkCmdDraw(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
18356
18357    /// Available if built with `prototypes`.
18358    #[cfg(any(doc, feature = "prototypes"))]
18359    pub fn vkCmdDrawClusterHUAWEI(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18360
18361    /// Available if built with `prototypes`.
18362    #[cfg(any(doc, feature = "prototypes"))]
18363    pub fn vkCmdDrawClusterIndirectHUAWEI(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
18364
18365    /// Available if built with `exported-prototypes`.
18366    #[cfg(any(doc, feature = "exported-prototypes"))]
18367    pub fn vkCmdDrawIndexed(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
18368
18369    /// Available if built with `exported-prototypes`.
18370    #[cfg(any(doc, feature = "exported-prototypes"))]
18371    pub fn vkCmdDrawIndexedIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18372
18373    /// Available if built with `exported-prototypes`.
18374    #[cfg(any(doc, feature = "exported-prototypes"))]
18375    pub fn vkCmdDrawIndexedIndirectCount(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18376
18377    /// Available if built with `prototypes`.
18378    #[cfg(any(doc, feature = "prototypes"))]
18379    pub fn vkCmdDrawIndexedIndirectCountAMD(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18380
18381    /// Available if built with `prototypes`.
18382    #[cfg(any(doc, feature = "prototypes"))]
18383    pub fn vkCmdDrawIndexedIndirectCountKHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18384
18385    /// Available if built with `exported-prototypes`.
18386    #[cfg(any(doc, feature = "exported-prototypes"))]
18387    pub fn vkCmdDrawIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18388
18389    /// Available if built with `prototypes`.
18390    #[cfg(any(doc, feature = "prototypes"))]
18391    pub fn vkCmdDrawIndirectByteCountEXT(commandBuffer: VkCommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: u32, vertexStride: u32);
18392
18393    /// Available if built with `exported-prototypes`.
18394    #[cfg(any(doc, feature = "exported-prototypes"))]
18395    pub fn vkCmdDrawIndirectCount(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18396
18397    /// Available if built with `prototypes`.
18398    #[cfg(any(doc, feature = "prototypes"))]
18399    pub fn vkCmdDrawIndirectCountAMD(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18400
18401    /// Available if built with `prototypes`.
18402    #[cfg(any(doc, feature = "prototypes"))]
18403    pub fn vkCmdDrawIndirectCountKHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18404
18405    /// Available if built with `prototypes`.
18406    #[cfg(any(doc, feature = "prototypes"))]
18407    pub fn vkCmdDrawMeshTasksEXT(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18408
18409    /// Available if built with `prototypes`.
18410    #[cfg(any(doc, feature = "prototypes"))]
18411    pub fn vkCmdDrawMeshTasksIndirectCountEXT(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18412
18413    /// Available if built with `prototypes`.
18414    #[cfg(any(doc, feature = "prototypes"))]
18415    pub fn vkCmdDrawMeshTasksIndirectCountNV(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18416
18417    /// Available if built with `prototypes`.
18418    #[cfg(any(doc, feature = "prototypes"))]
18419    pub fn vkCmdDrawMeshTasksIndirectEXT(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18420
18421    /// Available if built with `prototypes`.
18422    #[cfg(any(doc, feature = "prototypes"))]
18423    pub fn vkCmdDrawMeshTasksIndirectNV(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18424
18425    /// Available if built with `prototypes`.
18426    #[cfg(any(doc, feature = "prototypes"))]
18427    pub fn vkCmdDrawMeshTasksNV(commandBuffer: VkCommandBuffer, taskCount: u32, firstTask: u32);
18428
18429    /// Available if built with `prototypes`.
18430    #[cfg(any(doc, feature = "prototypes"))]
18431    pub fn vkCmdDrawMultiEXT(commandBuffer: VkCommandBuffer, drawCount: u32, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);
18432
18433    /// Available if built with `prototypes`.
18434    #[cfg(any(doc, feature = "prototypes"))]
18435    pub fn vkCmdDrawMultiIndexedEXT(commandBuffer: VkCommandBuffer, drawCount: u32, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: *const i32);
18436
18437    /// Available if built with `prototypes`.
18438    #[cfg(any(doc, feature = "prototypes"))]
18439    pub fn vkCmdEncodeVideoKHR(commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR);
18440
18441    /// Available if built with `prototypes`.
18442    #[cfg(any(doc, feature = "prototypes"))]
18443    pub fn vkCmdEndConditionalRenderingEXT(commandBuffer: VkCommandBuffer);
18444
18445    /// Available if built with `prototypes`.
18446    #[cfg(any(doc, feature = "prototypes"))]
18447    pub fn vkCmdEndDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer);
18448
18449    /// Available if built with `prototypes`.
18450    #[cfg(any(doc, feature = "prototypes"))]
18451    pub fn vkCmdEndPerTileExecutionQCOM(commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM);
18452
18453    /// Available if built with `exported-prototypes`.
18454    #[cfg(any(doc, feature = "exported-prototypes"))]
18455    pub fn vkCmdEndQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32);
18456
18457    /// Available if built with `prototypes`.
18458    #[cfg(any(doc, feature = "prototypes"))]
18459    pub fn vkCmdEndQueryIndexedEXT(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, index: u32);
18460
18461    /// Available if built with `exported-prototypes`.
18462    #[cfg(any(doc, feature = "exported-prototypes"))]
18463    pub fn vkCmdEndRenderPass(commandBuffer: VkCommandBuffer);
18464
18465    /// Available if built with `exported-prototypes`.
18466    #[cfg(any(doc, feature = "exported-prototypes"))]
18467    pub fn vkCmdEndRenderPass2(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
18468
18469    /// Available if built with `prototypes`.
18470    #[cfg(any(doc, feature = "prototypes"))]
18471    pub fn vkCmdEndRenderPass2KHR(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
18472
18473    /// Available if built with `exported-prototypes`.
18474    #[cfg(any(doc, feature = "exported-prototypes"))]
18475    pub fn vkCmdEndRendering(commandBuffer: VkCommandBuffer);
18476
18477    /// Available if built with `prototypes`.
18478    #[cfg(any(doc, feature = "prototypes"))]
18479    pub fn vkCmdEndRendering2EXT(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
18480
18481    /// Available if built with `prototypes`.
18482    #[cfg(any(doc, feature = "prototypes"))]
18483    pub fn vkCmdEndRendering2KHR(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
18484
18485    /// Available if built with `prototypes`.
18486    #[cfg(any(doc, feature = "prototypes"))]
18487    pub fn vkCmdEndRenderingKHR(commandBuffer: VkCommandBuffer);
18488
18489    /// Available if built with `prototypes`.
18490    #[cfg(any(doc, feature = "prototypes"))]
18491    pub fn vkCmdEndTransformFeedbackEXT(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
18492
18493    /// Available if built with `prototypes`.
18494    #[cfg(any(doc, feature = "prototypes"))]
18495    pub fn vkCmdEndVideoCodingKHR(commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR);
18496
18497    /// Available if built with `exported-prototypes`.
18498    #[cfg(any(doc, feature = "exported-prototypes"))]
18499    pub fn vkCmdExecuteCommands(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
18500
18501    /// Available if built with `prototypes`.
18502    #[cfg(any(doc, feature = "prototypes"))]
18503    pub fn vkCmdExecuteGeneratedCommandsEXT(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT);
18504
18505    /// Available if built with `prototypes`.
18506    #[cfg(any(doc, feature = "prototypes"))]
18507    pub fn vkCmdExecuteGeneratedCommandsNV(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
18508
18509    /// Available if built with `exported-prototypes`.
18510    #[cfg(any(doc, feature = "exported-prototypes"))]
18511    pub fn vkCmdFillBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: u32);
18512
18513    /// Available if built with `prototypes`.
18514    #[cfg(any(doc, feature = "prototypes"))]
18515    pub fn vkCmdInsertDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
18516
18517    /// Available if built with `exported-prototypes`.
18518    #[cfg(any(doc, feature = "exported-prototypes"))]
18519    pub fn vkCmdNextSubpass(commandBuffer: VkCommandBuffer, contents: VkSubpassContents);
18520
18521    /// Available if built with `exported-prototypes`.
18522    #[cfg(any(doc, feature = "exported-prototypes"))]
18523    pub fn vkCmdNextSubpass2(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
18524
18525    /// Available if built with `prototypes`.
18526    #[cfg(any(doc, feature = "prototypes"))]
18527    pub fn vkCmdNextSubpass2KHR(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
18528
18529    /// Available if built with `prototypes`.
18530    #[cfg(any(doc, feature = "prototypes"))]
18531    pub fn vkCmdOpticalFlowExecuteNV(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV);
18532
18533    /// Available if built with `exported-prototypes`.
18534    #[cfg(any(doc, feature = "exported-prototypes"))]
18535    pub fn vkCmdPipelineBarrier(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
18536
18537    /// Available if built with `exported-prototypes`.
18538    #[cfg(any(doc, feature = "exported-prototypes"))]
18539    pub fn vkCmdPipelineBarrier2(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
18540
18541    /// Available if built with `prototypes`.
18542    #[cfg(any(doc, feature = "prototypes"))]
18543    pub fn vkCmdPipelineBarrier2KHR(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
18544
18545    /// Available if built with `prototypes`.
18546    #[cfg(any(doc, feature = "prototypes"))]
18547    pub fn vkCmdPreprocessGeneratedCommandsEXT(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer);
18548
18549    /// Available if built with `prototypes`.
18550    #[cfg(any(doc, feature = "prototypes"))]
18551    pub fn vkCmdPreprocessGeneratedCommandsNV(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
18552
18553    /// Available if built with `exported-prototypes`.
18554    #[cfg(any(doc, feature = "exported-prototypes"))]
18555    pub fn vkCmdPushConstants(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const c_void);
18556
18557    /// Available if built with `exported-prototypes`.
18558    #[cfg(any(doc, feature = "exported-prototypes"))]
18559    pub fn vkCmdPushConstants2(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
18560
18561    /// Available if built with `prototypes`.
18562    #[cfg(any(doc, feature = "prototypes"))]
18563    pub fn vkCmdPushConstants2KHR(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
18564
18565    /// Available if built with `prototypes`.
18566    #[cfg(any(doc, feature = "prototypes"))]
18567    pub fn vkCmdPushDataEXT(commandBuffer: VkCommandBuffer, pPushDataInfo: *const VkPushDataInfoEXT);
18568
18569    /// Available if built with `exported-prototypes`.
18570    #[cfg(any(doc, feature = "exported-prototypes"))]
18571    pub fn vkCmdPushDescriptorSet(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
18572
18573    /// Available if built with `exported-prototypes`.
18574    #[cfg(any(doc, feature = "exported-prototypes"))]
18575    pub fn vkCmdPushDescriptorSet2(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
18576
18577    /// Available if built with `prototypes`.
18578    #[cfg(any(doc, feature = "prototypes"))]
18579    pub fn vkCmdPushDescriptorSet2KHR(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
18580
18581    /// Available if built with `prototypes`.
18582    #[cfg(any(doc, feature = "prototypes"))]
18583    pub fn vkCmdPushDescriptorSetKHR(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
18584
18585    /// Available if built with `exported-prototypes`.
18586    #[cfg(any(doc, feature = "exported-prototypes"))]
18587    pub fn vkCmdPushDescriptorSetWithTemplate(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
18588
18589    /// Available if built with `exported-prototypes`.
18590    #[cfg(any(doc, feature = "exported-prototypes"))]
18591    pub fn vkCmdPushDescriptorSetWithTemplate2(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
18592
18593    /// Available if built with `prototypes`.
18594    #[cfg(any(doc, feature = "prototypes"))]
18595    pub fn vkCmdPushDescriptorSetWithTemplate2KHR(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
18596
18597    /// Available if built with `prototypes`.
18598    #[cfg(any(doc, feature = "prototypes"))]
18599    pub fn vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
18600
18601    /// Available if built with `exported-prototypes`.
18602    #[cfg(any(doc, feature = "exported-prototypes"))]
18603    pub fn vkCmdResetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
18604
18605    /// Available if built with `exported-prototypes`.
18606    #[cfg(any(doc, feature = "exported-prototypes"))]
18607    pub fn vkCmdResetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
18608
18609    /// Available if built with `prototypes`.
18610    #[cfg(any(doc, feature = "prototypes"))]
18611    pub fn vkCmdResetEvent2KHR(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
18612
18613    /// Available if built with `exported-prototypes`.
18614    #[cfg(any(doc, feature = "exported-prototypes"))]
18615    pub fn vkCmdResetQueryPool(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
18616
18617    /// Available if built with `exported-prototypes`.
18618    #[cfg(any(doc, feature = "exported-prototypes"))]
18619    pub fn vkCmdResolveImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve);
18620
18621    /// Available if built with `exported-prototypes`.
18622    #[cfg(any(doc, feature = "exported-prototypes"))]
18623    pub fn vkCmdResolveImage2(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
18624
18625    /// Available if built with `prototypes`.
18626    #[cfg(any(doc, feature = "prototypes"))]
18627    pub fn vkCmdResolveImage2KHR(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
18628
18629    /// Available if built with `prototypes`.
18630    #[cfg(any(doc, feature = "prototypes"))]
18631    pub fn vkCmdSetAlphaToCoverageEnableEXT(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32);
18632
18633    /// Available if built with `prototypes`.
18634    #[cfg(any(doc, feature = "prototypes"))]
18635    pub fn vkCmdSetAlphaToOneEnableEXT(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32);
18636
18637    /// Available if built with `prototypes`.
18638    #[cfg(any(doc, feature = "prototypes"))]
18639    pub fn vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags);
18640
18641    /// Available if built with `exported-prototypes`.
18642    #[cfg(any(doc, feature = "exported-prototypes"))]
18643    pub fn vkCmdSetBlendConstants(commandBuffer: VkCommandBuffer, blendConstants: *const f32);
18644
18645    /// Available if built with `prototypes`.
18646    #[cfg(any(doc, feature = "prototypes"))]
18647    pub fn vkCmdSetCheckpointNV(commandBuffer: VkCommandBuffer, pCheckpointMarker: *const c_void);
18648
18649    /// Available if built with `prototypes`.
18650    #[cfg(any(doc, feature = "prototypes"))]
18651    pub fn vkCmdSetCoarseSampleOrderNV(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV);
18652
18653    /// Available if built with `prototypes`.
18654    #[cfg(any(doc, feature = "prototypes"))]
18655    pub fn vkCmdSetColorBlendAdvancedEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT);
18656
18657    /// Available if built with `prototypes`.
18658    #[cfg(any(doc, feature = "prototypes"))]
18659    pub fn vkCmdSetColorBlendEnableEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEnables: *const VkBool32);
18660
18661    /// Available if built with `prototypes`.
18662    #[cfg(any(doc, feature = "prototypes"))]
18663    pub fn vkCmdSetColorBlendEquationEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEquations: *const VkColorBlendEquationEXT);
18664
18665    /// Available if built with `prototypes`.
18666    #[cfg(any(doc, feature = "prototypes"))]
18667    pub fn vkCmdSetColorWriteEnableEXT(commandBuffer: VkCommandBuffer, attachmentCount: u32, pColorWriteEnables: *const VkBool32);
18668
18669    /// Available if built with `prototypes`.
18670    #[cfg(any(doc, feature = "prototypes"))]
18671    pub fn vkCmdSetColorWriteMaskEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorWriteMasks: *const VkColorComponentFlags);
18672
18673    /// Available if built with `prototypes`.
18674    #[cfg(any(doc, feature = "prototypes"))]
18675    pub fn vkCmdSetComputeOccupancyPriorityNV(commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV);
18676
18677    /// Available if built with `prototypes`.
18678    #[cfg(any(doc, feature = "prototypes"))]
18679    pub fn vkCmdSetConservativeRasterizationModeEXT(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT);
18680
18681    /// Available if built with `prototypes`.
18682    #[cfg(any(doc, feature = "prototypes"))]
18683    pub fn vkCmdSetCoverageModulationModeNV(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV);
18684
18685    /// Available if built with `prototypes`.
18686    #[cfg(any(doc, feature = "prototypes"))]
18687    pub fn vkCmdSetCoverageModulationTableEnableNV(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32);
18688
18689    /// Available if built with `prototypes`.
18690    #[cfg(any(doc, feature = "prototypes"))]
18691    pub fn vkCmdSetCoverageModulationTableNV(commandBuffer: VkCommandBuffer, coverageModulationTableCount: u32, pCoverageModulationTable: *const f32);
18692
18693    /// Available if built with `prototypes`.
18694    #[cfg(any(doc, feature = "prototypes"))]
18695    pub fn vkCmdSetCoverageReductionModeNV(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV);
18696
18697    /// Available if built with `prototypes`.
18698    #[cfg(any(doc, feature = "prototypes"))]
18699    pub fn vkCmdSetCoverageToColorEnableNV(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32);
18700
18701    /// Available if built with `prototypes`.
18702    #[cfg(any(doc, feature = "prototypes"))]
18703    pub fn vkCmdSetCoverageToColorLocationNV(commandBuffer: VkCommandBuffer, coverageToColorLocation: u32);
18704
18705    /// Available if built with `exported-prototypes`.
18706    #[cfg(any(doc, feature = "exported-prototypes"))]
18707    pub fn vkCmdSetCullMode(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
18708
18709    /// Available if built with `prototypes`.
18710    #[cfg(any(doc, feature = "prototypes"))]
18711    pub fn vkCmdSetCullModeEXT(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
18712
18713    /// Available if built with `exported-prototypes`.
18714    #[cfg(any(doc, feature = "exported-prototypes"))]
18715    pub fn vkCmdSetDepthBias(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);
18716
18717    /// Available if built with `prototypes`.
18718    #[cfg(any(doc, feature = "prototypes"))]
18719    pub fn vkCmdSetDepthBias2EXT(commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT);
18720
18721    /// Available if built with `exported-prototypes`.
18722    #[cfg(any(doc, feature = "exported-prototypes"))]
18723    pub fn vkCmdSetDepthBiasEnable(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
18724
18725    /// Available if built with `prototypes`.
18726    #[cfg(any(doc, feature = "prototypes"))]
18727    pub fn vkCmdSetDepthBiasEnableEXT(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
18728
18729    /// Available if built with `exported-prototypes`.
18730    #[cfg(any(doc, feature = "exported-prototypes"))]
18731    pub fn vkCmdSetDepthBounds(commandBuffer: VkCommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);
18732
18733    /// Available if built with `exported-prototypes`.
18734    #[cfg(any(doc, feature = "exported-prototypes"))]
18735    pub fn vkCmdSetDepthBoundsTestEnable(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
18736
18737    /// Available if built with `prototypes`.
18738    #[cfg(any(doc, feature = "prototypes"))]
18739    pub fn vkCmdSetDepthBoundsTestEnableEXT(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
18740
18741    /// Available if built with `prototypes`.
18742    #[cfg(any(doc, feature = "prototypes"))]
18743    pub fn vkCmdSetDepthClampEnableEXT(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32);
18744
18745    /// Available if built with `prototypes`.
18746    #[cfg(any(doc, feature = "prototypes"))]
18747    pub fn vkCmdSetDepthClampRangeEXT(commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT);
18748
18749    /// Available if built with `prototypes`.
18750    #[cfg(any(doc, feature = "prototypes"))]
18751    pub fn vkCmdSetDepthClipEnableEXT(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32);
18752
18753    /// Available if built with `prototypes`.
18754    #[cfg(any(doc, feature = "prototypes"))]
18755    pub fn vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32);
18756
18757    /// Available if built with `exported-prototypes`.
18758    #[cfg(any(doc, feature = "exported-prototypes"))]
18759    pub fn vkCmdSetDepthCompareOp(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
18760
18761    /// Available if built with `prototypes`.
18762    #[cfg(any(doc, feature = "prototypes"))]
18763    pub fn vkCmdSetDepthCompareOpEXT(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
18764
18765    /// Available if built with `exported-prototypes`.
18766    #[cfg(any(doc, feature = "exported-prototypes"))]
18767    pub fn vkCmdSetDepthTestEnable(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
18768
18769    /// Available if built with `prototypes`.
18770    #[cfg(any(doc, feature = "prototypes"))]
18771    pub fn vkCmdSetDepthTestEnableEXT(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
18772
18773    /// Available if built with `exported-prototypes`.
18774    #[cfg(any(doc, feature = "exported-prototypes"))]
18775    pub fn vkCmdSetDepthWriteEnable(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
18776
18777    /// Available if built with `prototypes`.
18778    #[cfg(any(doc, feature = "prototypes"))]
18779    pub fn vkCmdSetDepthWriteEnableEXT(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
18780
18781    /// Available if built with `prototypes`.
18782    #[cfg(any(doc, feature = "prototypes"))]
18783    pub fn vkCmdSetDescriptorBufferOffsets2EXT(commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT);
18784
18785    /// Available if built with `prototypes`.
18786    #[cfg(any(doc, feature = "prototypes"))]
18787    pub fn vkCmdSetDescriptorBufferOffsetsEXT(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, setCount: u32, pBufferIndices: *const u32, pOffsets: *const VkDeviceSize);
18788
18789    /// Available if built with `exported-prototypes`.
18790    #[cfg(any(doc, feature = "exported-prototypes"))]
18791    pub fn vkCmdSetDeviceMask(commandBuffer: VkCommandBuffer, deviceMask: u32);
18792
18793    /// Available if built with `prototypes`.
18794    #[cfg(any(doc, feature = "prototypes"))]
18795    pub fn vkCmdSetDeviceMaskKHR(commandBuffer: VkCommandBuffer, deviceMask: u32);
18796
18797    /// Available if built with `prototypes`.
18798    #[cfg(any(doc, feature = "prototypes"))]
18799    pub fn vkCmdSetDiscardRectangleEXT(commandBuffer: VkCommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: *const VkRect2D);
18800
18801    /// Available if built with `prototypes`.
18802    #[cfg(any(doc, feature = "prototypes"))]
18803    pub fn vkCmdSetDiscardRectangleEnableEXT(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32);
18804
18805    /// Available if built with `prototypes`.
18806    #[cfg(any(doc, feature = "prototypes"))]
18807    pub fn vkCmdSetDiscardRectangleModeEXT(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT);
18808
18809    /// Available if built with `exported-prototypes`.
18810    #[cfg(any(doc, feature = "exported-prototypes"))]
18811    pub fn vkCmdSetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
18812
18813    /// Available if built with `exported-prototypes`.
18814    #[cfg(any(doc, feature = "exported-prototypes"))]
18815    pub fn vkCmdSetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
18816
18817    /// Available if built with `prototypes`.
18818    #[cfg(any(doc, feature = "prototypes"))]
18819    pub fn vkCmdSetEvent2KHR(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
18820
18821    /// Available if built with `prototypes`.
18822    #[cfg(any(doc, feature = "prototypes"))]
18823    pub fn vkCmdSetExclusiveScissorEnableNV(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissorEnables: *const VkBool32);
18824
18825    /// Available if built with `prototypes`.
18826    #[cfg(any(doc, feature = "prototypes"))]
18827    pub fn vkCmdSetExclusiveScissorNV(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: *const VkRect2D);
18828
18829    /// Available if built with `prototypes`.
18830    #[cfg(any(doc, feature = "prototypes"))]
18831    pub fn vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: f32);
18832
18833    /// Available if built with `prototypes`.
18834    #[cfg(any(doc, feature = "prototypes"))]
18835    pub fn vkCmdSetFragmentShadingRateEnumNV(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
18836
18837    /// Available if built with `prototypes`.
18838    #[cfg(any(doc, feature = "prototypes"))]
18839    pub fn vkCmdSetFragmentShadingRateKHR(commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
18840
18841    /// Available if built with `exported-prototypes`.
18842    #[cfg(any(doc, feature = "exported-prototypes"))]
18843    pub fn vkCmdSetFrontFace(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
18844
18845    /// Available if built with `prototypes`.
18846    #[cfg(any(doc, feature = "prototypes"))]
18847    pub fn vkCmdSetFrontFaceEXT(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
18848
18849    /// Available if built with `prototypes`.
18850    #[cfg(any(doc, feature = "prototypes"))]
18851    pub fn vkCmdSetLineRasterizationModeEXT(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT);
18852
18853    /// Available if built with `exported-prototypes`.
18854    #[cfg(any(doc, feature = "exported-prototypes"))]
18855    pub fn vkCmdSetLineStipple(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
18856
18857    /// Available if built with `prototypes`.
18858    #[cfg(any(doc, feature = "prototypes"))]
18859    pub fn vkCmdSetLineStippleEXT(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
18860
18861    /// Available if built with `prototypes`.
18862    #[cfg(any(doc, feature = "prototypes"))]
18863    pub fn vkCmdSetLineStippleEnableEXT(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32);
18864
18865    /// Available if built with `prototypes`.
18866    #[cfg(any(doc, feature = "prototypes"))]
18867    pub fn vkCmdSetLineStippleKHR(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
18868
18869    /// Available if built with `exported-prototypes`.
18870    #[cfg(any(doc, feature = "exported-prototypes"))]
18871    pub fn vkCmdSetLineWidth(commandBuffer: VkCommandBuffer, lineWidth: f32);
18872
18873    /// Available if built with `prototypes`.
18874    #[cfg(any(doc, feature = "prototypes"))]
18875    pub fn vkCmdSetLogicOpEXT(commandBuffer: VkCommandBuffer, logicOp: VkLogicOp);
18876
18877    /// Available if built with `prototypes`.
18878    #[cfg(any(doc, feature = "prototypes"))]
18879    pub fn vkCmdSetLogicOpEnableEXT(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32);
18880
18881    /// Available if built with `prototypes`.
18882    #[cfg(any(doc, feature = "prototypes"))]
18883    pub fn vkCmdSetPatchControlPointsEXT(commandBuffer: VkCommandBuffer, patchControlPoints: u32);
18884
18885    /// Available if built with `prototypes`.
18886    #[cfg(any(doc, feature = "prototypes"))]
18887    pub fn vkCmdSetPerformanceMarkerINTEL(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult;
18888
18889    /// Available if built with `prototypes`.
18890    #[cfg(any(doc, feature = "prototypes"))]
18891    pub fn vkCmdSetPerformanceOverrideINTEL(commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult;
18892
18893    /// Available if built with `prototypes`.
18894    #[cfg(any(doc, feature = "prototypes"))]
18895    pub fn vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult;
18896
18897    /// Available if built with `prototypes`.
18898    #[cfg(any(doc, feature = "prototypes"))]
18899    pub fn vkCmdSetPolygonModeEXT(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode);
18900
18901    /// Available if built with `exported-prototypes`.
18902    #[cfg(any(doc, feature = "exported-prototypes"))]
18903    pub fn vkCmdSetPrimitiveRestartEnable(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
18904
18905    /// Available if built with `prototypes`.
18906    #[cfg(any(doc, feature = "prototypes"))]
18907    pub fn vkCmdSetPrimitiveRestartEnableEXT(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
18908
18909    /// Available if built with `exported-prototypes`.
18910    #[cfg(any(doc, feature = "exported-prototypes"))]
18911    pub fn vkCmdSetPrimitiveTopology(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
18912
18913    /// Available if built with `prototypes`.
18914    #[cfg(any(doc, feature = "prototypes"))]
18915    pub fn vkCmdSetPrimitiveTopologyEXT(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
18916
18917    /// Available if built with `prototypes`.
18918    #[cfg(any(doc, feature = "prototypes"))]
18919    pub fn vkCmdSetProvokingVertexModeEXT(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT);
18920
18921    /// Available if built with `prototypes`.
18922    #[cfg(any(doc, feature = "prototypes"))]
18923    pub fn vkCmdSetRasterizationSamplesEXT(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits);
18924
18925    /// Available if built with `prototypes`.
18926    #[cfg(any(doc, feature = "prototypes"))]
18927    pub fn vkCmdSetRasterizationStreamEXT(commandBuffer: VkCommandBuffer, rasterizationStream: u32);
18928
18929    /// Available if built with `exported-prototypes`.
18930    #[cfg(any(doc, feature = "exported-prototypes"))]
18931    pub fn vkCmdSetRasterizerDiscardEnable(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
18932
18933    /// Available if built with `prototypes`.
18934    #[cfg(any(doc, feature = "prototypes"))]
18935    pub fn vkCmdSetRasterizerDiscardEnableEXT(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
18936
18937    /// Available if built with `prototypes`.
18938    #[cfg(any(doc, feature = "prototypes"))]
18939    pub fn vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer: VkCommandBuffer, pipelineStackSize: u32);
18940
18941    /// Available if built with `exported-prototypes`.
18942    #[cfg(any(doc, feature = "exported-prototypes"))]
18943    pub fn vkCmdSetRenderingAttachmentLocations(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
18944
18945    /// Available if built with `prototypes`.
18946    #[cfg(any(doc, feature = "prototypes"))]
18947    pub fn vkCmdSetRenderingAttachmentLocationsKHR(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
18948
18949    /// Available if built with `exported-prototypes`.
18950    #[cfg(any(doc, feature = "exported-prototypes"))]
18951    pub fn vkCmdSetRenderingInputAttachmentIndices(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
18952
18953    /// Available if built with `prototypes`.
18954    #[cfg(any(doc, feature = "prototypes"))]
18955    pub fn vkCmdSetRenderingInputAttachmentIndicesKHR(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
18956
18957    /// Available if built with `prototypes`.
18958    #[cfg(any(doc, feature = "prototypes"))]
18959    pub fn vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32);
18960
18961    /// Available if built with `prototypes`.
18962    #[cfg(any(doc, feature = "prototypes"))]
18963    pub fn vkCmdSetSampleLocationsEXT(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT);
18964
18965    /// Available if built with `prototypes`.
18966    #[cfg(any(doc, feature = "prototypes"))]
18967    pub fn vkCmdSetSampleLocationsEnableEXT(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32);
18968
18969    /// Available if built with `prototypes`.
18970    #[cfg(any(doc, feature = "prototypes"))]
18971    pub fn vkCmdSetSampleMaskEXT(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: *const VkSampleMask);
18972
18973    /// Available if built with `exported-prototypes`.
18974    #[cfg(any(doc, feature = "exported-prototypes"))]
18975    pub fn vkCmdSetScissor(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D);
18976
18977    /// Available if built with `exported-prototypes`.
18978    #[cfg(any(doc, feature = "exported-prototypes"))]
18979    pub fn vkCmdSetScissorWithCount(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
18980
18981    /// Available if built with `prototypes`.
18982    #[cfg(any(doc, feature = "prototypes"))]
18983    pub fn vkCmdSetScissorWithCountEXT(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
18984
18985    /// Available if built with `prototypes`.
18986    #[cfg(any(doc, feature = "prototypes"))]
18987    pub fn vkCmdSetShadingRateImageEnableNV(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32);
18988
18989    /// Available if built with `exported-prototypes`.
18990    #[cfg(any(doc, feature = "exported-prototypes"))]
18991    pub fn vkCmdSetStencilCompareMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32);
18992
18993    /// Available if built with `exported-prototypes`.
18994    #[cfg(any(doc, feature = "exported-prototypes"))]
18995    pub fn vkCmdSetStencilOp(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
18996
18997    /// Available if built with `prototypes`.
18998    #[cfg(any(doc, feature = "prototypes"))]
18999    pub fn vkCmdSetStencilOpEXT(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
19000
19001    /// Available if built with `exported-prototypes`.
19002    #[cfg(any(doc, feature = "exported-prototypes"))]
19003    pub fn vkCmdSetStencilReference(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32);
19004
19005    /// Available if built with `exported-prototypes`.
19006    #[cfg(any(doc, feature = "exported-prototypes"))]
19007    pub fn vkCmdSetStencilTestEnable(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
19008
19009    /// Available if built with `prototypes`.
19010    #[cfg(any(doc, feature = "prototypes"))]
19011    pub fn vkCmdSetStencilTestEnableEXT(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
19012
19013    /// Available if built with `exported-prototypes`.
19014    #[cfg(any(doc, feature = "exported-prototypes"))]
19015    pub fn vkCmdSetStencilWriteMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32);
19016
19017    /// Available if built with `prototypes`.
19018    #[cfg(any(doc, feature = "prototypes"))]
19019    pub fn vkCmdSetTessellationDomainOriginEXT(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin);
19020
19021    /// Available if built with `prototypes`.
19022    #[cfg(any(doc, feature = "prototypes"))]
19023    pub fn vkCmdSetVertexInputEXT(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT);
19024
19025    /// Available if built with `exported-prototypes`.
19026    #[cfg(any(doc, feature = "exported-prototypes"))]
19027    pub fn vkCmdSetViewport(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport);
19028
19029    /// Available if built with `prototypes`.
19030    #[cfg(any(doc, feature = "prototypes"))]
19031    pub fn vkCmdSetViewportShadingRatePaletteNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: *const VkShadingRatePaletteNV);
19032
19033    /// Available if built with `prototypes`.
19034    #[cfg(any(doc, feature = "prototypes"))]
19035    pub fn vkCmdSetViewportSwizzleNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportSwizzles: *const VkViewportSwizzleNV);
19036
19037    /// Available if built with `prototypes`.
19038    #[cfg(any(doc, feature = "prototypes"))]
19039    pub fn vkCmdSetViewportWScalingEnableNV(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32);
19040
19041    /// Available if built with `prototypes`.
19042    #[cfg(any(doc, feature = "prototypes"))]
19043    pub fn vkCmdSetViewportWScalingNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: *const VkViewportWScalingNV);
19044
19045    /// Available if built with `exported-prototypes`.
19046    #[cfg(any(doc, feature = "exported-prototypes"))]
19047    pub fn vkCmdSetViewportWithCount(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
19048
19049    /// Available if built with `prototypes`.
19050    #[cfg(any(doc, feature = "prototypes"))]
19051    pub fn vkCmdSetViewportWithCountEXT(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
19052
19053    /// Available if built with `prototypes`.
19054    #[cfg(any(doc, feature = "prototypes"))]
19055    pub fn vkCmdSubpassShadingHUAWEI(commandBuffer: VkCommandBuffer);
19056
19057    /// Available if built with `prototypes`.
19058    #[cfg(any(doc, feature = "prototypes"))]
19059    pub fn vkCmdTraceRaysIndirect2KHR(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress);
19060
19061    /// Available if built with `prototypes`.
19062    #[cfg(any(doc, feature = "prototypes"))]
19063    pub fn vkCmdTraceRaysIndirectKHR(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress);
19064
19065    /// Available if built with `prototypes`.
19066    #[cfg(any(doc, feature = "prototypes"))]
19067    pub fn vkCmdTraceRaysKHR(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32);
19068
19069    /// Available if built with `prototypes`.
19070    #[cfg(any(doc, feature = "prototypes"))]
19071    pub fn vkCmdTraceRaysNV(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: u32, height: u32, depth: u32);
19072
19073    /// Available if built with `exported-prototypes`.
19074    #[cfg(any(doc, feature = "exported-prototypes"))]
19075    pub fn vkCmdUpdateBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const c_void);
19076
19077    /// Available if built with `prototypes`.
19078    #[cfg(any(doc, feature = "prototypes"))]
19079    pub fn vkCmdUpdatePipelineIndirectBufferNV(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
19080
19081    /// Available if built with `exported-prototypes`.
19082    #[cfg(any(doc, feature = "exported-prototypes"))]
19083    pub fn vkCmdWaitEvents(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
19084
19085    /// Available if built with `exported-prototypes`.
19086    #[cfg(any(doc, feature = "exported-prototypes"))]
19087    pub fn vkCmdWaitEvents2(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
19088
19089    /// Available if built with `prototypes`.
19090    #[cfg(any(doc, feature = "prototypes"))]
19091    pub fn vkCmdWaitEvents2KHR(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
19092
19093    /// Available if built with `prototypes`.
19094    #[cfg(any(doc, feature = "prototypes"))]
19095    pub fn vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
19096
19097    /// Available if built with `prototypes`.
19098    #[cfg(any(doc, feature = "prototypes"))]
19099    pub fn vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
19100
19101    /// Available if built with `prototypes`.
19102    #[cfg(any(doc, feature = "prototypes"))]
19103    pub fn vkCmdWriteBufferMarker2AMD(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
19104
19105    /// Available if built with `prototypes`.
19106    #[cfg(any(doc, feature = "prototypes"))]
19107    pub fn vkCmdWriteBufferMarkerAMD(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
19108
19109    /// Available if built with `prototypes`.
19110    #[cfg(any(doc, feature = "prototypes"))]
19111    pub fn vkCmdWriteMicromapsPropertiesEXT(commandBuffer: VkCommandBuffer, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
19112
19113    /// Available if built with `exported-prototypes`.
19114    #[cfg(any(doc, feature = "exported-prototypes"))]
19115    pub fn vkCmdWriteTimestamp(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: u32);
19116
19117    /// Available if built with `exported-prototypes`.
19118    #[cfg(any(doc, feature = "exported-prototypes"))]
19119    pub fn vkCmdWriteTimestamp2(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
19120
19121    /// Available if built with `prototypes`.
19122    #[cfg(any(doc, feature = "prototypes"))]
19123    pub fn vkCmdWriteTimestamp2KHR(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
19124
19125    /// Available if built with `prototypes`.
19126    #[cfg(any(doc, feature = "prototypes"))]
19127    pub fn vkCompileDeferredNV(device: VkDevice, pipeline: VkPipeline, shader: u32) -> VkResult;
19128
19129    /// Available if built with `prototypes`.
19130    #[cfg(any(doc, feature = "prototypes"))]
19131    pub fn vkConvertCooperativeVectorMatrixNV(device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult;
19132
19133    /// Available if built with `prototypes`.
19134    #[cfg(any(doc, feature = "prototypes"))]
19135    pub fn vkCopyAccelerationStructureKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult;
19136
19137    /// Available if built with `prototypes`.
19138    #[cfg(any(doc, feature = "prototypes"))]
19139    pub fn vkCopyAccelerationStructureToMemoryKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult;
19140
19141    /// Available if built with `exported-prototypes`.
19142    #[cfg(any(doc, feature = "exported-prototypes"))]
19143    pub fn vkCopyImageToImage(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
19144
19145    /// Available if built with `prototypes`.
19146    #[cfg(any(doc, feature = "prototypes"))]
19147    pub fn vkCopyImageToImageEXT(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
19148
19149    /// Available if built with `exported-prototypes`.
19150    #[cfg(any(doc, feature = "exported-prototypes"))]
19151    pub fn vkCopyImageToMemory(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
19152
19153    /// Available if built with `prototypes`.
19154    #[cfg(any(doc, feature = "prototypes"))]
19155    pub fn vkCopyImageToMemoryEXT(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
19156
19157    /// Available if built with `prototypes`.
19158    #[cfg(any(doc, feature = "prototypes"))]
19159    pub fn vkCopyMemoryToAccelerationStructureKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult;
19160
19161    /// Available if built with `exported-prototypes`.
19162    #[cfg(any(doc, feature = "exported-prototypes"))]
19163    pub fn vkCopyMemoryToImage(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
19164
19165    /// Available if built with `prototypes`.
19166    #[cfg(any(doc, feature = "prototypes"))]
19167    pub fn vkCopyMemoryToImageEXT(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
19168
19169    /// Available if built with `prototypes`.
19170    #[cfg(any(doc, feature = "prototypes"))]
19171    pub fn vkCopyMemoryToMicromapEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult;
19172
19173    /// Available if built with `prototypes`.
19174    #[cfg(any(doc, feature = "prototypes"))]
19175    pub fn vkCopyMicromapEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult;
19176
19177    /// Available if built with `prototypes`.
19178    #[cfg(any(doc, feature = "prototypes"))]
19179    pub fn vkCopyMicromapToMemoryEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult;
19180
19181    /// Available if built with `prototypes`.
19182    #[cfg(any(doc, feature = "prototypes"))]
19183    pub fn vkCreateAccelerationStructureKHR(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult;
19184
19185    /// Available if built with `prototypes`.
19186    #[cfg(any(doc, feature = "prototypes"))]
19187    pub fn vkCreateAccelerationStructureNV(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult;
19188
19189    /// Available if built with `exported-prototypes`.
19190    #[cfg(any(doc, feature = "exported-prototypes"))]
19191    pub fn vkCreateBuffer(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;
19192
19193    /// Available if built with `exported-prototypes`.
19194    #[cfg(any(doc, feature = "exported-prototypes"))]
19195    pub fn vkCreateBufferView(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;
19196
19197    /// Available if built with `exported-prototypes`.
19198    #[cfg(any(doc, feature = "exported-prototypes"))]
19199    pub fn vkCreateCommandPool(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;
19200
19201    /// Available if built with `exported-prototypes`.
19202    #[cfg(any(doc, feature = "exported-prototypes"))]
19203    pub fn vkCreateComputePipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19204
19205    /// Available if built with `prototypes`.
19206    #[cfg(any(doc, feature = "prototypes"))]
19207    pub fn vkCreateCuFunctionNVX(device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult;
19208
19209    /// Available if built with `prototypes`.
19210    #[cfg(any(doc, feature = "prototypes"))]
19211    pub fn vkCreateCuModuleNVX(device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult;
19212
19213    /// Available if built with `prototypes`.
19214    #[cfg(any(doc, feature = "prototypes"))]
19215    pub fn vkCreateDataGraphPipelineSessionARM(device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult;
19216
19217    /// Available if built with `prototypes`.
19218    #[cfg(any(doc, feature = "prototypes"))]
19219    pub fn vkCreateDataGraphPipelinesARM(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkDataGraphPipelineCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19220
19221    /// Available if built with `prototypes`.
19222    #[cfg(any(doc, feature = "prototypes"))]
19223    pub fn vkCreateDebugReportCallbackEXT(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult;
19224
19225    /// Available if built with `prototypes`.
19226    #[cfg(any(doc, feature = "prototypes"))]
19227    pub fn vkCreateDebugUtilsMessengerEXT(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult;
19228
19229    /// Available if built with `prototypes`.
19230    #[cfg(any(doc, feature = "prototypes"))]
19231    pub fn vkCreateDeferredOperationKHR(device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult;
19232
19233    /// Available if built with `exported-prototypes`.
19234    #[cfg(any(doc, feature = "exported-prototypes"))]
19235    pub fn vkCreateDescriptorPool(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult;
19236
19237    /// Available if built with `exported-prototypes`.
19238    #[cfg(any(doc, feature = "exported-prototypes"))]
19239    pub fn vkCreateDescriptorSetLayout(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;
19240
19241    /// Available if built with `exported-prototypes`.
19242    #[cfg(any(doc, feature = "exported-prototypes"))]
19243    pub fn vkCreateDescriptorUpdateTemplate(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
19244
19245    /// Available if built with `prototypes`.
19246    #[cfg(any(doc, feature = "prototypes"))]
19247    pub fn vkCreateDescriptorUpdateTemplateKHR(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
19248
19249    /// Available if built with `exported-prototypes`.
19250    #[cfg(any(doc, feature = "exported-prototypes"))]
19251    pub fn vkCreateDevice(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;
19252
19253    /// Available if built with `prototypes`.
19254    #[cfg(any(doc, feature = "prototypes"))]
19255    pub fn vkCreateDisplayModeKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;
19256
19257    /// Available if built with `prototypes`.
19258    #[cfg(any(doc, feature = "prototypes"))]
19259    pub fn vkCreateDisplayPlaneSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
19260
19261    /// Available if built with `exported-prototypes`.
19262    #[cfg(any(doc, feature = "exported-prototypes"))]
19263    pub fn vkCreateEvent(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;
19264
19265    /// Available if built with `prototypes`.
19266    #[cfg(any(doc, feature = "prototypes"))]
19267    pub fn vkCreateExternalComputeQueueNV(device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult;
19268
19269    /// Available if built with `exported-prototypes`.
19270    #[cfg(any(doc, feature = "exported-prototypes"))]
19271    pub fn vkCreateFence(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
19272
19273    /// Available if built with `exported-prototypes`.
19274    #[cfg(any(doc, feature = "exported-prototypes"))]
19275    pub fn vkCreateFramebuffer(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;
19276
19277    /// Available if built with `exported-prototypes`.
19278    #[cfg(any(doc, feature = "exported-prototypes"))]
19279    pub fn vkCreateGraphicsPipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19280
19281    /// Available if built with `prototypes`.
19282    #[cfg(any(doc, feature = "prototypes"))]
19283    pub fn vkCreateHeadlessSurfaceEXT(instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
19284
19285    /// Available if built with `exported-prototypes`.
19286    #[cfg(any(doc, feature = "exported-prototypes"))]
19287    pub fn vkCreateImage(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;
19288
19289    /// Available if built with `exported-prototypes`.
19290    #[cfg(any(doc, feature = "exported-prototypes"))]
19291    pub fn vkCreateImageView(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;
19292
19293    /// Available if built with `prototypes`.
19294    #[cfg(any(doc, feature = "prototypes"))]
19295    pub fn vkCreateIndirectCommandsLayoutEXT(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult;
19296
19297    /// Available if built with `prototypes`.
19298    #[cfg(any(doc, feature = "prototypes"))]
19299    pub fn vkCreateIndirectCommandsLayoutNV(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult;
19300
19301    /// Available if built with `prototypes`.
19302    #[cfg(any(doc, feature = "prototypes"))]
19303    pub fn vkCreateIndirectExecutionSetEXT(device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult;
19304
19305    /// Available if built with `exported-prototypes`.
19306    #[cfg(any(doc, feature = "exported-prototypes"))]
19307    pub fn vkCreateInstance(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;
19308
19309    /// Available if built with `prototypes`.
19310    #[cfg(any(doc, feature = "prototypes"))]
19311    pub fn vkCreateMicromapEXT(device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult;
19312
19313    /// Available if built with `prototypes`.
19314    #[cfg(any(doc, feature = "prototypes"))]
19315    pub fn vkCreateOpticalFlowSessionNV(device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult;
19316
19317    /// Available if built with `prototypes`.
19318    #[cfg(any(doc, feature = "prototypes"))]
19319    pub fn vkCreatePipelineBinariesKHR(device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult;
19320
19321    /// Available if built with `exported-prototypes`.
19322    #[cfg(any(doc, feature = "exported-prototypes"))]
19323    pub fn vkCreatePipelineCache(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;
19324
19325    /// Available if built with `exported-prototypes`.
19326    #[cfg(any(doc, feature = "exported-prototypes"))]
19327    pub fn vkCreatePipelineLayout(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;
19328
19329    /// Available if built with `exported-prototypes`.
19330    #[cfg(any(doc, feature = "exported-prototypes"))]
19331    pub fn vkCreatePrivateDataSlot(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
19332
19333    /// Available if built with `prototypes`.
19334    #[cfg(any(doc, feature = "prototypes"))]
19335    pub fn vkCreatePrivateDataSlotEXT(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
19336
19337    /// Available if built with `exported-prototypes`.
19338    #[cfg(any(doc, feature = "exported-prototypes"))]
19339    pub fn vkCreateQueryPool(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;
19340
19341    /// Available if built with `prototypes`.
19342    #[cfg(any(doc, feature = "prototypes"))]
19343    pub fn vkCreateRayTracingPipelinesKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19344
19345    /// Available if built with `prototypes`.
19346    #[cfg(any(doc, feature = "prototypes"))]
19347    pub fn vkCreateRayTracingPipelinesNV(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19348
19349    /// Available if built with `exported-prototypes`.
19350    #[cfg(any(doc, feature = "exported-prototypes"))]
19351    pub fn vkCreateRenderPass(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
19352
19353    /// Available if built with `exported-prototypes`.
19354    #[cfg(any(doc, feature = "exported-prototypes"))]
19355    pub fn vkCreateRenderPass2(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
19356
19357    /// Available if built with `prototypes`.
19358    #[cfg(any(doc, feature = "prototypes"))]
19359    pub fn vkCreateRenderPass2KHR(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
19360
19361    /// Available if built with `exported-prototypes`.
19362    #[cfg(any(doc, feature = "exported-prototypes"))]
19363    pub fn vkCreateSampler(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;
19364
19365    /// Available if built with `exported-prototypes`.
19366    #[cfg(any(doc, feature = "exported-prototypes"))]
19367    pub fn vkCreateSamplerYcbcrConversion(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
19368
19369    /// Available if built with `prototypes`.
19370    #[cfg(any(doc, feature = "prototypes"))]
19371    pub fn vkCreateSamplerYcbcrConversionKHR(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
19372
19373    /// Available if built with `exported-prototypes`.
19374    #[cfg(any(doc, feature = "exported-prototypes"))]
19375    pub fn vkCreateSemaphore(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;
19376
19377    /// Available if built with `exported-prototypes`.
19378    #[cfg(any(doc, feature = "exported-prototypes"))]
19379    pub fn vkCreateShaderModule(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult;
19380
19381    /// Available if built with `prototypes`.
19382    #[cfg(any(doc, feature = "prototypes"))]
19383    pub fn vkCreateShadersEXT(device: VkDevice, createInfoCount: u32, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult;
19384
19385    /// Available if built with `prototypes`.
19386    #[cfg(any(doc, feature = "prototypes"))]
19387    pub fn vkCreateSharedSwapchainsKHR(device: VkDevice, swapchainCount: u32, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult;
19388
19389    /// Available if built with `prototypes`.
19390    #[cfg(any(doc, feature = "prototypes"))]
19391    pub fn vkCreateSwapchainKHR(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;
19392
19393    /// Available if built with `prototypes`.
19394    #[cfg(any(doc, feature = "prototypes"))]
19395    pub fn vkCreateTensorARM(device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult;
19396
19397    /// Available if built with `prototypes`.
19398    #[cfg(any(doc, feature = "prototypes"))]
19399    pub fn vkCreateTensorViewARM(device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult;
19400
19401    /// Available if built with `prototypes`.
19402    #[cfg(any(doc, feature = "prototypes"))]
19403    pub fn vkCreateValidationCacheEXT(device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult;
19404
19405    /// Available if built with `prototypes`.
19406    #[cfg(any(doc, feature = "prototypes"))]
19407    pub fn vkCreateVideoSessionKHR(device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult;
19408
19409    /// Available if built with `prototypes`.
19410    #[cfg(any(doc, feature = "prototypes"))]
19411    pub fn vkCreateVideoSessionParametersKHR(device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult;
19412
19413    /// Available if built with `prototypes`.
19414    #[cfg(any(doc, feature = "prototypes"))]
19415    pub fn vkDebugMarkerSetObjectNameEXT(device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult;
19416
19417    /// Available if built with `prototypes`.
19418    #[cfg(any(doc, feature = "prototypes"))]
19419    pub fn vkDebugMarkerSetObjectTagEXT(device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult;
19420
19421    /// Available if built with `prototypes`.
19422    #[cfg(any(doc, feature = "prototypes"))]
19423    pub fn vkDebugReportMessageEXT(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const c_char, pMessage: *const c_char);
19424
19425    /// Available if built with `prototypes`.
19426    #[cfg(any(doc, feature = "prototypes"))]
19427    pub fn vkDeferredOperationJoinKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
19428
19429    /// Available if built with `prototypes`.
19430    #[cfg(any(doc, feature = "prototypes"))]
19431    pub fn vkDestroyAccelerationStructureKHR(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks);
19432
19433    /// Available if built with `prototypes`.
19434    #[cfg(any(doc, feature = "prototypes"))]
19435    pub fn vkDestroyAccelerationStructureNV(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks);
19436
19437    /// Available if built with `exported-prototypes`.
19438    #[cfg(any(doc, feature = "exported-prototypes"))]
19439    pub fn vkDestroyBuffer(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks);
19440
19441    /// Available if built with `exported-prototypes`.
19442    #[cfg(any(doc, feature = "exported-prototypes"))]
19443    pub fn vkDestroyBufferView(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks);
19444
19445    /// Available if built with `exported-prototypes`.
19446    #[cfg(any(doc, feature = "exported-prototypes"))]
19447    pub fn vkDestroyCommandPool(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks);
19448
19449    /// Available if built with `prototypes`.
19450    #[cfg(any(doc, feature = "prototypes"))]
19451    pub fn vkDestroyCuFunctionNVX(device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks);
19452
19453    /// Available if built with `prototypes`.
19454    #[cfg(any(doc, feature = "prototypes"))]
19455    pub fn vkDestroyCuModuleNVX(device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks);
19456
19457    /// Available if built with `prototypes`.
19458    #[cfg(any(doc, feature = "prototypes"))]
19459    pub fn vkDestroyDataGraphPipelineSessionARM(device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks);
19460
19461    /// Available if built with `prototypes`.
19462    #[cfg(any(doc, feature = "prototypes"))]
19463    pub fn vkDestroyDebugReportCallbackEXT(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks);
19464
19465    /// Available if built with `prototypes`.
19466    #[cfg(any(doc, feature = "prototypes"))]
19467    pub fn vkDestroyDebugUtilsMessengerEXT(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks);
19468
19469    /// Available if built with `prototypes`.
19470    #[cfg(any(doc, feature = "prototypes"))]
19471    pub fn vkDestroyDeferredOperationKHR(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks);
19472
19473    /// Available if built with `exported-prototypes`.
19474    #[cfg(any(doc, feature = "exported-prototypes"))]
19475    pub fn vkDestroyDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks);
19476
19477    /// Available if built with `exported-prototypes`.
19478    #[cfg(any(doc, feature = "exported-prototypes"))]
19479    pub fn vkDestroyDescriptorSetLayout(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks);
19480
19481    /// Available if built with `exported-prototypes`.
19482    #[cfg(any(doc, feature = "exported-prototypes"))]
19483    pub fn vkDestroyDescriptorUpdateTemplate(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
19484
19485    /// Available if built with `prototypes`.
19486    #[cfg(any(doc, feature = "prototypes"))]
19487    pub fn vkDestroyDescriptorUpdateTemplateKHR(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
19488
19489    /// Available if built with `exported-prototypes`.
19490    #[cfg(any(doc, feature = "exported-prototypes"))]
19491    pub fn vkDestroyDevice(device: VkDevice, pAllocator: *const VkAllocationCallbacks);
19492
19493    /// Available if built with `exported-prototypes`.
19494    #[cfg(any(doc, feature = "exported-prototypes"))]
19495    pub fn vkDestroyEvent(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks);
19496
19497    /// Available if built with `prototypes`.
19498    #[cfg(any(doc, feature = "prototypes"))]
19499    pub fn vkDestroyExternalComputeQueueNV(device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks);
19500
19501    /// Available if built with `exported-prototypes`.
19502    #[cfg(any(doc, feature = "exported-prototypes"))]
19503    pub fn vkDestroyFence(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks);
19504
19505    /// Available if built with `exported-prototypes`.
19506    #[cfg(any(doc, feature = "exported-prototypes"))]
19507    pub fn vkDestroyFramebuffer(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks);
19508
19509    /// Available if built with `exported-prototypes`.
19510    #[cfg(any(doc, feature = "exported-prototypes"))]
19511    pub fn vkDestroyImage(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks);
19512
19513    /// Available if built with `exported-prototypes`.
19514    #[cfg(any(doc, feature = "exported-prototypes"))]
19515    pub fn vkDestroyImageView(device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks);
19516
19517    /// Available if built with `prototypes`.
19518    #[cfg(any(doc, feature = "prototypes"))]
19519    pub fn vkDestroyIndirectCommandsLayoutEXT(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks);
19520
19521    /// Available if built with `prototypes`.
19522    #[cfg(any(doc, feature = "prototypes"))]
19523    pub fn vkDestroyIndirectCommandsLayoutNV(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks);
19524
19525    /// Available if built with `prototypes`.
19526    #[cfg(any(doc, feature = "prototypes"))]
19527    pub fn vkDestroyIndirectExecutionSetEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks);
19528
19529    /// Available if built with `exported-prototypes`.
19530    #[cfg(any(doc, feature = "exported-prototypes"))]
19531    pub fn vkDestroyInstance(instance: VkInstance, pAllocator: *const VkAllocationCallbacks);
19532
19533    /// Available if built with `prototypes`.
19534    #[cfg(any(doc, feature = "prototypes"))]
19535    pub fn vkDestroyMicromapEXT(device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks);
19536
19537    /// Available if built with `prototypes`.
19538    #[cfg(any(doc, feature = "prototypes"))]
19539    pub fn vkDestroyOpticalFlowSessionNV(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks);
19540
19541    /// Available if built with `exported-prototypes`.
19542    #[cfg(any(doc, feature = "exported-prototypes"))]
19543    pub fn vkDestroyPipeline(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks);
19544
19545    /// Available if built with `prototypes`.
19546    #[cfg(any(doc, feature = "prototypes"))]
19547    pub fn vkDestroyPipelineBinaryKHR(device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks);
19548
19549    /// Available if built with `exported-prototypes`.
19550    #[cfg(any(doc, feature = "exported-prototypes"))]
19551    pub fn vkDestroyPipelineCache(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks);
19552
19553    /// Available if built with `exported-prototypes`.
19554    #[cfg(any(doc, feature = "exported-prototypes"))]
19555    pub fn vkDestroyPipelineLayout(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks);
19556
19557    /// Available if built with `exported-prototypes`.
19558    #[cfg(any(doc, feature = "exported-prototypes"))]
19559    pub fn vkDestroyPrivateDataSlot(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
19560
19561    /// Available if built with `prototypes`.
19562    #[cfg(any(doc, feature = "prototypes"))]
19563    pub fn vkDestroyPrivateDataSlotEXT(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
19564
19565    /// Available if built with `exported-prototypes`.
19566    #[cfg(any(doc, feature = "exported-prototypes"))]
19567    pub fn vkDestroyQueryPool(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks);
19568
19569    /// Available if built with `exported-prototypes`.
19570    #[cfg(any(doc, feature = "exported-prototypes"))]
19571    pub fn vkDestroyRenderPass(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks);
19572
19573    /// Available if built with `exported-prototypes`.
19574    #[cfg(any(doc, feature = "exported-prototypes"))]
19575    pub fn vkDestroySampler(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks);
19576
19577    /// Available if built with `exported-prototypes`.
19578    #[cfg(any(doc, feature = "exported-prototypes"))]
19579    pub fn vkDestroySamplerYcbcrConversion(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
19580
19581    /// Available if built with `prototypes`.
19582    #[cfg(any(doc, feature = "prototypes"))]
19583    pub fn vkDestroySamplerYcbcrConversionKHR(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
19584
19585    /// Available if built with `exported-prototypes`.
19586    #[cfg(any(doc, feature = "exported-prototypes"))]
19587    pub fn vkDestroySemaphore(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks);
19588
19589    /// Available if built with `prototypes`.
19590    #[cfg(any(doc, feature = "prototypes"))]
19591    pub fn vkDestroyShaderEXT(device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks);
19592
19593    /// Available if built with `exported-prototypes`.
19594    #[cfg(any(doc, feature = "exported-prototypes"))]
19595    pub fn vkDestroyShaderModule(device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks);
19596
19597    /// Available if built with `prototypes`.
19598    #[cfg(any(doc, feature = "prototypes"))]
19599    pub fn vkDestroySurfaceKHR(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks);
19600
19601    /// Available if built with `prototypes`.
19602    #[cfg(any(doc, feature = "prototypes"))]
19603    pub fn vkDestroySwapchainKHR(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks);
19604
19605    /// Available if built with `prototypes`.
19606    #[cfg(any(doc, feature = "prototypes"))]
19607    pub fn vkDestroyTensorARM(device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks);
19608
19609    /// Available if built with `prototypes`.
19610    #[cfg(any(doc, feature = "prototypes"))]
19611    pub fn vkDestroyTensorViewARM(device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks);
19612
19613    /// Available if built with `prototypes`.
19614    #[cfg(any(doc, feature = "prototypes"))]
19615    pub fn vkDestroyValidationCacheEXT(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks);
19616
19617    /// Available if built with `prototypes`.
19618    #[cfg(any(doc, feature = "prototypes"))]
19619    pub fn vkDestroyVideoSessionKHR(device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks);
19620
19621    /// Available if built with `prototypes`.
19622    #[cfg(any(doc, feature = "prototypes"))]
19623    pub fn vkDestroyVideoSessionParametersKHR(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks);
19624
19625    /// Available if built with `exported-prototypes`.
19626    #[cfg(any(doc, feature = "exported-prototypes"))]
19627    pub fn vkDeviceWaitIdle(device: VkDevice) -> VkResult;
19628
19629    /// Available if built with `prototypes`.
19630    #[cfg(any(doc, feature = "prototypes"))]
19631    pub fn vkDisplayPowerControlEXT(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult;
19632
19633    /// Available if built with `exported-prototypes`.
19634    #[cfg(any(doc, feature = "exported-prototypes"))]
19635    pub fn vkEndCommandBuffer(commandBuffer: VkCommandBuffer) -> VkResult;
19636
19637    /// Available if built with `exported-prototypes`.
19638    #[cfg(any(doc, feature = "exported-prototypes"))]
19639    pub fn vkEnumerateDeviceExtensionProperties(physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
19640
19641    /// Available if built with `exported-prototypes`.
19642    #[cfg(any(doc, feature = "exported-prototypes"))]
19643    pub fn vkEnumerateDeviceLayerProperties(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
19644
19645    /// Available if built with `exported-prototypes`.
19646    #[cfg(any(doc, feature = "exported-prototypes"))]
19647    pub fn vkEnumerateInstanceExtensionProperties(pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
19648
19649    /// Available if built with `exported-prototypes`.
19650    #[cfg(any(doc, feature = "exported-prototypes"))]
19651    pub fn vkEnumerateInstanceLayerProperties(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
19652
19653    /// Available if built with `exported-prototypes`.
19654    #[cfg(any(doc, feature = "exported-prototypes"))]
19655    pub fn vkEnumerateInstanceVersion(pApiVersion: *mut u32) -> VkResult;
19656
19657    /// Available if built with `exported-prototypes`.
19658    #[cfg(any(doc, feature = "exported-prototypes"))]
19659    pub fn vkEnumeratePhysicalDeviceGroups(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
19660
19661    /// Available if built with `prototypes`.
19662    #[cfg(any(doc, feature = "prototypes"))]
19663    pub fn vkEnumeratePhysicalDeviceGroupsKHR(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
19664
19665    /// Available if built with `prototypes`.
19666    #[cfg(any(doc, feature = "prototypes"))]
19667    pub fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult;
19668
19669    /// Available if built with `prototypes`.
19670    #[cfg(any(doc, feature = "prototypes"))]
19671    pub fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult;
19672
19673    /// Available if built with `exported-prototypes`.
19674    #[cfg(any(doc, feature = "exported-prototypes"))]
19675    pub fn vkEnumeratePhysicalDevices(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;
19676
19677    /// Available if built with `exported-prototypes`.
19678    #[cfg(any(doc, feature = "exported-prototypes"))]
19679    pub fn vkFlushMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
19680
19681    /// Available if built with `exported-prototypes`.
19682    #[cfg(any(doc, feature = "exported-prototypes"))]
19683    pub fn vkFreeCommandBuffers(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
19684
19685    /// Available if built with `exported-prototypes`.
19686    #[cfg(any(doc, feature = "exported-prototypes"))]
19687    pub fn vkFreeDescriptorSets(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult;
19688
19689    /// Available if built with `exported-prototypes`.
19690    #[cfg(any(doc, feature = "exported-prototypes"))]
19691    pub fn vkFreeMemory(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks);
19692
19693    /// Available if built with `prototypes`.
19694    #[cfg(any(doc, feature = "prototypes"))]
19695    pub fn vkGetAccelerationStructureBuildSizesKHR(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const u32, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
19696
19697    /// Available if built with `prototypes`.
19698    #[cfg(any(doc, feature = "prototypes"))]
19699    pub fn vkGetAccelerationStructureDeviceAddressKHR(device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress;
19700
19701    /// Available if built with `prototypes`.
19702    #[cfg(any(doc, feature = "prototypes"))]
19703    pub fn vkGetAccelerationStructureHandleNV(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: usize, pData: *mut c_void) -> VkResult;
19704
19705    /// Available if built with `prototypes`.
19706    #[cfg(any(doc, feature = "prototypes"))]
19707    pub fn vkGetAccelerationStructureMemoryRequirementsNV(device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR);
19708
19709    /// Available if built with `prototypes`.
19710    #[cfg(any(doc, feature = "prototypes"))]
19711    pub fn vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
19712
19713    /// Available if built with `exported-prototypes`.
19714    #[cfg(any(doc, feature = "exported-prototypes"))]
19715    pub fn vkGetBufferDeviceAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
19716
19717    /// Available if built with `prototypes`.
19718    #[cfg(any(doc, feature = "prototypes"))]
19719    pub fn vkGetBufferDeviceAddressEXT(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
19720
19721    /// Available if built with `prototypes`.
19722    #[cfg(any(doc, feature = "prototypes"))]
19723    pub fn vkGetBufferDeviceAddressKHR(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
19724
19725    /// Available if built with `exported-prototypes`.
19726    #[cfg(any(doc, feature = "exported-prototypes"))]
19727    pub fn vkGetBufferMemoryRequirements(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements);
19728
19729    /// Available if built with `exported-prototypes`.
19730    #[cfg(any(doc, feature = "exported-prototypes"))]
19731    pub fn vkGetBufferMemoryRequirements2(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19732
19733    /// Available if built with `prototypes`.
19734    #[cfg(any(doc, feature = "prototypes"))]
19735    pub fn vkGetBufferMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19736
19737    /// Available if built with `exported-prototypes`.
19738    #[cfg(any(doc, feature = "exported-prototypes"))]
19739    pub fn vkGetBufferOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
19740
19741    /// Available if built with `prototypes`.
19742    #[cfg(any(doc, feature = "prototypes"))]
19743    pub fn vkGetBufferOpaqueCaptureAddressKHR(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
19744
19745    /// Available if built with `prototypes`.
19746    #[cfg(any(doc, feature = "prototypes"))]
19747    pub fn vkGetBufferOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
19748
19749    /// Available if built with `prototypes`.
19750    #[cfg(any(doc, feature = "prototypes"))]
19751    pub fn vkGetCalibratedTimestampsEXT(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
19752
19753    /// Available if built with `prototypes`.
19754    #[cfg(any(doc, feature = "prototypes"))]
19755    pub fn vkGetCalibratedTimestampsKHR(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
19756
19757    /// Available if built with `prototypes`.
19758    #[cfg(any(doc, feature = "prototypes"))]
19759    pub fn vkGetClusterAccelerationStructureBuildSizesNV(device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
19760
19761    /// Available if built with `prototypes`.
19762    #[cfg(any(doc, feature = "prototypes"))]
19763    pub fn vkGetDataGraphPipelineAvailablePropertiesARM(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut u32, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult;
19764
19765    /// Available if built with `prototypes`.
19766    #[cfg(any(doc, feature = "prototypes"))]
19767    pub fn vkGetDataGraphPipelinePropertiesARM(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: u32, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult;
19768
19769    /// Available if built with `prototypes`.
19770    #[cfg(any(doc, feature = "prototypes"))]
19771    pub fn vkGetDataGraphPipelineSessionBindPointRequirementsARM(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut u32, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult;
19772
19773    /// Available if built with `prototypes`.
19774    #[cfg(any(doc, feature = "prototypes"))]
19775    pub fn vkGetDataGraphPipelineSessionMemoryRequirementsARM(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
19776
19777    /// Available if built with `prototypes`.
19778    #[cfg(any(doc, feature = "prototypes"))]
19779    pub fn vkGetDeferredOperationMaxConcurrencyKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> u32;
19780
19781    /// Available if built with `prototypes`.
19782    #[cfg(any(doc, feature = "prototypes"))]
19783    pub fn vkGetDeferredOperationResultKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
19784
19785    /// Available if built with `prototypes`.
19786    #[cfg(any(doc, feature = "prototypes"))]
19787    pub fn vkGetDescriptorEXT(device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: usize, pDescriptor: *mut c_void);
19788
19789    /// Available if built with `prototypes`.
19790    #[cfg(any(doc, feature = "prototypes"))]
19791    pub fn vkGetDescriptorSetHostMappingVALVE(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut c_void);
19792
19793    /// Available if built with `prototypes`.
19794    #[cfg(any(doc, feature = "prototypes"))]
19795    pub fn vkGetDescriptorSetLayoutBindingOffsetEXT(device: VkDevice, layout: VkDescriptorSetLayout, binding: u32, pOffset: *mut VkDeviceSize);
19796
19797    /// Available if built with `prototypes`.
19798    #[cfg(any(doc, feature = "prototypes"))]
19799    pub fn vkGetDescriptorSetLayoutHostMappingInfoVALVE(device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE);
19800
19801    /// Available if built with `prototypes`.
19802    #[cfg(any(doc, feature = "prototypes"))]
19803    pub fn vkGetDescriptorSetLayoutSizeEXT(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize);
19804
19805    /// Available if built with `exported-prototypes`.
19806    #[cfg(any(doc, feature = "exported-prototypes"))]
19807    pub fn vkGetDescriptorSetLayoutSupport(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
19808
19809    /// Available if built with `prototypes`.
19810    #[cfg(any(doc, feature = "prototypes"))]
19811    pub fn vkGetDescriptorSetLayoutSupportKHR(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
19812
19813    /// Available if built with `prototypes`.
19814    #[cfg(any(doc, feature = "prototypes"))]
19815    pub fn vkGetDeviceAccelerationStructureCompatibilityKHR(device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
19816
19817    /// Available if built with `exported-prototypes`.
19818    #[cfg(any(doc, feature = "exported-prototypes"))]
19819    pub fn vkGetDeviceBufferMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19820
19821    /// Available if built with `prototypes`.
19822    #[cfg(any(doc, feature = "prototypes"))]
19823    pub fn vkGetDeviceBufferMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19824
19825    /// Available if built with `prototypes`.
19826    #[cfg(any(doc, feature = "prototypes"))]
19827    pub fn vkGetDeviceCombinedImageSamplerIndexNVX(device: VkDevice, imageViewIndex: u64, samplerIndex: u64) -> u64;
19828
19829    /// Available if built with `prototypes`.
19830    #[cfg(any(doc, feature = "prototypes"))]
19831    pub fn vkGetDeviceFaultInfoEXT(device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult;
19832
19833    /// Available if built with `exported-prototypes`.
19834    #[cfg(any(doc, feature = "exported-prototypes"))]
19835    pub fn vkGetDeviceGroupPeerMemoryFeatures(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
19836
19837    /// Available if built with `prototypes`.
19838    #[cfg(any(doc, feature = "prototypes"))]
19839    pub fn vkGetDeviceGroupPeerMemoryFeaturesKHR(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
19840
19841    /// Available if built with `prototypes`.
19842    #[cfg(any(doc, feature = "prototypes"))]
19843    pub fn vkGetDeviceGroupPresentCapabilitiesKHR(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult;
19844
19845    /// Available if built with `prototypes`.
19846    #[cfg(any(doc, feature = "prototypes"))]
19847    pub fn vkGetDeviceGroupSurfacePresentModesKHR(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;
19848
19849    /// Available if built with `exported-prototypes`.
19850    #[cfg(any(doc, feature = "exported-prototypes"))]
19851    pub fn vkGetDeviceImageMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19852
19853    /// Available if built with `prototypes`.
19854    #[cfg(any(doc, feature = "prototypes"))]
19855    pub fn vkGetDeviceImageMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19856
19857    /// Available if built with `exported-prototypes`.
19858    #[cfg(any(doc, feature = "exported-prototypes"))]
19859    pub fn vkGetDeviceImageSparseMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
19860
19861    /// Available if built with `prototypes`.
19862    #[cfg(any(doc, feature = "prototypes"))]
19863    pub fn vkGetDeviceImageSparseMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
19864
19865    /// Available if built with `exported-prototypes`.
19866    #[cfg(any(doc, feature = "exported-prototypes"))]
19867    pub fn vkGetDeviceImageSubresourceLayout(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
19868
19869    /// Available if built with `prototypes`.
19870    #[cfg(any(doc, feature = "prototypes"))]
19871    pub fn vkGetDeviceImageSubresourceLayoutKHR(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
19872
19873    /// Available if built with `exported-prototypes`.
19874    #[cfg(any(doc, feature = "exported-prototypes"))]
19875    pub fn vkGetDeviceMemoryCommitment(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize);
19876
19877    /// Available if built with `exported-prototypes`.
19878    #[cfg(any(doc, feature = "exported-prototypes"))]
19879    pub fn vkGetDeviceMemoryOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
19880
19881    /// Available if built with `prototypes`.
19882    #[cfg(any(doc, feature = "prototypes"))]
19883    pub fn vkGetDeviceMemoryOpaqueCaptureAddressKHR(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
19884
19885    /// Available if built with `prototypes`.
19886    #[cfg(any(doc, feature = "prototypes"))]
19887    pub fn vkGetDeviceMicromapCompatibilityEXT(device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
19888
19889    /// Available if built with `exported-prototypes`.
19890    #[cfg(any(doc, feature = "exported-prototypes"))]
19891    pub fn vkGetDeviceProcAddr(device: VkDevice, pName: *const c_char) -> PFN_vkVoidFunction;
19892
19893    /// Available if built with `exported-prototypes`.
19894    #[cfg(any(doc, feature = "exported-prototypes"))]
19895    pub fn vkGetDeviceQueue(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue);
19896
19897    /// Available if built with `exported-prototypes`.
19898    #[cfg(any(doc, feature = "exported-prototypes"))]
19899    pub fn vkGetDeviceQueue2(device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue);
19900
19901    /// Available if built with `prototypes`.
19902    #[cfg(any(doc, feature = "prototypes"))]
19903    pub fn vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult;
19904
19905    /// Available if built with `prototypes`.
19906    #[cfg(any(doc, feature = "prototypes"))]
19907    pub fn vkGetDeviceTensorMemoryRequirementsARM(device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2);
19908
19909    /// Available if built with `prototypes`.
19910    #[cfg(any(doc, feature = "prototypes"))]
19911    pub fn vkGetDisplayModeProperties2KHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult;
19912
19913    /// Available if built with `prototypes`.
19914    #[cfg(any(doc, feature = "prototypes"))]
19915    pub fn vkGetDisplayModePropertiesKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;
19916
19917    /// Available if built with `prototypes`.
19918    #[cfg(any(doc, feature = "prototypes"))]
19919    pub fn vkGetDisplayPlaneCapabilities2KHR(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult;
19920
19921    /// Available if built with `prototypes`.
19922    #[cfg(any(doc, feature = "prototypes"))]
19923    pub fn vkGetDisplayPlaneCapabilitiesKHR(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;
19924
19925    /// Available if built with `prototypes`.
19926    #[cfg(any(doc, feature = "prototypes"))]
19927    pub fn vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult;
19928
19929    /// Available if built with `prototypes`.
19930    #[cfg(any(doc, feature = "prototypes"))]
19931    pub fn vkGetDrmDisplayEXT(physicalDevice: VkPhysicalDevice, drmFd: i32, connectorId: u32, display: *mut VkDisplayKHR) -> VkResult;
19932
19933    /// Available if built with `prototypes`.
19934    #[cfg(any(doc, feature = "prototypes"))]
19935    pub fn vkGetDynamicRenderingTilePropertiesQCOM(device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
19936
19937    /// Available if built with `prototypes`.
19938    #[cfg(any(doc, feature = "prototypes"))]
19939    pub fn vkGetEncodedVideoSessionParametersKHR(device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
19940
19941    /// Available if built with `exported-prototypes`.
19942    #[cfg(any(doc, feature = "exported-prototypes"))]
19943    pub fn vkGetEventStatus(device: VkDevice, event: VkEvent) -> VkResult;
19944
19945    /// Available if built with `prototypes`.
19946    #[cfg(any(doc, feature = "prototypes"))]
19947    pub fn vkGetExternalComputeQueueDataNV(externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut c_void);
19948
19949    /// Available if built with `prototypes`.
19950    #[cfg(any(doc, feature = "prototypes"))]
19951    pub fn vkGetFenceFdKHR(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
19952
19953    /// Available if built with `exported-prototypes`.
19954    #[cfg(any(doc, feature = "exported-prototypes"))]
19955    pub fn vkGetFenceStatus(device: VkDevice, fence: VkFence) -> VkResult;
19956
19957    /// Available if built with `prototypes`.
19958    #[cfg(any(doc, feature = "prototypes"))]
19959    pub fn vkGetFramebufferTilePropertiesQCOM(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut u32, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
19960
19961    /// Available if built with `prototypes`.
19962    #[cfg(any(doc, feature = "prototypes"))]
19963    pub fn vkGetGeneratedCommandsMemoryRequirementsEXT(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2);
19964
19965    /// Available if built with `prototypes`.
19966    #[cfg(any(doc, feature = "prototypes"))]
19967    pub fn vkGetGeneratedCommandsMemoryRequirementsNV(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2);
19968
19969    /// Available if built with `prototypes`.
19970    #[cfg(any(doc, feature = "prototypes"))]
19971    pub fn vkGetImageDrmFormatModifierPropertiesEXT(device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult;
19972
19973    /// Available if built with `exported-prototypes`.
19974    #[cfg(any(doc, feature = "exported-prototypes"))]
19975    pub fn vkGetImageMemoryRequirements(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements);
19976
19977    /// Available if built with `exported-prototypes`.
19978    #[cfg(any(doc, feature = "exported-prototypes"))]
19979    pub fn vkGetImageMemoryRequirements2(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19980
19981    /// Available if built with `prototypes`.
19982    #[cfg(any(doc, feature = "prototypes"))]
19983    pub fn vkGetImageMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19984
19985    /// Available if built with `prototypes`.
19986    #[cfg(any(doc, feature = "prototypes"))]
19987    pub fn vkGetImageOpaqueCaptureDataEXT(device: VkDevice, imageCount: u32, pImages: *const VkImage, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
19988
19989    /// Available if built with `prototypes`.
19990    #[cfg(any(doc, feature = "prototypes"))]
19991    pub fn vkGetImageOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
19992
19993    /// Available if built with `exported-prototypes`.
19994    #[cfg(any(doc, feature = "exported-prototypes"))]
19995    pub fn vkGetImageSparseMemoryRequirements(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);
19996
19997    /// Available if built with `exported-prototypes`.
19998    #[cfg(any(doc, feature = "exported-prototypes"))]
19999    pub fn vkGetImageSparseMemoryRequirements2(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
20000
20001    /// Available if built with `prototypes`.
20002    #[cfg(any(doc, feature = "prototypes"))]
20003    pub fn vkGetImageSparseMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
20004
20005    /// Available if built with `exported-prototypes`.
20006    #[cfg(any(doc, feature = "exported-prototypes"))]
20007    pub fn vkGetImageSubresourceLayout(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout);
20008
20009    /// Available if built with `exported-prototypes`.
20010    #[cfg(any(doc, feature = "exported-prototypes"))]
20011    pub fn vkGetImageSubresourceLayout2(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
20012
20013    /// Available if built with `prototypes`.
20014    #[cfg(any(doc, feature = "prototypes"))]
20015    pub fn vkGetImageSubresourceLayout2EXT(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
20016
20017    /// Available if built with `prototypes`.
20018    #[cfg(any(doc, feature = "prototypes"))]
20019    pub fn vkGetImageSubresourceLayout2KHR(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
20020
20021    /// Available if built with `prototypes`.
20022    #[cfg(any(doc, feature = "prototypes"))]
20023    pub fn vkGetImageViewAddressNVX(device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult;
20024
20025    /// Available if built with `prototypes`.
20026    #[cfg(any(doc, feature = "prototypes"))]
20027    pub fn vkGetImageViewHandle64NVX(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u64;
20028
20029    /// Available if built with `prototypes`.
20030    #[cfg(any(doc, feature = "prototypes"))]
20031    pub fn vkGetImageViewHandleNVX(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u32;
20032
20033    /// Available if built with `prototypes`.
20034    #[cfg(any(doc, feature = "prototypes"))]
20035    pub fn vkGetImageViewOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
20036
20037    /// Available if built with `exported-prototypes`.
20038    #[cfg(any(doc, feature = "exported-prototypes"))]
20039    pub fn vkGetInstanceProcAddr(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
20040
20041    /// Available if built with `prototypes`.
20042    #[cfg(any(doc, feature = "prototypes"))]
20043    pub fn vkGetLatencyTimingsNV(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV);
20044
20045    /// Available if built with `prototypes`.
20046    #[cfg(any(doc, feature = "prototypes"))]
20047    pub fn vkGetMemoryFdKHR(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
20048
20049    /// Available if built with `prototypes`.
20050    #[cfg(any(doc, feature = "prototypes"))]
20051    pub fn vkGetMemoryFdPropertiesKHR(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: c_int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult;
20052
20053    /// Available if built with `prototypes`.
20054    #[cfg(any(doc, feature = "prototypes"))]
20055    pub fn vkGetMemoryHostPointerPropertiesEXT(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: *const c_void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult;
20056
20057    /// Available if built with `prototypes`.
20058    #[cfg(any(doc, feature = "prototypes"))]
20059    pub fn vkGetMemoryRemoteAddressNV(device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult;
20060
20061    /// Available if built with `prototypes`.
20062    #[cfg(any(doc, feature = "prototypes"))]
20063    pub fn vkGetMicromapBuildSizesEXT(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT);
20064
20065    /// Available if built with `prototypes`.
20066    #[cfg(any(doc, feature = "prototypes"))]
20067    pub fn vkGetPartitionedAccelerationStructuresBuildSizesNV(device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
20068
20069    /// Available if built with `prototypes`.
20070    #[cfg(any(doc, feature = "prototypes"))]
20071    pub fn vkGetPastPresentationTimingEXT(device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult;
20072
20073    /// Available if built with `prototypes`.
20074    #[cfg(any(doc, feature = "prototypes"))]
20075    pub fn vkGetPastPresentationTimingGOOGLE(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut u32, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult;
20076
20077    /// Available if built with `prototypes`.
20078    #[cfg(any(doc, feature = "prototypes"))]
20079    pub fn vkGetPerformanceParameterINTEL(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult;
20080
20081    /// Available if built with `prototypes`.
20082    #[cfg(any(doc, feature = "prototypes"))]
20083    pub fn vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
20084
20085    /// Available if built with `prototypes`.
20086    #[cfg(any(doc, feature = "prototypes"))]
20087    pub fn vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
20088
20089    /// Available if built with `prototypes`.
20090    #[cfg(any(doc, feature = "prototypes"))]
20091    pub fn vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult;
20092
20093    /// Available if built with `prototypes`.
20094    #[cfg(any(doc, feature = "prototypes"))]
20095    pub fn vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult;
20096
20097    /// Available if built with `prototypes`.
20098    #[cfg(any(doc, feature = "prototypes"))]
20099    pub fn vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult;
20100
20101    /// Available if built with `prototypes`.
20102    #[cfg(any(doc, feature = "prototypes"))]
20103    pub fn vkGetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult;
20104
20105    /// Available if built with `prototypes`.
20106    #[cfg(any(doc, feature = "prototypes"))]
20107    pub fn vkGetPhysicalDeviceDescriptorSizeEXT(physicalDevice: VkPhysicalDevice, descriptorType: VkDescriptorType) -> VkDeviceSize;
20108
20109    /// Available if built with `prototypes`.
20110    #[cfg(any(doc, feature = "prototypes"))]
20111    pub fn vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult;
20112
20113    /// Available if built with `prototypes`.
20114    #[cfg(any(doc, feature = "prototypes"))]
20115    pub fn vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;
20116
20117    /// Available if built with `prototypes`.
20118    #[cfg(any(doc, feature = "prototypes"))]
20119    pub fn vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayProperties2KHR) -> VkResult;
20120
20121    /// Available if built with `prototypes`.
20122    #[cfg(any(doc, feature = "prototypes"))]
20123    pub fn vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;
20124
20125    /// Available if built with `exported-prototypes`.
20126    #[cfg(any(doc, feature = "exported-prototypes"))]
20127    pub fn vkGetPhysicalDeviceExternalBufferProperties(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
20128
20129    /// Available if built with `prototypes`.
20130    #[cfg(any(doc, feature = "prototypes"))]
20131    pub fn vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
20132
20133    /// Available if built with `exported-prototypes`.
20134    #[cfg(any(doc, feature = "exported-prototypes"))]
20135    pub fn vkGetPhysicalDeviceExternalFenceProperties(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
20136
20137    /// Available if built with `prototypes`.
20138    #[cfg(any(doc, feature = "prototypes"))]
20139    pub fn vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
20140
20141    /// Available if built with `prototypes`.
20142    #[cfg(any(doc, feature = "prototypes"))]
20143    pub fn vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV) -> VkResult;
20144
20145    /// Available if built with `exported-prototypes`.
20146    #[cfg(any(doc, feature = "exported-prototypes"))]
20147    pub fn vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
20148
20149    /// Available if built with `prototypes`.
20150    #[cfg(any(doc, feature = "prototypes"))]
20151    pub fn vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
20152
20153    /// Available if built with `prototypes`.
20154    #[cfg(any(doc, feature = "prototypes"))]
20155    pub fn vkGetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM);
20156
20157    /// Available if built with `exported-prototypes`.
20158    #[cfg(any(doc, feature = "exported-prototypes"))]
20159    pub fn vkGetPhysicalDeviceFeatures(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures);
20160
20161    /// Available if built with `exported-prototypes`.
20162    #[cfg(any(doc, feature = "exported-prototypes"))]
20163    pub fn vkGetPhysicalDeviceFeatures2(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
20164
20165    /// Available if built with `prototypes`.
20166    #[cfg(any(doc, feature = "prototypes"))]
20167    pub fn vkGetPhysicalDeviceFeatures2KHR(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
20168
20169    /// Available if built with `exported-prototypes`.
20170    #[cfg(any(doc, feature = "exported-prototypes"))]
20171    pub fn vkGetPhysicalDeviceFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties);
20172
20173    /// Available if built with `exported-prototypes`.
20174    #[cfg(any(doc, feature = "exported-prototypes"))]
20175    pub fn vkGetPhysicalDeviceFormatProperties2(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
20176
20177    /// Available if built with `prototypes`.
20178    #[cfg(any(doc, feature = "prototypes"))]
20179    pub fn vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
20180
20181    /// Available if built with `prototypes`.
20182    #[cfg(any(doc, feature = "prototypes"))]
20183    pub fn vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut u32, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult;
20184
20185    /// Available if built with `exported-prototypes`.
20186    #[cfg(any(doc, feature = "exported-prototypes"))]
20187    pub fn vkGetPhysicalDeviceImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;
20188
20189    /// Available if built with `exported-prototypes`.
20190    #[cfg(any(doc, feature = "exported-prototypes"))]
20191    pub fn vkGetPhysicalDeviceImageFormatProperties2(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
20192
20193    /// Available if built with `prototypes`.
20194    #[cfg(any(doc, feature = "prototypes"))]
20195    pub fn vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
20196
20197    /// Available if built with `exported-prototypes`.
20198    #[cfg(any(doc, feature = "exported-prototypes"))]
20199    pub fn vkGetPhysicalDeviceMemoryProperties(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);
20200
20201    /// Available if built with `exported-prototypes`.
20202    #[cfg(any(doc, feature = "exported-prototypes"))]
20203    pub fn vkGetPhysicalDeviceMemoryProperties2(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
20204
20205    /// Available if built with `prototypes`.
20206    #[cfg(any(doc, feature = "prototypes"))]
20207    pub fn vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
20208
20209    /// Available if built with `prototypes`.
20210    #[cfg(any(doc, feature = "prototypes"))]
20211    pub fn vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: *mut VkMultisamplePropertiesEXT);
20212
20213    /// Available if built with `prototypes`.
20214    #[cfg(any(doc, feature = "prototypes"))]
20215    pub fn vkGetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut u32, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult;
20216
20217    /// Available if built with `prototypes`.
20218    #[cfg(any(doc, feature = "prototypes"))]
20219    pub fn vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut u32, pRects: *mut VkRect2D) -> VkResult;
20220
20221    /// Available if built with `exported-prototypes`.
20222    #[cfg(any(doc, feature = "exported-prototypes"))]
20223    pub fn vkGetPhysicalDeviceProperties(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties);
20224
20225    /// Available if built with `exported-prototypes`.
20226    #[cfg(any(doc, feature = "exported-prototypes"))]
20227    pub fn vkGetPhysicalDeviceProperties2(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
20228
20229    /// Available if built with `prototypes`.
20230    #[cfg(any(doc, feature = "prototypes"))]
20231    pub fn vkGetPhysicalDeviceProperties2KHR(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
20232
20233    /// Available if built with `prototypes`.
20234    #[cfg(any(doc, feature = "prototypes"))]
20235    pub fn vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM);
20236
20237    /// Available if built with `prototypes`.
20238    #[cfg(any(doc, feature = "prototypes"))]
20239    pub fn vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pQueueFamilyDataGraphPropertyCount: *mut u32, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult;
20240
20241    /// Available if built with `prototypes`.
20242    #[cfg(any(doc, feature = "prototypes"))]
20243    pub fn vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut u32);
20244
20245    /// Available if built with `exported-prototypes`.
20246    #[cfg(any(doc, feature = "exported-prototypes"))]
20247    pub fn vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties);
20248
20249    /// Available if built with `exported-prototypes`.
20250    #[cfg(any(doc, feature = "exported-prototypes"))]
20251    pub fn vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
20252
20253    /// Available if built with `prototypes`.
20254    #[cfg(any(doc, feature = "prototypes"))]
20255    pub fn vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
20256
20257    /// Available if built with `exported-prototypes`.
20258    #[cfg(any(doc, feature = "exported-prototypes"))]
20259    pub fn vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties);
20260
20261    /// Available if built with `exported-prototypes`.
20262    #[cfg(any(doc, feature = "exported-prototypes"))]
20263    pub fn vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
20264
20265    /// Available if built with `prototypes`.
20266    #[cfg(any(doc, feature = "prototypes"))]
20267    pub fn vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
20268
20269    /// Available if built with `prototypes`.
20270    #[cfg(any(doc, feature = "prototypes"))]
20271    pub fn vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice: VkPhysicalDevice, pCombinationCount: *mut u32, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult;
20272
20273    /// Available if built with `prototypes`.
20274    #[cfg(any(doc, feature = "prototypes"))]
20275    pub fn vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult;
20276
20277    /// Available if built with `prototypes`.
20278    #[cfg(any(doc, feature = "prototypes"))]
20279    pub fn vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult;
20280
20281    /// Available if built with `prototypes`.
20282    #[cfg(any(doc, feature = "prototypes"))]
20283    pub fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;
20284
20285    /// Available if built with `prototypes`.
20286    #[cfg(any(doc, feature = "prototypes"))]
20287    pub fn vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult;
20288
20289    /// Available if built with `prototypes`.
20290    #[cfg(any(doc, feature = "prototypes"))]
20291    pub fn vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;
20292
20293    /// Available if built with `prototypes`.
20294    #[cfg(any(doc, feature = "prototypes"))]
20295    pub fn vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult;
20296
20297    /// Available if built with `prototypes`.
20298    #[cfg(any(doc, feature = "prototypes"))]
20299    pub fn vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;
20300
20301    /// Available if built with `exported-prototypes`.
20302    #[cfg(any(doc, feature = "exported-prototypes"))]
20303    pub fn vkGetPhysicalDeviceToolProperties(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
20304
20305    /// Available if built with `prototypes`.
20306    #[cfg(any(doc, feature = "prototypes"))]
20307    pub fn vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
20308
20309    /// Available if built with `prototypes`.
20310    #[cfg(any(doc, feature = "prototypes"))]
20311    pub fn vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult;
20312
20313    /// Available if built with `prototypes`.
20314    #[cfg(any(doc, feature = "prototypes"))]
20315    pub fn vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult;
20316
20317    /// Available if built with `prototypes`.
20318    #[cfg(any(doc, feature = "prototypes"))]
20319    pub fn vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut u32, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult;
20320
20321    /// Available if built with `prototypes`.
20322    #[cfg(any(doc, feature = "prototypes"))]
20323    pub fn vkGetPipelineBinaryDataKHR(device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut usize, pPipelineBinaryData: *mut c_void) -> VkResult;
20324
20325    /// Available if built with `exported-prototypes`.
20326    #[cfg(any(doc, feature = "exported-prototypes"))]
20327    pub fn vkGetPipelineCacheData(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
20328
20329    /// Available if built with `prototypes`.
20330    #[cfg(any(doc, feature = "prototypes"))]
20331    pub fn vkGetPipelineExecutableInternalRepresentationsKHR(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut u32, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult;
20332
20333    /// Available if built with `prototypes`.
20334    #[cfg(any(doc, feature = "prototypes"))]
20335    pub fn vkGetPipelineExecutablePropertiesKHR(device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut u32, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult;
20336
20337    /// Available if built with `prototypes`.
20338    #[cfg(any(doc, feature = "prototypes"))]
20339    pub fn vkGetPipelineExecutableStatisticsKHR(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut u32, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult;
20340
20341    /// Available if built with `prototypes`.
20342    #[cfg(any(doc, feature = "prototypes"))]
20343    pub fn vkGetPipelineIndirectDeviceAddressNV(device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress;
20344
20345    /// Available if built with `prototypes`.
20346    #[cfg(any(doc, feature = "prototypes"))]
20347    pub fn vkGetPipelineIndirectMemoryRequirementsNV(device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2);
20348
20349    /// Available if built with `prototypes`.
20350    #[cfg(any(doc, feature = "prototypes"))]
20351    pub fn vkGetPipelineKeyKHR(device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult;
20352
20353    /// Available if built with `prototypes`.
20354    #[cfg(any(doc, feature = "prototypes"))]
20355    pub fn vkGetPipelinePropertiesEXT(device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult;
20356
20357    /// Available if built with `exported-prototypes`.
20358    #[cfg(any(doc, feature = "exported-prototypes"))]
20359    pub fn vkGetPrivateData(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
20360
20361    /// Available if built with `prototypes`.
20362    #[cfg(any(doc, feature = "prototypes"))]
20363    pub fn vkGetPrivateDataEXT(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
20364
20365    /// Available if built with `exported-prototypes`.
20366    #[cfg(any(doc, feature = "exported-prototypes"))]
20367    pub fn vkGetQueryPoolResults(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *mut c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult;
20368
20369    /// Available if built with `prototypes`.
20370    #[cfg(any(doc, feature = "prototypes"))]
20371    pub fn vkGetQueueCheckpointData2NV(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointData2NV);
20372
20373    /// Available if built with `prototypes`.
20374    #[cfg(any(doc, feature = "prototypes"))]
20375    pub fn vkGetQueueCheckpointDataNV(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointDataNV);
20376
20377    /// Available if built with `prototypes`.
20378    #[cfg(any(doc, feature = "prototypes"))]
20379    pub fn vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
20380
20381    /// Available if built with `prototypes`.
20382    #[cfg(any(doc, feature = "prototypes"))]
20383    pub fn vkGetRayTracingShaderGroupHandlesKHR(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
20384
20385    /// Available if built with `prototypes`.
20386    #[cfg(any(doc, feature = "prototypes"))]
20387    pub fn vkGetRayTracingShaderGroupHandlesNV(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
20388
20389    /// Available if built with `prototypes`.
20390    #[cfg(any(doc, feature = "prototypes"))]
20391    pub fn vkGetRayTracingShaderGroupStackSizeKHR(device: VkDevice, pipeline: VkPipeline, group: u32, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize;
20392
20393    /// Available if built with `prototypes`.
20394    #[cfg(any(doc, feature = "prototypes"))]
20395    pub fn vkGetRefreshCycleDurationGOOGLE(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult;
20396
20397    /// Available if built with `exported-prototypes`.
20398    #[cfg(any(doc, feature = "exported-prototypes"))]
20399    pub fn vkGetRenderAreaGranularity(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D);
20400
20401    /// Available if built with `exported-prototypes`.
20402    #[cfg(any(doc, feature = "exported-prototypes"))]
20403    pub fn vkGetRenderingAreaGranularity(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
20404
20405    /// Available if built with `prototypes`.
20406    #[cfg(any(doc, feature = "prototypes"))]
20407    pub fn vkGetRenderingAreaGranularityKHR(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
20408
20409    /// Available if built with `prototypes`.
20410    #[cfg(any(doc, feature = "prototypes"))]
20411    pub fn vkGetSamplerOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
20412
20413    /// Available if built with `exported-prototypes`.
20414    #[cfg(any(doc, feature = "exported-prototypes"))]
20415    pub fn vkGetSemaphoreCounterValue(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
20416
20417    /// Available if built with `prototypes`.
20418    #[cfg(any(doc, feature = "prototypes"))]
20419    pub fn vkGetSemaphoreCounterValueKHR(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
20420
20421    /// Available if built with `prototypes`.
20422    #[cfg(any(doc, feature = "prototypes"))]
20423    pub fn vkGetSemaphoreFdKHR(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
20424
20425    /// Available if built with `prototypes`.
20426    #[cfg(any(doc, feature = "prototypes"))]
20427    pub fn vkGetShaderBinaryDataEXT(device: VkDevice, shader: VkShaderEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
20428
20429    /// Available if built with `prototypes`.
20430    #[cfg(any(doc, feature = "prototypes"))]
20431    pub fn vkGetShaderInfoAMD(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut usize, pInfo: *mut c_void) -> VkResult;
20432
20433    /// Available if built with `prototypes`.
20434    #[cfg(any(doc, feature = "prototypes"))]
20435    pub fn vkGetShaderModuleCreateInfoIdentifierEXT(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT);
20436
20437    /// Available if built with `prototypes`.
20438    #[cfg(any(doc, feature = "prototypes"))]
20439    pub fn vkGetShaderModuleIdentifierEXT(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT);
20440
20441    /// Available if built with `prototypes`.
20442    #[cfg(any(doc, feature = "prototypes"))]
20443    pub fn vkGetSwapchainCounterEXT(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: *mut u64) -> VkResult;
20444
20445    /// Available if built with `prototypes`.
20446    #[cfg(any(doc, feature = "prototypes"))]
20447    pub fn vkGetSwapchainImagesKHR(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult;
20448
20449    /// Available if built with `prototypes`.
20450    #[cfg(any(doc, feature = "prototypes"))]
20451    pub fn vkGetSwapchainStatusKHR(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;
20452
20453    /// Available if built with `prototypes`.
20454    #[cfg(any(doc, feature = "prototypes"))]
20455    pub fn vkGetSwapchainTimeDomainPropertiesEXT(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut u64) -> VkResult;
20456
20457    /// Available if built with `prototypes`.
20458    #[cfg(any(doc, feature = "prototypes"))]
20459    pub fn vkGetSwapchainTimingPropertiesEXT(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut u64) -> VkResult;
20460
20461    /// Available if built with `prototypes`.
20462    #[cfg(any(doc, feature = "prototypes"))]
20463    pub fn vkGetTensorMemoryRequirementsARM(device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
20464
20465    /// Available if built with `prototypes`.
20466    #[cfg(any(doc, feature = "prototypes"))]
20467    pub fn vkGetTensorOpaqueCaptureDataARM(device: VkDevice, tensorCount: u32, pTensors: *const VkTensorARM, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
20468
20469    /// Available if built with `prototypes`.
20470    #[cfg(any(doc, feature = "prototypes"))]
20471    pub fn vkGetTensorOpaqueCaptureDescriptorDataARM(device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
20472
20473    /// Available if built with `prototypes`.
20474    #[cfg(any(doc, feature = "prototypes"))]
20475    pub fn vkGetTensorViewOpaqueCaptureDescriptorDataARM(device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
20476
20477    /// Available if built with `prototypes`.
20478    #[cfg(any(doc, feature = "prototypes"))]
20479    pub fn vkGetValidationCacheDataEXT(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
20480
20481    /// Available if built with `prototypes`.
20482    #[cfg(any(doc, feature = "prototypes"))]
20483    pub fn vkGetVideoSessionMemoryRequirementsKHR(device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut u32, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult;
20484
20485    /// Available if built with `prototypes`.
20486    #[cfg(any(doc, feature = "prototypes"))]
20487    pub fn vkImportFenceFdKHR(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult;
20488
20489    /// Available if built with `prototypes`.
20490    #[cfg(any(doc, feature = "prototypes"))]
20491    pub fn vkImportSemaphoreFdKHR(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult;
20492
20493    /// Available if built with `prototypes`.
20494    #[cfg(any(doc, feature = "prototypes"))]
20495    pub fn vkInitializePerformanceApiINTEL(device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult;
20496
20497    /// Available if built with `exported-prototypes`.
20498    #[cfg(any(doc, feature = "exported-prototypes"))]
20499    pub fn vkInvalidateMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
20500
20501    /// Available if built with `prototypes`.
20502    #[cfg(any(doc, feature = "prototypes"))]
20503    pub fn vkLatencySleepNV(device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult;
20504
20505    /// Available if built with `exported-prototypes`.
20506    #[cfg(any(doc, feature = "exported-prototypes"))]
20507    pub fn vkMapMemory(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut c_void) -> VkResult;
20508
20509    /// Available if built with `exported-prototypes`.
20510    #[cfg(any(doc, feature = "exported-prototypes"))]
20511    pub fn vkMapMemory2(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
20512
20513    /// Available if built with `prototypes`.
20514    #[cfg(any(doc, feature = "prototypes"))]
20515    pub fn vkMapMemory2KHR(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
20516
20517    /// Available if built with `exported-prototypes`.
20518    #[cfg(any(doc, feature = "exported-prototypes"))]
20519    pub fn vkMergePipelineCaches(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult;
20520
20521    /// Available if built with `prototypes`.
20522    #[cfg(any(doc, feature = "prototypes"))]
20523    pub fn vkMergeValidationCachesEXT(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: u32, pSrcCaches: *const VkValidationCacheEXT) -> VkResult;
20524
20525    /// Available if built with `prototypes`.
20526    #[cfg(any(doc, feature = "prototypes"))]
20527    pub fn vkQueueBeginDebugUtilsLabelEXT(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
20528
20529    /// Available if built with `exported-prototypes`.
20530    #[cfg(any(doc, feature = "exported-prototypes"))]
20531    pub fn vkQueueBindSparse(queue: VkQueue, bindInfoCount: u32, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult;
20532
20533    /// Available if built with `prototypes`.
20534    #[cfg(any(doc, feature = "prototypes"))]
20535    pub fn vkQueueEndDebugUtilsLabelEXT(queue: VkQueue);
20536
20537    /// Available if built with `prototypes`.
20538    #[cfg(any(doc, feature = "prototypes"))]
20539    pub fn vkQueueInsertDebugUtilsLabelEXT(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
20540
20541    /// Available if built with `prototypes`.
20542    #[cfg(any(doc, feature = "prototypes"))]
20543    pub fn vkQueueNotifyOutOfBandNV(queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV);
20544
20545    /// Available if built with `prototypes`.
20546    #[cfg(any(doc, feature = "prototypes"))]
20547    pub fn vkQueuePresentKHR(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;
20548
20549    /// Available if built with `prototypes`.
20550    #[cfg(any(doc, feature = "prototypes"))]
20551    pub fn vkQueueSetPerformanceConfigurationINTEL(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
20552
20553    /// Available if built with `exported-prototypes`.
20554    #[cfg(any(doc, feature = "exported-prototypes"))]
20555    pub fn vkQueueSubmit(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;
20556
20557    /// Available if built with `exported-prototypes`.
20558    #[cfg(any(doc, feature = "exported-prototypes"))]
20559    pub fn vkQueueSubmit2(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
20560
20561    /// Available if built with `prototypes`.
20562    #[cfg(any(doc, feature = "prototypes"))]
20563    pub fn vkQueueSubmit2KHR(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
20564
20565    /// Available if built with `exported-prototypes`.
20566    #[cfg(any(doc, feature = "exported-prototypes"))]
20567    pub fn vkQueueWaitIdle(queue: VkQueue) -> VkResult;
20568
20569    /// Available if built with `prototypes`.
20570    #[cfg(any(doc, feature = "prototypes"))]
20571    pub fn vkRegisterCustomBorderColorEXT(device: VkDevice, pBorderColor: *const VkSamplerCustomBorderColorCreateInfoEXT, requestIndex: VkBool32, pIndex: *mut u32) -> VkResult;
20572
20573    /// Available if built with `prototypes`.
20574    #[cfg(any(doc, feature = "prototypes"))]
20575    pub fn vkRegisterDeviceEventEXT(device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
20576
20577    /// Available if built with `prototypes`.
20578    #[cfg(any(doc, feature = "prototypes"))]
20579    pub fn vkRegisterDisplayEventEXT(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
20580
20581    /// Available if built with `prototypes`.
20582    #[cfg(any(doc, feature = "prototypes"))]
20583    pub fn vkReleaseCapturedPipelineDataKHR(device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult;
20584
20585    /// Available if built with `prototypes`.
20586    #[cfg(any(doc, feature = "prototypes"))]
20587    pub fn vkReleaseDisplayEXT(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;
20588
20589    /// Available if built with `prototypes`.
20590    #[cfg(any(doc, feature = "prototypes"))]
20591    pub fn vkReleasePerformanceConfigurationINTEL(device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
20592
20593    /// Available if built with `prototypes`.
20594    #[cfg(any(doc, feature = "prototypes"))]
20595    pub fn vkReleaseProfilingLockKHR(device: VkDevice);
20596
20597    /// Available if built with `prototypes`.
20598    #[cfg(any(doc, feature = "prototypes"))]
20599    pub fn vkReleaseSwapchainImagesEXT(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
20600
20601    /// Available if built with `prototypes`.
20602    #[cfg(any(doc, feature = "prototypes"))]
20603    pub fn vkReleaseSwapchainImagesKHR(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
20604
20605    /// Available if built with `exported-prototypes`.
20606    #[cfg(any(doc, feature = "exported-prototypes"))]
20607    pub fn vkResetCommandBuffer(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;
20608
20609    /// Available if built with `exported-prototypes`.
20610    #[cfg(any(doc, feature = "exported-prototypes"))]
20611    pub fn vkResetCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;
20612
20613    /// Available if built with `exported-prototypes`.
20614    #[cfg(any(doc, feature = "exported-prototypes"))]
20615    pub fn vkResetDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;
20616
20617    /// Available if built with `exported-prototypes`.
20618    #[cfg(any(doc, feature = "exported-prototypes"))]
20619    pub fn vkResetEvent(device: VkDevice, event: VkEvent) -> VkResult;
20620
20621    /// Available if built with `exported-prototypes`.
20622    #[cfg(any(doc, feature = "exported-prototypes"))]
20623    pub fn vkResetFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult;
20624
20625    /// Available if built with `exported-prototypes`.
20626    #[cfg(any(doc, feature = "exported-prototypes"))]
20627    pub fn vkResetQueryPool(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
20628
20629    /// Available if built with `prototypes`.
20630    #[cfg(any(doc, feature = "prototypes"))]
20631    pub fn vkResetQueryPoolEXT(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
20632
20633    /// Available if built with `prototypes`.
20634    #[cfg(any(doc, feature = "prototypes"))]
20635    pub fn vkSetDebugUtilsObjectNameEXT(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult;
20636
20637    /// Available if built with `prototypes`.
20638    #[cfg(any(doc, feature = "prototypes"))]
20639    pub fn vkSetDebugUtilsObjectTagEXT(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult;
20640
20641    /// Available if built with `prototypes`.
20642    #[cfg(any(doc, feature = "prototypes"))]
20643    pub fn vkSetDeviceMemoryPriorityEXT(device: VkDevice, memory: VkDeviceMemory, priority: f32);
20644
20645    /// Available if built with `exported-prototypes`.
20646    #[cfg(any(doc, feature = "exported-prototypes"))]
20647    pub fn vkSetEvent(device: VkDevice, event: VkEvent) -> VkResult;
20648
20649    /// Available if built with `prototypes`.
20650    #[cfg(any(doc, feature = "prototypes"))]
20651    pub fn vkSetHdrMetadataEXT(device: VkDevice, swapchainCount: u32, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT);
20652
20653    /// Available if built with `prototypes`.
20654    #[cfg(any(doc, feature = "prototypes"))]
20655    pub fn vkSetLatencyMarkerNV(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV);
20656
20657    /// Available if built with `prototypes`.
20658    #[cfg(any(doc, feature = "prototypes"))]
20659    pub fn vkSetLatencySleepModeNV(device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult;
20660
20661    /// Available if built with `prototypes`.
20662    #[cfg(any(doc, feature = "prototypes"))]
20663    pub fn vkSetLocalDimmingAMD(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32);
20664
20665    /// Available if built with `exported-prototypes`.
20666    #[cfg(any(doc, feature = "exported-prototypes"))]
20667    pub fn vkSetPrivateData(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
20668
20669    /// Available if built with `prototypes`.
20670    #[cfg(any(doc, feature = "prototypes"))]
20671    pub fn vkSetPrivateDataEXT(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
20672
20673    /// Available if built with `prototypes`.
20674    #[cfg(any(doc, feature = "prototypes"))]
20675    pub fn vkSetSwapchainPresentTimingQueueSizeEXT(device: VkDevice, swapchain: VkSwapchainKHR, size: u32) -> VkResult;
20676
20677    /// Available if built with `exported-prototypes`.
20678    #[cfg(any(doc, feature = "exported-prototypes"))]
20679    pub fn vkSignalSemaphore(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
20680
20681    /// Available if built with `prototypes`.
20682    #[cfg(any(doc, feature = "prototypes"))]
20683    pub fn vkSignalSemaphoreKHR(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
20684
20685    /// Available if built with `prototypes`.
20686    #[cfg(any(doc, feature = "prototypes"))]
20687    pub fn vkSubmitDebugUtilsMessageEXT(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT);
20688
20689    /// Available if built with `exported-prototypes`.
20690    #[cfg(any(doc, feature = "exported-prototypes"))]
20691    pub fn vkTransitionImageLayout(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
20692
20693    /// Available if built with `prototypes`.
20694    #[cfg(any(doc, feature = "prototypes"))]
20695    pub fn vkTransitionImageLayoutEXT(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
20696
20697    /// Available if built with `exported-prototypes`.
20698    #[cfg(any(doc, feature = "exported-prototypes"))]
20699    pub fn vkTrimCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
20700
20701    /// Available if built with `prototypes`.
20702    #[cfg(any(doc, feature = "prototypes"))]
20703    pub fn vkTrimCommandPoolKHR(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
20704
20705    /// Available if built with `prototypes`.
20706    #[cfg(any(doc, feature = "prototypes"))]
20707    pub fn vkUninitializePerformanceApiINTEL(device: VkDevice);
20708
20709    /// Available if built with `exported-prototypes`.
20710    #[cfg(any(doc, feature = "exported-prototypes"))]
20711    pub fn vkUnmapMemory(device: VkDevice, memory: VkDeviceMemory);
20712
20713    /// Available if built with `exported-prototypes`.
20714    #[cfg(any(doc, feature = "exported-prototypes"))]
20715    pub fn vkUnmapMemory2(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
20716
20717    /// Available if built with `prototypes`.
20718    #[cfg(any(doc, feature = "prototypes"))]
20719    pub fn vkUnmapMemory2KHR(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
20720
20721    /// Available if built with `prototypes`.
20722    #[cfg(any(doc, feature = "prototypes"))]
20723    pub fn vkUnregisterCustomBorderColorEXT(device: VkDevice, index: u32);
20724
20725    /// Available if built with `exported-prototypes`.
20726    #[cfg(any(doc, feature = "exported-prototypes"))]
20727    pub fn vkUpdateDescriptorSetWithTemplate(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
20728
20729    /// Available if built with `prototypes`.
20730    #[cfg(any(doc, feature = "prototypes"))]
20731    pub fn vkUpdateDescriptorSetWithTemplateKHR(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
20732
20733    /// Available if built with `exported-prototypes`.
20734    #[cfg(any(doc, feature = "exported-prototypes"))]
20735    pub fn vkUpdateDescriptorSets(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet);
20736
20737    /// Available if built with `prototypes`.
20738    #[cfg(any(doc, feature = "prototypes"))]
20739    pub fn vkUpdateIndirectExecutionSetPipelineEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT);
20740
20741    /// Available if built with `prototypes`.
20742    #[cfg(any(doc, feature = "prototypes"))]
20743    pub fn vkUpdateIndirectExecutionSetShaderEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT);
20744
20745    /// Available if built with `prototypes`.
20746    #[cfg(any(doc, feature = "prototypes"))]
20747    pub fn vkUpdateVideoSessionParametersKHR(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult;
20748
20749    /// Available if built with `exported-prototypes`.
20750    #[cfg(any(doc, feature = "exported-prototypes"))]
20751    pub fn vkWaitForFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult;
20752
20753    /// Available if built with `prototypes`.
20754    #[cfg(any(doc, feature = "prototypes"))]
20755    pub fn vkWaitForPresent2KHR(device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult;
20756
20757    /// Available if built with `prototypes`.
20758    #[cfg(any(doc, feature = "prototypes"))]
20759    pub fn vkWaitForPresentKHR(device: VkDevice, swapchain: VkSwapchainKHR, presentId: u64, timeout: u64) -> VkResult;
20760
20761    /// Available if built with `exported-prototypes`.
20762    #[cfg(any(doc, feature = "exported-prototypes"))]
20763    pub fn vkWaitSemaphores(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
20764
20765    /// Available if built with `prototypes`.
20766    #[cfg(any(doc, feature = "prototypes"))]
20767    pub fn vkWaitSemaphoresKHR(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
20768
20769    /// Available if built with `prototypes`.
20770    #[cfg(any(doc, feature = "prototypes"))]
20771    pub fn vkWriteAccelerationStructuresPropertiesKHR(device: VkDevice, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
20772
20773    /// Available if built with `prototypes`.
20774    #[cfg(any(doc, feature = "prototypes"))]
20775    pub fn vkWriteMicromapsPropertiesEXT(device: VkDevice, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
20776
20777    /// Available if built with `prototypes`.
20778    #[cfg(any(doc, feature = "prototypes"))]
20779    pub fn vkWriteResourceDescriptorsEXT(device: VkDevice, resourceCount: u32, pResources: *const VkResourceDescriptorInfoEXT, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
20780
20781    /// Available if built with `prototypes`.
20782    #[cfg(any(doc, feature = "prototypes"))]
20783    pub fn vkWriteSamplerDescriptorsEXT(device: VkDevice, samplerCount: u32, pSamplers: *const VkSamplerCreateInfo, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
20784}
20785
20786pub type NonNullPFN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, display: VkDisplayKHR) -> VkResult;
20787pub type NonNullPFN_vkAcquireNextImage2KHR = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut u32) -> VkResult;
20788pub type NonNullPFN_vkAcquireNextImageKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult;
20789pub type NonNullPFN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult;
20790pub type NonNullPFN_vkAcquireProfilingLockKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult;
20791pub type NonNullPFN_vkAllocateCommandBuffers = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;
20792pub type NonNullPFN_vkAllocateDescriptorSets = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;
20793pub type NonNullPFN_vkAllocateMemory = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;
20794pub type NonNullPFN_vkAllocationFunction = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut c_void;
20795pub type NonNullPFN_vkAntiLagUpdateAMD = unsafe extern "system" fn(device: VkDevice, pData: *const VkAntiLagDataAMD);
20796pub type NonNullPFN_vkBeginCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;
20797pub type NonNullPFN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult;
20798pub type NonNullPFN_vkBindBufferMemory = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
20799pub type NonNullPFN_vkBindBufferMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
20800pub type NonNullPFN_vkBindBufferMemory2KHR = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
20801pub type NonNullPFN_vkBindDataGraphPipelineSessionMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult;
20802pub type NonNullPFN_vkBindImageMemory = unsafe extern "system" fn(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
20803pub type NonNullPFN_vkBindImageMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
20804pub type NonNullPFN_vkBindImageMemory2KHR = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
20805pub type NonNullPFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult;
20806pub type NonNullPFN_vkBindTensorMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult;
20807pub type NonNullPFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: u32, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult;
20808pub type NonNullPFN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult;
20809pub type NonNullPFN_vkBuildMicromapsEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult;
20810pub type NonNullPFN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT);
20811pub type NonNullPFN_vkCmdBeginCustomResolveEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT);
20812pub type NonNullPFN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
20813pub type NonNullPFN_vkCmdBeginPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM);
20814pub type NonNullPFN_vkCmdBeginQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags);
20815pub type NonNullPFN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags, index: u32);
20816pub type NonNullPFN_vkCmdBeginRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents);
20817pub type NonNullPFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
20818pub type NonNullPFN_vkCmdBeginRenderPass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
20819pub type NonNullPFN_vkCmdBeginRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
20820pub type NonNullPFN_vkCmdBeginRenderingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
20821pub type NonNullPFN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
20822pub type NonNullPFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR);
20823pub type NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
20824pub type NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32);
20825pub type NonNullPFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, bufferCount: u32, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT);
20826pub type NonNullPFN_vkCmdBindDescriptorSets = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: *const u32);
20827pub type NonNullPFN_vkCmdBindDescriptorSets2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
20828pub type NonNullPFN_vkCmdBindDescriptorSets2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
20829pub type NonNullPFN_vkCmdBindIndexBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType);
20830pub type NonNullPFN_vkCmdBindIndexBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
20831pub type NonNullPFN_vkCmdBindIndexBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
20832pub type NonNullPFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
20833pub type NonNullPFN_vkCmdBindPipeline = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
20834pub type NonNullPFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: u32);
20835pub type NonNullPFN_vkCmdBindResourceHeapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
20836pub type NonNullPFN_vkCmdBindSamplerHeapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
20837pub type NonNullPFN_vkCmdBindShadersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stageCount: u32, pStages: *const VkShaderStageFlagBits, pShaders: *const VkShaderEXT);
20838pub type NonNullPFN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
20839pub type NonNullPFN_vkCmdBindTileMemoryQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM);
20840pub type NonNullPFN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize);
20841pub type NonNullPFN_vkCmdBindVertexBuffers = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize);
20842pub type NonNullPFN_vkCmdBindVertexBuffers2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
20843pub type NonNullPFN_vkCmdBindVertexBuffers2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
20844pub type NonNullPFN_vkCmdBlitImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filter: VkFilter);
20845pub type NonNullPFN_vkCmdBlitImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
20846pub type NonNullPFN_vkCmdBlitImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
20847pub type NonNullPFN_vkCmdBuildAccelerationStructureNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize);
20848pub type NonNullPFN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const u32, ppMaxPrimitiveCounts: *const *const u32);
20849pub type NonNullPFN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR);
20850pub type NonNullPFN_vkCmdBuildClusterAccelerationStructureIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV);
20851pub type NonNullPFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT);
20852pub type NonNullPFN_vkCmdBuildPartitionedAccelerationStructuresNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV);
20853pub type NonNullPFN_vkCmdClearAttachments = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect);
20854pub type NonNullPFN_vkCmdClearColorImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
20855pub type NonNullPFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
20856pub type NonNullPFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR);
20857pub type NonNullPFN_vkCmdConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV);
20858pub type NonNullPFN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR);
20859pub type NonNullPFN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR);
20860pub type NonNullPFN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR);
20861pub type NonNullPFN_vkCmdCopyBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy);
20862pub type NonNullPFN_vkCmdCopyBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
20863pub type NonNullPFN_vkCmdCopyBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
20864pub type NonNullPFN_vkCmdCopyBufferToImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy);
20865pub type NonNullPFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
20866pub type NonNullPFN_vkCmdCopyBufferToImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
20867pub type NonNullPFN_vkCmdCopyImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy);
20868pub type NonNullPFN_vkCmdCopyImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
20869pub type NonNullPFN_vkCmdCopyImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
20870pub type NonNullPFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy);
20871pub type NonNullPFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
20872pub type NonNullPFN_vkCmdCopyImageToBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
20873pub type NonNullPFN_vkCmdCopyMemoryIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR);
20874pub type NonNullPFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32);
20875pub type NonNullPFN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR);
20876pub type NonNullPFN_vkCmdCopyMemoryToImageIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR);
20877pub type NonNullPFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers);
20878pub type NonNullPFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT);
20879pub type NonNullPFN_vkCmdCopyMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT);
20880pub type NonNullPFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT);
20881pub type NonNullPFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags);
20882pub type NonNullPFN_vkCmdCopyTensorARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM);
20883pub type NonNullPFN_vkCmdCuLaunchKernelNVX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX);
20884pub type NonNullPFN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
20885pub type NonNullPFN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20886pub type NonNullPFN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
20887pub type NonNullPFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR);
20888pub type NonNullPFN_vkCmdDecompressMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT);
20889pub type NonNullPFN_vkCmdDecompressMemoryIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: u32, stride: u32);
20890pub type NonNullPFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: u32);
20891pub type NonNullPFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressRegionCount: u32, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV);
20892pub type NonNullPFN_vkCmdDispatch = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20893pub type NonNullPFN_vkCmdDispatchBase = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20894pub type NonNullPFN_vkCmdDispatchBaseKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20895pub type NonNullPFN_vkCmdDispatchDataGraphARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM);
20896pub type NonNullPFN_vkCmdDispatchIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
20897pub type NonNullPFN_vkCmdDispatchTileQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM);
20898pub type NonNullPFN_vkCmdDraw = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
20899pub type NonNullPFN_vkCmdDrawClusterHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20900pub type NonNullPFN_vkCmdDrawClusterIndirectHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
20901pub type NonNullPFN_vkCmdDrawIndexed = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
20902pub type NonNullPFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20903pub type NonNullPFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20904pub type NonNullPFN_vkCmdDrawIndexedIndirectCountAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20905pub type NonNullPFN_vkCmdDrawIndexedIndirectCountKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20906pub type NonNullPFN_vkCmdDrawIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20907pub type NonNullPFN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: u32, vertexStride: u32);
20908pub type NonNullPFN_vkCmdDrawIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20909pub type NonNullPFN_vkCmdDrawIndirectCountAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20910pub type NonNullPFN_vkCmdDrawIndirectCountKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20911pub type NonNullPFN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20912pub type NonNullPFN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20913pub type NonNullPFN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20914pub type NonNullPFN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20915pub type NonNullPFN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20916pub type NonNullPFN_vkCmdDrawMeshTasksNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, taskCount: u32, firstTask: u32);
20917pub type NonNullPFN_vkCmdDrawMultiEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: u32, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);
20918pub type NonNullPFN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: u32, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: *const i32);
20919pub type NonNullPFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR);
20920pub type NonNullPFN_vkCmdEndConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20921pub type NonNullPFN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20922pub type NonNullPFN_vkCmdEndPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM);
20923pub type NonNullPFN_vkCmdEndQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32);
20924pub type NonNullPFN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, index: u32);
20925pub type NonNullPFN_vkCmdEndRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20926pub type NonNullPFN_vkCmdEndRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
20927pub type NonNullPFN_vkCmdEndRenderPass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
20928pub type NonNullPFN_vkCmdEndRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20929pub type NonNullPFN_vkCmdEndRendering2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
20930pub type NonNullPFN_vkCmdEndRendering2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
20931pub type NonNullPFN_vkCmdEndRenderingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20932pub type NonNullPFN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
20933pub type NonNullPFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR);
20934pub type NonNullPFN_vkCmdExecuteCommands = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
20935pub type NonNullPFN_vkCmdExecuteGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT);
20936pub type NonNullPFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
20937pub type NonNullPFN_vkCmdFillBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: u32);
20938pub type NonNullPFN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
20939pub type NonNullPFN_vkCmdNextSubpass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, contents: VkSubpassContents);
20940pub type NonNullPFN_vkCmdNextSubpass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
20941pub type NonNullPFN_vkCmdNextSubpass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
20942pub type NonNullPFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV);
20943pub type NonNullPFN_vkCmdPipelineBarrier = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, dependencyFlags: VkDependencyFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
20944pub type NonNullPFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
20945pub type NonNullPFN_vkCmdPipelineBarrier2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
20946pub type NonNullPFN_vkCmdPreprocessGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer);
20947pub type NonNullPFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
20948pub type NonNullPFN_vkCmdPushConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const c_void);
20949pub type NonNullPFN_vkCmdPushConstants2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
20950pub type NonNullPFN_vkCmdPushConstants2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
20951pub type NonNullPFN_vkCmdPushDataEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDataInfo: *const VkPushDataInfoEXT);
20952pub type NonNullPFN_vkCmdPushDescriptorSet = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
20953pub type NonNullPFN_vkCmdPushDescriptorSet2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
20954pub type NonNullPFN_vkCmdPushDescriptorSet2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
20955pub type NonNullPFN_vkCmdPushDescriptorSetKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
20956pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
20957pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
20958pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
20959pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplateKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
20960pub type NonNullPFN_vkCmdResetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
20961pub type NonNullPFN_vkCmdResetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
20962pub type NonNullPFN_vkCmdResetEvent2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
20963pub type NonNullPFN_vkCmdResetQueryPool = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
20964pub type NonNullPFN_vkCmdResolveImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve);
20965pub type NonNullPFN_vkCmdResolveImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
20966pub type NonNullPFN_vkCmdResolveImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
20967pub type NonNullPFN_vkCmdSetAlphaToCoverageEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32);
20968pub type NonNullPFN_vkCmdSetAlphaToOneEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32);
20969pub type NonNullPFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags);
20970pub type NonNullPFN_vkCmdSetBlendConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, blendConstants: *const f32);
20971pub type NonNullPFN_vkCmdSetCheckpointNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCheckpointMarker: *const c_void);
20972pub type NonNullPFN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV);
20973pub type NonNullPFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT);
20974pub type NonNullPFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEnables: *const VkBool32);
20975pub type NonNullPFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEquations: *const VkColorBlendEquationEXT);
20976pub type NonNullPFN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pColorWriteEnables: *const VkBool32);
20977pub type NonNullPFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorWriteMasks: *const VkColorComponentFlags);
20978pub type NonNullPFN_vkCmdSetComputeOccupancyPriorityNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV);
20979pub type NonNullPFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT);
20980pub type NonNullPFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV);
20981pub type NonNullPFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32);
20982pub type NonNullPFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableCount: u32, pCoverageModulationTable: *const f32);
20983pub type NonNullPFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV);
20984pub type NonNullPFN_vkCmdSetCoverageToColorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32);
20985pub type NonNullPFN_vkCmdSetCoverageToColorLocationNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorLocation: u32);
20986pub type NonNullPFN_vkCmdSetCullMode = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
20987pub type NonNullPFN_vkCmdSetCullModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
20988pub type NonNullPFN_vkCmdSetDepthBias = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);
20989pub type NonNullPFN_vkCmdSetDepthBias2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT);
20990pub type NonNullPFN_vkCmdSetDepthBiasEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
20991pub type NonNullPFN_vkCmdSetDepthBiasEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
20992pub type NonNullPFN_vkCmdSetDepthBounds = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);
20993pub type NonNullPFN_vkCmdSetDepthBoundsTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
20994pub type NonNullPFN_vkCmdSetDepthBoundsTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
20995pub type NonNullPFN_vkCmdSetDepthClampEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32);
20996pub type NonNullPFN_vkCmdSetDepthClampRangeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT);
20997pub type NonNullPFN_vkCmdSetDepthClipEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32);
20998pub type NonNullPFN_vkCmdSetDepthClipNegativeOneToOneEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32);
20999pub type NonNullPFN_vkCmdSetDepthCompareOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
21000pub type NonNullPFN_vkCmdSetDepthCompareOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
21001pub type NonNullPFN_vkCmdSetDepthTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
21002pub type NonNullPFN_vkCmdSetDepthTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
21003pub type NonNullPFN_vkCmdSetDepthWriteEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
21004pub type NonNullPFN_vkCmdSetDepthWriteEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
21005pub type NonNullPFN_vkCmdSetDescriptorBufferOffsets2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT);
21006pub type NonNullPFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, setCount: u32, pBufferIndices: *const u32, pOffsets: *const VkDeviceSize);
21007pub type NonNullPFN_vkCmdSetDeviceMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32);
21008pub type NonNullPFN_vkCmdSetDeviceMaskKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32);
21009pub type NonNullPFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: *const VkRect2D);
21010pub type NonNullPFN_vkCmdSetDiscardRectangleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32);
21011pub type NonNullPFN_vkCmdSetDiscardRectangleModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT);
21012pub type NonNullPFN_vkCmdSetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
21013pub type NonNullPFN_vkCmdSetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
21014pub type NonNullPFN_vkCmdSetEvent2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
21015pub type NonNullPFN_vkCmdSetExclusiveScissorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissorEnables: *const VkBool32);
21016pub type NonNullPFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: *const VkRect2D);
21017pub type NonNullPFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: f32);
21018pub type NonNullPFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
21019pub type NonNullPFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
21020pub type NonNullPFN_vkCmdSetFrontFace = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
21021pub type NonNullPFN_vkCmdSetFrontFaceEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
21022pub type NonNullPFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT);
21023pub type NonNullPFN_vkCmdSetLineStipple = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
21024pub type NonNullPFN_vkCmdSetLineStippleEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
21025pub type NonNullPFN_vkCmdSetLineStippleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32);
21026pub type NonNullPFN_vkCmdSetLineStippleKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
21027pub type NonNullPFN_vkCmdSetLineWidth = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineWidth: f32);
21028pub type NonNullPFN_vkCmdSetLogicOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOp: VkLogicOp);
21029pub type NonNullPFN_vkCmdSetLogicOpEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32);
21030pub type NonNullPFN_vkCmdSetPatchControlPointsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, patchControlPoints: u32);
21031pub type NonNullPFN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult;
21032pub type NonNullPFN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult;
21033pub type NonNullPFN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult;
21034pub type NonNullPFN_vkCmdSetPolygonModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode);
21035pub type NonNullPFN_vkCmdSetPrimitiveRestartEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
21036pub type NonNullPFN_vkCmdSetPrimitiveRestartEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
21037pub type NonNullPFN_vkCmdSetPrimitiveTopology = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
21038pub type NonNullPFN_vkCmdSetPrimitiveTopologyEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
21039pub type NonNullPFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT);
21040pub type NonNullPFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits);
21041pub type NonNullPFN_vkCmdSetRasterizationStreamEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationStream: u32);
21042pub type NonNullPFN_vkCmdSetRasterizerDiscardEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
21043pub type NonNullPFN_vkCmdSetRasterizerDiscardEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
21044pub type NonNullPFN_vkCmdSetRayTracingPipelineStackSizeKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStackSize: u32);
21045pub type NonNullPFN_vkCmdSetRenderingAttachmentLocations = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
21046pub type NonNullPFN_vkCmdSetRenderingAttachmentLocationsKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
21047pub type NonNullPFN_vkCmdSetRenderingInputAttachmentIndices = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
21048pub type NonNullPFN_vkCmdSetRenderingInputAttachmentIndicesKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
21049pub type NonNullPFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32);
21050pub type NonNullPFN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT);
21051pub type NonNullPFN_vkCmdSetSampleLocationsEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32);
21052pub type NonNullPFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: *const VkSampleMask);
21053pub type NonNullPFN_vkCmdSetScissor = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D);
21054pub type NonNullPFN_vkCmdSetScissorWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
21055pub type NonNullPFN_vkCmdSetScissorWithCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
21056pub type NonNullPFN_vkCmdSetShadingRateImageEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32);
21057pub type NonNullPFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32);
21058pub type NonNullPFN_vkCmdSetStencilOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
21059pub type NonNullPFN_vkCmdSetStencilOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
21060pub type NonNullPFN_vkCmdSetStencilReference = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32);
21061pub type NonNullPFN_vkCmdSetStencilTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
21062pub type NonNullPFN_vkCmdSetStencilTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
21063pub type NonNullPFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32);
21064pub type NonNullPFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin);
21065pub type NonNullPFN_vkCmdSetVertexInputEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT);
21066pub type NonNullPFN_vkCmdSetViewport = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport);
21067pub type NonNullPFN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: *const VkShadingRatePaletteNV);
21068pub type NonNullPFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportSwizzles: *const VkViewportSwizzleNV);
21069pub type NonNullPFN_vkCmdSetViewportWScalingEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32);
21070pub type NonNullPFN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: *const VkViewportWScalingNV);
21071pub type NonNullPFN_vkCmdSetViewportWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
21072pub type NonNullPFN_vkCmdSetViewportWithCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
21073pub type NonNullPFN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
21074pub type NonNullPFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress);
21075pub type NonNullPFN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress);
21076pub type NonNullPFN_vkCmdTraceRaysKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32);
21077pub type NonNullPFN_vkCmdTraceRaysNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, raygenShaderBindingTableBuffer: VkBuffer, raygenShaderBindingOffset: VkDeviceSize, missShaderBindingTableBuffer: VkBuffer, missShaderBindingOffset: VkDeviceSize, missShaderBindingStride: VkDeviceSize, hitShaderBindingTableBuffer: VkBuffer, hitShaderBindingOffset: VkDeviceSize, hitShaderBindingStride: VkDeviceSize, callableShaderBindingTableBuffer: VkBuffer, callableShaderBindingOffset: VkDeviceSize, callableShaderBindingStride: VkDeviceSize, width: u32, height: u32, depth: u32);
21078pub type NonNullPFN_vkCmdUpdateBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const c_void);
21079pub type NonNullPFN_vkCmdUpdatePipelineIndirectBufferNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
21080pub type NonNullPFN_vkCmdWaitEvents = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, srcStageMask: VkPipelineStageFlags, dstStageMask: VkPipelineStageFlags, memoryBarrierCount: u32, pMemoryBarriers: *const VkMemoryBarrier, bufferMemoryBarrierCount: u32, pBufferMemoryBarriers: *const VkBufferMemoryBarrier, imageMemoryBarrierCount: u32, pImageMemoryBarriers: *const VkImageMemoryBarrier);
21081pub type NonNullPFN_vkCmdWaitEvents2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
21082pub type NonNullPFN_vkCmdWaitEvents2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
21083pub type NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
21084pub type NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
21085pub type NonNullPFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
21086pub type NonNullPFN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
21087pub type NonNullPFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
21088pub type NonNullPFN_vkCmdWriteTimestamp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: u32);
21089pub type NonNullPFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
21090pub type NonNullPFN_vkCmdWriteTimestamp2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
21091pub type NonNullPFN_vkCompileDeferredNV = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shader: u32) -> VkResult;
21092pub type NonNullPFN_vkConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult;
21093pub type NonNullPFN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult;
21094pub type NonNullPFN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult;
21095pub type NonNullPFN_vkCopyImageToImage = unsafe extern "system" fn(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
21096pub type NonNullPFN_vkCopyImageToImageEXT = unsafe extern "system" fn(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
21097pub type NonNullPFN_vkCopyImageToMemory = unsafe extern "system" fn(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
21098pub type NonNullPFN_vkCopyImageToMemoryEXT = unsafe extern "system" fn(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
21099pub type NonNullPFN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult;
21100pub type NonNullPFN_vkCopyMemoryToImage = unsafe extern "system" fn(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
21101pub type NonNullPFN_vkCopyMemoryToImageEXT = unsafe extern "system" fn(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
21102pub type NonNullPFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult;
21103pub type NonNullPFN_vkCopyMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult;
21104pub type NonNullPFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult;
21105pub type NonNullPFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult;
21106pub type NonNullPFN_vkCreateAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult;
21107pub type NonNullPFN_vkCreateBuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;
21108pub type NonNullPFN_vkCreateBufferView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;
21109pub type NonNullPFN_vkCreateCommandPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;
21110pub type NonNullPFN_vkCreateComputePipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21111pub type NonNullPFN_vkCreateCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult;
21112pub type NonNullPFN_vkCreateCuModuleNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult;
21113pub type NonNullPFN_vkCreateDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult;
21114pub type NonNullPFN_vkCreateDataGraphPipelinesARM = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkDataGraphPipelineCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21115pub type NonNullPFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult;
21116pub type NonNullPFN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult;
21117pub type NonNullPFN_vkCreateDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult;
21118pub type NonNullPFN_vkCreateDescriptorPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult;
21119pub type NonNullPFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;
21120pub type NonNullPFN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
21121pub type NonNullPFN_vkCreateDescriptorUpdateTemplateKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
21122pub type NonNullPFN_vkCreateDevice = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;
21123pub type NonNullPFN_vkCreateDisplayModeKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;
21124pub type NonNullPFN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
21125pub type NonNullPFN_vkCreateEvent = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;
21126pub type NonNullPFN_vkCreateExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult;
21127pub type NonNullPFN_vkCreateFence = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
21128pub type NonNullPFN_vkCreateFramebuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;
21129pub type NonNullPFN_vkCreateGraphicsPipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21130pub type NonNullPFN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
21131pub type NonNullPFN_vkCreateImage = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;
21132pub type NonNullPFN_vkCreateImageView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;
21133pub type NonNullPFN_vkCreateIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult;
21134pub type NonNullPFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult;
21135pub type NonNullPFN_vkCreateIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult;
21136pub type NonNullPFN_vkCreateInstance = unsafe extern "system" fn(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;
21137pub type NonNullPFN_vkCreateMicromapEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult;
21138pub type NonNullPFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult;
21139pub type NonNullPFN_vkCreatePipelineBinariesKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult;
21140pub type NonNullPFN_vkCreatePipelineCache = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;
21141pub type NonNullPFN_vkCreatePipelineLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;
21142pub type NonNullPFN_vkCreatePrivateDataSlot = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
21143pub type NonNullPFN_vkCreatePrivateDataSlotEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
21144pub type NonNullPFN_vkCreateQueryPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;
21145pub type NonNullPFN_vkCreateRayTracingPipelinesKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21146pub type NonNullPFN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21147pub type NonNullPFN_vkCreateRenderPass = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
21148pub type NonNullPFN_vkCreateRenderPass2 = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
21149pub type NonNullPFN_vkCreateRenderPass2KHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
21150pub type NonNullPFN_vkCreateSampler = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;
21151pub type NonNullPFN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
21152pub type NonNullPFN_vkCreateSamplerYcbcrConversionKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
21153pub type NonNullPFN_vkCreateSemaphore = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;
21154pub type NonNullPFN_vkCreateShaderModule = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult;
21155pub type NonNullPFN_vkCreateShadersEXT = unsafe extern "system" fn(device: VkDevice, createInfoCount: u32, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult;
21156pub type NonNullPFN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn(device: VkDevice, swapchainCount: u32, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult;
21157pub type NonNullPFN_vkCreateSwapchainKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;
21158pub type NonNullPFN_vkCreateTensorARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult;
21159pub type NonNullPFN_vkCreateTensorViewARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult;
21160pub type NonNullPFN_vkCreateValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult;
21161pub type NonNullPFN_vkCreateVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult;
21162pub type NonNullPFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult;
21163pub type NonNullPFN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult;
21164pub type NonNullPFN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult;
21165pub type NonNullPFN_vkDebugReportCallbackEXT = unsafe extern "system" fn(flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const c_char, pMessage: *const c_char, pUserData: *mut c_void) -> VkBool32;
21166pub type NonNullPFN_vkDebugReportMessageEXT = unsafe extern "system" fn(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const c_char, pMessage: *const c_char);
21167pub type NonNullPFN_vkDebugUtilsMessengerCallbackEXT = unsafe extern "system" fn(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT, pUserData: *mut c_void) -> VkBool32;
21168pub type NonNullPFN_vkDeferredOperationJoinKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
21169pub type NonNullPFN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks);
21170pub type NonNullPFN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks);
21171pub type NonNullPFN_vkDestroyBuffer = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks);
21172pub type NonNullPFN_vkDestroyBufferView = unsafe extern "system" fn(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks);
21173pub type NonNullPFN_vkDestroyCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks);
21174pub type NonNullPFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks);
21175pub type NonNullPFN_vkDestroyCuModuleNVX = unsafe extern "system" fn(device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks);
21176pub type NonNullPFN_vkDestroyDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks);
21177pub type NonNullPFN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks);
21178pub type NonNullPFN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks);
21179pub type NonNullPFN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks);
21180pub type NonNullPFN_vkDestroyDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks);
21181pub type NonNullPFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks);
21182pub type NonNullPFN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
21183pub type NonNullPFN_vkDestroyDescriptorUpdateTemplateKHR = unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
21184pub type NonNullPFN_vkDestroyDevice = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks);
21185pub type NonNullPFN_vkDestroyEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks);
21186pub type NonNullPFN_vkDestroyExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks);
21187pub type NonNullPFN_vkDestroyFence = unsafe extern "system" fn(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks);
21188pub type NonNullPFN_vkDestroyFramebuffer = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks);
21189pub type NonNullPFN_vkDestroyImage = unsafe extern "system" fn(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks);
21190pub type NonNullPFN_vkDestroyImageView = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks);
21191pub type NonNullPFN_vkDestroyIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks);
21192pub type NonNullPFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks);
21193pub type NonNullPFN_vkDestroyIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks);
21194pub type NonNullPFN_vkDestroyInstance = unsafe extern "system" fn(instance: VkInstance, pAllocator: *const VkAllocationCallbacks);
21195pub type NonNullPFN_vkDestroyMicromapEXT = unsafe extern "system" fn(device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks);
21196pub type NonNullPFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks);
21197pub type NonNullPFN_vkDestroyPipeline = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks);
21198pub type NonNullPFN_vkDestroyPipelineBinaryKHR = unsafe extern "system" fn(device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks);
21199pub type NonNullPFN_vkDestroyPipelineCache = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks);
21200pub type NonNullPFN_vkDestroyPipelineLayout = unsafe extern "system" fn(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks);
21201pub type NonNullPFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
21202pub type NonNullPFN_vkDestroyPrivateDataSlotEXT = unsafe extern "system" fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
21203pub type NonNullPFN_vkDestroyQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks);
21204pub type NonNullPFN_vkDestroyRenderPass = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks);
21205pub type NonNullPFN_vkDestroySampler = unsafe extern "system" fn(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks);
21206pub type NonNullPFN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
21207pub type NonNullPFN_vkDestroySamplerYcbcrConversionKHR = unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
21208pub type NonNullPFN_vkDestroySemaphore = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks);
21209pub type NonNullPFN_vkDestroyShaderEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks);
21210pub type NonNullPFN_vkDestroyShaderModule = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks);
21211pub type NonNullPFN_vkDestroySurfaceKHR = unsafe extern "system" fn(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks);
21212pub type NonNullPFN_vkDestroySwapchainKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks);
21213pub type NonNullPFN_vkDestroyTensorARM = unsafe extern "system" fn(device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks);
21214pub type NonNullPFN_vkDestroyTensorViewARM = unsafe extern "system" fn(device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks);
21215pub type NonNullPFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks);
21216pub type NonNullPFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks);
21217pub type NonNullPFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks);
21218pub type NonNullPFN_vkDeviceMemoryReportCallbackEXT = unsafe extern "system" fn(pCallbackData: *const VkDeviceMemoryReportCallbackDataEXT, pUserData: *mut c_void);
21219pub type NonNullPFN_vkDeviceWaitIdle = unsafe extern "system" fn(device: VkDevice) -> VkResult;
21220pub type NonNullPFN_vkDisplayPowerControlEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult;
21221pub type NonNullPFN_vkEndCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> VkResult;
21222pub type NonNullPFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
21223pub type NonNullPFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
21224pub type NonNullPFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn(pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
21225pub type NonNullPFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
21226pub type NonNullPFN_vkEnumerateInstanceVersion = unsafe extern "system" fn(pApiVersion: *mut u32) -> VkResult;
21227pub type NonNullPFN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
21228pub type NonNullPFN_vkEnumeratePhysicalDeviceGroupsKHR = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
21229pub type NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult;
21230pub type NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult;
21231pub type NonNullPFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;
21232pub type NonNullPFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
21233pub type NonNullPFN_vkFreeCommandBuffers = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
21234pub type NonNullPFN_vkFreeDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult;
21235pub type NonNullPFN_vkFreeFunction = unsafe extern "system" fn(pUserData: *mut c_void, pMemory: *mut c_void);
21236pub type NonNullPFN_vkFreeMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks);
21237pub type NonNullPFN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const u32, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
21238pub type NonNullPFN_vkGetAccelerationStructureDeviceAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress;
21239pub type NonNullPFN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: usize, pData: *mut c_void) -> VkResult;
21240pub type NonNullPFN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR);
21241pub type NonNullPFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21242pub type NonNullPFN_vkGetBufferDeviceAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
21243pub type NonNullPFN_vkGetBufferDeviceAddressEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
21244pub type NonNullPFN_vkGetBufferDeviceAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
21245pub type NonNullPFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements);
21246pub type NonNullPFN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21247pub type NonNullPFN_vkGetBufferMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21248pub type NonNullPFN_vkGetBufferOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
21249pub type NonNullPFN_vkGetBufferOpaqueCaptureAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
21250pub type NonNullPFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21251pub type NonNullPFN_vkGetCalibratedTimestampsEXT = unsafe extern "system" fn(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
21252pub type NonNullPFN_vkGetCalibratedTimestampsKHR = unsafe extern "system" fn(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
21253pub type NonNullPFN_vkGetClusterAccelerationStructureBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
21254pub type NonNullPFN_vkGetDataGraphPipelineAvailablePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut u32, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult;
21255pub type NonNullPFN_vkGetDataGraphPipelinePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: u32, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult;
21256pub type NonNullPFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut u32, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult;
21257pub type NonNullPFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
21258pub type NonNullPFN_vkGetDeferredOperationMaxConcurrencyKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> u32;
21259pub type NonNullPFN_vkGetDeferredOperationResultKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
21260pub type NonNullPFN_vkGetDescriptorEXT = unsafe extern "system" fn(device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: usize, pDescriptor: *mut c_void);
21261pub type NonNullPFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut c_void);
21262pub type NonNullPFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, binding: u32, pOffset: *mut VkDeviceSize);
21263pub type NonNullPFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn(device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE);
21264pub type NonNullPFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize);
21265pub type NonNullPFN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
21266pub type NonNullPFN_vkGetDescriptorSetLayoutSupportKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
21267pub type NonNullPFN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
21268pub type NonNullPFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21269pub type NonNullPFN_vkGetDeviceBufferMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21270pub type NonNullPFN_vkGetDeviceCombinedImageSamplerIndexNVX = unsafe extern "system" fn(device: VkDevice, imageViewIndex: u64, samplerIndex: u64) -> u64;
21271pub type NonNullPFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn(device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult;
21272pub type NonNullPFN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
21273pub type NonNullPFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
21274pub type NonNullPFN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult;
21275pub type NonNullPFN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;
21276pub type NonNullPFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21277pub type NonNullPFN_vkGetDeviceImageMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21278pub type NonNullPFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21279pub type NonNullPFN_vkGetDeviceImageSparseMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21280pub type NonNullPFN_vkGetDeviceImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
21281pub type NonNullPFN_vkGetDeviceImageSubresourceLayoutKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
21282pub type NonNullPFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize);
21283pub type NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
21284pub type NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
21285pub type NonNullPFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
21286pub type NonNullPFN_vkGetDeviceProcAddr = unsafe extern "system" fn(device: VkDevice, pName: *const c_char) -> PFN_vkVoidFunction;
21287pub type NonNullPFN_vkGetDeviceQueue = unsafe extern "system" fn(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue);
21288pub type NonNullPFN_vkGetDeviceQueue2 = unsafe extern "system" fn(device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue);
21289pub type NonNullPFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult;
21290pub type NonNullPFN_vkGetDeviceTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2);
21291pub type NonNullPFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult;
21292pub type NonNullPFN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;
21293pub type NonNullPFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult;
21294pub type NonNullPFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;
21295pub type NonNullPFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult;
21296pub type NonNullPFN_vkGetDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, connectorId: u32, display: *mut VkDisplayKHR) -> VkResult;
21297pub type NonNullPFN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
21298pub type NonNullPFN_vkGetEncodedVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21299pub type NonNullPFN_vkGetEventStatus = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
21300pub type NonNullPFN_vkGetExternalComputeQueueDataNV = unsafe extern "system" fn(externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut c_void);
21301pub type NonNullPFN_vkGetFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
21302pub type NonNullPFN_vkGetFenceStatus = unsafe extern "system" fn(device: VkDevice, fence: VkFence) -> VkResult;
21303pub type NonNullPFN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut u32, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
21304pub type NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2);
21305pub type NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2);
21306pub type NonNullPFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn(device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult;
21307pub type NonNullPFN_vkGetImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements);
21308pub type NonNullPFN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21309pub type NonNullPFN_vkGetImageMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21310pub type NonNullPFN_vkGetImageOpaqueCaptureDataEXT = unsafe extern "system" fn(device: VkDevice, imageCount: u32, pImages: *const VkImage, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
21311pub type NonNullPFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21312pub type NonNullPFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);
21313pub type NonNullPFN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21314pub type NonNullPFN_vkGetImageSparseMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21315pub type NonNullPFN_vkGetImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout);
21316pub type NonNullPFN_vkGetImageSubresourceLayout2 = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
21317pub type NonNullPFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
21318pub type NonNullPFN_vkGetImageSubresourceLayout2KHR = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
21319pub type NonNullPFN_vkGetImageViewAddressNVX = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult;
21320pub type NonNullPFN_vkGetImageViewHandle64NVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u64;
21321pub type NonNullPFN_vkGetImageViewHandleNVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u32;
21322pub type NonNullPFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21323pub type NonNullPFN_vkGetInstanceProcAddr = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
21324pub type NonNullPFN_vkGetInstanceProcAddrLUNARG = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
21325pub type NonNullPFN_vkGetLatencyTimingsNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV);
21326pub type NonNullPFN_vkGetMemoryFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
21327pub type NonNullPFN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: c_int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult;
21328pub type NonNullPFN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: *const c_void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult;
21329pub type NonNullPFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult;
21330pub type NonNullPFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT);
21331pub type NonNullPFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
21332pub type NonNullPFN_vkGetPastPresentationTimingEXT = unsafe extern "system" fn(device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult;
21333pub type NonNullPFN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut u32, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult;
21334pub type NonNullPFN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult;
21335pub type NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
21336pub type NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
21337pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult;
21338pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult;
21339pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult;
21340pub type NonNullPFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult;
21341pub type NonNullPFN_vkGetPhysicalDeviceDescriptorSizeEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, descriptorType: VkDescriptorType) -> VkDeviceSize;
21342pub type NonNullPFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult;
21343pub type NonNullPFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;
21344pub type NonNullPFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayProperties2KHR) -> VkResult;
21345pub type NonNullPFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;
21346pub type NonNullPFN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
21347pub type NonNullPFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
21348pub type NonNullPFN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
21349pub type NonNullPFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
21350pub type NonNullPFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV) -> VkResult;
21351pub type NonNullPFN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
21352pub type NonNullPFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
21353pub type NonNullPFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM);
21354pub type NonNullPFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures);
21355pub type NonNullPFN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
21356pub type NonNullPFN_vkGetPhysicalDeviceFeatures2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
21357pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties);
21358pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
21359pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
21360pub type NonNullPFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut u32, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult;
21361pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;
21362pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
21363pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
21364pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);
21365pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
21366pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
21367pub type NonNullPFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: *mut VkMultisamplePropertiesEXT);
21368pub type NonNullPFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut u32, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult;
21369pub type NonNullPFN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut u32, pRects: *mut VkRect2D) -> VkResult;
21370pub type NonNullPFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties);
21371pub type NonNullPFN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
21372pub type NonNullPFN_vkGetPhysicalDeviceProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
21373pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM);
21374pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pQueueFamilyDataGraphPropertyCount: *mut u32, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult;
21375pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut u32);
21376pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties);
21377pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
21378pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
21379pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties);
21380pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
21381pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
21382pub type NonNullPFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCombinationCount: *mut u32, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult;
21383pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult;
21384pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult;
21385pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;
21386pub type NonNullPFN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult;
21387pub type NonNullPFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;
21388pub type NonNullPFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult;
21389pub type NonNullPFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;
21390pub type NonNullPFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
21391pub type NonNullPFN_vkGetPhysicalDeviceToolPropertiesEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
21392pub type NonNullPFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult;
21393pub type NonNullPFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult;
21394pub type NonNullPFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut u32, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult;
21395pub type NonNullPFN_vkGetPipelineBinaryDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut usize, pPipelineBinaryData: *mut c_void) -> VkResult;
21396pub type NonNullPFN_vkGetPipelineCacheData = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21397pub type NonNullPFN_vkGetPipelineExecutableInternalRepresentationsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut u32, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult;
21398pub type NonNullPFN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut u32, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult;
21399pub type NonNullPFN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut u32, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult;
21400pub type NonNullPFN_vkGetPipelineIndirectDeviceAddressNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress;
21401pub type NonNullPFN_vkGetPipelineIndirectMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2);
21402pub type NonNullPFN_vkGetPipelineKeyKHR = unsafe extern "system" fn(device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult;
21403pub type NonNullPFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult;
21404pub type NonNullPFN_vkGetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
21405pub type NonNullPFN_vkGetPrivateDataEXT = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
21406pub type NonNullPFN_vkGetQueryPoolResults = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *mut c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult;
21407pub type NonNullPFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointData2NV);
21408pub type NonNullPFN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointDataNV);
21409pub type NonNullPFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
21410pub type NonNullPFN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
21411pub type NonNullPFN_vkGetRayTracingShaderGroupHandlesNV = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
21412pub type NonNullPFN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, group: u32, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize;
21413pub type NonNullPFN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult;
21414pub type NonNullPFN_vkGetRenderAreaGranularity = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D);
21415pub type NonNullPFN_vkGetRenderingAreaGranularity = unsafe extern "system" fn(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
21416pub type NonNullPFN_vkGetRenderingAreaGranularityKHR = unsafe extern "system" fn(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
21417pub type NonNullPFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21418pub type NonNullPFN_vkGetSemaphoreCounterValue = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
21419pub type NonNullPFN_vkGetSemaphoreCounterValueKHR = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
21420pub type NonNullPFN_vkGetSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
21421pub type NonNullPFN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21422pub type NonNullPFN_vkGetShaderInfoAMD = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut usize, pInfo: *mut c_void) -> VkResult;
21423pub type NonNullPFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT);
21424pub type NonNullPFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT);
21425pub type NonNullPFN_vkGetSwapchainCounterEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: *mut u64) -> VkResult;
21426pub type NonNullPFN_vkGetSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult;
21427pub type NonNullPFN_vkGetSwapchainStatusKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;
21428pub type NonNullPFN_vkGetSwapchainTimeDomainPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut u64) -> VkResult;
21429pub type NonNullPFN_vkGetSwapchainTimingPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut u64) -> VkResult;
21430pub type NonNullPFN_vkGetTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
21431pub type NonNullPFN_vkGetTensorOpaqueCaptureDataARM = unsafe extern "system" fn(device: VkDevice, tensorCount: u32, pTensors: *const VkTensorARM, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
21432pub type NonNullPFN_vkGetTensorOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
21433pub type NonNullPFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
21434pub type NonNullPFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21435pub type NonNullPFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut u32, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult;
21436pub type NonNullPFN_vkImportFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult;
21437pub type NonNullPFN_vkImportSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult;
21438pub type NonNullPFN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult;
21439pub type NonNullPFN_vkInternalAllocationNotification = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
21440pub type NonNullPFN_vkInternalFreeNotification = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
21441pub type NonNullPFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
21442pub type NonNullPFN_vkLatencySleepNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult;
21443pub type NonNullPFN_vkMapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut c_void) -> VkResult;
21444pub type NonNullPFN_vkMapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
21445pub type NonNullPFN_vkMapMemory2KHR = unsafe extern "system" fn(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
21446pub type NonNullPFN_vkMergePipelineCaches = unsafe extern "system" fn(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult;
21447pub type NonNullPFN_vkMergeValidationCachesEXT = unsafe extern "system" fn(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: u32, pSrcCaches: *const VkValidationCacheEXT) -> VkResult;
21448pub type NonNullPFN_vkQueueBeginDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
21449pub type NonNullPFN_vkQueueBindSparse = unsafe extern "system" fn(queue: VkQueue, bindInfoCount: u32, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult;
21450pub type NonNullPFN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue);
21451pub type NonNullPFN_vkQueueInsertDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
21452pub type NonNullPFN_vkQueueNotifyOutOfBandNV = unsafe extern "system" fn(queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV);
21453pub type NonNullPFN_vkQueuePresentKHR = unsafe extern "system" fn(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;
21454pub type NonNullPFN_vkQueueSetPerformanceConfigurationINTEL = unsafe extern "system" fn(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
21455pub type NonNullPFN_vkQueueSubmit = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;
21456pub type NonNullPFN_vkQueueSubmit2 = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
21457pub type NonNullPFN_vkQueueSubmit2KHR = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
21458pub type NonNullPFN_vkQueueWaitIdle = unsafe extern "system" fn(queue: VkQueue) -> VkResult;
21459pub type NonNullPFN_vkReallocationFunction = unsafe extern "system" fn(pUserData: *mut c_void, pOriginal: *mut c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut c_void;
21460pub type NonNullPFN_vkRegisterCustomBorderColorEXT = unsafe extern "system" fn(device: VkDevice, pBorderColor: *const VkSamplerCustomBorderColorCreateInfoEXT, requestIndex: VkBool32, pIndex: *mut u32) -> VkResult;
21461pub type NonNullPFN_vkRegisterDeviceEventEXT = unsafe extern "system" fn(device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
21462pub type NonNullPFN_vkRegisterDisplayEventEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
21463pub type NonNullPFN_vkReleaseCapturedPipelineDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult;
21464pub type NonNullPFN_vkReleaseDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;
21465pub type NonNullPFN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
21466pub type NonNullPFN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: VkDevice);
21467pub type NonNullPFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
21468pub type NonNullPFN_vkReleaseSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
21469pub type NonNullPFN_vkResetCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;
21470pub type NonNullPFN_vkResetCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;
21471pub type NonNullPFN_vkResetDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;
21472pub type NonNullPFN_vkResetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
21473pub type NonNullPFN_vkResetFences = unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult;
21474pub type NonNullPFN_vkResetQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
21475pub type NonNullPFN_vkResetQueryPoolEXT = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
21476pub type NonNullPFN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult;
21477pub type NonNullPFN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult;
21478pub type NonNullPFN_vkSetDeviceMemoryPriorityEXT = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, priority: f32);
21479pub type NonNullPFN_vkSetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
21480pub type NonNullPFN_vkSetHdrMetadataEXT = unsafe extern "system" fn(device: VkDevice, swapchainCount: u32, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT);
21481pub type NonNullPFN_vkSetLatencyMarkerNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV);
21482pub type NonNullPFN_vkSetLatencySleepModeNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult;
21483pub type NonNullPFN_vkSetLocalDimmingAMD = unsafe extern "system" fn(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32);
21484pub type NonNullPFN_vkSetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
21485pub type NonNullPFN_vkSetPrivateDataEXT = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
21486pub type NonNullPFN_vkSetSwapchainPresentTimingQueueSizeEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, size: u32) -> VkResult;
21487pub type NonNullPFN_vkSignalSemaphore = unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
21488pub type NonNullPFN_vkSignalSemaphoreKHR = unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
21489pub type NonNullPFN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT);
21490pub type NonNullPFN_vkTransitionImageLayout = unsafe extern "system" fn(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
21491pub type NonNullPFN_vkTransitionImageLayoutEXT = unsafe extern "system" fn(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
21492pub type NonNullPFN_vkTrimCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
21493pub type NonNullPFN_vkTrimCommandPoolKHR = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
21494pub type NonNullPFN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice);
21495pub type NonNullPFN_vkUnmapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory);
21496pub type NonNullPFN_vkUnmapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
21497pub type NonNullPFN_vkUnmapMemory2KHR = unsafe extern "system" fn(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
21498pub type NonNullPFN_vkUnregisterCustomBorderColorEXT = unsafe extern "system" fn(device: VkDevice, index: u32);
21499pub type NonNullPFN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
21500pub type NonNullPFN_vkUpdateDescriptorSetWithTemplateKHR = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
21501pub type NonNullPFN_vkUpdateDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet);
21502pub type NonNullPFN_vkUpdateIndirectExecutionSetPipelineEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT);
21503pub type NonNullPFN_vkUpdateIndirectExecutionSetShaderEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT);
21504pub type NonNullPFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult;
21505pub type NonNullPFN_vkVoidFunction = unsafe extern "system" fn();
21506pub type NonNullPFN_vkWaitForFences = unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult;
21507pub type NonNullPFN_vkWaitForPresent2KHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult;
21508pub type NonNullPFN_vkWaitForPresentKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, presentId: u64, timeout: u64) -> VkResult;
21509pub type NonNullPFN_vkWaitSemaphores = unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
21510pub type NonNullPFN_vkWaitSemaphoresKHR = unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
21511pub type NonNullPFN_vkWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(device: VkDevice, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
21512pub type NonNullPFN_vkWriteMicromapsPropertiesEXT = unsafe extern "system" fn(device: VkDevice, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
21513pub type NonNullPFN_vkWriteResourceDescriptorsEXT = unsafe extern "system" fn(device: VkDevice, resourceCount: u32, pResources: *const VkResourceDescriptorInfoEXT, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
21514pub type NonNullPFN_vkWriteSamplerDescriptorsEXT = unsafe extern "system" fn(device: VkDevice, samplerCount: u32, pSamplers: *const VkSamplerCreateInfo, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
21515pub type NonNullVkAccelerationStructureKHR = NonNull<VkAccelerationStructureKHR_T>;
21516pub type NonNullVkAccelerationStructureNV = NonNull<VkAccelerationStructureNV_T>;
21517pub type NonNullVkBuffer = NonNull<VkBuffer_T>;
21518pub type NonNullVkBufferView = NonNull<VkBufferView_T>;
21519pub type NonNullVkCommandBuffer = NonNull<VkCommandBuffer_T>;
21520pub type NonNullVkCommandPool = NonNull<VkCommandPool_T>;
21521pub type NonNullVkCuFunctionNVX = NonNull<VkCuFunctionNVX_T>;
21522pub type NonNullVkCuModuleNVX = NonNull<VkCuModuleNVX_T>;
21523pub type NonNullVkDataGraphPipelineSessionARM = NonNull<VkDataGraphPipelineSessionARM_T>;
21524pub type NonNullVkDebugReportCallbackEXT = NonNull<VkDebugReportCallbackEXT_T>;
21525pub type NonNullVkDebugUtilsMessengerEXT = NonNull<VkDebugUtilsMessengerEXT_T>;
21526pub type NonNullVkDeferredOperationKHR = NonNull<VkDeferredOperationKHR_T>;
21527pub type NonNullVkDescriptorPool = NonNull<VkDescriptorPool_T>;
21528pub type NonNullVkDescriptorSet = NonNull<VkDescriptorSet_T>;
21529pub type NonNullVkDescriptorSetLayout = NonNull<VkDescriptorSetLayout_T>;
21530pub type NonNullVkDescriptorUpdateTemplate = NonNull<VkDescriptorUpdateTemplate_T>;
21531pub type NonNullVkDescriptorUpdateTemplateKHR = NonNull<VkDescriptorUpdateTemplateKHR_T>;
21532pub type NonNullVkDevice = NonNull<VkDevice_T>;
21533pub type NonNullVkDeviceMemory = NonNull<VkDeviceMemory_T>;
21534pub type NonNullVkDisplayKHR = NonNull<VkDisplayKHR_T>;
21535pub type NonNullVkDisplayModeKHR = NonNull<VkDisplayModeKHR_T>;
21536pub type NonNullVkEvent = NonNull<VkEvent_T>;
21537pub type NonNullVkExternalComputeQueueNV = NonNull<VkExternalComputeQueueNV_T>;
21538pub type NonNullVkFence = NonNull<VkFence_T>;
21539pub type NonNullVkFramebuffer = NonNull<VkFramebuffer_T>;
21540pub type NonNullVkImage = NonNull<VkImage_T>;
21541pub type NonNullVkImageView = NonNull<VkImageView_T>;
21542pub type NonNullVkIndirectCommandsLayoutEXT = NonNull<VkIndirectCommandsLayoutEXT_T>;
21543pub type NonNullVkIndirectCommandsLayoutNV = NonNull<VkIndirectCommandsLayoutNV_T>;
21544pub type NonNullVkIndirectExecutionSetEXT = NonNull<VkIndirectExecutionSetEXT_T>;
21545pub type NonNullVkInstance = NonNull<VkInstance_T>;
21546pub type NonNullVkMicromapEXT = NonNull<VkMicromapEXT_T>;
21547pub type NonNullVkOpticalFlowSessionNV = NonNull<VkOpticalFlowSessionNV_T>;
21548pub type NonNullVkPerformanceConfigurationINTEL = NonNull<VkPerformanceConfigurationINTEL_T>;
21549pub type NonNullVkPhysicalDevice = NonNull<VkPhysicalDevice_T>;
21550pub type NonNullVkPipeline = NonNull<VkPipeline_T>;
21551pub type NonNullVkPipelineBinaryKHR = NonNull<VkPipelineBinaryKHR_T>;
21552pub type NonNullVkPipelineCache = NonNull<VkPipelineCache_T>;
21553pub type NonNullVkPipelineLayout = NonNull<VkPipelineLayout_T>;
21554pub type NonNullVkPrivateDataSlot = NonNull<VkPrivateDataSlot_T>;
21555pub type NonNullVkPrivateDataSlotEXT = NonNull<VkPrivateDataSlotEXT_T>;
21556pub type NonNullVkQueryPool = NonNull<VkQueryPool_T>;
21557pub type NonNullVkQueue = NonNull<VkQueue_T>;
21558pub type NonNullVkRenderPass = NonNull<VkRenderPass_T>;
21559pub type NonNullVkSampler = NonNull<VkSampler_T>;
21560pub type NonNullVkSamplerYcbcrConversion = NonNull<VkSamplerYcbcrConversion_T>;
21561pub type NonNullVkSamplerYcbcrConversionKHR = NonNull<VkSamplerYcbcrConversionKHR_T>;
21562pub type NonNullVkSemaphore = NonNull<VkSemaphore_T>;
21563pub type NonNullVkShaderEXT = NonNull<VkShaderEXT_T>;
21564pub type NonNullVkShaderModule = NonNull<VkShaderModule_T>;
21565pub type NonNullVkSurfaceKHR = NonNull<VkSurfaceKHR_T>;
21566pub type NonNullVkSwapchainKHR = NonNull<VkSwapchainKHR_T>;
21567pub type NonNullVkTensorARM = NonNull<VkTensorARM_T>;
21568pub type NonNullVkTensorViewARM = NonNull<VkTensorViewARM_T>;
21569pub type NonNullVkValidationCacheEXT = NonNull<VkValidationCacheEXT_T>;
21570pub type NonNullVkVideoSessionKHR = NonNull<VkVideoSessionKHR_T>;
21571pub type NonNullVkVideoSessionParametersKHR = NonNull<VkVideoSessionParametersKHR_T>;
21572pub type PFN_vkAcquireDrmDisplayEXT = Option<NonNullPFN_vkAcquireDrmDisplayEXT>;
21573pub type PFN_vkAcquireNextImage2KHR = Option<NonNullPFN_vkAcquireNextImage2KHR>;
21574pub type PFN_vkAcquireNextImageKHR = Option<NonNullPFN_vkAcquireNextImageKHR>;
21575pub type PFN_vkAcquirePerformanceConfigurationINTEL = Option<NonNullPFN_vkAcquirePerformanceConfigurationINTEL>;
21576pub type PFN_vkAcquireProfilingLockKHR = Option<NonNullPFN_vkAcquireProfilingLockKHR>;
21577pub type PFN_vkAllocateCommandBuffers = Option<NonNullPFN_vkAllocateCommandBuffers>;
21578pub type PFN_vkAllocateDescriptorSets = Option<NonNullPFN_vkAllocateDescriptorSets>;
21579pub type PFN_vkAllocateMemory = Option<NonNullPFN_vkAllocateMemory>;
21580pub type PFN_vkAllocationFunction = Option<NonNullPFN_vkAllocationFunction>;
21581pub type PFN_vkAntiLagUpdateAMD = Option<NonNullPFN_vkAntiLagUpdateAMD>;
21582pub type PFN_vkBeginCommandBuffer = Option<NonNullPFN_vkBeginCommandBuffer>;
21583pub type PFN_vkBindAccelerationStructureMemoryNV = Option<NonNullPFN_vkBindAccelerationStructureMemoryNV>;
21584pub type PFN_vkBindBufferMemory = Option<NonNullPFN_vkBindBufferMemory>;
21585pub type PFN_vkBindBufferMemory2 = Option<NonNullPFN_vkBindBufferMemory2>;
21586pub type PFN_vkBindBufferMemory2KHR = Option<NonNullPFN_vkBindBufferMemory2KHR>;
21587pub type PFN_vkBindDataGraphPipelineSessionMemoryARM = Option<NonNullPFN_vkBindDataGraphPipelineSessionMemoryARM>;
21588pub type PFN_vkBindImageMemory = Option<NonNullPFN_vkBindImageMemory>;
21589pub type PFN_vkBindImageMemory2 = Option<NonNullPFN_vkBindImageMemory2>;
21590pub type PFN_vkBindImageMemory2KHR = Option<NonNullPFN_vkBindImageMemory2KHR>;
21591pub type PFN_vkBindOpticalFlowSessionImageNV = Option<NonNullPFN_vkBindOpticalFlowSessionImageNV>;
21592pub type PFN_vkBindTensorMemoryARM = Option<NonNullPFN_vkBindTensorMemoryARM>;
21593pub type PFN_vkBindVideoSessionMemoryKHR = Option<NonNullPFN_vkBindVideoSessionMemoryKHR>;
21594pub type PFN_vkBuildAccelerationStructuresKHR = Option<NonNullPFN_vkBuildAccelerationStructuresKHR>;
21595pub type PFN_vkBuildMicromapsEXT = Option<NonNullPFN_vkBuildMicromapsEXT>;
21596pub type PFN_vkCmdBeginConditionalRenderingEXT = Option<NonNullPFN_vkCmdBeginConditionalRenderingEXT>;
21597pub type PFN_vkCmdBeginCustomResolveEXT = Option<NonNullPFN_vkCmdBeginCustomResolveEXT>;
21598pub type PFN_vkCmdBeginDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdBeginDebugUtilsLabelEXT>;
21599pub type PFN_vkCmdBeginPerTileExecutionQCOM = Option<NonNullPFN_vkCmdBeginPerTileExecutionQCOM>;
21600pub type PFN_vkCmdBeginQuery = Option<NonNullPFN_vkCmdBeginQuery>;
21601pub type PFN_vkCmdBeginQueryIndexedEXT = Option<NonNullPFN_vkCmdBeginQueryIndexedEXT>;
21602pub type PFN_vkCmdBeginRenderPass = Option<NonNullPFN_vkCmdBeginRenderPass>;
21603pub type PFN_vkCmdBeginRenderPass2 = Option<NonNullPFN_vkCmdBeginRenderPass2>;
21604pub type PFN_vkCmdBeginRenderPass2KHR = Option<NonNullPFN_vkCmdBeginRenderPass2KHR>;
21605pub type PFN_vkCmdBeginRendering = Option<NonNullPFN_vkCmdBeginRendering>;
21606pub type PFN_vkCmdBeginRenderingKHR = Option<NonNullPFN_vkCmdBeginRenderingKHR>;
21607pub type PFN_vkCmdBeginTransformFeedbackEXT = Option<NonNullPFN_vkCmdBeginTransformFeedbackEXT>;
21608pub type PFN_vkCmdBeginVideoCodingKHR = Option<NonNullPFN_vkCmdBeginVideoCodingKHR>;
21609pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = Option<NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT>;
21610pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = Option<NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT>;
21611pub type PFN_vkCmdBindDescriptorBuffersEXT = Option<NonNullPFN_vkCmdBindDescriptorBuffersEXT>;
21612pub type PFN_vkCmdBindDescriptorSets = Option<NonNullPFN_vkCmdBindDescriptorSets>;
21613pub type PFN_vkCmdBindDescriptorSets2 = Option<NonNullPFN_vkCmdBindDescriptorSets2>;
21614pub type PFN_vkCmdBindDescriptorSets2KHR = Option<NonNullPFN_vkCmdBindDescriptorSets2KHR>;
21615pub type PFN_vkCmdBindIndexBuffer = Option<NonNullPFN_vkCmdBindIndexBuffer>;
21616pub type PFN_vkCmdBindIndexBuffer2 = Option<NonNullPFN_vkCmdBindIndexBuffer2>;
21617pub type PFN_vkCmdBindIndexBuffer2KHR = Option<NonNullPFN_vkCmdBindIndexBuffer2KHR>;
21618pub type PFN_vkCmdBindInvocationMaskHUAWEI = Option<NonNullPFN_vkCmdBindInvocationMaskHUAWEI>;
21619pub type PFN_vkCmdBindPipeline = Option<NonNullPFN_vkCmdBindPipeline>;
21620pub type PFN_vkCmdBindPipelineShaderGroupNV = Option<NonNullPFN_vkCmdBindPipelineShaderGroupNV>;
21621pub type PFN_vkCmdBindResourceHeapEXT = Option<NonNullPFN_vkCmdBindResourceHeapEXT>;
21622pub type PFN_vkCmdBindSamplerHeapEXT = Option<NonNullPFN_vkCmdBindSamplerHeapEXT>;
21623pub type PFN_vkCmdBindShadersEXT = Option<NonNullPFN_vkCmdBindShadersEXT>;
21624pub type PFN_vkCmdBindShadingRateImageNV = Option<NonNullPFN_vkCmdBindShadingRateImageNV>;
21625pub type PFN_vkCmdBindTileMemoryQCOM = Option<NonNullPFN_vkCmdBindTileMemoryQCOM>;
21626pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = Option<NonNullPFN_vkCmdBindTransformFeedbackBuffersEXT>;
21627pub type PFN_vkCmdBindVertexBuffers = Option<NonNullPFN_vkCmdBindVertexBuffers>;
21628pub type PFN_vkCmdBindVertexBuffers2 = Option<NonNullPFN_vkCmdBindVertexBuffers2>;
21629pub type PFN_vkCmdBindVertexBuffers2EXT = Option<NonNullPFN_vkCmdBindVertexBuffers2EXT>;
21630pub type PFN_vkCmdBlitImage = Option<NonNullPFN_vkCmdBlitImage>;
21631pub type PFN_vkCmdBlitImage2 = Option<NonNullPFN_vkCmdBlitImage2>;
21632pub type PFN_vkCmdBlitImage2KHR = Option<NonNullPFN_vkCmdBlitImage2KHR>;
21633pub type PFN_vkCmdBuildAccelerationStructureNV = Option<NonNullPFN_vkCmdBuildAccelerationStructureNV>;
21634pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = Option<NonNullPFN_vkCmdBuildAccelerationStructuresIndirectKHR>;
21635pub type PFN_vkCmdBuildAccelerationStructuresKHR = Option<NonNullPFN_vkCmdBuildAccelerationStructuresKHR>;
21636pub type PFN_vkCmdBuildClusterAccelerationStructureIndirectNV = Option<NonNullPFN_vkCmdBuildClusterAccelerationStructureIndirectNV>;
21637pub type PFN_vkCmdBuildMicromapsEXT = Option<NonNullPFN_vkCmdBuildMicromapsEXT>;
21638pub type PFN_vkCmdBuildPartitionedAccelerationStructuresNV = Option<NonNullPFN_vkCmdBuildPartitionedAccelerationStructuresNV>;
21639pub type PFN_vkCmdClearAttachments = Option<NonNullPFN_vkCmdClearAttachments>;
21640pub type PFN_vkCmdClearColorImage = Option<NonNullPFN_vkCmdClearColorImage>;
21641pub type PFN_vkCmdClearDepthStencilImage = Option<NonNullPFN_vkCmdClearDepthStencilImage>;
21642pub type PFN_vkCmdControlVideoCodingKHR = Option<NonNullPFN_vkCmdControlVideoCodingKHR>;
21643pub type PFN_vkCmdConvertCooperativeVectorMatrixNV = Option<NonNullPFN_vkCmdConvertCooperativeVectorMatrixNV>;
21644pub type PFN_vkCmdCopyAccelerationStructureKHR = Option<NonNullPFN_vkCmdCopyAccelerationStructureKHR>;
21645pub type PFN_vkCmdCopyAccelerationStructureNV = Option<NonNullPFN_vkCmdCopyAccelerationStructureNV>;
21646pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = Option<NonNullPFN_vkCmdCopyAccelerationStructureToMemoryKHR>;
21647pub type PFN_vkCmdCopyBuffer = Option<NonNullPFN_vkCmdCopyBuffer>;
21648pub type PFN_vkCmdCopyBuffer2 = Option<NonNullPFN_vkCmdCopyBuffer2>;
21649pub type PFN_vkCmdCopyBuffer2KHR = Option<NonNullPFN_vkCmdCopyBuffer2KHR>;
21650pub type PFN_vkCmdCopyBufferToImage = Option<NonNullPFN_vkCmdCopyBufferToImage>;
21651pub type PFN_vkCmdCopyBufferToImage2 = Option<NonNullPFN_vkCmdCopyBufferToImage2>;
21652pub type PFN_vkCmdCopyBufferToImage2KHR = Option<NonNullPFN_vkCmdCopyBufferToImage2KHR>;
21653pub type PFN_vkCmdCopyImage = Option<NonNullPFN_vkCmdCopyImage>;
21654pub type PFN_vkCmdCopyImage2 = Option<NonNullPFN_vkCmdCopyImage2>;
21655pub type PFN_vkCmdCopyImage2KHR = Option<NonNullPFN_vkCmdCopyImage2KHR>;
21656pub type PFN_vkCmdCopyImageToBuffer = Option<NonNullPFN_vkCmdCopyImageToBuffer>;
21657pub type PFN_vkCmdCopyImageToBuffer2 = Option<NonNullPFN_vkCmdCopyImageToBuffer2>;
21658pub type PFN_vkCmdCopyImageToBuffer2KHR = Option<NonNullPFN_vkCmdCopyImageToBuffer2KHR>;
21659pub type PFN_vkCmdCopyMemoryIndirectKHR = Option<NonNullPFN_vkCmdCopyMemoryIndirectKHR>;
21660pub type PFN_vkCmdCopyMemoryIndirectNV = Option<NonNullPFN_vkCmdCopyMemoryIndirectNV>;
21661pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = Option<NonNullPFN_vkCmdCopyMemoryToAccelerationStructureKHR>;
21662pub type PFN_vkCmdCopyMemoryToImageIndirectKHR = Option<NonNullPFN_vkCmdCopyMemoryToImageIndirectKHR>;
21663pub type PFN_vkCmdCopyMemoryToImageIndirectNV = Option<NonNullPFN_vkCmdCopyMemoryToImageIndirectNV>;
21664pub type PFN_vkCmdCopyMemoryToMicromapEXT = Option<NonNullPFN_vkCmdCopyMemoryToMicromapEXT>;
21665pub type PFN_vkCmdCopyMicromapEXT = Option<NonNullPFN_vkCmdCopyMicromapEXT>;
21666pub type PFN_vkCmdCopyMicromapToMemoryEXT = Option<NonNullPFN_vkCmdCopyMicromapToMemoryEXT>;
21667pub type PFN_vkCmdCopyQueryPoolResults = Option<NonNullPFN_vkCmdCopyQueryPoolResults>;
21668pub type PFN_vkCmdCopyTensorARM = Option<NonNullPFN_vkCmdCopyTensorARM>;
21669pub type PFN_vkCmdCuLaunchKernelNVX = Option<NonNullPFN_vkCmdCuLaunchKernelNVX>;
21670pub type PFN_vkCmdDebugMarkerBeginEXT = Option<NonNullPFN_vkCmdDebugMarkerBeginEXT>;
21671pub type PFN_vkCmdDebugMarkerEndEXT = Option<NonNullPFN_vkCmdDebugMarkerEndEXT>;
21672pub type PFN_vkCmdDebugMarkerInsertEXT = Option<NonNullPFN_vkCmdDebugMarkerInsertEXT>;
21673pub type PFN_vkCmdDecodeVideoKHR = Option<NonNullPFN_vkCmdDecodeVideoKHR>;
21674pub type PFN_vkCmdDecompressMemoryEXT = Option<NonNullPFN_vkCmdDecompressMemoryEXT>;
21675pub type PFN_vkCmdDecompressMemoryIndirectCountEXT = Option<NonNullPFN_vkCmdDecompressMemoryIndirectCountEXT>;
21676pub type PFN_vkCmdDecompressMemoryIndirectCountNV = Option<NonNullPFN_vkCmdDecompressMemoryIndirectCountNV>;
21677pub type PFN_vkCmdDecompressMemoryNV = Option<NonNullPFN_vkCmdDecompressMemoryNV>;
21678pub type PFN_vkCmdDispatch = Option<NonNullPFN_vkCmdDispatch>;
21679pub type PFN_vkCmdDispatchBase = Option<NonNullPFN_vkCmdDispatchBase>;
21680pub type PFN_vkCmdDispatchBaseKHR = Option<NonNullPFN_vkCmdDispatchBaseKHR>;
21681pub type PFN_vkCmdDispatchDataGraphARM = Option<NonNullPFN_vkCmdDispatchDataGraphARM>;
21682pub type PFN_vkCmdDispatchIndirect = Option<NonNullPFN_vkCmdDispatchIndirect>;
21683pub type PFN_vkCmdDispatchTileQCOM = Option<NonNullPFN_vkCmdDispatchTileQCOM>;
21684pub type PFN_vkCmdDraw = Option<NonNullPFN_vkCmdDraw>;
21685pub type PFN_vkCmdDrawClusterHUAWEI = Option<NonNullPFN_vkCmdDrawClusterHUAWEI>;
21686pub type PFN_vkCmdDrawClusterIndirectHUAWEI = Option<NonNullPFN_vkCmdDrawClusterIndirectHUAWEI>;
21687pub type PFN_vkCmdDrawIndexed = Option<NonNullPFN_vkCmdDrawIndexed>;
21688pub type PFN_vkCmdDrawIndexedIndirect = Option<NonNullPFN_vkCmdDrawIndexedIndirect>;
21689pub type PFN_vkCmdDrawIndexedIndirectCount = Option<NonNullPFN_vkCmdDrawIndexedIndirectCount>;
21690pub type PFN_vkCmdDrawIndexedIndirectCountAMD = Option<NonNullPFN_vkCmdDrawIndexedIndirectCountAMD>;
21691pub type PFN_vkCmdDrawIndexedIndirectCountKHR = Option<NonNullPFN_vkCmdDrawIndexedIndirectCountKHR>;
21692pub type PFN_vkCmdDrawIndirect = Option<NonNullPFN_vkCmdDrawIndirect>;
21693pub type PFN_vkCmdDrawIndirectByteCountEXT = Option<NonNullPFN_vkCmdDrawIndirectByteCountEXT>;
21694pub type PFN_vkCmdDrawIndirectCount = Option<NonNullPFN_vkCmdDrawIndirectCount>;
21695pub type PFN_vkCmdDrawIndirectCountAMD = Option<NonNullPFN_vkCmdDrawIndirectCountAMD>;
21696pub type PFN_vkCmdDrawIndirectCountKHR = Option<NonNullPFN_vkCmdDrawIndirectCountKHR>;
21697pub type PFN_vkCmdDrawMeshTasksEXT = Option<NonNullPFN_vkCmdDrawMeshTasksEXT>;
21698pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectCountEXT>;
21699pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectCountNV>;
21700pub type PFN_vkCmdDrawMeshTasksIndirectEXT = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectEXT>;
21701pub type PFN_vkCmdDrawMeshTasksIndirectNV = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectNV>;
21702pub type PFN_vkCmdDrawMeshTasksNV = Option<NonNullPFN_vkCmdDrawMeshTasksNV>;
21703pub type PFN_vkCmdDrawMultiEXT = Option<NonNullPFN_vkCmdDrawMultiEXT>;
21704pub type PFN_vkCmdDrawMultiIndexedEXT = Option<NonNullPFN_vkCmdDrawMultiIndexedEXT>;
21705pub type PFN_vkCmdEncodeVideoKHR = Option<NonNullPFN_vkCmdEncodeVideoKHR>;
21706pub type PFN_vkCmdEndConditionalRenderingEXT = Option<NonNullPFN_vkCmdEndConditionalRenderingEXT>;
21707pub type PFN_vkCmdEndDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdEndDebugUtilsLabelEXT>;
21708pub type PFN_vkCmdEndPerTileExecutionQCOM = Option<NonNullPFN_vkCmdEndPerTileExecutionQCOM>;
21709pub type PFN_vkCmdEndQuery = Option<NonNullPFN_vkCmdEndQuery>;
21710pub type PFN_vkCmdEndQueryIndexedEXT = Option<NonNullPFN_vkCmdEndQueryIndexedEXT>;
21711pub type PFN_vkCmdEndRenderPass = Option<NonNullPFN_vkCmdEndRenderPass>;
21712pub type PFN_vkCmdEndRenderPass2 = Option<NonNullPFN_vkCmdEndRenderPass2>;
21713pub type PFN_vkCmdEndRenderPass2KHR = Option<NonNullPFN_vkCmdEndRenderPass2KHR>;
21714pub type PFN_vkCmdEndRendering = Option<NonNullPFN_vkCmdEndRendering>;
21715pub type PFN_vkCmdEndRendering2EXT = Option<NonNullPFN_vkCmdEndRendering2EXT>;
21716pub type PFN_vkCmdEndRendering2KHR = Option<NonNullPFN_vkCmdEndRendering2KHR>;
21717pub type PFN_vkCmdEndRenderingKHR = Option<NonNullPFN_vkCmdEndRenderingKHR>;
21718pub type PFN_vkCmdEndTransformFeedbackEXT = Option<NonNullPFN_vkCmdEndTransformFeedbackEXT>;
21719pub type PFN_vkCmdEndVideoCodingKHR = Option<NonNullPFN_vkCmdEndVideoCodingKHR>;
21720pub type PFN_vkCmdExecuteCommands = Option<NonNullPFN_vkCmdExecuteCommands>;
21721pub type PFN_vkCmdExecuteGeneratedCommandsEXT = Option<NonNullPFN_vkCmdExecuteGeneratedCommandsEXT>;
21722pub type PFN_vkCmdExecuteGeneratedCommandsNV = Option<NonNullPFN_vkCmdExecuteGeneratedCommandsNV>;
21723pub type PFN_vkCmdFillBuffer = Option<NonNullPFN_vkCmdFillBuffer>;
21724pub type PFN_vkCmdInsertDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdInsertDebugUtilsLabelEXT>;
21725pub type PFN_vkCmdNextSubpass = Option<NonNullPFN_vkCmdNextSubpass>;
21726pub type PFN_vkCmdNextSubpass2 = Option<NonNullPFN_vkCmdNextSubpass2>;
21727pub type PFN_vkCmdNextSubpass2KHR = Option<NonNullPFN_vkCmdNextSubpass2KHR>;
21728pub type PFN_vkCmdOpticalFlowExecuteNV = Option<NonNullPFN_vkCmdOpticalFlowExecuteNV>;
21729pub type PFN_vkCmdPipelineBarrier = Option<NonNullPFN_vkCmdPipelineBarrier>;
21730pub type PFN_vkCmdPipelineBarrier2 = Option<NonNullPFN_vkCmdPipelineBarrier2>;
21731pub type PFN_vkCmdPipelineBarrier2KHR = Option<NonNullPFN_vkCmdPipelineBarrier2KHR>;
21732pub type PFN_vkCmdPreprocessGeneratedCommandsEXT = Option<NonNullPFN_vkCmdPreprocessGeneratedCommandsEXT>;
21733pub type PFN_vkCmdPreprocessGeneratedCommandsNV = Option<NonNullPFN_vkCmdPreprocessGeneratedCommandsNV>;
21734pub type PFN_vkCmdPushConstants = Option<NonNullPFN_vkCmdPushConstants>;
21735pub type PFN_vkCmdPushConstants2 = Option<NonNullPFN_vkCmdPushConstants2>;
21736pub type PFN_vkCmdPushConstants2KHR = Option<NonNullPFN_vkCmdPushConstants2KHR>;
21737pub type PFN_vkCmdPushDataEXT = Option<NonNullPFN_vkCmdPushDataEXT>;
21738pub type PFN_vkCmdPushDescriptorSet = Option<NonNullPFN_vkCmdPushDescriptorSet>;
21739pub type PFN_vkCmdPushDescriptorSet2 = Option<NonNullPFN_vkCmdPushDescriptorSet2>;
21740pub type PFN_vkCmdPushDescriptorSet2KHR = Option<NonNullPFN_vkCmdPushDescriptorSet2KHR>;
21741pub type PFN_vkCmdPushDescriptorSetKHR = Option<NonNullPFN_vkCmdPushDescriptorSetKHR>;
21742pub type PFN_vkCmdPushDescriptorSetWithTemplate = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate>;
21743pub type PFN_vkCmdPushDescriptorSetWithTemplate2 = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate2>;
21744pub type PFN_vkCmdPushDescriptorSetWithTemplate2KHR = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate2KHR>;
21745pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplateKHR>;
21746pub type PFN_vkCmdResetEvent = Option<NonNullPFN_vkCmdResetEvent>;
21747pub type PFN_vkCmdResetEvent2 = Option<NonNullPFN_vkCmdResetEvent2>;
21748pub type PFN_vkCmdResetEvent2KHR = Option<NonNullPFN_vkCmdResetEvent2KHR>;
21749pub type PFN_vkCmdResetQueryPool = Option<NonNullPFN_vkCmdResetQueryPool>;
21750pub type PFN_vkCmdResolveImage = Option<NonNullPFN_vkCmdResolveImage>;
21751pub type PFN_vkCmdResolveImage2 = Option<NonNullPFN_vkCmdResolveImage2>;
21752pub type PFN_vkCmdResolveImage2KHR = Option<NonNullPFN_vkCmdResolveImage2KHR>;
21753pub type PFN_vkCmdSetAlphaToCoverageEnableEXT = Option<NonNullPFN_vkCmdSetAlphaToCoverageEnableEXT>;
21754pub type PFN_vkCmdSetAlphaToOneEnableEXT = Option<NonNullPFN_vkCmdSetAlphaToOneEnableEXT>;
21755pub type PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = Option<NonNullPFN_vkCmdSetAttachmentFeedbackLoopEnableEXT>;
21756pub type PFN_vkCmdSetBlendConstants = Option<NonNullPFN_vkCmdSetBlendConstants>;
21757pub type PFN_vkCmdSetCheckpointNV = Option<NonNullPFN_vkCmdSetCheckpointNV>;
21758pub type PFN_vkCmdSetCoarseSampleOrderNV = Option<NonNullPFN_vkCmdSetCoarseSampleOrderNV>;
21759pub type PFN_vkCmdSetColorBlendAdvancedEXT = Option<NonNullPFN_vkCmdSetColorBlendAdvancedEXT>;
21760pub type PFN_vkCmdSetColorBlendEnableEXT = Option<NonNullPFN_vkCmdSetColorBlendEnableEXT>;
21761pub type PFN_vkCmdSetColorBlendEquationEXT = Option<NonNullPFN_vkCmdSetColorBlendEquationEXT>;
21762pub type PFN_vkCmdSetColorWriteEnableEXT = Option<NonNullPFN_vkCmdSetColorWriteEnableEXT>;
21763pub type PFN_vkCmdSetColorWriteMaskEXT = Option<NonNullPFN_vkCmdSetColorWriteMaskEXT>;
21764pub type PFN_vkCmdSetComputeOccupancyPriorityNV = Option<NonNullPFN_vkCmdSetComputeOccupancyPriorityNV>;
21765pub type PFN_vkCmdSetConservativeRasterizationModeEXT = Option<NonNullPFN_vkCmdSetConservativeRasterizationModeEXT>;
21766pub type PFN_vkCmdSetCoverageModulationModeNV = Option<NonNullPFN_vkCmdSetCoverageModulationModeNV>;
21767pub type PFN_vkCmdSetCoverageModulationTableEnableNV = Option<NonNullPFN_vkCmdSetCoverageModulationTableEnableNV>;
21768pub type PFN_vkCmdSetCoverageModulationTableNV = Option<NonNullPFN_vkCmdSetCoverageModulationTableNV>;
21769pub type PFN_vkCmdSetCoverageReductionModeNV = Option<NonNullPFN_vkCmdSetCoverageReductionModeNV>;
21770pub type PFN_vkCmdSetCoverageToColorEnableNV = Option<NonNullPFN_vkCmdSetCoverageToColorEnableNV>;
21771pub type PFN_vkCmdSetCoverageToColorLocationNV = Option<NonNullPFN_vkCmdSetCoverageToColorLocationNV>;
21772pub type PFN_vkCmdSetCullMode = Option<NonNullPFN_vkCmdSetCullMode>;
21773pub type PFN_vkCmdSetCullModeEXT = Option<NonNullPFN_vkCmdSetCullModeEXT>;
21774pub type PFN_vkCmdSetDepthBias = Option<NonNullPFN_vkCmdSetDepthBias>;
21775pub type PFN_vkCmdSetDepthBias2EXT = Option<NonNullPFN_vkCmdSetDepthBias2EXT>;
21776pub type PFN_vkCmdSetDepthBiasEnable = Option<NonNullPFN_vkCmdSetDepthBiasEnable>;
21777pub type PFN_vkCmdSetDepthBiasEnableEXT = Option<NonNullPFN_vkCmdSetDepthBiasEnableEXT>;
21778pub type PFN_vkCmdSetDepthBounds = Option<NonNullPFN_vkCmdSetDepthBounds>;
21779pub type PFN_vkCmdSetDepthBoundsTestEnable = Option<NonNullPFN_vkCmdSetDepthBoundsTestEnable>;
21780pub type PFN_vkCmdSetDepthBoundsTestEnableEXT = Option<NonNullPFN_vkCmdSetDepthBoundsTestEnableEXT>;
21781pub type PFN_vkCmdSetDepthClampEnableEXT = Option<NonNullPFN_vkCmdSetDepthClampEnableEXT>;
21782pub type PFN_vkCmdSetDepthClampRangeEXT = Option<NonNullPFN_vkCmdSetDepthClampRangeEXT>;
21783pub type PFN_vkCmdSetDepthClipEnableEXT = Option<NonNullPFN_vkCmdSetDepthClipEnableEXT>;
21784pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT = Option<NonNullPFN_vkCmdSetDepthClipNegativeOneToOneEXT>;
21785pub type PFN_vkCmdSetDepthCompareOp = Option<NonNullPFN_vkCmdSetDepthCompareOp>;
21786pub type PFN_vkCmdSetDepthCompareOpEXT = Option<NonNullPFN_vkCmdSetDepthCompareOpEXT>;
21787pub type PFN_vkCmdSetDepthTestEnable = Option<NonNullPFN_vkCmdSetDepthTestEnable>;
21788pub type PFN_vkCmdSetDepthTestEnableEXT = Option<NonNullPFN_vkCmdSetDepthTestEnableEXT>;
21789pub type PFN_vkCmdSetDepthWriteEnable = Option<NonNullPFN_vkCmdSetDepthWriteEnable>;
21790pub type PFN_vkCmdSetDepthWriteEnableEXT = Option<NonNullPFN_vkCmdSetDepthWriteEnableEXT>;
21791pub type PFN_vkCmdSetDescriptorBufferOffsets2EXT = Option<NonNullPFN_vkCmdSetDescriptorBufferOffsets2EXT>;
21792pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = Option<NonNullPFN_vkCmdSetDescriptorBufferOffsetsEXT>;
21793pub type PFN_vkCmdSetDeviceMask = Option<NonNullPFN_vkCmdSetDeviceMask>;
21794pub type PFN_vkCmdSetDeviceMaskKHR = Option<NonNullPFN_vkCmdSetDeviceMaskKHR>;
21795pub type PFN_vkCmdSetDiscardRectangleEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleEXT>;
21796pub type PFN_vkCmdSetDiscardRectangleEnableEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleEnableEXT>;
21797pub type PFN_vkCmdSetDiscardRectangleModeEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleModeEXT>;
21798pub type PFN_vkCmdSetEvent = Option<NonNullPFN_vkCmdSetEvent>;
21799pub type PFN_vkCmdSetEvent2 = Option<NonNullPFN_vkCmdSetEvent2>;
21800pub type PFN_vkCmdSetEvent2KHR = Option<NonNullPFN_vkCmdSetEvent2KHR>;
21801pub type PFN_vkCmdSetExclusiveScissorEnableNV = Option<NonNullPFN_vkCmdSetExclusiveScissorEnableNV>;
21802pub type PFN_vkCmdSetExclusiveScissorNV = Option<NonNullPFN_vkCmdSetExclusiveScissorNV>;
21803pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = Option<NonNullPFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT>;
21804pub type PFN_vkCmdSetFragmentShadingRateEnumNV = Option<NonNullPFN_vkCmdSetFragmentShadingRateEnumNV>;
21805pub type PFN_vkCmdSetFragmentShadingRateKHR = Option<NonNullPFN_vkCmdSetFragmentShadingRateKHR>;
21806pub type PFN_vkCmdSetFrontFace = Option<NonNullPFN_vkCmdSetFrontFace>;
21807pub type PFN_vkCmdSetFrontFaceEXT = Option<NonNullPFN_vkCmdSetFrontFaceEXT>;
21808pub type PFN_vkCmdSetLineRasterizationModeEXT = Option<NonNullPFN_vkCmdSetLineRasterizationModeEXT>;
21809pub type PFN_vkCmdSetLineStipple = Option<NonNullPFN_vkCmdSetLineStipple>;
21810pub type PFN_vkCmdSetLineStippleEXT = Option<NonNullPFN_vkCmdSetLineStippleEXT>;
21811pub type PFN_vkCmdSetLineStippleEnableEXT = Option<NonNullPFN_vkCmdSetLineStippleEnableEXT>;
21812pub type PFN_vkCmdSetLineStippleKHR = Option<NonNullPFN_vkCmdSetLineStippleKHR>;
21813pub type PFN_vkCmdSetLineWidth = Option<NonNullPFN_vkCmdSetLineWidth>;
21814pub type PFN_vkCmdSetLogicOpEXT = Option<NonNullPFN_vkCmdSetLogicOpEXT>;
21815pub type PFN_vkCmdSetLogicOpEnableEXT = Option<NonNullPFN_vkCmdSetLogicOpEnableEXT>;
21816pub type PFN_vkCmdSetPatchControlPointsEXT = Option<NonNullPFN_vkCmdSetPatchControlPointsEXT>;
21817pub type PFN_vkCmdSetPerformanceMarkerINTEL = Option<NonNullPFN_vkCmdSetPerformanceMarkerINTEL>;
21818pub type PFN_vkCmdSetPerformanceOverrideINTEL = Option<NonNullPFN_vkCmdSetPerformanceOverrideINTEL>;
21819pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = Option<NonNullPFN_vkCmdSetPerformanceStreamMarkerINTEL>;
21820pub type PFN_vkCmdSetPolygonModeEXT = Option<NonNullPFN_vkCmdSetPolygonModeEXT>;
21821pub type PFN_vkCmdSetPrimitiveRestartEnable = Option<NonNullPFN_vkCmdSetPrimitiveRestartEnable>;
21822pub type PFN_vkCmdSetPrimitiveRestartEnableEXT = Option<NonNullPFN_vkCmdSetPrimitiveRestartEnableEXT>;
21823pub type PFN_vkCmdSetPrimitiveTopology = Option<NonNullPFN_vkCmdSetPrimitiveTopology>;
21824pub type PFN_vkCmdSetPrimitiveTopologyEXT = Option<NonNullPFN_vkCmdSetPrimitiveTopologyEXT>;
21825pub type PFN_vkCmdSetProvokingVertexModeEXT = Option<NonNullPFN_vkCmdSetProvokingVertexModeEXT>;
21826pub type PFN_vkCmdSetRasterizationSamplesEXT = Option<NonNullPFN_vkCmdSetRasterizationSamplesEXT>;
21827pub type PFN_vkCmdSetRasterizationStreamEXT = Option<NonNullPFN_vkCmdSetRasterizationStreamEXT>;
21828pub type PFN_vkCmdSetRasterizerDiscardEnable = Option<NonNullPFN_vkCmdSetRasterizerDiscardEnable>;
21829pub type PFN_vkCmdSetRasterizerDiscardEnableEXT = Option<NonNullPFN_vkCmdSetRasterizerDiscardEnableEXT>;
21830pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR = Option<NonNullPFN_vkCmdSetRayTracingPipelineStackSizeKHR>;
21831pub type PFN_vkCmdSetRenderingAttachmentLocations = Option<NonNullPFN_vkCmdSetRenderingAttachmentLocations>;
21832pub type PFN_vkCmdSetRenderingAttachmentLocationsKHR = Option<NonNullPFN_vkCmdSetRenderingAttachmentLocationsKHR>;
21833pub type PFN_vkCmdSetRenderingInputAttachmentIndices = Option<NonNullPFN_vkCmdSetRenderingInputAttachmentIndices>;
21834pub type PFN_vkCmdSetRenderingInputAttachmentIndicesKHR = Option<NonNullPFN_vkCmdSetRenderingInputAttachmentIndicesKHR>;
21835pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = Option<NonNullPFN_vkCmdSetRepresentativeFragmentTestEnableNV>;
21836pub type PFN_vkCmdSetSampleLocationsEXT = Option<NonNullPFN_vkCmdSetSampleLocationsEXT>;
21837pub type PFN_vkCmdSetSampleLocationsEnableEXT = Option<NonNullPFN_vkCmdSetSampleLocationsEnableEXT>;
21838pub type PFN_vkCmdSetSampleMaskEXT = Option<NonNullPFN_vkCmdSetSampleMaskEXT>;
21839pub type PFN_vkCmdSetScissor = Option<NonNullPFN_vkCmdSetScissor>;
21840pub type PFN_vkCmdSetScissorWithCount = Option<NonNullPFN_vkCmdSetScissorWithCount>;
21841pub type PFN_vkCmdSetScissorWithCountEXT = Option<NonNullPFN_vkCmdSetScissorWithCountEXT>;
21842pub type PFN_vkCmdSetShadingRateImageEnableNV = Option<NonNullPFN_vkCmdSetShadingRateImageEnableNV>;
21843pub type PFN_vkCmdSetStencilCompareMask = Option<NonNullPFN_vkCmdSetStencilCompareMask>;
21844pub type PFN_vkCmdSetStencilOp = Option<NonNullPFN_vkCmdSetStencilOp>;
21845pub type PFN_vkCmdSetStencilOpEXT = Option<NonNullPFN_vkCmdSetStencilOpEXT>;
21846pub type PFN_vkCmdSetStencilReference = Option<NonNullPFN_vkCmdSetStencilReference>;
21847pub type PFN_vkCmdSetStencilTestEnable = Option<NonNullPFN_vkCmdSetStencilTestEnable>;
21848pub type PFN_vkCmdSetStencilTestEnableEXT = Option<NonNullPFN_vkCmdSetStencilTestEnableEXT>;
21849pub type PFN_vkCmdSetStencilWriteMask = Option<NonNullPFN_vkCmdSetStencilWriteMask>;
21850pub type PFN_vkCmdSetTessellationDomainOriginEXT = Option<NonNullPFN_vkCmdSetTessellationDomainOriginEXT>;
21851pub type PFN_vkCmdSetVertexInputEXT = Option<NonNullPFN_vkCmdSetVertexInputEXT>;
21852pub type PFN_vkCmdSetViewport = Option<NonNullPFN_vkCmdSetViewport>;
21853pub type PFN_vkCmdSetViewportShadingRatePaletteNV = Option<NonNullPFN_vkCmdSetViewportShadingRatePaletteNV>;
21854pub type PFN_vkCmdSetViewportSwizzleNV = Option<NonNullPFN_vkCmdSetViewportSwizzleNV>;
21855pub type PFN_vkCmdSetViewportWScalingEnableNV = Option<NonNullPFN_vkCmdSetViewportWScalingEnableNV>;
21856pub type PFN_vkCmdSetViewportWScalingNV = Option<NonNullPFN_vkCmdSetViewportWScalingNV>;
21857pub type PFN_vkCmdSetViewportWithCount = Option<NonNullPFN_vkCmdSetViewportWithCount>;
21858pub type PFN_vkCmdSetViewportWithCountEXT = Option<NonNullPFN_vkCmdSetViewportWithCountEXT>;
21859pub type PFN_vkCmdSubpassShadingHUAWEI = Option<NonNullPFN_vkCmdSubpassShadingHUAWEI>;
21860pub type PFN_vkCmdTraceRaysIndirect2KHR = Option<NonNullPFN_vkCmdTraceRaysIndirect2KHR>;
21861pub type PFN_vkCmdTraceRaysIndirectKHR = Option<NonNullPFN_vkCmdTraceRaysIndirectKHR>;
21862pub type PFN_vkCmdTraceRaysKHR = Option<NonNullPFN_vkCmdTraceRaysKHR>;
21863pub type PFN_vkCmdTraceRaysNV = Option<NonNullPFN_vkCmdTraceRaysNV>;
21864pub type PFN_vkCmdUpdateBuffer = Option<NonNullPFN_vkCmdUpdateBuffer>;
21865pub type PFN_vkCmdUpdatePipelineIndirectBufferNV = Option<NonNullPFN_vkCmdUpdatePipelineIndirectBufferNV>;
21866pub type PFN_vkCmdWaitEvents = Option<NonNullPFN_vkCmdWaitEvents>;
21867pub type PFN_vkCmdWaitEvents2 = Option<NonNullPFN_vkCmdWaitEvents2>;
21868pub type PFN_vkCmdWaitEvents2KHR = Option<NonNullPFN_vkCmdWaitEvents2KHR>;
21869pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = Option<NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesKHR>;
21870pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = Option<NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesNV>;
21871pub type PFN_vkCmdWriteBufferMarker2AMD = Option<NonNullPFN_vkCmdWriteBufferMarker2AMD>;
21872pub type PFN_vkCmdWriteBufferMarkerAMD = Option<NonNullPFN_vkCmdWriteBufferMarkerAMD>;
21873pub type PFN_vkCmdWriteMicromapsPropertiesEXT = Option<NonNullPFN_vkCmdWriteMicromapsPropertiesEXT>;
21874pub type PFN_vkCmdWriteTimestamp = Option<NonNullPFN_vkCmdWriteTimestamp>;
21875pub type PFN_vkCmdWriteTimestamp2 = Option<NonNullPFN_vkCmdWriteTimestamp2>;
21876pub type PFN_vkCmdWriteTimestamp2KHR = Option<NonNullPFN_vkCmdWriteTimestamp2KHR>;
21877pub type PFN_vkCompileDeferredNV = Option<NonNullPFN_vkCompileDeferredNV>;
21878pub type PFN_vkConvertCooperativeVectorMatrixNV = Option<NonNullPFN_vkConvertCooperativeVectorMatrixNV>;
21879pub type PFN_vkCopyAccelerationStructureKHR = Option<NonNullPFN_vkCopyAccelerationStructureKHR>;
21880pub type PFN_vkCopyAccelerationStructureToMemoryKHR = Option<NonNullPFN_vkCopyAccelerationStructureToMemoryKHR>;
21881pub type PFN_vkCopyImageToImage = Option<NonNullPFN_vkCopyImageToImage>;
21882pub type PFN_vkCopyImageToImageEXT = Option<NonNullPFN_vkCopyImageToImageEXT>;
21883pub type PFN_vkCopyImageToMemory = Option<NonNullPFN_vkCopyImageToMemory>;
21884pub type PFN_vkCopyImageToMemoryEXT = Option<NonNullPFN_vkCopyImageToMemoryEXT>;
21885pub type PFN_vkCopyMemoryToAccelerationStructureKHR = Option<NonNullPFN_vkCopyMemoryToAccelerationStructureKHR>;
21886pub type PFN_vkCopyMemoryToImage = Option<NonNullPFN_vkCopyMemoryToImage>;
21887pub type PFN_vkCopyMemoryToImageEXT = Option<NonNullPFN_vkCopyMemoryToImageEXT>;
21888pub type PFN_vkCopyMemoryToMicromapEXT = Option<NonNullPFN_vkCopyMemoryToMicromapEXT>;
21889pub type PFN_vkCopyMicromapEXT = Option<NonNullPFN_vkCopyMicromapEXT>;
21890pub type PFN_vkCopyMicromapToMemoryEXT = Option<NonNullPFN_vkCopyMicromapToMemoryEXT>;
21891pub type PFN_vkCreateAccelerationStructureKHR = Option<NonNullPFN_vkCreateAccelerationStructureKHR>;
21892pub type PFN_vkCreateAccelerationStructureNV = Option<NonNullPFN_vkCreateAccelerationStructureNV>;
21893pub type PFN_vkCreateBuffer = Option<NonNullPFN_vkCreateBuffer>;
21894pub type PFN_vkCreateBufferView = Option<NonNullPFN_vkCreateBufferView>;
21895pub type PFN_vkCreateCommandPool = Option<NonNullPFN_vkCreateCommandPool>;
21896pub type PFN_vkCreateComputePipelines = Option<NonNullPFN_vkCreateComputePipelines>;
21897pub type PFN_vkCreateCuFunctionNVX = Option<NonNullPFN_vkCreateCuFunctionNVX>;
21898pub type PFN_vkCreateCuModuleNVX = Option<NonNullPFN_vkCreateCuModuleNVX>;
21899pub type PFN_vkCreateDataGraphPipelineSessionARM = Option<NonNullPFN_vkCreateDataGraphPipelineSessionARM>;
21900pub type PFN_vkCreateDataGraphPipelinesARM = Option<NonNullPFN_vkCreateDataGraphPipelinesARM>;
21901pub type PFN_vkCreateDebugReportCallbackEXT = Option<NonNullPFN_vkCreateDebugReportCallbackEXT>;
21902pub type PFN_vkCreateDebugUtilsMessengerEXT = Option<NonNullPFN_vkCreateDebugUtilsMessengerEXT>;
21903pub type PFN_vkCreateDeferredOperationKHR = Option<NonNullPFN_vkCreateDeferredOperationKHR>;
21904pub type PFN_vkCreateDescriptorPool = Option<NonNullPFN_vkCreateDescriptorPool>;
21905pub type PFN_vkCreateDescriptorSetLayout = Option<NonNullPFN_vkCreateDescriptorSetLayout>;
21906pub type PFN_vkCreateDescriptorUpdateTemplate = Option<NonNullPFN_vkCreateDescriptorUpdateTemplate>;
21907pub type PFN_vkCreateDescriptorUpdateTemplateKHR = Option<NonNullPFN_vkCreateDescriptorUpdateTemplateKHR>;
21908pub type PFN_vkCreateDevice = Option<NonNullPFN_vkCreateDevice>;
21909pub type PFN_vkCreateDisplayModeKHR = Option<NonNullPFN_vkCreateDisplayModeKHR>;
21910pub type PFN_vkCreateDisplayPlaneSurfaceKHR = Option<NonNullPFN_vkCreateDisplayPlaneSurfaceKHR>;
21911pub type PFN_vkCreateEvent = Option<NonNullPFN_vkCreateEvent>;
21912pub type PFN_vkCreateExternalComputeQueueNV = Option<NonNullPFN_vkCreateExternalComputeQueueNV>;
21913pub type PFN_vkCreateFence = Option<NonNullPFN_vkCreateFence>;
21914pub type PFN_vkCreateFramebuffer = Option<NonNullPFN_vkCreateFramebuffer>;
21915pub type PFN_vkCreateGraphicsPipelines = Option<NonNullPFN_vkCreateGraphicsPipelines>;
21916pub type PFN_vkCreateHeadlessSurfaceEXT = Option<NonNullPFN_vkCreateHeadlessSurfaceEXT>;
21917pub type PFN_vkCreateImage = Option<NonNullPFN_vkCreateImage>;
21918pub type PFN_vkCreateImageView = Option<NonNullPFN_vkCreateImageView>;
21919pub type PFN_vkCreateIndirectCommandsLayoutEXT = Option<NonNullPFN_vkCreateIndirectCommandsLayoutEXT>;
21920pub type PFN_vkCreateIndirectCommandsLayoutNV = Option<NonNullPFN_vkCreateIndirectCommandsLayoutNV>;
21921pub type PFN_vkCreateIndirectExecutionSetEXT = Option<NonNullPFN_vkCreateIndirectExecutionSetEXT>;
21922pub type PFN_vkCreateInstance = Option<NonNullPFN_vkCreateInstance>;
21923pub type PFN_vkCreateMicromapEXT = Option<NonNullPFN_vkCreateMicromapEXT>;
21924pub type PFN_vkCreateOpticalFlowSessionNV = Option<NonNullPFN_vkCreateOpticalFlowSessionNV>;
21925pub type PFN_vkCreatePipelineBinariesKHR = Option<NonNullPFN_vkCreatePipelineBinariesKHR>;
21926pub type PFN_vkCreatePipelineCache = Option<NonNullPFN_vkCreatePipelineCache>;
21927pub type PFN_vkCreatePipelineLayout = Option<NonNullPFN_vkCreatePipelineLayout>;
21928pub type PFN_vkCreatePrivateDataSlot = Option<NonNullPFN_vkCreatePrivateDataSlot>;
21929pub type PFN_vkCreatePrivateDataSlotEXT = Option<NonNullPFN_vkCreatePrivateDataSlotEXT>;
21930pub type PFN_vkCreateQueryPool = Option<NonNullPFN_vkCreateQueryPool>;
21931pub type PFN_vkCreateRayTracingPipelinesKHR = Option<NonNullPFN_vkCreateRayTracingPipelinesKHR>;
21932pub type PFN_vkCreateRayTracingPipelinesNV = Option<NonNullPFN_vkCreateRayTracingPipelinesNV>;
21933pub type PFN_vkCreateRenderPass = Option<NonNullPFN_vkCreateRenderPass>;
21934pub type PFN_vkCreateRenderPass2 = Option<NonNullPFN_vkCreateRenderPass2>;
21935pub type PFN_vkCreateRenderPass2KHR = Option<NonNullPFN_vkCreateRenderPass2KHR>;
21936pub type PFN_vkCreateSampler = Option<NonNullPFN_vkCreateSampler>;
21937pub type PFN_vkCreateSamplerYcbcrConversion = Option<NonNullPFN_vkCreateSamplerYcbcrConversion>;
21938pub type PFN_vkCreateSamplerYcbcrConversionKHR = Option<NonNullPFN_vkCreateSamplerYcbcrConversionKHR>;
21939pub type PFN_vkCreateSemaphore = Option<NonNullPFN_vkCreateSemaphore>;
21940pub type PFN_vkCreateShaderModule = Option<NonNullPFN_vkCreateShaderModule>;
21941pub type PFN_vkCreateShadersEXT = Option<NonNullPFN_vkCreateShadersEXT>;
21942pub type PFN_vkCreateSharedSwapchainsKHR = Option<NonNullPFN_vkCreateSharedSwapchainsKHR>;
21943pub type PFN_vkCreateSwapchainKHR = Option<NonNullPFN_vkCreateSwapchainKHR>;
21944pub type PFN_vkCreateTensorARM = Option<NonNullPFN_vkCreateTensorARM>;
21945pub type PFN_vkCreateTensorViewARM = Option<NonNullPFN_vkCreateTensorViewARM>;
21946pub type PFN_vkCreateValidationCacheEXT = Option<NonNullPFN_vkCreateValidationCacheEXT>;
21947pub type PFN_vkCreateVideoSessionKHR = Option<NonNullPFN_vkCreateVideoSessionKHR>;
21948pub type PFN_vkCreateVideoSessionParametersKHR = Option<NonNullPFN_vkCreateVideoSessionParametersKHR>;
21949pub type PFN_vkDebugMarkerSetObjectNameEXT = Option<NonNullPFN_vkDebugMarkerSetObjectNameEXT>;
21950pub type PFN_vkDebugMarkerSetObjectTagEXT = Option<NonNullPFN_vkDebugMarkerSetObjectTagEXT>;
21951pub type PFN_vkDebugReportCallbackEXT = Option<NonNullPFN_vkDebugReportCallbackEXT>;
21952pub type PFN_vkDebugReportMessageEXT = Option<NonNullPFN_vkDebugReportMessageEXT>;
21953pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<NonNullPFN_vkDebugUtilsMessengerCallbackEXT>;
21954pub type PFN_vkDeferredOperationJoinKHR = Option<NonNullPFN_vkDeferredOperationJoinKHR>;
21955pub type PFN_vkDestroyAccelerationStructureKHR = Option<NonNullPFN_vkDestroyAccelerationStructureKHR>;
21956pub type PFN_vkDestroyAccelerationStructureNV = Option<NonNullPFN_vkDestroyAccelerationStructureNV>;
21957pub type PFN_vkDestroyBuffer = Option<NonNullPFN_vkDestroyBuffer>;
21958pub type PFN_vkDestroyBufferView = Option<NonNullPFN_vkDestroyBufferView>;
21959pub type PFN_vkDestroyCommandPool = Option<NonNullPFN_vkDestroyCommandPool>;
21960pub type PFN_vkDestroyCuFunctionNVX = Option<NonNullPFN_vkDestroyCuFunctionNVX>;
21961pub type PFN_vkDestroyCuModuleNVX = Option<NonNullPFN_vkDestroyCuModuleNVX>;
21962pub type PFN_vkDestroyDataGraphPipelineSessionARM = Option<NonNullPFN_vkDestroyDataGraphPipelineSessionARM>;
21963pub type PFN_vkDestroyDebugReportCallbackEXT = Option<NonNullPFN_vkDestroyDebugReportCallbackEXT>;
21964pub type PFN_vkDestroyDebugUtilsMessengerEXT = Option<NonNullPFN_vkDestroyDebugUtilsMessengerEXT>;
21965pub type PFN_vkDestroyDeferredOperationKHR = Option<NonNullPFN_vkDestroyDeferredOperationKHR>;
21966pub type PFN_vkDestroyDescriptorPool = Option<NonNullPFN_vkDestroyDescriptorPool>;
21967pub type PFN_vkDestroyDescriptorSetLayout = Option<NonNullPFN_vkDestroyDescriptorSetLayout>;
21968pub type PFN_vkDestroyDescriptorUpdateTemplate = Option<NonNullPFN_vkDestroyDescriptorUpdateTemplate>;
21969pub type PFN_vkDestroyDescriptorUpdateTemplateKHR = Option<NonNullPFN_vkDestroyDescriptorUpdateTemplateKHR>;
21970pub type PFN_vkDestroyDevice = Option<NonNullPFN_vkDestroyDevice>;
21971pub type PFN_vkDestroyEvent = Option<NonNullPFN_vkDestroyEvent>;
21972pub type PFN_vkDestroyExternalComputeQueueNV = Option<NonNullPFN_vkDestroyExternalComputeQueueNV>;
21973pub type PFN_vkDestroyFence = Option<NonNullPFN_vkDestroyFence>;
21974pub type PFN_vkDestroyFramebuffer = Option<NonNullPFN_vkDestroyFramebuffer>;
21975pub type PFN_vkDestroyImage = Option<NonNullPFN_vkDestroyImage>;
21976pub type PFN_vkDestroyImageView = Option<NonNullPFN_vkDestroyImageView>;
21977pub type PFN_vkDestroyIndirectCommandsLayoutEXT = Option<NonNullPFN_vkDestroyIndirectCommandsLayoutEXT>;
21978pub type PFN_vkDestroyIndirectCommandsLayoutNV = Option<NonNullPFN_vkDestroyIndirectCommandsLayoutNV>;
21979pub type PFN_vkDestroyIndirectExecutionSetEXT = Option<NonNullPFN_vkDestroyIndirectExecutionSetEXT>;
21980pub type PFN_vkDestroyInstance = Option<NonNullPFN_vkDestroyInstance>;
21981pub type PFN_vkDestroyMicromapEXT = Option<NonNullPFN_vkDestroyMicromapEXT>;
21982pub type PFN_vkDestroyOpticalFlowSessionNV = Option<NonNullPFN_vkDestroyOpticalFlowSessionNV>;
21983pub type PFN_vkDestroyPipeline = Option<NonNullPFN_vkDestroyPipeline>;
21984pub type PFN_vkDestroyPipelineBinaryKHR = Option<NonNullPFN_vkDestroyPipelineBinaryKHR>;
21985pub type PFN_vkDestroyPipelineCache = Option<NonNullPFN_vkDestroyPipelineCache>;
21986pub type PFN_vkDestroyPipelineLayout = Option<NonNullPFN_vkDestroyPipelineLayout>;
21987pub type PFN_vkDestroyPrivateDataSlot = Option<NonNullPFN_vkDestroyPrivateDataSlot>;
21988pub type PFN_vkDestroyPrivateDataSlotEXT = Option<NonNullPFN_vkDestroyPrivateDataSlotEXT>;
21989pub type PFN_vkDestroyQueryPool = Option<NonNullPFN_vkDestroyQueryPool>;
21990pub type PFN_vkDestroyRenderPass = Option<NonNullPFN_vkDestroyRenderPass>;
21991pub type PFN_vkDestroySampler = Option<NonNullPFN_vkDestroySampler>;
21992pub type PFN_vkDestroySamplerYcbcrConversion = Option<NonNullPFN_vkDestroySamplerYcbcrConversion>;
21993pub type PFN_vkDestroySamplerYcbcrConversionKHR = Option<NonNullPFN_vkDestroySamplerYcbcrConversionKHR>;
21994pub type PFN_vkDestroySemaphore = Option<NonNullPFN_vkDestroySemaphore>;
21995pub type PFN_vkDestroyShaderEXT = Option<NonNullPFN_vkDestroyShaderEXT>;
21996pub type PFN_vkDestroyShaderModule = Option<NonNullPFN_vkDestroyShaderModule>;
21997pub type PFN_vkDestroySurfaceKHR = Option<NonNullPFN_vkDestroySurfaceKHR>;
21998pub type PFN_vkDestroySwapchainKHR = Option<NonNullPFN_vkDestroySwapchainKHR>;
21999pub type PFN_vkDestroyTensorARM = Option<NonNullPFN_vkDestroyTensorARM>;
22000pub type PFN_vkDestroyTensorViewARM = Option<NonNullPFN_vkDestroyTensorViewARM>;
22001pub type PFN_vkDestroyValidationCacheEXT = Option<NonNullPFN_vkDestroyValidationCacheEXT>;
22002pub type PFN_vkDestroyVideoSessionKHR = Option<NonNullPFN_vkDestroyVideoSessionKHR>;
22003pub type PFN_vkDestroyVideoSessionParametersKHR = Option<NonNullPFN_vkDestroyVideoSessionParametersKHR>;
22004pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<NonNullPFN_vkDeviceMemoryReportCallbackEXT>;
22005pub type PFN_vkDeviceWaitIdle = Option<NonNullPFN_vkDeviceWaitIdle>;
22006pub type PFN_vkDisplayPowerControlEXT = Option<NonNullPFN_vkDisplayPowerControlEXT>;
22007pub type PFN_vkEndCommandBuffer = Option<NonNullPFN_vkEndCommandBuffer>;
22008pub type PFN_vkEnumerateDeviceExtensionProperties = Option<NonNullPFN_vkEnumerateDeviceExtensionProperties>;
22009pub type PFN_vkEnumerateDeviceLayerProperties = Option<NonNullPFN_vkEnumerateDeviceLayerProperties>;
22010pub type PFN_vkEnumerateInstanceExtensionProperties = Option<NonNullPFN_vkEnumerateInstanceExtensionProperties>;
22011pub type PFN_vkEnumerateInstanceLayerProperties = Option<NonNullPFN_vkEnumerateInstanceLayerProperties>;
22012pub type PFN_vkEnumerateInstanceVersion = Option<NonNullPFN_vkEnumerateInstanceVersion>;
22013pub type PFN_vkEnumeratePhysicalDeviceGroups = Option<NonNullPFN_vkEnumeratePhysicalDeviceGroups>;
22014pub type PFN_vkEnumeratePhysicalDeviceGroupsKHR = Option<NonNullPFN_vkEnumeratePhysicalDeviceGroupsKHR>;
22015pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = Option<NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM>;
22016pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = Option<NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR>;
22017pub type PFN_vkEnumeratePhysicalDevices = Option<NonNullPFN_vkEnumeratePhysicalDevices>;
22018pub type PFN_vkFlushMappedMemoryRanges = Option<NonNullPFN_vkFlushMappedMemoryRanges>;
22019pub type PFN_vkFreeCommandBuffers = Option<NonNullPFN_vkFreeCommandBuffers>;
22020pub type PFN_vkFreeDescriptorSets = Option<NonNullPFN_vkFreeDescriptorSets>;
22021pub type PFN_vkFreeFunction = Option<NonNullPFN_vkFreeFunction>;
22022pub type PFN_vkFreeMemory = Option<NonNullPFN_vkFreeMemory>;
22023pub type PFN_vkGetAccelerationStructureBuildSizesKHR = Option<NonNullPFN_vkGetAccelerationStructureBuildSizesKHR>;
22024pub type PFN_vkGetAccelerationStructureDeviceAddressKHR = Option<NonNullPFN_vkGetAccelerationStructureDeviceAddressKHR>;
22025pub type PFN_vkGetAccelerationStructureHandleNV = Option<NonNullPFN_vkGetAccelerationStructureHandleNV>;
22026pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = Option<NonNullPFN_vkGetAccelerationStructureMemoryRequirementsNV>;
22027pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT>;
22028pub type PFN_vkGetBufferDeviceAddress = Option<NonNullPFN_vkGetBufferDeviceAddress>;
22029pub type PFN_vkGetBufferDeviceAddressEXT = Option<NonNullPFN_vkGetBufferDeviceAddressEXT>;
22030pub type PFN_vkGetBufferDeviceAddressKHR = Option<NonNullPFN_vkGetBufferDeviceAddressKHR>;
22031pub type PFN_vkGetBufferMemoryRequirements = Option<NonNullPFN_vkGetBufferMemoryRequirements>;
22032pub type PFN_vkGetBufferMemoryRequirements2 = Option<NonNullPFN_vkGetBufferMemoryRequirements2>;
22033pub type PFN_vkGetBufferMemoryRequirements2KHR = Option<NonNullPFN_vkGetBufferMemoryRequirements2KHR>;
22034pub type PFN_vkGetBufferOpaqueCaptureAddress = Option<NonNullPFN_vkGetBufferOpaqueCaptureAddress>;
22035pub type PFN_vkGetBufferOpaqueCaptureAddressKHR = Option<NonNullPFN_vkGetBufferOpaqueCaptureAddressKHR>;
22036pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetBufferOpaqueCaptureDescriptorDataEXT>;
22037pub type PFN_vkGetCalibratedTimestampsEXT = Option<NonNullPFN_vkGetCalibratedTimestampsEXT>;
22038pub type PFN_vkGetCalibratedTimestampsKHR = Option<NonNullPFN_vkGetCalibratedTimestampsKHR>;
22039pub type PFN_vkGetClusterAccelerationStructureBuildSizesNV = Option<NonNullPFN_vkGetClusterAccelerationStructureBuildSizesNV>;
22040pub type PFN_vkGetDataGraphPipelineAvailablePropertiesARM = Option<NonNullPFN_vkGetDataGraphPipelineAvailablePropertiesARM>;
22041pub type PFN_vkGetDataGraphPipelinePropertiesARM = Option<NonNullPFN_vkGetDataGraphPipelinePropertiesARM>;
22042pub type PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = Option<NonNullPFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM>;
22043pub type PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = Option<NonNullPFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM>;
22044pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = Option<NonNullPFN_vkGetDeferredOperationMaxConcurrencyKHR>;
22045pub type PFN_vkGetDeferredOperationResultKHR = Option<NonNullPFN_vkGetDeferredOperationResultKHR>;
22046pub type PFN_vkGetDescriptorEXT = Option<NonNullPFN_vkGetDescriptorEXT>;
22047pub type PFN_vkGetDescriptorSetHostMappingVALVE = Option<NonNullPFN_vkGetDescriptorSetHostMappingVALVE>;
22048pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = Option<NonNullPFN_vkGetDescriptorSetLayoutBindingOffsetEXT>;
22049pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = Option<NonNullPFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE>;
22050pub type PFN_vkGetDescriptorSetLayoutSizeEXT = Option<NonNullPFN_vkGetDescriptorSetLayoutSizeEXT>;
22051pub type PFN_vkGetDescriptorSetLayoutSupport = Option<NonNullPFN_vkGetDescriptorSetLayoutSupport>;
22052pub type PFN_vkGetDescriptorSetLayoutSupportKHR = Option<NonNullPFN_vkGetDescriptorSetLayoutSupportKHR>;
22053pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = Option<NonNullPFN_vkGetDeviceAccelerationStructureCompatibilityKHR>;
22054pub type PFN_vkGetDeviceBufferMemoryRequirements = Option<NonNullPFN_vkGetDeviceBufferMemoryRequirements>;
22055pub type PFN_vkGetDeviceBufferMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceBufferMemoryRequirementsKHR>;
22056pub type PFN_vkGetDeviceCombinedImageSamplerIndexNVX = Option<NonNullPFN_vkGetDeviceCombinedImageSamplerIndexNVX>;
22057pub type PFN_vkGetDeviceFaultInfoEXT = Option<NonNullPFN_vkGetDeviceFaultInfoEXT>;
22058pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = Option<NonNullPFN_vkGetDeviceGroupPeerMemoryFeatures>;
22059pub type PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = Option<NonNullPFN_vkGetDeviceGroupPeerMemoryFeaturesKHR>;
22060pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = Option<NonNullPFN_vkGetDeviceGroupPresentCapabilitiesKHR>;
22061pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = Option<NonNullPFN_vkGetDeviceGroupSurfacePresentModesKHR>;
22062pub type PFN_vkGetDeviceImageMemoryRequirements = Option<NonNullPFN_vkGetDeviceImageMemoryRequirements>;
22063pub type PFN_vkGetDeviceImageMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceImageMemoryRequirementsKHR>;
22064pub type PFN_vkGetDeviceImageSparseMemoryRequirements = Option<NonNullPFN_vkGetDeviceImageSparseMemoryRequirements>;
22065pub type PFN_vkGetDeviceImageSparseMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceImageSparseMemoryRequirementsKHR>;
22066pub type PFN_vkGetDeviceImageSubresourceLayout = Option<NonNullPFN_vkGetDeviceImageSubresourceLayout>;
22067pub type PFN_vkGetDeviceImageSubresourceLayoutKHR = Option<NonNullPFN_vkGetDeviceImageSubresourceLayoutKHR>;
22068pub type PFN_vkGetDeviceMemoryCommitment = Option<NonNullPFN_vkGetDeviceMemoryCommitment>;
22069pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = Option<NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddress>;
22070pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = Option<NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR>;
22071pub type PFN_vkGetDeviceMicromapCompatibilityEXT = Option<NonNullPFN_vkGetDeviceMicromapCompatibilityEXT>;
22072pub type PFN_vkGetDeviceProcAddr = Option<NonNullPFN_vkGetDeviceProcAddr>;
22073pub type PFN_vkGetDeviceQueue = Option<NonNullPFN_vkGetDeviceQueue>;
22074pub type PFN_vkGetDeviceQueue2 = Option<NonNullPFN_vkGetDeviceQueue2>;
22075pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = Option<NonNullPFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI>;
22076pub type PFN_vkGetDeviceTensorMemoryRequirementsARM = Option<NonNullPFN_vkGetDeviceTensorMemoryRequirementsARM>;
22077pub type PFN_vkGetDisplayModeProperties2KHR = Option<NonNullPFN_vkGetDisplayModeProperties2KHR>;
22078pub type PFN_vkGetDisplayModePropertiesKHR = Option<NonNullPFN_vkGetDisplayModePropertiesKHR>;
22079pub type PFN_vkGetDisplayPlaneCapabilities2KHR = Option<NonNullPFN_vkGetDisplayPlaneCapabilities2KHR>;
22080pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = Option<NonNullPFN_vkGetDisplayPlaneCapabilitiesKHR>;
22081pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = Option<NonNullPFN_vkGetDisplayPlaneSupportedDisplaysKHR>;
22082pub type PFN_vkGetDrmDisplayEXT = Option<NonNullPFN_vkGetDrmDisplayEXT>;
22083pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = Option<NonNullPFN_vkGetDynamicRenderingTilePropertiesQCOM>;
22084pub type PFN_vkGetEncodedVideoSessionParametersKHR = Option<NonNullPFN_vkGetEncodedVideoSessionParametersKHR>;
22085pub type PFN_vkGetEventStatus = Option<NonNullPFN_vkGetEventStatus>;
22086pub type PFN_vkGetExternalComputeQueueDataNV = Option<NonNullPFN_vkGetExternalComputeQueueDataNV>;
22087pub type PFN_vkGetFenceFdKHR = Option<NonNullPFN_vkGetFenceFdKHR>;
22088pub type PFN_vkGetFenceStatus = Option<NonNullPFN_vkGetFenceStatus>;
22089pub type PFN_vkGetFramebufferTilePropertiesQCOM = Option<NonNullPFN_vkGetFramebufferTilePropertiesQCOM>;
22090pub type PFN_vkGetGeneratedCommandsMemoryRequirementsEXT = Option<NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsEXT>;
22091pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = Option<NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsNV>;
22092pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = Option<NonNullPFN_vkGetImageDrmFormatModifierPropertiesEXT>;
22093pub type PFN_vkGetImageMemoryRequirements = Option<NonNullPFN_vkGetImageMemoryRequirements>;
22094pub type PFN_vkGetImageMemoryRequirements2 = Option<NonNullPFN_vkGetImageMemoryRequirements2>;
22095pub type PFN_vkGetImageMemoryRequirements2KHR = Option<NonNullPFN_vkGetImageMemoryRequirements2KHR>;
22096pub type PFN_vkGetImageOpaqueCaptureDataEXT = Option<NonNullPFN_vkGetImageOpaqueCaptureDataEXT>;
22097pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetImageOpaqueCaptureDescriptorDataEXT>;
22098pub type PFN_vkGetImageSparseMemoryRequirements = Option<NonNullPFN_vkGetImageSparseMemoryRequirements>;
22099pub type PFN_vkGetImageSparseMemoryRequirements2 = Option<NonNullPFN_vkGetImageSparseMemoryRequirements2>;
22100pub type PFN_vkGetImageSparseMemoryRequirements2KHR = Option<NonNullPFN_vkGetImageSparseMemoryRequirements2KHR>;
22101pub type PFN_vkGetImageSubresourceLayout = Option<NonNullPFN_vkGetImageSubresourceLayout>;
22102pub type PFN_vkGetImageSubresourceLayout2 = Option<NonNullPFN_vkGetImageSubresourceLayout2>;
22103pub type PFN_vkGetImageSubresourceLayout2EXT = Option<NonNullPFN_vkGetImageSubresourceLayout2EXT>;
22104pub type PFN_vkGetImageSubresourceLayout2KHR = Option<NonNullPFN_vkGetImageSubresourceLayout2KHR>;
22105pub type PFN_vkGetImageViewAddressNVX = Option<NonNullPFN_vkGetImageViewAddressNVX>;
22106pub type PFN_vkGetImageViewHandle64NVX = Option<NonNullPFN_vkGetImageViewHandle64NVX>;
22107pub type PFN_vkGetImageViewHandleNVX = Option<NonNullPFN_vkGetImageViewHandleNVX>;
22108pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT>;
22109pub type PFN_vkGetInstanceProcAddr = Option<NonNullPFN_vkGetInstanceProcAddr>;
22110pub type PFN_vkGetInstanceProcAddrLUNARG = Option<NonNullPFN_vkGetInstanceProcAddrLUNARG>;
22111pub type PFN_vkGetLatencyTimingsNV = Option<NonNullPFN_vkGetLatencyTimingsNV>;
22112pub type PFN_vkGetMemoryFdKHR = Option<NonNullPFN_vkGetMemoryFdKHR>;
22113pub type PFN_vkGetMemoryFdPropertiesKHR = Option<NonNullPFN_vkGetMemoryFdPropertiesKHR>;
22114pub type PFN_vkGetMemoryHostPointerPropertiesEXT = Option<NonNullPFN_vkGetMemoryHostPointerPropertiesEXT>;
22115pub type PFN_vkGetMemoryRemoteAddressNV = Option<NonNullPFN_vkGetMemoryRemoteAddressNV>;
22116pub type PFN_vkGetMicromapBuildSizesEXT = Option<NonNullPFN_vkGetMicromapBuildSizesEXT>;
22117pub type PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = Option<NonNullPFN_vkGetPartitionedAccelerationStructuresBuildSizesNV>;
22118pub type PFN_vkGetPastPresentationTimingEXT = Option<NonNullPFN_vkGetPastPresentationTimingEXT>;
22119pub type PFN_vkGetPastPresentationTimingGOOGLE = Option<NonNullPFN_vkGetPastPresentationTimingGOOGLE>;
22120pub type PFN_vkGetPerformanceParameterINTEL = Option<NonNullPFN_vkGetPerformanceParameterINTEL>;
22121pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = Option<NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT>;
22122pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = Option<NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR>;
22123pub type PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV>;
22124pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR>;
22125pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV>;
22126pub type PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV>;
22127pub type PFN_vkGetPhysicalDeviceDescriptorSizeEXT = Option<NonNullPFN_vkGetPhysicalDeviceDescriptorSizeEXT>;
22128pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR>;
22129pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>;
22130pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayProperties2KHR>;
22131pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPropertiesKHR>;
22132pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalBufferProperties>;
22133pub type PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR>;
22134pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalFenceProperties>;
22135pub type PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalFencePropertiesKHR>;
22136pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV>;
22137pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalSemaphoreProperties>;
22138pub type PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR>;
22139pub type PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceExternalTensorPropertiesARM>;
22140pub type PFN_vkGetPhysicalDeviceFeatures = Option<NonNullPFN_vkGetPhysicalDeviceFeatures>;
22141pub type PFN_vkGetPhysicalDeviceFeatures2 = Option<NonNullPFN_vkGetPhysicalDeviceFeatures2>;
22142pub type PFN_vkGetPhysicalDeviceFeatures2KHR = Option<NonNullPFN_vkGetPhysicalDeviceFeatures2KHR>;
22143pub type PFN_vkGetPhysicalDeviceFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties>;
22144pub type PFN_vkGetPhysicalDeviceFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties2>;
22145pub type PFN_vkGetPhysicalDeviceFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties2KHR>;
22146pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = Option<NonNullPFN_vkGetPhysicalDeviceFragmentShadingRatesKHR>;
22147pub type PFN_vkGetPhysicalDeviceImageFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties>;
22148pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2>;
22149pub type PFN_vkGetPhysicalDeviceImageFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2KHR>;
22150pub type PFN_vkGetPhysicalDeviceMemoryProperties = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties>;
22151pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties2>;
22152pub type PFN_vkGetPhysicalDeviceMemoryProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties2KHR>;
22153pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = Option<NonNullPFN_vkGetPhysicalDeviceMultisamplePropertiesEXT>;
22154pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = Option<NonNullPFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV>;
22155pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = Option<NonNullPFN_vkGetPhysicalDevicePresentRectanglesKHR>;
22156pub type PFN_vkGetPhysicalDeviceProperties = Option<NonNullPFN_vkGetPhysicalDeviceProperties>;
22157pub type PFN_vkGetPhysicalDeviceProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceProperties2>;
22158pub type PFN_vkGetPhysicalDeviceProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceProperties2KHR>;
22159pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM>;
22160pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM>;
22161pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR>;
22162pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties>;
22163pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2>;
22164pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR>;
22165pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties>;
22166pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2>;
22167pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR>;
22168pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = Option<NonNullPFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV>;
22169pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT>;
22170pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR>;
22171pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>;
22172pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceFormats2KHR>;
22173pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceFormatsKHR>;
22174pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfacePresentModesKHR>;
22175pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceSupportKHR>;
22176pub type PFN_vkGetPhysicalDeviceToolProperties = Option<NonNullPFN_vkGetPhysicalDeviceToolProperties>;
22177pub type PFN_vkGetPhysicalDeviceToolPropertiesEXT = Option<NonNullPFN_vkGetPhysicalDeviceToolPropertiesEXT>;
22178pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoCapabilitiesKHR>;
22179pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR>;
22180pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR>;
22181pub type PFN_vkGetPipelineBinaryDataKHR = Option<NonNullPFN_vkGetPipelineBinaryDataKHR>;
22182pub type PFN_vkGetPipelineCacheData = Option<NonNullPFN_vkGetPipelineCacheData>;
22183pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = Option<NonNullPFN_vkGetPipelineExecutableInternalRepresentationsKHR>;
22184pub type PFN_vkGetPipelineExecutablePropertiesKHR = Option<NonNullPFN_vkGetPipelineExecutablePropertiesKHR>;
22185pub type PFN_vkGetPipelineExecutableStatisticsKHR = Option<NonNullPFN_vkGetPipelineExecutableStatisticsKHR>;
22186pub type PFN_vkGetPipelineIndirectDeviceAddressNV = Option<NonNullPFN_vkGetPipelineIndirectDeviceAddressNV>;
22187pub type PFN_vkGetPipelineIndirectMemoryRequirementsNV = Option<NonNullPFN_vkGetPipelineIndirectMemoryRequirementsNV>;
22188pub type PFN_vkGetPipelineKeyKHR = Option<NonNullPFN_vkGetPipelineKeyKHR>;
22189pub type PFN_vkGetPipelinePropertiesEXT = Option<NonNullPFN_vkGetPipelinePropertiesEXT>;
22190pub type PFN_vkGetPrivateData = Option<NonNullPFN_vkGetPrivateData>;
22191pub type PFN_vkGetPrivateDataEXT = Option<NonNullPFN_vkGetPrivateDataEXT>;
22192pub type PFN_vkGetQueryPoolResults = Option<NonNullPFN_vkGetQueryPoolResults>;
22193pub type PFN_vkGetQueueCheckpointData2NV = Option<NonNullPFN_vkGetQueueCheckpointData2NV>;
22194pub type PFN_vkGetQueueCheckpointDataNV = Option<NonNullPFN_vkGetQueueCheckpointDataNV>;
22195pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = Option<NonNullPFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR>;
22196pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = Option<NonNullPFN_vkGetRayTracingShaderGroupHandlesKHR>;
22197pub type PFN_vkGetRayTracingShaderGroupHandlesNV = Option<NonNullPFN_vkGetRayTracingShaderGroupHandlesNV>;
22198pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = Option<NonNullPFN_vkGetRayTracingShaderGroupStackSizeKHR>;
22199pub type PFN_vkGetRefreshCycleDurationGOOGLE = Option<NonNullPFN_vkGetRefreshCycleDurationGOOGLE>;
22200pub type PFN_vkGetRenderAreaGranularity = Option<NonNullPFN_vkGetRenderAreaGranularity>;
22201pub type PFN_vkGetRenderingAreaGranularity = Option<NonNullPFN_vkGetRenderingAreaGranularity>;
22202pub type PFN_vkGetRenderingAreaGranularityKHR = Option<NonNullPFN_vkGetRenderingAreaGranularityKHR>;
22203pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT>;
22204pub type PFN_vkGetSemaphoreCounterValue = Option<NonNullPFN_vkGetSemaphoreCounterValue>;
22205pub type PFN_vkGetSemaphoreCounterValueKHR = Option<NonNullPFN_vkGetSemaphoreCounterValueKHR>;
22206pub type PFN_vkGetSemaphoreFdKHR = Option<NonNullPFN_vkGetSemaphoreFdKHR>;
22207pub type PFN_vkGetShaderBinaryDataEXT = Option<NonNullPFN_vkGetShaderBinaryDataEXT>;
22208pub type PFN_vkGetShaderInfoAMD = Option<NonNullPFN_vkGetShaderInfoAMD>;
22209pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = Option<NonNullPFN_vkGetShaderModuleCreateInfoIdentifierEXT>;
22210pub type PFN_vkGetShaderModuleIdentifierEXT = Option<NonNullPFN_vkGetShaderModuleIdentifierEXT>;
22211pub type PFN_vkGetSwapchainCounterEXT = Option<NonNullPFN_vkGetSwapchainCounterEXT>;
22212pub type PFN_vkGetSwapchainImagesKHR = Option<NonNullPFN_vkGetSwapchainImagesKHR>;
22213pub type PFN_vkGetSwapchainStatusKHR = Option<NonNullPFN_vkGetSwapchainStatusKHR>;
22214pub type PFN_vkGetSwapchainTimeDomainPropertiesEXT = Option<NonNullPFN_vkGetSwapchainTimeDomainPropertiesEXT>;
22215pub type PFN_vkGetSwapchainTimingPropertiesEXT = Option<NonNullPFN_vkGetSwapchainTimingPropertiesEXT>;
22216pub type PFN_vkGetTensorMemoryRequirementsARM = Option<NonNullPFN_vkGetTensorMemoryRequirementsARM>;
22217pub type PFN_vkGetTensorOpaqueCaptureDataARM = Option<NonNullPFN_vkGetTensorOpaqueCaptureDataARM>;
22218pub type PFN_vkGetTensorOpaqueCaptureDescriptorDataARM = Option<NonNullPFN_vkGetTensorOpaqueCaptureDescriptorDataARM>;
22219pub type PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = Option<NonNullPFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM>;
22220pub type PFN_vkGetValidationCacheDataEXT = Option<NonNullPFN_vkGetValidationCacheDataEXT>;
22221pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = Option<NonNullPFN_vkGetVideoSessionMemoryRequirementsKHR>;
22222pub type PFN_vkImportFenceFdKHR = Option<NonNullPFN_vkImportFenceFdKHR>;
22223pub type PFN_vkImportSemaphoreFdKHR = Option<NonNullPFN_vkImportSemaphoreFdKHR>;
22224pub type PFN_vkInitializePerformanceApiINTEL = Option<NonNullPFN_vkInitializePerformanceApiINTEL>;
22225pub type PFN_vkInternalAllocationNotification = Option<NonNullPFN_vkInternalAllocationNotification>;
22226pub type PFN_vkInternalFreeNotification = Option<NonNullPFN_vkInternalFreeNotification>;
22227pub type PFN_vkInvalidateMappedMemoryRanges = Option<NonNullPFN_vkInvalidateMappedMemoryRanges>;
22228pub type PFN_vkLatencySleepNV = Option<NonNullPFN_vkLatencySleepNV>;
22229pub type PFN_vkMapMemory = Option<NonNullPFN_vkMapMemory>;
22230pub type PFN_vkMapMemory2 = Option<NonNullPFN_vkMapMemory2>;
22231pub type PFN_vkMapMemory2KHR = Option<NonNullPFN_vkMapMemory2KHR>;
22232pub type PFN_vkMergePipelineCaches = Option<NonNullPFN_vkMergePipelineCaches>;
22233pub type PFN_vkMergeValidationCachesEXT = Option<NonNullPFN_vkMergeValidationCachesEXT>;
22234pub type PFN_vkQueueBeginDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueBeginDebugUtilsLabelEXT>;
22235pub type PFN_vkQueueBindSparse = Option<NonNullPFN_vkQueueBindSparse>;
22236pub type PFN_vkQueueEndDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueEndDebugUtilsLabelEXT>;
22237pub type PFN_vkQueueInsertDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueInsertDebugUtilsLabelEXT>;
22238pub type PFN_vkQueueNotifyOutOfBandNV = Option<NonNullPFN_vkQueueNotifyOutOfBandNV>;
22239pub type PFN_vkQueuePresentKHR = Option<NonNullPFN_vkQueuePresentKHR>;
22240pub type PFN_vkQueueSetPerformanceConfigurationINTEL = Option<NonNullPFN_vkQueueSetPerformanceConfigurationINTEL>;
22241pub type PFN_vkQueueSubmit = Option<NonNullPFN_vkQueueSubmit>;
22242pub type PFN_vkQueueSubmit2 = Option<NonNullPFN_vkQueueSubmit2>;
22243pub type PFN_vkQueueSubmit2KHR = Option<NonNullPFN_vkQueueSubmit2KHR>;
22244pub type PFN_vkQueueWaitIdle = Option<NonNullPFN_vkQueueWaitIdle>;
22245pub type PFN_vkReallocationFunction = Option<NonNullPFN_vkReallocationFunction>;
22246pub type PFN_vkRegisterCustomBorderColorEXT = Option<NonNullPFN_vkRegisterCustomBorderColorEXT>;
22247pub type PFN_vkRegisterDeviceEventEXT = Option<NonNullPFN_vkRegisterDeviceEventEXT>;
22248pub type PFN_vkRegisterDisplayEventEXT = Option<NonNullPFN_vkRegisterDisplayEventEXT>;
22249pub type PFN_vkReleaseCapturedPipelineDataKHR = Option<NonNullPFN_vkReleaseCapturedPipelineDataKHR>;
22250pub type PFN_vkReleaseDisplayEXT = Option<NonNullPFN_vkReleaseDisplayEXT>;
22251pub type PFN_vkReleasePerformanceConfigurationINTEL = Option<NonNullPFN_vkReleasePerformanceConfigurationINTEL>;
22252pub type PFN_vkReleaseProfilingLockKHR = Option<NonNullPFN_vkReleaseProfilingLockKHR>;
22253pub type PFN_vkReleaseSwapchainImagesEXT = Option<NonNullPFN_vkReleaseSwapchainImagesEXT>;
22254pub type PFN_vkReleaseSwapchainImagesKHR = Option<NonNullPFN_vkReleaseSwapchainImagesKHR>;
22255pub type PFN_vkResetCommandBuffer = Option<NonNullPFN_vkResetCommandBuffer>;
22256pub type PFN_vkResetCommandPool = Option<NonNullPFN_vkResetCommandPool>;
22257pub type PFN_vkResetDescriptorPool = Option<NonNullPFN_vkResetDescriptorPool>;
22258pub type PFN_vkResetEvent = Option<NonNullPFN_vkResetEvent>;
22259pub type PFN_vkResetFences = Option<NonNullPFN_vkResetFences>;
22260pub type PFN_vkResetQueryPool = Option<NonNullPFN_vkResetQueryPool>;
22261pub type PFN_vkResetQueryPoolEXT = Option<NonNullPFN_vkResetQueryPoolEXT>;
22262pub type PFN_vkSetDebugUtilsObjectNameEXT = Option<NonNullPFN_vkSetDebugUtilsObjectNameEXT>;
22263pub type PFN_vkSetDebugUtilsObjectTagEXT = Option<NonNullPFN_vkSetDebugUtilsObjectTagEXT>;
22264pub type PFN_vkSetDeviceMemoryPriorityEXT = Option<NonNullPFN_vkSetDeviceMemoryPriorityEXT>;
22265pub type PFN_vkSetEvent = Option<NonNullPFN_vkSetEvent>;
22266pub type PFN_vkSetHdrMetadataEXT = Option<NonNullPFN_vkSetHdrMetadataEXT>;
22267pub type PFN_vkSetLatencyMarkerNV = Option<NonNullPFN_vkSetLatencyMarkerNV>;
22268pub type PFN_vkSetLatencySleepModeNV = Option<NonNullPFN_vkSetLatencySleepModeNV>;
22269pub type PFN_vkSetLocalDimmingAMD = Option<NonNullPFN_vkSetLocalDimmingAMD>;
22270pub type PFN_vkSetPrivateData = Option<NonNullPFN_vkSetPrivateData>;
22271pub type PFN_vkSetPrivateDataEXT = Option<NonNullPFN_vkSetPrivateDataEXT>;
22272pub type PFN_vkSetSwapchainPresentTimingQueueSizeEXT = Option<NonNullPFN_vkSetSwapchainPresentTimingQueueSizeEXT>;
22273pub type PFN_vkSignalSemaphore = Option<NonNullPFN_vkSignalSemaphore>;
22274pub type PFN_vkSignalSemaphoreKHR = Option<NonNullPFN_vkSignalSemaphoreKHR>;
22275pub type PFN_vkSubmitDebugUtilsMessageEXT = Option<NonNullPFN_vkSubmitDebugUtilsMessageEXT>;
22276pub type PFN_vkTransitionImageLayout = Option<NonNullPFN_vkTransitionImageLayout>;
22277pub type PFN_vkTransitionImageLayoutEXT = Option<NonNullPFN_vkTransitionImageLayoutEXT>;
22278pub type PFN_vkTrimCommandPool = Option<NonNullPFN_vkTrimCommandPool>;
22279pub type PFN_vkTrimCommandPoolKHR = Option<NonNullPFN_vkTrimCommandPoolKHR>;
22280pub type PFN_vkUninitializePerformanceApiINTEL = Option<NonNullPFN_vkUninitializePerformanceApiINTEL>;
22281pub type PFN_vkUnmapMemory = Option<NonNullPFN_vkUnmapMemory>;
22282pub type PFN_vkUnmapMemory2 = Option<NonNullPFN_vkUnmapMemory2>;
22283pub type PFN_vkUnmapMemory2KHR = Option<NonNullPFN_vkUnmapMemory2KHR>;
22284pub type PFN_vkUnregisterCustomBorderColorEXT = Option<NonNullPFN_vkUnregisterCustomBorderColorEXT>;
22285pub type PFN_vkUpdateDescriptorSetWithTemplate = Option<NonNullPFN_vkUpdateDescriptorSetWithTemplate>;
22286pub type PFN_vkUpdateDescriptorSetWithTemplateKHR = Option<NonNullPFN_vkUpdateDescriptorSetWithTemplateKHR>;
22287pub type PFN_vkUpdateDescriptorSets = Option<NonNullPFN_vkUpdateDescriptorSets>;
22288pub type PFN_vkUpdateIndirectExecutionSetPipelineEXT = Option<NonNullPFN_vkUpdateIndirectExecutionSetPipelineEXT>;
22289pub type PFN_vkUpdateIndirectExecutionSetShaderEXT = Option<NonNullPFN_vkUpdateIndirectExecutionSetShaderEXT>;
22290pub type PFN_vkUpdateVideoSessionParametersKHR = Option<NonNullPFN_vkUpdateVideoSessionParametersKHR>;
22291pub type PFN_vkVoidFunction = Option<NonNullPFN_vkVoidFunction>;
22292pub type PFN_vkWaitForFences = Option<NonNullPFN_vkWaitForFences>;
22293pub type PFN_vkWaitForPresent2KHR = Option<NonNullPFN_vkWaitForPresent2KHR>;
22294pub type PFN_vkWaitForPresentKHR = Option<NonNullPFN_vkWaitForPresentKHR>;
22295pub type PFN_vkWaitSemaphores = Option<NonNullPFN_vkWaitSemaphores>;
22296pub type PFN_vkWaitSemaphoresKHR = Option<NonNullPFN_vkWaitSemaphoresKHR>;
22297pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = Option<NonNullPFN_vkWriteAccelerationStructuresPropertiesKHR>;
22298pub type PFN_vkWriteMicromapsPropertiesEXT = Option<NonNullPFN_vkWriteMicromapsPropertiesEXT>;
22299pub type PFN_vkWriteResourceDescriptorsEXT = Option<NonNullPFN_vkWriteResourceDescriptorsEXT>;
22300pub type PFN_vkWriteSamplerDescriptorsEXT = Option<NonNullPFN_vkWriteSamplerDescriptorsEXT>;
22301pub type VkAabbPositionsNV = VkAabbPositionsKHR;
22302pub type VkAccelerationStructureBuildTypeKHR = i32;
22303pub type VkAccelerationStructureCompatibilityKHR = i32;
22304pub type VkAccelerationStructureCreateFlagBitsKHR = VkFlags;
22305pub type VkAccelerationStructureCreateFlagsKHR = VkFlags;
22306pub type VkAccelerationStructureInstanceNV = VkAccelerationStructureInstanceKHR;
22307pub type VkAccelerationStructureKHR = *mut VkAccelerationStructureKHR_T;
22308pub type VkAccelerationStructureMemoryRequirementsTypeNV = i32;
22309pub type VkAccelerationStructureMotionInfoFlagsNV = VkFlags;
22310pub type VkAccelerationStructureMotionInstanceFlagsNV = VkFlags;
22311pub type VkAccelerationStructureMotionInstanceTypeNV = i32;
22312pub type VkAccelerationStructureNV = *mut VkAccelerationStructureNV_T;
22313pub type VkAccelerationStructureTypeKHR = i32;
22314pub type VkAccelerationStructureTypeNV = VkAccelerationStructureTypeKHR;
22315pub type VkAccessFlagBits = VkFlags;
22316pub type VkAccessFlagBits2 = VkFlags64;
22317pub type VkAccessFlagBits2KHR = VkAccessFlagBits2;
22318pub type VkAccessFlagBits3KHR = VkFlags64;
22319pub type VkAccessFlags = VkFlags;
22320pub type VkAccessFlags2 = VkFlags64;
22321pub type VkAccessFlags2KHR = VkAccessFlags2;
22322pub type VkAccessFlags3KHR = VkFlags64;
22323pub type VkAcquireProfilingLockFlagBitsKHR = VkFlags;
22324pub type VkAcquireProfilingLockFlagsKHR = VkFlags;
22325pub type VkAddressCopyFlagBitsKHR = VkFlags;
22326pub type VkAddressCopyFlagsKHR = VkFlags;
22327pub type VkAntiLagModeAMD = i32;
22328pub type VkAntiLagStageAMD = i32;
22329pub type VkAttachmentDescription2KHR = VkAttachmentDescription2;
22330pub type VkAttachmentDescriptionFlagBits = VkFlags;
22331pub type VkAttachmentDescriptionFlags = VkFlags;
22332pub type VkAttachmentDescriptionStencilLayoutKHR = VkAttachmentDescriptionStencilLayout;
22333pub type VkAttachmentLoadOp = i32;
22334pub type VkAttachmentReference2KHR = VkAttachmentReference2;
22335pub type VkAttachmentReferenceStencilLayoutKHR = VkAttachmentReferenceStencilLayout;
22336pub type VkAttachmentSampleCountInfoNV = VkAttachmentSampleCountInfoAMD;
22337pub type VkAttachmentStoreOp = i32;
22338pub type VkBindBufferMemoryDeviceGroupInfoKHR = VkBindBufferMemoryDeviceGroupInfo;
22339pub type VkBindBufferMemoryInfoKHR = VkBindBufferMemoryInfo;
22340pub type VkBindDescriptorSetsInfoKHR = VkBindDescriptorSetsInfo;
22341pub type VkBindImageMemoryDeviceGroupInfoKHR = VkBindImageMemoryDeviceGroupInfo;
22342pub type VkBindImageMemoryInfoKHR = VkBindImageMemoryInfo;
22343pub type VkBindImagePlaneMemoryInfoKHR = VkBindImagePlaneMemoryInfo;
22344pub type VkBindMemoryStatusKHR = VkBindMemoryStatus;
22345pub type VkBlendFactor = i32;
22346pub type VkBlendOp = i32;
22347pub type VkBlendOverlapEXT = i32;
22348pub type VkBlitImageInfo2KHR = VkBlitImageInfo2;
22349pub type VkBlockMatchWindowCompareModeQCOM = i32;
22350pub type VkBool32 = u32;
22351pub type VkBorderColor = i32;
22352pub type VkBuffer = *mut VkBuffer_T;
22353pub type VkBufferCopy2KHR = VkBufferCopy2;
22354pub type VkBufferCreateFlagBits = VkFlags;
22355pub type VkBufferCreateFlags = VkFlags;
22356pub type VkBufferDeviceAddressInfoEXT = VkBufferDeviceAddressInfo;
22357pub type VkBufferDeviceAddressInfoKHR = VkBufferDeviceAddressInfo;
22358pub type VkBufferImageCopy2KHR = VkBufferImageCopy2;
22359pub type VkBufferMemoryBarrier2KHR = VkBufferMemoryBarrier2;
22360pub type VkBufferMemoryRequirementsInfo2KHR = VkBufferMemoryRequirementsInfo2;
22361pub type VkBufferOpaqueCaptureAddressCreateInfoKHR = VkBufferOpaqueCaptureAddressCreateInfo;
22362pub type VkBufferUsageFlagBits = VkFlags;
22363pub type VkBufferUsageFlagBits2 = VkFlags64;
22364pub type VkBufferUsageFlagBits2KHR = VkBufferUsageFlagBits2;
22365pub type VkBufferUsageFlags = VkFlags;
22366pub type VkBufferUsageFlags2 = VkFlags64;
22367pub type VkBufferUsageFlags2CreateInfoKHR = VkBufferUsageFlags2CreateInfo;
22368pub type VkBufferUsageFlags2KHR = VkBufferUsageFlags2;
22369pub type VkBufferView = *mut VkBufferView_T;
22370pub type VkBufferViewCreateFlags = VkFlags;
22371pub type VkBuildAccelerationStructureFlagBitsKHR = VkFlags;
22372pub type VkBuildAccelerationStructureFlagBitsNV = VkBuildAccelerationStructureFlagBitsKHR;
22373pub type VkBuildAccelerationStructureFlagsKHR = VkFlags;
22374pub type VkBuildAccelerationStructureFlagsNV = VkBuildAccelerationStructureFlagsKHR;
22375pub type VkBuildAccelerationStructureModeKHR = i32;
22376pub type VkBuildMicromapFlagBitsEXT = VkFlags;
22377pub type VkBuildMicromapFlagsEXT = VkFlags;
22378pub type VkBuildMicromapModeEXT = i32;
22379pub type VkCalibratedTimestampInfoEXT = VkCalibratedTimestampInfoKHR;
22380pub type VkChromaLocation = i32;
22381pub type VkChromaLocationKHR = VkChromaLocation;
22382pub type VkClusterAccelerationStructureAddressResolutionFlagBitsNV = VkFlags;
22383pub type VkClusterAccelerationStructureAddressResolutionFlagsNV = VkFlags;
22384pub type VkClusterAccelerationStructureClusterFlagBitsNV = VkFlags;
22385pub type VkClusterAccelerationStructureClusterFlagsNV = VkFlags;
22386pub type VkClusterAccelerationStructureGeometryFlagBitsNV = VkFlags;
22387pub type VkClusterAccelerationStructureGeometryFlagsNV = VkFlags;
22388pub type VkClusterAccelerationStructureIndexFormatFlagBitsNV = VkFlags;
22389pub type VkClusterAccelerationStructureIndexFormatFlagsNV = VkFlags;
22390pub type VkClusterAccelerationStructureOpModeNV = i32;
22391pub type VkClusterAccelerationStructureOpTypeNV = i32;
22392pub type VkClusterAccelerationStructureTypeNV = i32;
22393pub type VkCoarseSampleOrderTypeNV = i32;
22394pub type VkColorComponentFlagBits = VkFlags;
22395pub type VkColorComponentFlags = VkFlags;
22396pub type VkColorSpaceKHR = i32;
22397pub type VkCommandBuffer = *mut VkCommandBuffer_T;
22398pub type VkCommandBufferInheritanceRenderingInfoKHR = VkCommandBufferInheritanceRenderingInfo;
22399pub type VkCommandBufferLevel = i32;
22400pub type VkCommandBufferResetFlagBits = VkFlags;
22401pub type VkCommandBufferResetFlags = VkFlags;
22402pub type VkCommandBufferSubmitInfoKHR = VkCommandBufferSubmitInfo;
22403pub type VkCommandBufferUsageFlagBits = VkFlags;
22404pub type VkCommandBufferUsageFlags = VkFlags;
22405pub type VkCommandPool = *mut VkCommandPool_T;
22406pub type VkCommandPoolCreateFlagBits = VkFlags;
22407pub type VkCommandPoolCreateFlags = VkFlags;
22408pub type VkCommandPoolResetFlagBits = VkFlags;
22409pub type VkCommandPoolResetFlags = VkFlags;
22410pub type VkCommandPoolTrimFlags = VkFlags;
22411pub type VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlags;
22412pub type VkCompareOp = i32;
22413pub type VkComponentSwizzle = i32;
22414pub type VkComponentTypeKHR = i32;
22415pub type VkComponentTypeNV = VkComponentTypeKHR;
22416pub type VkCompositeAlphaFlagBitsKHR = VkFlags;
22417pub type VkCompositeAlphaFlagsKHR = VkFlags;
22418pub type VkConditionalRenderingFlagBitsEXT = VkFlags;
22419pub type VkConditionalRenderingFlagsEXT = VkFlags;
22420pub type VkConformanceVersionKHR = VkConformanceVersion;
22421pub type VkConservativeRasterizationModeEXT = i32;
22422pub type VkCooperativeVectorMatrixLayoutNV = i32;
22423pub type VkCopyAccelerationStructureModeKHR = i32;
22424pub type VkCopyAccelerationStructureModeNV = VkCopyAccelerationStructureModeKHR;
22425pub type VkCopyBufferInfo2KHR = VkCopyBufferInfo2;
22426pub type VkCopyBufferToImageInfo2KHR = VkCopyBufferToImageInfo2;
22427pub type VkCopyImageInfo2KHR = VkCopyImageInfo2;
22428pub type VkCopyImageToBufferInfo2KHR = VkCopyImageToBufferInfo2;
22429pub type VkCopyImageToImageInfoEXT = VkCopyImageToImageInfo;
22430pub type VkCopyImageToMemoryInfoEXT = VkCopyImageToMemoryInfo;
22431pub type VkCopyMemoryIndirectCommandNV = VkCopyMemoryIndirectCommandKHR;
22432pub type VkCopyMemoryToImageIndirectCommandNV = VkCopyMemoryToImageIndirectCommandKHR;
22433pub type VkCopyMemoryToImageInfoEXT = VkCopyMemoryToImageInfo;
22434pub type VkCopyMicromapModeEXT = i32;
22435pub type VkCoverageModulationModeNV = i32;
22436pub type VkCoverageReductionModeNV = i32;
22437pub type VkCuFunctionNVX = *mut VkCuFunctionNVX_T;
22438pub type VkCuModuleNVX = *mut VkCuModuleNVX_T;
22439pub type VkCubicFilterWeightsQCOM = i32;
22440pub type VkCullModeFlagBits = VkFlags;
22441pub type VkCullModeFlags = VkFlags;
22442pub type VkDataGraphModelCacheTypeQCOM = i32;
22443pub type VkDataGraphPipelineDispatchFlagBitsARM = VkFlags64;
22444pub type VkDataGraphPipelineDispatchFlagsARM = VkFlags64;
22445pub type VkDataGraphPipelinePropertyARM = i32;
22446pub type VkDataGraphPipelineSessionARM = *mut VkDataGraphPipelineSessionARM_T;
22447pub type VkDataGraphPipelineSessionBindPointARM = i32;
22448pub type VkDataGraphPipelineSessionBindPointTypeARM = i32;
22449pub type VkDataGraphPipelineSessionCreateFlagBitsARM = VkFlags64;
22450pub type VkDataGraphPipelineSessionCreateFlagsARM = VkFlags64;
22451pub type VkDebugReportCallbackEXT = *mut VkDebugReportCallbackEXT_T;
22452pub type VkDebugReportFlagBitsEXT = VkFlags;
22453pub type VkDebugReportFlagsEXT = VkFlags;
22454pub type VkDebugReportObjectTypeEXT = i32;
22455pub type VkDebugUtilsMessageSeverityFlagBitsEXT = VkFlags;
22456pub type VkDebugUtilsMessageSeverityFlagsEXT = VkFlags;
22457pub type VkDebugUtilsMessageTypeFlagBitsEXT = VkFlags;
22458pub type VkDebugUtilsMessageTypeFlagsEXT = VkFlags;
22459pub type VkDebugUtilsMessengerCallbackDataFlagsEXT = VkFlags;
22460pub type VkDebugUtilsMessengerCreateFlagsEXT = VkFlags;
22461pub type VkDebugUtilsMessengerEXT = *mut VkDebugUtilsMessengerEXT_T;
22462pub type VkDefaultVertexAttributeValueKHR = i32;
22463pub type VkDeferredOperationKHR = *mut VkDeferredOperationKHR_T;
22464pub type VkDependencyFlagBits = VkFlags;
22465pub type VkDependencyFlags = VkFlags;
22466pub type VkDependencyInfoKHR = VkDependencyInfo;
22467pub type VkDepthBiasRepresentationEXT = i32;
22468pub type VkDepthClampModeEXT = i32;
22469pub type VkDescriptorBindingFlagBits = VkFlags;
22470pub type VkDescriptorBindingFlagBitsEXT = VkDescriptorBindingFlagBits;
22471pub type VkDescriptorBindingFlags = VkFlags;
22472pub type VkDescriptorBindingFlagsEXT = VkDescriptorBindingFlags;
22473pub type VkDescriptorMappingSourceEXT = i32;
22474pub type VkDescriptorPool = *mut VkDescriptorPool_T;
22475pub type VkDescriptorPoolCreateFlagBits = VkFlags;
22476pub type VkDescriptorPoolCreateFlags = VkFlags;
22477pub type VkDescriptorPoolInlineUniformBlockCreateInfoEXT = VkDescriptorPoolInlineUniformBlockCreateInfo;
22478pub type VkDescriptorPoolResetFlags = VkFlags;
22479pub type VkDescriptorSet = *mut VkDescriptorSet_T;
22480pub type VkDescriptorSetLayout = *mut VkDescriptorSetLayout_T;
22481pub type VkDescriptorSetLayoutBindingFlagsCreateInfoEXT = VkDescriptorSetLayoutBindingFlagsCreateInfo;
22482pub type VkDescriptorSetLayoutCreateFlagBits = VkFlags;
22483pub type VkDescriptorSetLayoutCreateFlags = VkFlags;
22484pub type VkDescriptorSetLayoutSupportKHR = VkDescriptorSetLayoutSupport;
22485pub type VkDescriptorSetVariableDescriptorCountAllocateInfoEXT = VkDescriptorSetVariableDescriptorCountAllocateInfo;
22486pub type VkDescriptorSetVariableDescriptorCountLayoutSupportEXT = VkDescriptorSetVariableDescriptorCountLayoutSupport;
22487pub type VkDescriptorType = i32;
22488pub type VkDescriptorUpdateTemplate = *mut VkDescriptorUpdateTemplate_T;
22489pub type VkDescriptorUpdateTemplateCreateFlags = VkFlags;
22490pub type VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlags;
22491pub type VkDescriptorUpdateTemplateCreateInfoKHR = VkDescriptorUpdateTemplateCreateInfo;
22492pub type VkDescriptorUpdateTemplateEntryKHR = VkDescriptorUpdateTemplateEntry;
22493pub type VkDescriptorUpdateTemplateKHR = *mut VkDescriptorUpdateTemplateKHR_T;
22494pub type VkDescriptorUpdateTemplateKHR_T = VkDescriptorUpdateTemplate_T;
22495pub type VkDescriptorUpdateTemplateType = i32;
22496pub type VkDescriptorUpdateTemplateTypeKHR = VkDescriptorUpdateTemplateType;
22497pub type VkDevice = *mut VkDevice_T;
22498pub type VkDeviceAddress = u64;
22499pub type VkDeviceAddressBindingFlagBitsEXT = VkFlags;
22500pub type VkDeviceAddressBindingFlagsEXT = VkFlags;
22501pub type VkDeviceAddressBindingTypeEXT = i32;
22502pub type VkDeviceBufferMemoryRequirementsKHR = VkDeviceBufferMemoryRequirements;
22503pub type VkDeviceCreateFlags = VkFlags;
22504pub type VkDeviceDiagnosticsConfigFlagBitsNV = VkFlags;
22505pub type VkDeviceDiagnosticsConfigFlagsNV = VkFlags;
22506pub type VkDeviceEventTypeEXT = i32;
22507pub type VkDeviceFaultAddressTypeEXT = i32;
22508pub type VkDeviceFaultVendorBinaryHeaderVersionEXT = i32;
22509pub type VkDeviceGroupBindSparseInfoKHR = VkDeviceGroupBindSparseInfo;
22510pub type VkDeviceGroupCommandBufferBeginInfoKHR = VkDeviceGroupCommandBufferBeginInfo;
22511pub type VkDeviceGroupDeviceCreateInfoKHR = VkDeviceGroupDeviceCreateInfo;
22512pub type VkDeviceGroupPresentModeFlagBitsKHR = VkFlags;
22513pub type VkDeviceGroupPresentModeFlagsKHR = VkFlags;
22514pub type VkDeviceGroupRenderPassBeginInfoKHR = VkDeviceGroupRenderPassBeginInfo;
22515pub type VkDeviceGroupSubmitInfoKHR = VkDeviceGroupSubmitInfo;
22516pub type VkDeviceImageMemoryRequirementsKHR = VkDeviceImageMemoryRequirements;
22517pub type VkDeviceImageSubresourceInfoKHR = VkDeviceImageSubresourceInfo;
22518pub type VkDeviceMemory = *mut VkDeviceMemory_T;
22519pub type VkDeviceMemoryOpaqueCaptureAddressInfoKHR = VkDeviceMemoryOpaqueCaptureAddressInfo;
22520pub type VkDeviceMemoryReportEventTypeEXT = i32;
22521pub type VkDeviceMemoryReportFlagsEXT = VkFlags;
22522pub type VkDevicePrivateDataCreateInfoEXT = VkDevicePrivateDataCreateInfo;
22523pub type VkDeviceQueueCreateFlagBits = VkFlags;
22524pub type VkDeviceQueueCreateFlags = VkFlags;
22525pub type VkDeviceQueueGlobalPriorityCreateInfoEXT = VkDeviceQueueGlobalPriorityCreateInfo;
22526pub type VkDeviceQueueGlobalPriorityCreateInfoKHR = VkDeviceQueueGlobalPriorityCreateInfo;
22527pub type VkDeviceSize = u64;
22528pub type VkDirectDriverLoadingFlagsLUNARG = VkFlags;
22529pub type VkDirectDriverLoadingModeLUNARG = i32;
22530pub type VkDiscardRectangleModeEXT = i32;
22531pub type VkDisplayEventTypeEXT = i32;
22532pub type VkDisplayKHR = *mut VkDisplayKHR_T;
22533pub type VkDisplayModeCreateFlagsKHR = VkFlags;
22534pub type VkDisplayModeKHR = *mut VkDisplayModeKHR_T;
22535pub type VkDisplayPlaneAlphaFlagBitsKHR = VkFlags;
22536pub type VkDisplayPlaneAlphaFlagsKHR = VkFlags;
22537pub type VkDisplayPowerStateEXT = i32;
22538pub type VkDisplaySurfaceCreateFlagsKHR = VkFlags;
22539pub type VkDisplaySurfaceStereoTypeNV = i32;
22540pub type VkDriverId = i32;
22541pub type VkDriverIdKHR = VkDriverId;
22542pub type VkDynamicState = i32;
22543pub type VkEvent = *mut VkEvent_T;
22544pub type VkEventCreateFlagBits = VkFlags;
22545pub type VkEventCreateFlags = VkFlags;
22546pub type VkExportFenceCreateInfoKHR = VkExportFenceCreateInfo;
22547pub type VkExportMemoryAllocateInfoKHR = VkExportMemoryAllocateInfo;
22548pub type VkExportSemaphoreCreateInfoKHR = VkExportSemaphoreCreateInfo;
22549pub type VkExternalBufferPropertiesKHR = VkExternalBufferProperties;
22550pub type VkExternalComputeQueueNV = *mut VkExternalComputeQueueNV_T;
22551pub type VkExternalFenceFeatureFlagBits = VkFlags;
22552pub type VkExternalFenceFeatureFlagBitsKHR = VkExternalFenceFeatureFlagBits;
22553pub type VkExternalFenceFeatureFlags = VkFlags;
22554pub type VkExternalFenceFeatureFlagsKHR = VkExternalFenceFeatureFlags;
22555pub type VkExternalFenceHandleTypeFlagBits = VkFlags;
22556pub type VkExternalFenceHandleTypeFlagBitsKHR = VkExternalFenceHandleTypeFlagBits;
22557pub type VkExternalFenceHandleTypeFlags = VkFlags;
22558pub type VkExternalFenceHandleTypeFlagsKHR = VkExternalFenceHandleTypeFlags;
22559pub type VkExternalFencePropertiesKHR = VkExternalFenceProperties;
22560pub type VkExternalImageFormatPropertiesKHR = VkExternalImageFormatProperties;
22561pub type VkExternalMemoryBufferCreateInfoKHR = VkExternalMemoryBufferCreateInfo;
22562pub type VkExternalMemoryFeatureFlagBits = VkFlags;
22563pub type VkExternalMemoryFeatureFlagBitsKHR = VkExternalMemoryFeatureFlagBits;
22564pub type VkExternalMemoryFeatureFlagBitsNV = VkFlags;
22565pub type VkExternalMemoryFeatureFlags = VkFlags;
22566pub type VkExternalMemoryFeatureFlagsKHR = VkExternalMemoryFeatureFlags;
22567pub type VkExternalMemoryFeatureFlagsNV = VkFlags;
22568pub type VkExternalMemoryHandleTypeFlagBits = VkFlags;
22569pub type VkExternalMemoryHandleTypeFlagBitsKHR = VkExternalMemoryHandleTypeFlagBits;
22570pub type VkExternalMemoryHandleTypeFlagBitsNV = VkFlags;
22571pub type VkExternalMemoryHandleTypeFlags = VkFlags;
22572pub type VkExternalMemoryHandleTypeFlagsKHR = VkExternalMemoryHandleTypeFlags;
22573pub type VkExternalMemoryHandleTypeFlagsNV = VkFlags;
22574pub type VkExternalMemoryImageCreateInfoKHR = VkExternalMemoryImageCreateInfo;
22575pub type VkExternalMemoryPropertiesKHR = VkExternalMemoryProperties;
22576pub type VkExternalSemaphoreFeatureFlagBits = VkFlags;
22577pub type VkExternalSemaphoreFeatureFlagBitsKHR = VkExternalSemaphoreFeatureFlagBits;
22578pub type VkExternalSemaphoreFeatureFlags = VkFlags;
22579pub type VkExternalSemaphoreFeatureFlagsKHR = VkExternalSemaphoreFeatureFlags;
22580pub type VkExternalSemaphoreHandleTypeFlagBits = VkFlags;
22581pub type VkExternalSemaphoreHandleTypeFlagBitsKHR = VkExternalSemaphoreHandleTypeFlagBits;
22582pub type VkExternalSemaphoreHandleTypeFlags = VkFlags;
22583pub type VkExternalSemaphoreHandleTypeFlagsKHR = VkExternalSemaphoreHandleTypeFlags;
22584pub type VkExternalSemaphorePropertiesKHR = VkExternalSemaphoreProperties;
22585pub type VkFence = *mut VkFence_T;
22586pub type VkFenceCreateFlagBits = VkFlags;
22587pub type VkFenceCreateFlags = VkFlags;
22588pub type VkFenceImportFlagBits = VkFlags;
22589pub type VkFenceImportFlagBitsKHR = VkFenceImportFlagBits;
22590pub type VkFenceImportFlags = VkFlags;
22591pub type VkFenceImportFlagsKHR = VkFenceImportFlags;
22592pub type VkFilter = i32;
22593pub type VkFlags = u32;
22594pub type VkFlags64 = u64;
22595pub type VkFormat = i32;
22596pub type VkFormatFeatureFlagBits = VkFlags;
22597pub type VkFormatFeatureFlagBits2 = VkFlags64;
22598pub type VkFormatFeatureFlagBits2KHR = VkFormatFeatureFlagBits2;
22599pub type VkFormatFeatureFlags = VkFlags;
22600pub type VkFormatFeatureFlags2 = VkFlags64;
22601pub type VkFormatFeatureFlags2KHR = VkFormatFeatureFlags2;
22602pub type VkFormatProperties2KHR = VkFormatProperties2;
22603pub type VkFormatProperties3KHR = VkFormatProperties3;
22604pub type VkFragmentShadingRateCombinerOpKHR = i32;
22605pub type VkFragmentShadingRateNV = i32;
22606pub type VkFragmentShadingRateTypeNV = i32;
22607pub type VkFrameBoundaryFlagBitsEXT = VkFlags;
22608pub type VkFrameBoundaryFlagsEXT = VkFlags;
22609pub type VkFramebuffer = *mut VkFramebuffer_T;
22610pub type VkFramebufferAttachmentImageInfoKHR = VkFramebufferAttachmentImageInfo;
22611pub type VkFramebufferAttachmentsCreateInfoKHR = VkFramebufferAttachmentsCreateInfo;
22612pub type VkFramebufferCreateFlagBits = VkFlags;
22613pub type VkFramebufferCreateFlags = VkFlags;
22614pub type VkFrontFace = i32;
22615pub type VkGeometryFlagBitsKHR = VkFlags;
22616pub type VkGeometryFlagBitsNV = VkGeometryFlagBitsKHR;
22617pub type VkGeometryFlagsKHR = VkFlags;
22618pub type VkGeometryFlagsNV = VkGeometryFlagsKHR;
22619pub type VkGeometryInstanceFlagBitsKHR = VkFlags;
22620pub type VkGeometryInstanceFlagBitsNV = VkGeometryInstanceFlagBitsKHR;
22621pub type VkGeometryInstanceFlagsKHR = VkFlags;
22622pub type VkGeometryInstanceFlagsNV = VkGeometryInstanceFlagsKHR;
22623pub type VkGeometryTypeKHR = i32;
22624pub type VkGeometryTypeNV = VkGeometryTypeKHR;
22625pub type VkGraphicsPipelineLibraryFlagBitsEXT = VkFlags;
22626pub type VkGraphicsPipelineLibraryFlagsEXT = VkFlags;
22627pub type VkHeadlessSurfaceCreateFlagsEXT = VkFlags;
22628pub type VkHostImageCopyDevicePerformanceQueryEXT = VkHostImageCopyDevicePerformanceQuery;
22629pub type VkHostImageCopyFlagBits = VkFlags;
22630pub type VkHostImageCopyFlagBitsEXT = VkHostImageCopyFlagBits;
22631pub type VkHostImageCopyFlags = VkFlags;
22632pub type VkHostImageCopyFlagsEXT = VkHostImageCopyFlags;
22633pub type VkHostImageLayoutTransitionInfoEXT = VkHostImageLayoutTransitionInfo;
22634pub type VkImage = *mut VkImage_T;
22635pub type VkImageAspectFlagBits = VkFlags;
22636pub type VkImageAspectFlags = VkFlags;
22637pub type VkImageBlit2KHR = VkImageBlit2;
22638pub type VkImageCompressionFixedRateFlagBitsEXT = VkFlags;
22639pub type VkImageCompressionFixedRateFlagsEXT = VkFlags;
22640pub type VkImageCompressionFlagBitsEXT = VkFlags;
22641pub type VkImageCompressionFlagsEXT = VkFlags;
22642pub type VkImageCopy2KHR = VkImageCopy2;
22643pub type VkImageCreateFlagBits = VkFlags;
22644pub type VkImageCreateFlags = VkFlags;
22645pub type VkImageFormatListCreateInfoKHR = VkImageFormatListCreateInfo;
22646pub type VkImageFormatProperties2KHR = VkImageFormatProperties2;
22647pub type VkImageLayout = i32;
22648pub type VkImageMemoryBarrier2KHR = VkImageMemoryBarrier2;
22649pub type VkImageMemoryRequirementsInfo2KHR = VkImageMemoryRequirementsInfo2;
22650pub type VkImagePlaneMemoryRequirementsInfoKHR = VkImagePlaneMemoryRequirementsInfo;
22651pub type VkImageResolve2KHR = VkImageResolve2;
22652pub type VkImageSparseMemoryRequirementsInfo2KHR = VkImageSparseMemoryRequirementsInfo2;
22653pub type VkImageStencilUsageCreateInfoEXT = VkImageStencilUsageCreateInfo;
22654pub type VkImageSubresource2EXT = VkImageSubresource2;
22655pub type VkImageSubresource2KHR = VkImageSubresource2;
22656pub type VkImageTiling = i32;
22657pub type VkImageToMemoryCopyEXT = VkImageToMemoryCopy;
22658pub type VkImageType = i32;
22659pub type VkImageUsageFlagBits = VkFlags;
22660pub type VkImageUsageFlags = VkFlags;
22661pub type VkImageView = *mut VkImageView_T;
22662pub type VkImageViewCreateFlagBits = VkFlags;
22663pub type VkImageViewCreateFlags = VkFlags;
22664pub type VkImageViewType = i32;
22665pub type VkImageViewUsageCreateInfoKHR = VkImageViewUsageCreateInfo;
22666pub type VkIndexType = i32;
22667pub type VkIndirectCommandsInputModeFlagBitsEXT = VkFlags;
22668pub type VkIndirectCommandsInputModeFlagsEXT = VkFlags;
22669pub type VkIndirectCommandsLayoutEXT = *mut VkIndirectCommandsLayoutEXT_T;
22670pub type VkIndirectCommandsLayoutNV = *mut VkIndirectCommandsLayoutNV_T;
22671pub type VkIndirectCommandsLayoutUsageFlagBitsEXT = VkFlags;
22672pub type VkIndirectCommandsLayoutUsageFlagBitsNV = VkFlags;
22673pub type VkIndirectCommandsLayoutUsageFlagsEXT = VkFlags;
22674pub type VkIndirectCommandsLayoutUsageFlagsNV = VkFlags;
22675pub type VkIndirectCommandsTokenTypeEXT = i32;
22676pub type VkIndirectCommandsTokenTypeNV = i32;
22677pub type VkIndirectExecutionSetEXT = *mut VkIndirectExecutionSetEXT_T;
22678pub type VkIndirectExecutionSetInfoTypeEXT = i32;
22679pub type VkIndirectStateFlagBitsNV = VkFlags;
22680pub type VkIndirectStateFlagsNV = VkFlags;
22681pub type VkInputAttachmentAspectReferenceKHR = VkInputAttachmentAspectReference;
22682pub type VkInstance = *mut VkInstance_T;
22683pub type VkInstanceCreateFlagBits = VkFlags;
22684pub type VkInstanceCreateFlags = VkFlags;
22685pub type VkInternalAllocationType = i32;
22686pub type VkLatencyMarkerNV = i32;
22687pub type VkLayerSettingTypeEXT = i32;
22688pub type VkLayeredDriverUnderlyingApiMSFT = i32;
22689pub type VkLineRasterizationMode = i32;
22690pub type VkLineRasterizationModeEXT = VkLineRasterizationMode;
22691pub type VkLineRasterizationModeKHR = VkLineRasterizationMode;
22692pub type VkLogicOp = i32;
22693pub type VkMemoryAllocateFlagBits = VkFlags;
22694pub type VkMemoryAllocateFlagBitsKHR = VkMemoryAllocateFlagBits;
22695pub type VkMemoryAllocateFlags = VkFlags;
22696pub type VkMemoryAllocateFlagsInfoKHR = VkMemoryAllocateFlagsInfo;
22697pub type VkMemoryAllocateFlagsKHR = VkMemoryAllocateFlags;
22698pub type VkMemoryBarrier2KHR = VkMemoryBarrier2;
22699pub type VkMemoryDecompressionMethodFlagBitsEXT = VkFlags64;
22700pub type VkMemoryDecompressionMethodFlagBitsNV = VkMemoryDecompressionMethodFlagBitsEXT;
22701pub type VkMemoryDecompressionMethodFlagsEXT = VkFlags64;
22702pub type VkMemoryDecompressionMethodFlagsNV = VkMemoryDecompressionMethodFlagsEXT;
22703pub type VkMemoryDedicatedAllocateInfoKHR = VkMemoryDedicatedAllocateInfo;
22704pub type VkMemoryDedicatedRequirementsKHR = VkMemoryDedicatedRequirements;
22705pub type VkMemoryHeapFlagBits = VkFlags;
22706pub type VkMemoryHeapFlags = VkFlags;
22707pub type VkMemoryMapFlagBits = VkFlags;
22708pub type VkMemoryMapFlags = VkFlags;
22709pub type VkMemoryMapInfoKHR = VkMemoryMapInfo;
22710pub type VkMemoryOpaqueCaptureAddressAllocateInfoKHR = VkMemoryOpaqueCaptureAddressAllocateInfo;
22711pub type VkMemoryOverallocationBehaviorAMD = i32;
22712pub type VkMemoryPropertyFlagBits = VkFlags;
22713pub type VkMemoryPropertyFlags = VkFlags;
22714pub type VkMemoryRequirements2KHR = VkMemoryRequirements2;
22715pub type VkMemoryToImageCopyEXT = VkMemoryToImageCopy;
22716pub type VkMemoryUnmapFlagBits = VkFlags;
22717pub type VkMemoryUnmapFlagBitsKHR = VkMemoryUnmapFlagBits;
22718pub type VkMemoryUnmapFlags = VkFlags;
22719pub type VkMemoryUnmapFlagsKHR = VkMemoryUnmapFlags;
22720pub type VkMemoryUnmapInfoKHR = VkMemoryUnmapInfo;
22721pub type VkMicromapCreateFlagBitsEXT = VkFlags;
22722pub type VkMicromapCreateFlagsEXT = VkFlags;
22723pub type VkMicromapEXT = *mut VkMicromapEXT_T;
22724pub type VkMicromapTypeEXT = i32;
22725pub type VkMutableDescriptorTypeCreateInfoVALVE = VkMutableDescriptorTypeCreateInfoEXT;
22726pub type VkMutableDescriptorTypeListVALVE = VkMutableDescriptorTypeListEXT;
22727pub type VkObjectType = i32;
22728pub type VkOpacityMicromapFormatEXT = i32;
22729pub type VkOpacityMicromapSpecialIndexEXT = i32;
22730pub type VkOpticalFlowExecuteFlagBitsNV = VkFlags;
22731pub type VkOpticalFlowExecuteFlagsNV = VkFlags;
22732pub type VkOpticalFlowGridSizeFlagBitsNV = VkFlags;
22733pub type VkOpticalFlowGridSizeFlagsNV = VkFlags;
22734pub type VkOpticalFlowPerformanceLevelNV = i32;
22735pub type VkOpticalFlowSessionBindingPointNV = i32;
22736pub type VkOpticalFlowSessionCreateFlagBitsNV = VkFlags;
22737pub type VkOpticalFlowSessionCreateFlagsNV = VkFlags;
22738pub type VkOpticalFlowSessionNV = *mut VkOpticalFlowSessionNV_T;
22739pub type VkOpticalFlowUsageFlagBitsNV = VkFlags;
22740pub type VkOpticalFlowUsageFlagsNV = VkFlags;
22741pub type VkOutOfBandQueueTypeNV = i32;
22742pub type VkPartitionedAccelerationStructureInstanceFlagBitsNV = VkFlags;
22743pub type VkPartitionedAccelerationStructureInstanceFlagsNV = VkFlags;
22744pub type VkPartitionedAccelerationStructureOpTypeNV = i32;
22745pub type VkPastPresentationTimingFlagBitsEXT = VkFlags;
22746pub type VkPastPresentationTimingFlagsEXT = VkFlags;
22747pub type VkPeerMemoryFeatureFlagBits = VkFlags;
22748pub type VkPeerMemoryFeatureFlagBitsKHR = VkPeerMemoryFeatureFlagBits;
22749pub type VkPeerMemoryFeatureFlags = VkFlags;
22750pub type VkPeerMemoryFeatureFlagsKHR = VkPeerMemoryFeatureFlags;
22751pub type VkPerformanceConfigurationINTEL = *mut VkPerformanceConfigurationINTEL_T;
22752pub type VkPerformanceConfigurationTypeINTEL = i32;
22753pub type VkPerformanceCounterDescriptionFlagBitsKHR = VkFlags;
22754pub type VkPerformanceCounterDescriptionFlagsARM = VkFlags;
22755pub type VkPerformanceCounterDescriptionFlagsKHR = VkFlags;
22756pub type VkPerformanceCounterScopeKHR = i32;
22757pub type VkPerformanceCounterStorageKHR = i32;
22758pub type VkPerformanceCounterUnitKHR = i32;
22759pub type VkPerformanceOverrideTypeINTEL = i32;
22760pub type VkPerformanceParameterTypeINTEL = i32;
22761pub type VkPerformanceValueTypeINTEL = i32;
22762pub type VkPhysicalDevice = *mut VkPhysicalDevice_T;
22763pub type VkPhysicalDevice16BitStorageFeaturesKHR = VkPhysicalDevice16BitStorageFeatures;
22764pub type VkPhysicalDevice8BitStorageFeaturesKHR = VkPhysicalDevice8BitStorageFeatures;
22765pub type VkPhysicalDeviceBufferAddressFeaturesEXT = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
22766pub type VkPhysicalDeviceBufferDeviceAddressFeaturesKHR = VkPhysicalDeviceBufferDeviceAddressFeatures;
22767pub type VkPhysicalDeviceComputeShaderDerivativesFeaturesNV = VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR;
22768pub type VkPhysicalDeviceCopyMemoryIndirectPropertiesNV = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR;
22769pub type VkPhysicalDeviceDataGraphOperationTypeARM = i32;
22770pub type VkPhysicalDeviceDataGraphProcessingEngineTypeARM = i32;
22771pub type VkPhysicalDeviceDepthClampZeroOneFeaturesEXT = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR;
22772pub type VkPhysicalDeviceDepthStencilResolvePropertiesKHR = VkPhysicalDeviceDepthStencilResolveProperties;
22773pub type VkPhysicalDeviceDescriptorIndexingFeaturesEXT = VkPhysicalDeviceDescriptorIndexingFeatures;
22774pub type VkPhysicalDeviceDescriptorIndexingPropertiesEXT = VkPhysicalDeviceDescriptorIndexingProperties;
22775pub type VkPhysicalDeviceDriverPropertiesKHR = VkPhysicalDeviceDriverProperties;
22776pub type VkPhysicalDeviceDynamicRenderingFeaturesKHR = VkPhysicalDeviceDynamicRenderingFeatures;
22777pub type VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = VkPhysicalDeviceDynamicRenderingLocalReadFeatures;
22778pub type VkPhysicalDeviceExternalBufferInfoKHR = VkPhysicalDeviceExternalBufferInfo;
22779pub type VkPhysicalDeviceExternalFenceInfoKHR = VkPhysicalDeviceExternalFenceInfo;
22780pub type VkPhysicalDeviceExternalImageFormatInfoKHR = VkPhysicalDeviceExternalImageFormatInfo;
22781pub type VkPhysicalDeviceExternalSemaphoreInfoKHR = VkPhysicalDeviceExternalSemaphoreInfo;
22782pub type VkPhysicalDeviceFeatures2KHR = VkPhysicalDeviceFeatures2;
22783pub type VkPhysicalDeviceFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;
22784pub type VkPhysicalDeviceFloatControlsPropertiesKHR = VkPhysicalDeviceFloatControlsProperties;
22785pub type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
22786pub type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
22787pub type VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV = VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
22788pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT = VkPhysicalDeviceGlobalPriorityQueryFeatures;
22789pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR = VkPhysicalDeviceGlobalPriorityQueryFeatures;
22790pub type VkPhysicalDeviceGroupPropertiesKHR = VkPhysicalDeviceGroupProperties;
22791pub type VkPhysicalDeviceHostImageCopyFeaturesEXT = VkPhysicalDeviceHostImageCopyFeatures;
22792pub type VkPhysicalDeviceHostImageCopyPropertiesEXT = VkPhysicalDeviceHostImageCopyProperties;
22793pub type VkPhysicalDeviceHostQueryResetFeaturesEXT = VkPhysicalDeviceHostQueryResetFeatures;
22794pub type VkPhysicalDeviceIDPropertiesKHR = VkPhysicalDeviceIDProperties;
22795pub type VkPhysicalDeviceImageFormatInfo2KHR = VkPhysicalDeviceImageFormatInfo2;
22796pub type VkPhysicalDeviceImageRobustnessFeaturesEXT = VkPhysicalDeviceImageRobustnessFeatures;
22797pub type VkPhysicalDeviceImagelessFramebufferFeaturesKHR = VkPhysicalDeviceImagelessFramebufferFeatures;
22798pub type VkPhysicalDeviceIndexTypeUint8FeaturesEXT = VkPhysicalDeviceIndexTypeUint8Features;
22799pub type VkPhysicalDeviceIndexTypeUint8FeaturesKHR = VkPhysicalDeviceIndexTypeUint8Features;
22800pub type VkPhysicalDeviceInlineUniformBlockFeaturesEXT = VkPhysicalDeviceInlineUniformBlockFeatures;
22801pub type VkPhysicalDeviceInlineUniformBlockPropertiesEXT = VkPhysicalDeviceInlineUniformBlockProperties;
22802pub type VkPhysicalDeviceLayeredApiKHR = i32;
22803pub type VkPhysicalDeviceLineRasterizationFeaturesEXT = VkPhysicalDeviceLineRasterizationFeatures;
22804pub type VkPhysicalDeviceLineRasterizationFeaturesKHR = VkPhysicalDeviceLineRasterizationFeatures;
22805pub type VkPhysicalDeviceLineRasterizationPropertiesEXT = VkPhysicalDeviceLineRasterizationProperties;
22806pub type VkPhysicalDeviceLineRasterizationPropertiesKHR = VkPhysicalDeviceLineRasterizationProperties;
22807pub type VkPhysicalDeviceMaintenance3PropertiesKHR = VkPhysicalDeviceMaintenance3Properties;
22808pub type VkPhysicalDeviceMaintenance4FeaturesKHR = VkPhysicalDeviceMaintenance4Features;
22809pub type VkPhysicalDeviceMaintenance4PropertiesKHR = VkPhysicalDeviceMaintenance4Properties;
22810pub type VkPhysicalDeviceMaintenance5FeaturesKHR = VkPhysicalDeviceMaintenance5Features;
22811pub type VkPhysicalDeviceMaintenance5PropertiesKHR = VkPhysicalDeviceMaintenance5Properties;
22812pub type VkPhysicalDeviceMaintenance6FeaturesKHR = VkPhysicalDeviceMaintenance6Features;
22813pub type VkPhysicalDeviceMaintenance6PropertiesKHR = VkPhysicalDeviceMaintenance6Properties;
22814pub type VkPhysicalDeviceMemoryDecompressionFeaturesNV = VkPhysicalDeviceMemoryDecompressionFeaturesEXT;
22815pub type VkPhysicalDeviceMemoryDecompressionPropertiesNV = VkPhysicalDeviceMemoryDecompressionPropertiesEXT;
22816pub type VkPhysicalDeviceMemoryProperties2KHR = VkPhysicalDeviceMemoryProperties2;
22817pub type VkPhysicalDeviceMultiviewFeaturesKHR = VkPhysicalDeviceMultiviewFeatures;
22818pub type VkPhysicalDeviceMultiviewPropertiesKHR = VkPhysicalDeviceMultiviewProperties;
22819pub type VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT;
22820pub type VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT = VkPhysicalDevicePipelineCreationCacheControlFeatures;
22821pub type VkPhysicalDevicePipelineProtectedAccessFeaturesEXT = VkPhysicalDevicePipelineProtectedAccessFeatures;
22822pub type VkPhysicalDevicePipelineRobustnessFeaturesEXT = VkPhysicalDevicePipelineRobustnessFeatures;
22823pub type VkPhysicalDevicePipelineRobustnessPropertiesEXT = VkPhysicalDevicePipelineRobustnessProperties;
22824pub type VkPhysicalDevicePointClippingPropertiesKHR = VkPhysicalDevicePointClippingProperties;
22825pub type VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
22826pub type VkPhysicalDevicePrivateDataFeaturesEXT = VkPhysicalDevicePrivateDataFeatures;
22827pub type VkPhysicalDeviceProperties2KHR = VkPhysicalDeviceProperties2;
22828pub type VkPhysicalDevicePushDescriptorPropertiesKHR = VkPhysicalDevicePushDescriptorProperties;
22829pub type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
22830pub type VkPhysicalDeviceRobustness2FeaturesEXT = VkPhysicalDeviceRobustness2FeaturesKHR;
22831pub type VkPhysicalDeviceRobustness2PropertiesEXT = VkPhysicalDeviceRobustness2PropertiesKHR;
22832pub type VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VkPhysicalDeviceSamplerFilterMinmaxProperties;
22833pub type VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VkPhysicalDeviceSamplerYcbcrConversionFeatures;
22834pub type VkPhysicalDeviceScalarBlockLayoutFeaturesEXT = VkPhysicalDeviceScalarBlockLayoutFeatures;
22835pub type VkPhysicalDeviceSchedulingControlsFlagBitsARM = VkFlags64;
22836pub type VkPhysicalDeviceSchedulingControlsFlagsARM = VkFlags64;
22837pub type VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
22838pub type VkPhysicalDeviceShaderAtomicInt64FeaturesKHR = VkPhysicalDeviceShaderAtomicInt64Features;
22839pub type VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;
22840pub type VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures;
22841pub type VkPhysicalDeviceShaderExpectAssumeFeaturesKHR = VkPhysicalDeviceShaderExpectAssumeFeatures;
22842pub type VkPhysicalDeviceShaderFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;
22843pub type VkPhysicalDeviceShaderFloatControls2FeaturesKHR = VkPhysicalDeviceShaderFloatControls2Features;
22844pub type VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR = VkPhysicalDeviceShaderIntegerDotProductFeatures;
22845pub type VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR = VkPhysicalDeviceShaderIntegerDotProductProperties;
22846pub type VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
22847pub type VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR = VkPhysicalDeviceShaderSubgroupRotateFeatures;
22848pub type VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR = VkPhysicalDeviceShaderTerminateInvocationFeatures;
22849pub type VkPhysicalDeviceSparseImageFormatInfo2KHR = VkPhysicalDeviceSparseImageFormatInfo2;
22850pub type VkPhysicalDeviceSubgroupSizeControlFeaturesEXT = VkPhysicalDeviceSubgroupSizeControlFeatures;
22851pub type VkPhysicalDeviceSubgroupSizeControlPropertiesEXT = VkPhysicalDeviceSubgroupSizeControlProperties;
22852pub type VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT = VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR;
22853pub type VkPhysicalDeviceSynchronization2FeaturesKHR = VkPhysicalDeviceSynchronization2Features;
22854pub type VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = VkPhysicalDeviceTexelBufferAlignmentProperties;
22855pub type VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = VkPhysicalDeviceTextureCompressionASTCHDRFeatures;
22856pub type VkPhysicalDeviceTimelineSemaphoreFeaturesKHR = VkPhysicalDeviceTimelineSemaphoreFeatures;
22857pub type VkPhysicalDeviceTimelineSemaphorePropertiesKHR = VkPhysicalDeviceTimelineSemaphoreProperties;
22858pub type VkPhysicalDeviceToolPropertiesEXT = VkPhysicalDeviceToolProperties;
22859pub type VkPhysicalDeviceType = i32;
22860pub type VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
22861pub type VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures;
22862pub type VkPhysicalDeviceVariablePointerFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;
22863pub type VkPhysicalDeviceVariablePointersFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;
22864pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = VkPhysicalDeviceVertexAttributeDivisorFeatures;
22865pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR = VkPhysicalDeviceVertexAttributeDivisorFeatures;
22866pub type VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR = VkPhysicalDeviceVertexAttributeDivisorProperties;
22867pub type VkPhysicalDeviceVulkanMemoryModelFeaturesKHR = VkPhysicalDeviceVulkanMemoryModelFeatures;
22868pub type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
22869pub type VkPipeline = *mut VkPipeline_T;
22870pub type VkPipelineBinaryKHR = *mut VkPipelineBinaryKHR_T;
22871pub type VkPipelineBindPoint = i32;
22872pub type VkPipelineCache = *mut VkPipelineCache_T;
22873pub type VkPipelineCacheCreateFlagBits = VkFlags;
22874pub type VkPipelineCacheCreateFlags = VkFlags;
22875pub type VkPipelineCacheHeaderVersion = i32;
22876pub type VkPipelineColorBlendStateCreateFlagBits = VkFlags;
22877pub type VkPipelineColorBlendStateCreateFlags = VkFlags;
22878pub type VkPipelineCompilerControlFlagBitsAMD = VkFlags;
22879pub type VkPipelineCompilerControlFlagsAMD = VkFlags;
22880pub type VkPipelineCoverageModulationStateCreateFlagsNV = VkFlags;
22881pub type VkPipelineCoverageReductionStateCreateFlagsNV = VkFlags;
22882pub type VkPipelineCoverageToColorStateCreateFlagsNV = VkFlags;
22883pub type VkPipelineCreateFlagBits = VkFlags;
22884pub type VkPipelineCreateFlagBits2 = VkFlags64;
22885pub type VkPipelineCreateFlagBits2KHR = VkPipelineCreateFlagBits2;
22886pub type VkPipelineCreateFlags = VkFlags;
22887pub type VkPipelineCreateFlags2 = VkFlags64;
22888pub type VkPipelineCreateFlags2CreateInfoKHR = VkPipelineCreateFlags2CreateInfo;
22889pub type VkPipelineCreateFlags2KHR = VkPipelineCreateFlags2;
22890pub type VkPipelineCreationFeedbackCreateInfoEXT = VkPipelineCreationFeedbackCreateInfo;
22891pub type VkPipelineCreationFeedbackEXT = VkPipelineCreationFeedback;
22892pub type VkPipelineCreationFeedbackFlagBits = VkFlags;
22893pub type VkPipelineCreationFeedbackFlagBitsEXT = VkPipelineCreationFeedbackFlagBits;
22894pub type VkPipelineCreationFeedbackFlags = VkFlags;
22895pub type VkPipelineCreationFeedbackFlagsEXT = VkPipelineCreationFeedbackFlags;
22896pub type VkPipelineDepthStencilStateCreateFlagBits = VkFlags;
22897pub type VkPipelineDepthStencilStateCreateFlags = VkFlags;
22898pub type VkPipelineDiscardRectangleStateCreateFlagsEXT = VkFlags;
22899pub type VkPipelineDynamicStateCreateFlags = VkFlags;
22900pub type VkPipelineExecutableStatisticFormatKHR = i32;
22901pub type VkPipelineInfoEXT = VkPipelineInfoKHR;
22902pub type VkPipelineInputAssemblyStateCreateFlags = VkFlags;
22903pub type VkPipelineLayout = *mut VkPipelineLayout_T;
22904pub type VkPipelineLayoutCreateFlagBits = VkFlags;
22905pub type VkPipelineLayoutCreateFlags = VkFlags;
22906pub type VkPipelineMultisampleStateCreateFlags = VkFlags;
22907pub type VkPipelineRasterizationConservativeStateCreateFlagsEXT = VkFlags;
22908pub type VkPipelineRasterizationDepthClipStateCreateFlagsEXT = VkFlags;
22909pub type VkPipelineRasterizationLineStateCreateInfoEXT = VkPipelineRasterizationLineStateCreateInfo;
22910pub type VkPipelineRasterizationLineStateCreateInfoKHR = VkPipelineRasterizationLineStateCreateInfo;
22911pub type VkPipelineRasterizationStateCreateFlags = VkFlags;
22912pub type VkPipelineRasterizationStateStreamCreateFlagsEXT = VkFlags;
22913pub type VkPipelineRenderingCreateInfoKHR = VkPipelineRenderingCreateInfo;
22914pub type VkPipelineRobustnessBufferBehavior = i32;
22915pub type VkPipelineRobustnessBufferBehaviorEXT = VkPipelineRobustnessBufferBehavior;
22916pub type VkPipelineRobustnessCreateInfoEXT = VkPipelineRobustnessCreateInfo;
22917pub type VkPipelineRobustnessImageBehavior = i32;
22918pub type VkPipelineRobustnessImageBehaviorEXT = VkPipelineRobustnessImageBehavior;
22919pub type VkPipelineShaderStageCreateFlagBits = VkFlags;
22920pub type VkPipelineShaderStageCreateFlags = VkFlags;
22921pub type VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
22922pub type VkPipelineStageFlagBits = VkFlags;
22923pub type VkPipelineStageFlagBits2 = VkFlags64;
22924pub type VkPipelineStageFlagBits2KHR = VkPipelineStageFlagBits2;
22925pub type VkPipelineStageFlags = VkFlags;
22926pub type VkPipelineStageFlags2 = VkFlags64;
22927pub type VkPipelineStageFlags2KHR = VkPipelineStageFlags2;
22928pub type VkPipelineTessellationDomainOriginStateCreateInfoKHR = VkPipelineTessellationDomainOriginStateCreateInfo;
22929pub type VkPipelineTessellationStateCreateFlags = VkFlags;
22930pub type VkPipelineVertexInputDivisorStateCreateInfoEXT = VkPipelineVertexInputDivisorStateCreateInfo;
22931pub type VkPipelineVertexInputDivisorStateCreateInfoKHR = VkPipelineVertexInputDivisorStateCreateInfo;
22932pub type VkPipelineVertexInputStateCreateFlags = VkFlags;
22933pub type VkPipelineViewportStateCreateFlags = VkFlags;
22934pub type VkPipelineViewportSwizzleStateCreateFlagsNV = VkFlags;
22935pub type VkPointClippingBehavior = i32;
22936pub type VkPointClippingBehaviorKHR = VkPointClippingBehavior;
22937pub type VkPolygonMode = i32;
22938pub type VkPresentGravityFlagBitsEXT = VkPresentGravityFlagBitsKHR;
22939pub type VkPresentGravityFlagBitsKHR = VkFlags;
22940pub type VkPresentGravityFlagsEXT = VkPresentGravityFlagsKHR;
22941pub type VkPresentGravityFlagsKHR = VkFlags;
22942pub type VkPresentModeKHR = i32;
22943pub type VkPresentScalingFlagBitsEXT = VkPresentScalingFlagBitsKHR;
22944pub type VkPresentScalingFlagBitsKHR = VkFlags;
22945pub type VkPresentScalingFlagsEXT = VkPresentScalingFlagsKHR;
22946pub type VkPresentScalingFlagsKHR = VkFlags;
22947pub type VkPresentStageFlagBitsEXT = VkFlags;
22948pub type VkPresentStageFlagsEXT = VkFlags;
22949pub type VkPresentTimingInfoFlagBitsEXT = VkFlags;
22950pub type VkPresentTimingInfoFlagsEXT = VkFlags;
22951pub type VkPrimitiveTopology = i32;
22952pub type VkPrivateDataSlot = *mut VkPrivateDataSlot_T;
22953pub type VkPrivateDataSlotCreateFlags = VkFlags;
22954pub type VkPrivateDataSlotCreateFlagsEXT = VkPrivateDataSlotCreateFlags;
22955pub type VkPrivateDataSlotCreateInfoEXT = VkPrivateDataSlotCreateInfo;
22956pub type VkPrivateDataSlotEXT = *mut VkPrivateDataSlotEXT_T;
22957pub type VkPrivateDataSlotEXT_T = VkPrivateDataSlot_T;
22958pub type VkProvokingVertexModeEXT = i32;
22959pub type VkPushConstantsInfoKHR = VkPushConstantsInfo;
22960pub type VkPushDescriptorSetInfoKHR = VkPushDescriptorSetInfo;
22961pub type VkPushDescriptorSetWithTemplateInfoKHR = VkPushDescriptorSetWithTemplateInfo;
22962pub type VkQueryControlFlagBits = VkFlags;
22963pub type VkQueryControlFlags = VkFlags;
22964pub type VkQueryPipelineStatisticFlagBits = VkFlags;
22965pub type VkQueryPipelineStatisticFlags = VkFlags;
22966pub type VkQueryPool = *mut VkQueryPool_T;
22967pub type VkQueryPoolCreateFlagBits = VkFlags;
22968pub type VkQueryPoolCreateFlags = VkFlags;
22969pub type VkQueryPoolCreateInfoINTEL = VkQueryPoolPerformanceQueryCreateInfoINTEL;
22970pub type VkQueryPoolSamplingModeINTEL = i32;
22971pub type VkQueryResultFlagBits = VkFlags;
22972pub type VkQueryResultFlags = VkFlags;
22973pub type VkQueryResultStatusKHR = i32;
22974pub type VkQueryType = i32;
22975pub type VkQueue = *mut VkQueue_T;
22976pub type VkQueueFamilyGlobalPriorityPropertiesEXT = VkQueueFamilyGlobalPriorityProperties;
22977pub type VkQueueFamilyGlobalPriorityPropertiesKHR = VkQueueFamilyGlobalPriorityProperties;
22978pub type VkQueueFamilyProperties2KHR = VkQueueFamilyProperties2;
22979pub type VkQueueFlagBits = VkFlags;
22980pub type VkQueueFlags = VkFlags;
22981pub type VkQueueGlobalPriority = i32;
22982pub type VkQueueGlobalPriorityEXT = VkQueueGlobalPriority;
22983pub type VkQueueGlobalPriorityKHR = VkQueueGlobalPriority;
22984pub type VkRasterizationOrderAMD = i32;
22985pub type VkRayTracingInvocationReorderModeEXT = i32;
22986pub type VkRayTracingInvocationReorderModeNV = VkRayTracingInvocationReorderModeEXT;
22987pub type VkRayTracingLssIndexingModeNV = i32;
22988pub type VkRayTracingLssPrimitiveEndCapsModeNV = i32;
22989pub type VkRayTracingShaderGroupTypeKHR = i32;
22990pub type VkRayTracingShaderGroupTypeNV = VkRayTracingShaderGroupTypeKHR;
22991pub type VkReleaseSwapchainImagesInfoEXT = VkReleaseSwapchainImagesInfoKHR;
22992pub type VkRemoteAddressNV = *mut c_void;
22993pub type VkRenderPass = *mut VkRenderPass_T;
22994pub type VkRenderPassAttachmentBeginInfoKHR = VkRenderPassAttachmentBeginInfo;
22995pub type VkRenderPassCreateFlagBits = VkFlags;
22996pub type VkRenderPassCreateFlags = VkFlags;
22997pub type VkRenderPassCreateInfo2KHR = VkRenderPassCreateInfo2;
22998pub type VkRenderPassInputAttachmentAspectCreateInfoKHR = VkRenderPassInputAttachmentAspectCreateInfo;
22999pub type VkRenderPassMultiviewCreateInfoKHR = VkRenderPassMultiviewCreateInfo;
23000pub type VkRenderingAreaInfoKHR = VkRenderingAreaInfo;
23001pub type VkRenderingAttachmentFlagBitsKHR = VkFlags;
23002pub type VkRenderingAttachmentFlagsKHR = VkFlags;
23003pub type VkRenderingAttachmentInfoKHR = VkRenderingAttachmentInfo;
23004pub type VkRenderingAttachmentLocationInfoKHR = VkRenderingAttachmentLocationInfo;
23005pub type VkRenderingEndInfoEXT = VkRenderingEndInfoKHR;
23006pub type VkRenderingFlagBits = VkFlags;
23007pub type VkRenderingFlagBitsKHR = VkRenderingFlagBits;
23008pub type VkRenderingFlags = VkFlags;
23009pub type VkRenderingFlagsKHR = VkRenderingFlags;
23010pub type VkRenderingInfoKHR = VkRenderingInfo;
23011pub type VkRenderingInputAttachmentIndexInfoKHR = VkRenderingInputAttachmentIndexInfo;
23012pub type VkResolveImageFlagBitsKHR = VkFlags;
23013pub type VkResolveImageFlagsKHR = VkFlags;
23014pub type VkResolveImageInfo2KHR = VkResolveImageInfo2;
23015pub type VkResolveModeFlagBits = VkFlags;
23016pub type VkResolveModeFlagBitsKHR = VkResolveModeFlagBits;
23017pub type VkResolveModeFlags = VkFlags;
23018pub type VkResolveModeFlagsKHR = VkResolveModeFlags;
23019pub type VkResult = i32;
23020pub type VkSampleCountFlagBits = VkFlags;
23021pub type VkSampleCountFlags = VkFlags;
23022pub type VkSampleMask = u32;
23023pub type VkSampler = *mut VkSampler_T;
23024pub type VkSamplerAddressMode = i32;
23025pub type VkSamplerCreateFlagBits = VkFlags;
23026pub type VkSamplerCreateFlags = VkFlags;
23027pub type VkSamplerMipmapMode = i32;
23028pub type VkSamplerReductionMode = i32;
23029pub type VkSamplerReductionModeCreateInfoEXT = VkSamplerReductionModeCreateInfo;
23030pub type VkSamplerReductionModeEXT = VkSamplerReductionMode;
23031pub type VkSamplerYcbcrConversion = *mut VkSamplerYcbcrConversion_T;
23032pub type VkSamplerYcbcrConversionCreateInfoKHR = VkSamplerYcbcrConversionCreateInfo;
23033pub type VkSamplerYcbcrConversionImageFormatPropertiesKHR = VkSamplerYcbcrConversionImageFormatProperties;
23034pub type VkSamplerYcbcrConversionInfoKHR = VkSamplerYcbcrConversionInfo;
23035pub type VkSamplerYcbcrConversionKHR = *mut VkSamplerYcbcrConversionKHR_T;
23036pub type VkSamplerYcbcrConversionKHR_T = VkSamplerYcbcrConversion_T;
23037pub type VkSamplerYcbcrModelConversion = i32;
23038pub type VkSamplerYcbcrModelConversionKHR = VkSamplerYcbcrModelConversion;
23039pub type VkSamplerYcbcrRange = i32;
23040pub type VkSamplerYcbcrRangeKHR = VkSamplerYcbcrRange;
23041pub type VkScopeKHR = i32;
23042pub type VkScopeNV = VkScopeKHR;
23043pub type VkSemaphore = *mut VkSemaphore_T;
23044pub type VkSemaphoreCreateFlags = VkFlags;
23045pub type VkSemaphoreImportFlagBits = VkFlags;
23046pub type VkSemaphoreImportFlagBitsKHR = VkSemaphoreImportFlagBits;
23047pub type VkSemaphoreImportFlags = VkFlags;
23048pub type VkSemaphoreImportFlagsKHR = VkSemaphoreImportFlags;
23049pub type VkSemaphoreSignalInfoKHR = VkSemaphoreSignalInfo;
23050pub type VkSemaphoreSubmitInfoKHR = VkSemaphoreSubmitInfo;
23051pub type VkSemaphoreType = i32;
23052pub type VkSemaphoreTypeCreateInfoKHR = VkSemaphoreTypeCreateInfo;
23053pub type VkSemaphoreTypeKHR = VkSemaphoreType;
23054pub type VkSemaphoreWaitFlagBits = VkFlags;
23055pub type VkSemaphoreWaitFlagBitsKHR = VkSemaphoreWaitFlagBits;
23056pub type VkSemaphoreWaitFlags = VkFlags;
23057pub type VkSemaphoreWaitFlagsKHR = VkSemaphoreWaitFlags;
23058pub type VkSemaphoreWaitInfoKHR = VkSemaphoreWaitInfo;
23059pub type VkShaderCodeTypeEXT = i32;
23060pub type VkShaderCorePropertiesFlagBitsAMD = VkFlags;
23061pub type VkShaderCorePropertiesFlagsAMD = VkFlags;
23062pub type VkShaderCreateFlagBitsEXT = VkFlags;
23063pub type VkShaderCreateFlagsEXT = VkFlags;
23064pub type VkShaderEXT = *mut VkShaderEXT_T;
23065pub type VkShaderFloatControlsIndependence = i32;
23066pub type VkShaderFloatControlsIndependenceKHR = VkShaderFloatControlsIndependence;
23067pub type VkShaderGroupShaderKHR = i32;
23068pub type VkShaderInfoTypeAMD = i32;
23069pub type VkShaderModule = *mut VkShaderModule_T;
23070pub type VkShaderModuleCreateFlags = VkFlags;
23071pub type VkShaderRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
23072pub type VkShaderStageFlagBits = VkFlags;
23073pub type VkShaderStageFlags = VkFlags;
23074pub type VkShadingRatePaletteEntryNV = i32;
23075pub type VkSharingMode = i32;
23076pub type VkSparseImageFormatFlagBits = VkFlags;
23077pub type VkSparseImageFormatFlags = VkFlags;
23078pub type VkSparseImageFormatProperties2KHR = VkSparseImageFormatProperties2;
23079pub type VkSparseImageMemoryRequirements2KHR = VkSparseImageMemoryRequirements2;
23080pub type VkSparseMemoryBindFlagBits = VkFlags;
23081pub type VkSparseMemoryBindFlags = VkFlags;
23082pub type VkSpirvResourceTypeFlagBitsEXT = VkFlags;
23083pub type VkSpirvResourceTypeFlagsEXT = VkFlags;
23084pub type VkStencilFaceFlagBits = VkFlags;
23085pub type VkStencilFaceFlags = VkFlags;
23086pub type VkStencilOp = i32;
23087pub type VkStructureType = i32;
23088pub type VkSubgroupFeatureFlagBits = VkFlags;
23089pub type VkSubgroupFeatureFlags = VkFlags;
23090pub type VkSubmitFlagBits = VkFlags;
23091pub type VkSubmitFlagBitsKHR = VkSubmitFlagBits;
23092pub type VkSubmitFlags = VkFlags;
23093pub type VkSubmitFlagsKHR = VkSubmitFlags;
23094pub type VkSubmitInfo2KHR = VkSubmitInfo2;
23095pub type VkSubpassBeginInfoKHR = VkSubpassBeginInfo;
23096pub type VkSubpassContents = i32;
23097pub type VkSubpassDependency2KHR = VkSubpassDependency2;
23098pub type VkSubpassDescription2KHR = VkSubpassDescription2;
23099pub type VkSubpassDescriptionDepthStencilResolveKHR = VkSubpassDescriptionDepthStencilResolve;
23100pub type VkSubpassDescriptionFlagBits = VkFlags;
23101pub type VkSubpassDescriptionFlags = VkFlags;
23102pub type VkSubpassEndInfoKHR = VkSubpassEndInfo;
23103pub type VkSubpassFragmentDensityMapOffsetEndInfoQCOM = VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
23104pub type VkSubpassMergeStatusEXT = i32;
23105pub type VkSubresourceHostMemcpySizeEXT = VkSubresourceHostMemcpySize;
23106pub type VkSubresourceLayout2EXT = VkSubresourceLayout2;
23107pub type VkSubresourceLayout2KHR = VkSubresourceLayout2;
23108pub type VkSurfaceCounterFlagBitsEXT = VkFlags;
23109pub type VkSurfaceCounterFlagsEXT = VkFlags;
23110pub type VkSurfaceKHR = *mut VkSurfaceKHR_T;
23111pub type VkSurfacePresentModeCompatibilityEXT = VkSurfacePresentModeCompatibilityKHR;
23112pub type VkSurfacePresentModeEXT = VkSurfacePresentModeKHR;
23113pub type VkSurfacePresentScalingCapabilitiesEXT = VkSurfacePresentScalingCapabilitiesKHR;
23114pub type VkSurfaceTransformFlagBitsKHR = VkFlags;
23115pub type VkSurfaceTransformFlagsKHR = VkFlags;
23116pub type VkSwapchainCreateFlagBitsKHR = VkFlags;
23117pub type VkSwapchainCreateFlagsKHR = VkFlags;
23118pub type VkSwapchainKHR = *mut VkSwapchainKHR_T;
23119pub type VkSwapchainPresentFenceInfoEXT = VkSwapchainPresentFenceInfoKHR;
23120pub type VkSwapchainPresentModeInfoEXT = VkSwapchainPresentModeInfoKHR;
23121pub type VkSwapchainPresentModesCreateInfoEXT = VkSwapchainPresentModesCreateInfoKHR;
23122pub type VkSwapchainPresentScalingCreateInfoEXT = VkSwapchainPresentScalingCreateInfoKHR;
23123pub type VkSystemAllocationScope = i32;
23124pub type VkTensorARM = *mut VkTensorARM_T;
23125pub type VkTensorCreateFlagBitsARM = VkFlags64;
23126pub type VkTensorCreateFlagsARM = VkFlags64;
23127pub type VkTensorTilingARM = i32;
23128pub type VkTensorUsageFlagBitsARM = VkFlags64;
23129pub type VkTensorUsageFlagsARM = VkFlags64;
23130pub type VkTensorViewARM = *mut VkTensorViewARM_T;
23131pub type VkTensorViewCreateFlagBitsARM = VkFlags64;
23132pub type VkTensorViewCreateFlagsARM = VkFlags64;
23133pub type VkTessellationDomainOrigin = i32;
23134pub type VkTessellationDomainOriginKHR = VkTessellationDomainOrigin;
23135pub type VkTileShadingRenderPassFlagBitsQCOM = VkFlags;
23136pub type VkTileShadingRenderPassFlagsQCOM = VkFlags;
23137pub type VkTimeDomainEXT = VkTimeDomainKHR;
23138pub type VkTimeDomainKHR = i32;
23139pub type VkTimelineSemaphoreSubmitInfoKHR = VkTimelineSemaphoreSubmitInfo;
23140pub type VkToolPurposeFlagBits = VkFlags;
23141pub type VkToolPurposeFlagBitsEXT = VkToolPurposeFlagBits;
23142pub type VkToolPurposeFlags = VkFlags;
23143pub type VkToolPurposeFlagsEXT = VkToolPurposeFlags;
23144pub type VkTransformMatrixNV = VkTransformMatrixKHR;
23145pub type VkValidationCacheCreateFlagsEXT = VkFlags;
23146pub type VkValidationCacheEXT = *mut VkValidationCacheEXT_T;
23147pub type VkValidationCacheHeaderVersionEXT = i32;
23148pub type VkValidationCheckEXT = i32;
23149pub type VkValidationFeatureDisableEXT = i32;
23150pub type VkValidationFeatureEnableEXT = i32;
23151pub type VkVendorId = i32;
23152pub type VkVertexInputBindingDivisorDescriptionEXT = VkVertexInputBindingDivisorDescription;
23153pub type VkVertexInputBindingDivisorDescriptionKHR = VkVertexInputBindingDivisorDescription;
23154pub type VkVertexInputRate = i32;
23155pub type VkVideoBeginCodingFlagsKHR = VkFlags;
23156pub type VkVideoCapabilityFlagBitsKHR = VkFlags;
23157pub type VkVideoCapabilityFlagsKHR = VkFlags;
23158pub type VkVideoChromaSubsamplingFlagBitsKHR = VkFlags;
23159pub type VkVideoChromaSubsamplingFlagsKHR = VkFlags;
23160pub type VkVideoCodecOperationFlagBitsKHR = VkFlags;
23161pub type VkVideoCodecOperationFlagsKHR = VkFlags;
23162pub type VkVideoCodingControlFlagBitsKHR = VkFlags;
23163pub type VkVideoCodingControlFlagsKHR = VkFlags;
23164pub type VkVideoComponentBitDepthFlagBitsKHR = VkFlags;
23165pub type VkVideoComponentBitDepthFlagsKHR = VkFlags;
23166pub type VkVideoDecodeCapabilityFlagBitsKHR = VkFlags;
23167pub type VkVideoDecodeCapabilityFlagsKHR = VkFlags;
23168pub type VkVideoDecodeFlagsKHR = VkFlags;
23169pub type VkVideoDecodeH264PictureLayoutFlagBitsKHR = VkFlags;
23170pub type VkVideoDecodeH264PictureLayoutFlagsKHR = VkFlags;
23171pub type VkVideoDecodeUsageFlagBitsKHR = VkFlags;
23172pub type VkVideoDecodeUsageFlagsKHR = VkFlags;
23173pub type VkVideoEncodeAV1CapabilityFlagBitsKHR = VkFlags;
23174pub type VkVideoEncodeAV1CapabilityFlagsKHR = VkFlags;
23175pub type VkVideoEncodeAV1PredictionModeKHR = i32;
23176pub type VkVideoEncodeAV1RateControlFlagBitsKHR = VkFlags;
23177pub type VkVideoEncodeAV1RateControlFlagsKHR = VkFlags;
23178pub type VkVideoEncodeAV1RateControlGroupKHR = i32;
23179pub type VkVideoEncodeAV1StdFlagBitsKHR = VkFlags;
23180pub type VkVideoEncodeAV1StdFlagsKHR = VkFlags;
23181pub type VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = VkFlags;
23182pub type VkVideoEncodeAV1SuperblockSizeFlagsKHR = VkFlags;
23183pub type VkVideoEncodeCapabilityFlagBitsKHR = VkFlags;
23184pub type VkVideoEncodeCapabilityFlagsKHR = VkFlags;
23185pub type VkVideoEncodeContentFlagBitsKHR = VkFlags;
23186pub type VkVideoEncodeContentFlagsKHR = VkFlags;
23187pub type VkVideoEncodeFeedbackFlagBitsKHR = VkFlags;
23188pub type VkVideoEncodeFeedbackFlagsKHR = VkFlags;
23189pub type VkVideoEncodeFlagBitsKHR = VkFlags;
23190pub type VkVideoEncodeFlagsKHR = VkFlags;
23191pub type VkVideoEncodeH264CapabilityFlagBitsKHR = VkFlags;
23192pub type VkVideoEncodeH264CapabilityFlagsKHR = VkFlags;
23193pub type VkVideoEncodeH264RateControlFlagBitsKHR = VkFlags;
23194pub type VkVideoEncodeH264RateControlFlagsKHR = VkFlags;
23195pub type VkVideoEncodeH264StdFlagBitsKHR = VkFlags;
23196pub type VkVideoEncodeH264StdFlagsKHR = VkFlags;
23197pub type VkVideoEncodeH265CapabilityFlagBitsKHR = VkFlags;
23198pub type VkVideoEncodeH265CapabilityFlagsKHR = VkFlags;
23199pub type VkVideoEncodeH265CtbSizeFlagBitsKHR = VkFlags;
23200pub type VkVideoEncodeH265CtbSizeFlagsKHR = VkFlags;
23201pub type VkVideoEncodeH265RateControlFlagBitsKHR = VkFlags;
23202pub type VkVideoEncodeH265RateControlFlagsKHR = VkFlags;
23203pub type VkVideoEncodeH265StdFlagBitsKHR = VkFlags;
23204pub type VkVideoEncodeH265StdFlagsKHR = VkFlags;
23205pub type VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = VkFlags;
23206pub type VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkFlags;
23207pub type VkVideoEncodeIntraRefreshModeFlagBitsKHR = VkFlags;
23208pub type VkVideoEncodeIntraRefreshModeFlagsKHR = VkFlags;
23209pub type VkVideoEncodeRateControlFlagsKHR = VkFlags;
23210pub type VkVideoEncodeRateControlModeFlagBitsKHR = VkFlags;
23211pub type VkVideoEncodeRateControlModeFlagsKHR = VkFlags;
23212pub type VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = VkFlags;
23213pub type VkVideoEncodeRgbChromaOffsetFlagsVALVE = VkFlags;
23214pub type VkVideoEncodeRgbModelConversionFlagBitsVALVE = VkFlags;
23215pub type VkVideoEncodeRgbModelConversionFlagsVALVE = VkFlags;
23216pub type VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = VkFlags;
23217pub type VkVideoEncodeRgbRangeCompressionFlagsVALVE = VkFlags;
23218pub type VkVideoEncodeTuningModeKHR = i32;
23219pub type VkVideoEncodeUsageFlagBitsKHR = VkFlags;
23220pub type VkVideoEncodeUsageFlagsKHR = VkFlags;
23221pub type VkVideoEndCodingFlagsKHR = VkFlags;
23222pub type VkVideoSessionCreateFlagBitsKHR = VkFlags;
23223pub type VkVideoSessionCreateFlagsKHR = VkFlags;
23224pub type VkVideoSessionKHR = *mut VkVideoSessionKHR_T;
23225pub type VkVideoSessionParametersCreateFlagBitsKHR = VkFlags;
23226pub type VkVideoSessionParametersCreateFlagsKHR = VkFlags;
23227pub type VkVideoSessionParametersKHR = *mut VkVideoSessionParametersKHR_T;
23228pub type VkViewportCoordinateSwizzleNV = i32;
23229pub type VkWriteDescriptorSetInlineUniformBlockEXT = VkWriteDescriptorSetInlineUniformBlock;
23230
23231#[derive(Clone, Copy)]
23232#[repr(C)]
23233pub union VkAccelerationStructureGeometryDataKHR {
23234    pub triangles: VkAccelerationStructureGeometryTrianglesDataKHR,
23235    pub aabbs: VkAccelerationStructureGeometryAabbsDataKHR,
23236    pub instances: VkAccelerationStructureGeometryInstancesDataKHR,
23237}
23238
23239#[derive(Clone, Copy)]
23240#[repr(C)]
23241pub union VkAccelerationStructureMotionInstanceDataNV {
23242    pub staticInstance: VkAccelerationStructureInstanceKHR,
23243    pub matrixMotionInstance: VkAccelerationStructureMatrixMotionInstanceNV,
23244    pub srtMotionInstance: VkAccelerationStructureSRTMotionInstanceNV,
23245}
23246
23247#[derive(Clone, Copy)]
23248#[repr(C)]
23249pub union VkClearColorValue {
23250    pub float32: [f32; 4 as usize],
23251    pub int32: [i32; 4 as usize],
23252    pub uint32: [u32; 4 as usize],
23253}
23254
23255#[derive(Clone, Copy)]
23256#[repr(C)]
23257pub union VkClearValue {
23258    pub color: VkClearColorValue,
23259    pub depthStencil: VkClearDepthStencilValue,
23260}
23261
23262#[derive(Clone, Copy)]
23263#[repr(C)]
23264pub union VkClusterAccelerationStructureOpInputNV {
23265    pub pClustersBottomLevel: *mut VkClusterAccelerationStructureClustersBottomLevelInputNV,
23266    pub pTriangleClusters: *mut VkClusterAccelerationStructureTriangleClusterInputNV,
23267    pub pMoveObjects: *mut VkClusterAccelerationStructureMoveObjectsInputNV,
23268}
23269
23270#[derive(Clone, Copy)]
23271#[repr(C)]
23272pub union VkDescriptorDataEXT {
23273    pub pSampler: *const VkSampler,
23274    pub pCombinedImageSampler: *const VkDescriptorImageInfo,
23275    pub pInputAttachmentImage: *const VkDescriptorImageInfo,
23276    pub pSampledImage: *const VkDescriptorImageInfo,
23277    pub pStorageImage: *const VkDescriptorImageInfo,
23278    pub pUniformTexelBuffer: *const VkDescriptorAddressInfoEXT,
23279    pub pStorageTexelBuffer: *const VkDescriptorAddressInfoEXT,
23280    pub pUniformBuffer: *const VkDescriptorAddressInfoEXT,
23281    pub pStorageBuffer: *const VkDescriptorAddressInfoEXT,
23282    pub accelerationStructure: VkDeviceAddress,
23283}
23284
23285#[derive(Clone, Copy)]
23286#[repr(C)]
23287pub union VkDescriptorMappingSourceDataEXT {
23288    pub constantOffset: VkDescriptorMappingSourceConstantOffsetEXT,
23289    pub pushIndex: VkDescriptorMappingSourcePushIndexEXT,
23290    pub indirectIndex: VkDescriptorMappingSourceIndirectIndexEXT,
23291    pub indirectIndexArray: VkDescriptorMappingSourceIndirectIndexArrayEXT,
23292    pub heapData: VkDescriptorMappingSourceHeapDataEXT,
23293    pub pushDataOffset: u32,
23294    pub pushAddressOffset: u32,
23295    pub indirectAddress: VkDescriptorMappingSourceIndirectAddressEXT,
23296    pub shaderRecordIndex: VkDescriptorMappingSourceShaderRecordIndexEXT,
23297    pub shaderRecordDataOffset: u32,
23298    pub shaderRecordAddressOffset: u32,
23299}
23300
23301#[derive(Clone, Copy)]
23302#[repr(C)]
23303pub union VkDeviceOrHostAddressConstKHR {
23304    pub deviceAddress: VkDeviceAddress,
23305    pub hostAddress: *const c_void,
23306}
23307
23308#[derive(Clone, Copy)]
23309#[repr(C)]
23310pub union VkDeviceOrHostAddressKHR {
23311    pub deviceAddress: VkDeviceAddress,
23312    pub hostAddress: *mut c_void,
23313}
23314
23315#[derive(Clone, Copy)]
23316#[repr(C)]
23317pub union VkIndirectCommandsTokenDataEXT {
23318    pub pPushConstant: *const VkIndirectCommandsPushConstantTokenEXT,
23319    pub pVertexBuffer: *const VkIndirectCommandsVertexBufferTokenEXT,
23320    pub pIndexBuffer: *const VkIndirectCommandsIndexBufferTokenEXT,
23321    pub pExecutionSet: *const VkIndirectCommandsExecutionSetTokenEXT,
23322}
23323
23324#[derive(Clone, Copy)]
23325#[repr(C)]
23326pub union VkIndirectExecutionSetInfoEXT {
23327    pub pPipelineInfo: *const VkIndirectExecutionSetPipelineInfoEXT,
23328    pub pShaderInfo: *const VkIndirectExecutionSetShaderInfoEXT,
23329}
23330
23331#[derive(Clone, Copy)]
23332#[repr(C)]
23333pub union VkPerformanceCounterResultKHR {
23334    pub int32: i32,
23335    pub int64: i64,
23336    pub uint32: u32,
23337    pub uint64: u64,
23338    pub float32: f32,
23339    pub float64: f64,
23340}
23341
23342#[derive(Clone, Copy)]
23343#[repr(C)]
23344pub union VkPerformanceValueDataINTEL {
23345    pub value32: u32,
23346    pub value64: u64,
23347    pub valueFloat: f32,
23348    pub valueBool: VkBool32,
23349    pub valueString: *const c_char,
23350}
23351
23352#[derive(Clone, Copy)]
23353#[repr(C)]
23354pub union VkPipelineExecutableStatisticValueKHR {
23355    pub b32: VkBool32,
23356    pub i64: i64,
23357    pub u64: u64,
23358    pub f64: f64,
23359}
23360
23361#[derive(Clone, Copy)]
23362#[repr(C)]
23363pub union VkResourceDescriptorDataEXT {
23364    pub pImage: *const VkImageDescriptorInfoEXT,
23365    pub pTexelBuffer: *const VkTexelBufferDescriptorInfoEXT,
23366    pub pAddressRange: *const VkDeviceAddressRangeEXT,
23367    pub pTensorARM: *const VkTensorViewCreateInfoARM,
23368}