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 VkPhysicalDeviceCooperativeMatrixConversionFeaturesQCOM {
5197    pub sType: VkStructureType,
5198    pub pNext: *mut c_void,
5199    pub cooperativeMatrixConversion: VkBool32,
5200}
5201
5202#[derive(Clone, Copy)]
5203#[repr(C)]
5204pub struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR {
5205    pub sType: VkStructureType,
5206    pub pNext: *mut c_void,
5207    pub cooperativeMatrix: VkBool32,
5208    pub cooperativeMatrixRobustBufferAccess: VkBool32,
5209}
5210
5211#[derive(Clone, Copy)]
5212#[repr(C)]
5213pub struct VkPhysicalDeviceCooperativeMatrixFeaturesNV {
5214    pub sType: VkStructureType,
5215    pub pNext: *mut c_void,
5216    pub cooperativeMatrix: VkBool32,
5217    pub cooperativeMatrixRobustBufferAccess: VkBool32,
5218}
5219
5220#[derive(Clone, Copy)]
5221#[repr(C)]
5222pub struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR {
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 VkPhysicalDeviceCooperativeMatrixPropertiesNV {
5231    pub sType: VkStructureType,
5232    pub pNext: *mut c_void,
5233    pub cooperativeMatrixSupportedStages: VkShaderStageFlags,
5234}
5235
5236#[derive(Clone, Copy)]
5237#[repr(C)]
5238pub struct VkPhysicalDeviceCooperativeVectorFeaturesNV {
5239    pub sType: VkStructureType,
5240    pub pNext: *mut c_void,
5241    pub cooperativeVector: VkBool32,
5242    pub cooperativeVectorTraining: VkBool32,
5243}
5244
5245#[derive(Clone, Copy)]
5246#[repr(C)]
5247pub struct VkPhysicalDeviceCooperativeVectorPropertiesNV {
5248    pub sType: VkStructureType,
5249    pub pNext: *mut c_void,
5250    pub cooperativeVectorSupportedStages: VkShaderStageFlags,
5251    pub cooperativeVectorTrainingFloat16Accumulation: VkBool32,
5252    pub cooperativeVectorTrainingFloat32Accumulation: VkBool32,
5253    pub maxCooperativeVectorComponents: u32,
5254}
5255
5256#[derive(Clone, Copy)]
5257#[repr(C)]
5258pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesKHR {
5259    pub sType: VkStructureType,
5260    pub pNext: *mut c_void,
5261    pub indirectMemoryCopy: VkBool32,
5262    pub indirectMemoryToImageCopy: VkBool32,
5263}
5264
5265#[derive(Clone, Copy)]
5266#[repr(C)]
5267pub struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV {
5268    pub sType: VkStructureType,
5269    pub pNext: *mut c_void,
5270    pub indirectCopy: VkBool32,
5271}
5272
5273#[derive(Clone, Copy)]
5274#[repr(C)]
5275pub struct VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR {
5276    pub sType: VkStructureType,
5277    pub pNext: *mut c_void,
5278    pub supportedQueues: VkQueueFlags,
5279}
5280
5281#[derive(Clone, Copy)]
5282#[repr(C)]
5283pub struct VkPhysicalDeviceCornerSampledImageFeaturesNV {
5284    pub sType: VkStructureType,
5285    pub pNext: *mut c_void,
5286    pub cornerSampledImage: VkBool32,
5287}
5288
5289#[derive(Clone, Copy)]
5290#[repr(C)]
5291pub struct VkPhysicalDeviceCoverageReductionModeFeaturesNV {
5292    pub sType: VkStructureType,
5293    pub pNext: *mut c_void,
5294    pub coverageReductionMode: VkBool32,
5295}
5296
5297#[derive(Clone, Copy)]
5298#[repr(C)]
5299pub struct VkPhysicalDeviceCubicClampFeaturesQCOM {
5300    pub sType: VkStructureType,
5301    pub pNext: *mut c_void,
5302    pub cubicRangeClamp: VkBool32,
5303}
5304
5305#[derive(Clone, Copy)]
5306#[repr(C)]
5307pub struct VkPhysicalDeviceCubicWeightsFeaturesQCOM {
5308    pub sType: VkStructureType,
5309    pub pNext: *mut c_void,
5310    pub selectableCubicWeights: VkBool32,
5311}
5312
5313#[derive(Clone, Copy)]
5314#[repr(C)]
5315pub struct VkPhysicalDeviceCustomBorderColorFeaturesEXT {
5316    pub sType: VkStructureType,
5317    pub pNext: *mut c_void,
5318    pub customBorderColors: VkBool32,
5319    pub customBorderColorWithoutFormat: VkBool32,
5320}
5321
5322#[derive(Clone, Copy)]
5323#[repr(C)]
5324pub struct VkPhysicalDeviceCustomBorderColorPropertiesEXT {
5325    pub sType: VkStructureType,
5326    pub pNext: *mut c_void,
5327    pub maxCustomBorderColorSamplers: u32,
5328}
5329
5330#[derive(Clone, Copy)]
5331#[repr(C)]
5332pub struct VkPhysicalDeviceCustomResolveFeaturesEXT {
5333    pub sType: VkStructureType,
5334    pub pNext: *mut c_void,
5335    pub customResolve: VkBool32,
5336}
5337
5338#[derive(Clone, Copy)]
5339#[repr(C)]
5340pub struct VkPhysicalDeviceDataGraphFeaturesARM {
5341    pub sType: VkStructureType,
5342    pub pNext: *mut c_void,
5343    pub dataGraph: VkBool32,
5344    pub dataGraphUpdateAfterBind: VkBool32,
5345    pub dataGraphSpecializationConstants: VkBool32,
5346    pub dataGraphDescriptorBuffer: VkBool32,
5347    pub dataGraphShaderModule: VkBool32,
5348}
5349
5350#[derive(Clone, Copy)]
5351#[repr(C)]
5352pub struct VkPhysicalDeviceDataGraphModelFeaturesQCOM {
5353    pub sType: VkStructureType,
5354    pub pNext: *mut c_void,
5355    pub dataGraphModel: VkBool32,
5356}
5357
5358#[derive(Clone, Copy)]
5359#[repr(C)]
5360pub struct VkPhysicalDeviceDataGraphOperationSupportARM {
5361    pub operationType: VkPhysicalDeviceDataGraphOperationTypeARM,
5362    pub name: [c_char; VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM as usize],
5363    pub version: u32,
5364}
5365
5366#[derive(Clone, Copy)]
5367#[repr(C)]
5368pub struct VkPhysicalDeviceDataGraphProcessingEngineARM {
5369    pub typ: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
5370    pub isForeign: VkBool32,
5371}
5372
5373#[derive(Clone, Copy)]
5374#[repr(C)]
5375pub struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
5376    pub sType: VkStructureType,
5377    pub pNext: *mut c_void,
5378    pub dedicatedAllocationImageAliasing: VkBool32,
5379}
5380
5381#[derive(Clone, Copy)]
5382#[repr(C)]
5383pub struct VkPhysicalDeviceDepthBiasControlFeaturesEXT {
5384    pub sType: VkStructureType,
5385    pub pNext: *mut c_void,
5386    pub depthBiasControl: VkBool32,
5387    pub leastRepresentableValueForceUnormRepresentation: VkBool32,
5388    pub floatRepresentation: VkBool32,
5389    pub depthBiasExact: VkBool32,
5390}
5391
5392#[derive(Clone, Copy)]
5393#[repr(C)]
5394pub struct VkPhysicalDeviceDepthClampControlFeaturesEXT {
5395    pub sType: VkStructureType,
5396    pub pNext: *mut c_void,
5397    pub depthClampControl: VkBool32,
5398}
5399
5400#[derive(Clone, Copy)]
5401#[repr(C)]
5402pub struct VkPhysicalDeviceDepthClampZeroOneFeaturesKHR {
5403    pub sType: VkStructureType,
5404    pub pNext: *mut c_void,
5405    pub depthClampZeroOne: VkBool32,
5406}
5407
5408#[derive(Clone, Copy)]
5409#[repr(C)]
5410pub struct VkPhysicalDeviceDepthClipControlFeaturesEXT {
5411    pub sType: VkStructureType,
5412    pub pNext: *mut c_void,
5413    pub depthClipControl: VkBool32,
5414}
5415
5416#[derive(Clone, Copy)]
5417#[repr(C)]
5418pub struct VkPhysicalDeviceDepthClipEnableFeaturesEXT {
5419    pub sType: VkStructureType,
5420    pub pNext: *mut c_void,
5421    pub depthClipEnable: VkBool32,
5422}
5423
5424#[derive(Clone, Copy)]
5425#[repr(C)]
5426pub struct VkPhysicalDeviceDepthStencilResolveProperties {
5427    pub sType: VkStructureType,
5428    pub pNext: *mut c_void,
5429    pub supportedDepthResolveModes: VkResolveModeFlags,
5430    pub supportedStencilResolveModes: VkResolveModeFlags,
5431    pub independentResolveNone: VkBool32,
5432    pub independentResolve: VkBool32,
5433}
5434
5435#[derive(Clone, Copy)]
5436#[repr(C)]
5437pub struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
5438    pub sType: VkStructureType,
5439    pub pNext: *mut c_void,
5440    pub combinedImageSamplerDensityMapDescriptorSize: usize,
5441}
5442
5443#[derive(Clone, Copy)]
5444#[repr(C)]
5445pub struct VkPhysicalDeviceDescriptorBufferFeaturesEXT {
5446    pub sType: VkStructureType,
5447    pub pNext: *mut c_void,
5448    pub descriptorBuffer: VkBool32,
5449    pub descriptorBufferCaptureReplay: VkBool32,
5450    pub descriptorBufferImageLayoutIgnored: VkBool32,
5451    pub descriptorBufferPushDescriptors: VkBool32,
5452}
5453
5454#[derive(Clone, Copy)]
5455#[repr(C)]
5456pub struct VkPhysicalDeviceDescriptorBufferPropertiesEXT {
5457    pub sType: VkStructureType,
5458    pub pNext: *mut c_void,
5459    pub combinedImageSamplerDescriptorSingleArray: VkBool32,
5460    pub bufferlessPushDescriptors: VkBool32,
5461    pub allowSamplerImageViewPostSubmitCreation: VkBool32,
5462    pub descriptorBufferOffsetAlignment: VkDeviceSize,
5463    pub maxDescriptorBufferBindings: u32,
5464    pub maxResourceDescriptorBufferBindings: u32,
5465    pub maxSamplerDescriptorBufferBindings: u32,
5466    pub maxEmbeddedImmutableSamplerBindings: u32,
5467    pub maxEmbeddedImmutableSamplers: u32,
5468    pub bufferCaptureReplayDescriptorDataSize: usize,
5469    pub imageCaptureReplayDescriptorDataSize: usize,
5470    pub imageViewCaptureReplayDescriptorDataSize: usize,
5471    pub samplerCaptureReplayDescriptorDataSize: usize,
5472    pub accelerationStructureCaptureReplayDescriptorDataSize: usize,
5473    pub samplerDescriptorSize: usize,
5474    pub combinedImageSamplerDescriptorSize: usize,
5475    pub sampledImageDescriptorSize: usize,
5476    pub storageImageDescriptorSize: usize,
5477    pub uniformTexelBufferDescriptorSize: usize,
5478    pub robustUniformTexelBufferDescriptorSize: usize,
5479    pub storageTexelBufferDescriptorSize: usize,
5480    pub robustStorageTexelBufferDescriptorSize: usize,
5481    pub uniformBufferDescriptorSize: usize,
5482    pub robustUniformBufferDescriptorSize: usize,
5483    pub storageBufferDescriptorSize: usize,
5484    pub robustStorageBufferDescriptorSize: usize,
5485    pub inputAttachmentDescriptorSize: usize,
5486    pub accelerationStructureDescriptorSize: usize,
5487    pub maxSamplerDescriptorBufferRange: VkDeviceSize,
5488    pub maxResourceDescriptorBufferRange: VkDeviceSize,
5489    pub samplerDescriptorBufferAddressSpaceSize: VkDeviceSize,
5490    pub resourceDescriptorBufferAddressSpaceSize: VkDeviceSize,
5491    pub descriptorBufferAddressSpaceSize: VkDeviceSize,
5492}
5493
5494#[derive(Clone, Copy)]
5495#[repr(C)]
5496pub struct VkPhysicalDeviceDescriptorBufferTensorFeaturesARM {
5497    pub sType: VkStructureType,
5498    pub pNext: *mut c_void,
5499    pub descriptorBufferTensorDescriptors: VkBool32,
5500}
5501
5502#[derive(Clone, Copy)]
5503#[repr(C)]
5504pub struct VkPhysicalDeviceDescriptorBufferTensorPropertiesARM {
5505    pub sType: VkStructureType,
5506    pub pNext: *mut c_void,
5507    pub tensorCaptureReplayDescriptorDataSize: usize,
5508    pub tensorViewCaptureReplayDescriptorDataSize: usize,
5509    pub tensorDescriptorSize: usize,
5510}
5511
5512#[derive(Clone, Copy)]
5513#[repr(C)]
5514pub struct VkPhysicalDeviceDescriptorHeapFeaturesEXT {
5515    pub sType: VkStructureType,
5516    pub pNext: *mut c_void,
5517    pub descriptorHeap: VkBool32,
5518    pub descriptorHeapCaptureReplay: VkBool32,
5519}
5520
5521#[derive(Clone, Copy)]
5522#[repr(C)]
5523pub struct VkPhysicalDeviceDescriptorHeapPropertiesEXT {
5524    pub sType: VkStructureType,
5525    pub pNext: *mut c_void,
5526    pub samplerHeapAlignment: VkDeviceSize,
5527    pub resourceHeapAlignment: VkDeviceSize,
5528    pub maxSamplerHeapSize: VkDeviceSize,
5529    pub maxResourceHeapSize: VkDeviceSize,
5530    pub minSamplerHeapReservedRange: VkDeviceSize,
5531    pub minSamplerHeapReservedRangeWithEmbedded: VkDeviceSize,
5532    pub minResourceHeapReservedRange: VkDeviceSize,
5533    pub samplerDescriptorSize: VkDeviceSize,
5534    pub imageDescriptorSize: VkDeviceSize,
5535    pub bufferDescriptorSize: VkDeviceSize,
5536    pub samplerDescriptorAlignment: VkDeviceSize,
5537    pub imageDescriptorAlignment: VkDeviceSize,
5538    pub bufferDescriptorAlignment: VkDeviceSize,
5539    pub maxPushDataSize: VkDeviceSize,
5540    pub imageCaptureReplayOpaqueDataSize: usize,
5541    pub maxDescriptorHeapEmbeddedSamplers: u32,
5542    pub samplerYcbcrConversionCount: u32,
5543    pub sparseDescriptorHeaps: VkBool32,
5544    pub protectedDescriptorHeaps: VkBool32,
5545}
5546
5547#[derive(Clone, Copy)]
5548#[repr(C)]
5549pub struct VkPhysicalDeviceDescriptorHeapTensorPropertiesARM {
5550    pub sType: VkStructureType,
5551    pub pNext: *mut c_void,
5552    pub tensorDescriptorSize: VkDeviceSize,
5553    pub tensorDescriptorAlignment: VkDeviceSize,
5554    pub tensorCaptureReplayOpaqueDataSize: usize,
5555}
5556
5557#[derive(Clone, Copy)]
5558#[repr(C)]
5559pub struct VkPhysicalDeviceDescriptorIndexingFeatures {
5560    pub sType: VkStructureType,
5561    pub pNext: *mut c_void,
5562    pub shaderInputAttachmentArrayDynamicIndexing: VkBool32,
5563    pub shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
5564    pub shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
5565    pub shaderUniformBufferArrayNonUniformIndexing: VkBool32,
5566    pub shaderSampledImageArrayNonUniformIndexing: VkBool32,
5567    pub shaderStorageBufferArrayNonUniformIndexing: VkBool32,
5568    pub shaderStorageImageArrayNonUniformIndexing: VkBool32,
5569    pub shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
5570    pub shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
5571    pub shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
5572    pub descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
5573    pub descriptorBindingSampledImageUpdateAfterBind: VkBool32,
5574    pub descriptorBindingStorageImageUpdateAfterBind: VkBool32,
5575    pub descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
5576    pub descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
5577    pub descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
5578    pub descriptorBindingUpdateUnusedWhilePending: VkBool32,
5579    pub descriptorBindingPartiallyBound: VkBool32,
5580    pub descriptorBindingVariableDescriptorCount: VkBool32,
5581    pub runtimeDescriptorArray: VkBool32,
5582}
5583
5584#[derive(Clone, Copy)]
5585#[repr(C)]
5586pub struct VkPhysicalDeviceDescriptorIndexingProperties {
5587    pub sType: VkStructureType,
5588    pub pNext: *mut c_void,
5589    pub maxUpdateAfterBindDescriptorsInAllPools: u32,
5590    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
5591    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
5592    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
5593    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
5594    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
5595    pub robustBufferAccessUpdateAfterBind: VkBool32,
5596    pub quadDivergentImplicitLod: VkBool32,
5597    pub maxPerStageDescriptorUpdateAfterBindSamplers: u32,
5598    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
5599    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
5600    pub maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
5601    pub maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
5602    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
5603    pub maxPerStageUpdateAfterBindResources: u32,
5604    pub maxDescriptorSetUpdateAfterBindSamplers: u32,
5605    pub maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
5606    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
5607    pub maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
5608    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
5609    pub maxDescriptorSetUpdateAfterBindSampledImages: u32,
5610    pub maxDescriptorSetUpdateAfterBindStorageImages: u32,
5611    pub maxDescriptorSetUpdateAfterBindInputAttachments: u32,
5612}
5613
5614#[derive(Clone, Copy)]
5615#[repr(C)]
5616pub struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
5617    pub sType: VkStructureType,
5618    pub pNext: *mut c_void,
5619    pub descriptorPoolOverallocation: VkBool32,
5620}
5621
5622#[derive(Clone, Copy)]
5623#[repr(C)]
5624pub struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
5625    pub sType: VkStructureType,
5626    pub pNext: *mut c_void,
5627    pub descriptorSetHostMapping: VkBool32,
5628}
5629
5630#[derive(Clone, Copy)]
5631#[repr(C)]
5632pub struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
5633    pub sType: VkStructureType,
5634    pub pNext: *mut c_void,
5635    pub deviceGeneratedCompute: VkBool32,
5636    pub deviceGeneratedComputePipelines: VkBool32,
5637    pub deviceGeneratedComputeCaptureReplay: VkBool32,
5638}
5639
5640#[derive(Clone, Copy)]
5641#[repr(C)]
5642pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesEXT {
5643    pub sType: VkStructureType,
5644    pub pNext: *mut c_void,
5645    pub deviceGeneratedCommands: VkBool32,
5646    pub dynamicGeneratedPipelineLayout: VkBool32,
5647}
5648
5649#[derive(Clone, Copy)]
5650#[repr(C)]
5651pub struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
5652    pub sType: VkStructureType,
5653    pub pNext: *mut c_void,
5654    pub deviceGeneratedCommands: VkBool32,
5655}
5656
5657#[derive(Clone, Copy)]
5658#[repr(C)]
5659pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesEXT {
5660    pub sType: VkStructureType,
5661    pub pNext: *mut c_void,
5662    pub maxIndirectPipelineCount: u32,
5663    pub maxIndirectShaderObjectCount: u32,
5664    pub maxIndirectSequenceCount: u32,
5665    pub maxIndirectCommandsTokenCount: u32,
5666    pub maxIndirectCommandsTokenOffset: u32,
5667    pub maxIndirectCommandsIndirectStride: u32,
5668    pub supportedIndirectCommandsInputModes: VkIndirectCommandsInputModeFlagsEXT,
5669    pub supportedIndirectCommandsShaderStages: VkShaderStageFlags,
5670    pub supportedIndirectCommandsShaderStagesPipelineBinding: VkShaderStageFlags,
5671    pub supportedIndirectCommandsShaderStagesShaderBinding: VkShaderStageFlags,
5672    pub deviceGeneratedCommandsTransformFeedback: VkBool32,
5673    pub deviceGeneratedCommandsMultiDrawIndirectCount: VkBool32,
5674}
5675
5676#[derive(Clone, Copy)]
5677#[repr(C)]
5678pub struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
5679    pub sType: VkStructureType,
5680    pub pNext: *mut c_void,
5681    pub maxGraphicsShaderGroupCount: u32,
5682    pub maxIndirectSequenceCount: u32,
5683    pub maxIndirectCommandsTokenCount: u32,
5684    pub maxIndirectCommandsStreamCount: u32,
5685    pub maxIndirectCommandsTokenOffset: u32,
5686    pub maxIndirectCommandsStreamStride: u32,
5687    pub minSequencesCountBufferOffsetAlignment: u32,
5688    pub minSequencesIndexBufferOffsetAlignment: u32,
5689    pub minIndirectCommandsBufferOffsetAlignment: u32,
5690}
5691
5692#[derive(Clone, Copy)]
5693#[repr(C)]
5694pub struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT {
5695    pub sType: VkStructureType,
5696    pub pNext: *mut c_void,
5697    pub deviceMemoryReport: VkBool32,
5698}
5699
5700#[derive(Clone, Copy)]
5701#[repr(C)]
5702pub struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV {
5703    pub sType: VkStructureType,
5704    pub pNext: *mut c_void,
5705    pub diagnosticsConfig: VkBool32,
5706}
5707
5708#[derive(Clone, Copy)]
5709#[repr(C)]
5710pub struct VkPhysicalDeviceDiscardRectanglePropertiesEXT {
5711    pub sType: VkStructureType,
5712    pub pNext: *mut c_void,
5713    pub maxDiscardRectangles: u32,
5714}
5715
5716#[derive(Clone, Copy)]
5717#[repr(C)]
5718pub struct VkPhysicalDeviceDriverProperties {
5719    pub sType: VkStructureType,
5720    pub pNext: *mut c_void,
5721    pub driverID: VkDriverId,
5722    pub driverName: [c_char; VK_MAX_DRIVER_NAME_SIZE as usize],
5723    pub driverInfo: [c_char; VK_MAX_DRIVER_INFO_SIZE as usize],
5724    pub conformanceVersion: VkConformanceVersion,
5725}
5726
5727#[derive(Clone, Copy)]
5728#[repr(C)]
5729pub struct VkPhysicalDeviceDrmPropertiesEXT {
5730    pub sType: VkStructureType,
5731    pub pNext: *mut c_void,
5732    pub hasPrimary: VkBool32,
5733    pub hasRender: VkBool32,
5734    pub primaryMajor: i64,
5735    pub primaryMinor: i64,
5736    pub renderMajor: i64,
5737    pub renderMinor: i64,
5738}
5739
5740#[derive(Clone, Copy)]
5741#[repr(C)]
5742pub struct VkPhysicalDeviceDynamicRenderingFeatures {
5743    pub sType: VkStructureType,
5744    pub pNext: *mut c_void,
5745    pub dynamicRendering: VkBool32,
5746}
5747
5748#[derive(Clone, Copy)]
5749#[repr(C)]
5750pub struct VkPhysicalDeviceDynamicRenderingLocalReadFeatures {
5751    pub sType: VkStructureType,
5752    pub pNext: *mut c_void,
5753    pub dynamicRenderingLocalRead: VkBool32,
5754}
5755
5756#[derive(Clone, Copy)]
5757#[repr(C)]
5758pub struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
5759    pub sType: VkStructureType,
5760    pub pNext: *mut c_void,
5761    pub dynamicRenderingUnusedAttachments: VkBool32,
5762}
5763
5764#[derive(Clone, Copy)]
5765#[repr(C)]
5766pub struct VkPhysicalDeviceExclusiveScissorFeaturesNV {
5767    pub sType: VkStructureType,
5768    pub pNext: *mut c_void,
5769    pub exclusiveScissor: VkBool32,
5770}
5771
5772#[derive(Clone, Copy)]
5773#[repr(C)]
5774pub struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT {
5775    pub sType: VkStructureType,
5776    pub pNext: *mut c_void,
5777    pub extendedDynamicState2: VkBool32,
5778    pub extendedDynamicState2LogicOp: VkBool32,
5779    pub extendedDynamicState2PatchControlPoints: VkBool32,
5780}
5781
5782#[derive(Clone, Copy)]
5783#[repr(C)]
5784pub struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT {
5785    pub sType: VkStructureType,
5786    pub pNext: *mut c_void,
5787    pub extendedDynamicState3TessellationDomainOrigin: VkBool32,
5788    pub extendedDynamicState3DepthClampEnable: VkBool32,
5789    pub extendedDynamicState3PolygonMode: VkBool32,
5790    pub extendedDynamicState3RasterizationSamples: VkBool32,
5791    pub extendedDynamicState3SampleMask: VkBool32,
5792    pub extendedDynamicState3AlphaToCoverageEnable: VkBool32,
5793    pub extendedDynamicState3AlphaToOneEnable: VkBool32,
5794    pub extendedDynamicState3LogicOpEnable: VkBool32,
5795    pub extendedDynamicState3ColorBlendEnable: VkBool32,
5796    pub extendedDynamicState3ColorBlendEquation: VkBool32,
5797    pub extendedDynamicState3ColorWriteMask: VkBool32,
5798    pub extendedDynamicState3RasterizationStream: VkBool32,
5799    pub extendedDynamicState3ConservativeRasterizationMode: VkBool32,
5800    pub extendedDynamicState3ExtraPrimitiveOverestimationSize: VkBool32,
5801    pub extendedDynamicState3DepthClipEnable: VkBool32,
5802    pub extendedDynamicState3SampleLocationsEnable: VkBool32,
5803    pub extendedDynamicState3ColorBlendAdvanced: VkBool32,
5804    pub extendedDynamicState3ProvokingVertexMode: VkBool32,
5805    pub extendedDynamicState3LineRasterizationMode: VkBool32,
5806    pub extendedDynamicState3LineStippleEnable: VkBool32,
5807    pub extendedDynamicState3DepthClipNegativeOneToOne: VkBool32,
5808    pub extendedDynamicState3ViewportWScalingEnable: VkBool32,
5809    pub extendedDynamicState3ViewportSwizzle: VkBool32,
5810    pub extendedDynamicState3CoverageToColorEnable: VkBool32,
5811    pub extendedDynamicState3CoverageToColorLocation: VkBool32,
5812    pub extendedDynamicState3CoverageModulationMode: VkBool32,
5813    pub extendedDynamicState3CoverageModulationTableEnable: VkBool32,
5814    pub extendedDynamicState3CoverageModulationTable: VkBool32,
5815    pub extendedDynamicState3CoverageReductionMode: VkBool32,
5816    pub extendedDynamicState3RepresentativeFragmentTestEnable: VkBool32,
5817    pub extendedDynamicState3ShadingRateImageEnable: VkBool32,
5818}
5819
5820#[derive(Clone, Copy)]
5821#[repr(C)]
5822pub struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT {
5823    pub sType: VkStructureType,
5824    pub pNext: *mut c_void,
5825    pub dynamicPrimitiveTopologyUnrestricted: VkBool32,
5826}
5827
5828#[derive(Clone, Copy)]
5829#[repr(C)]
5830pub struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT {
5831    pub sType: VkStructureType,
5832    pub pNext: *mut c_void,
5833    pub extendedDynamicState: VkBool32,
5834}
5835
5836#[derive(Clone, Copy)]
5837#[repr(C)]
5838pub struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
5839    pub sType: VkStructureType,
5840    pub pNext: *mut c_void,
5841    pub extendedSparseAddressSpace: VkBool32,
5842}
5843
5844#[derive(Clone, Copy)]
5845#[repr(C)]
5846pub struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
5847    pub sType: VkStructureType,
5848    pub pNext: *mut c_void,
5849    pub extendedSparseAddressSpaceSize: VkDeviceSize,
5850    pub extendedSparseImageUsageFlags: VkImageUsageFlags,
5851    pub extendedSparseBufferUsageFlags: VkBufferUsageFlags,
5852}
5853
5854#[derive(Clone, Copy)]
5855#[repr(C)]
5856pub struct VkPhysicalDeviceExternalBufferInfo {
5857    pub sType: VkStructureType,
5858    pub pNext: *const c_void,
5859    pub flags: VkBufferCreateFlags,
5860    pub usage: VkBufferUsageFlags,
5861    pub handleType: VkExternalMemoryHandleTypeFlagBits,
5862}
5863
5864#[derive(Clone, Copy)]
5865#[repr(C)]
5866pub struct VkPhysicalDeviceExternalComputeQueuePropertiesNV {
5867    pub sType: VkStructureType,
5868    pub pNext: *mut c_void,
5869    pub externalDataSize: u32,
5870    pub maxExternalQueues: u32,
5871}
5872
5873#[derive(Clone, Copy)]
5874#[repr(C)]
5875pub struct VkPhysicalDeviceExternalFenceInfo {
5876    pub sType: VkStructureType,
5877    pub pNext: *const c_void,
5878    pub handleType: VkExternalFenceHandleTypeFlagBits,
5879}
5880
5881#[derive(Clone, Copy)]
5882#[repr(C)]
5883pub struct VkPhysicalDeviceExternalImageFormatInfo {
5884    pub sType: VkStructureType,
5885    pub pNext: *const c_void,
5886    pub handleType: VkExternalMemoryHandleTypeFlagBits,
5887}
5888
5889#[derive(Clone, Copy)]
5890#[repr(C)]
5891pub struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT {
5892    pub sType: VkStructureType,
5893    pub pNext: *mut c_void,
5894    pub minImportedHostPointerAlignment: VkDeviceSize,
5895}
5896
5897#[derive(Clone, Copy)]
5898#[repr(C)]
5899pub struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV {
5900    pub sType: VkStructureType,
5901    pub pNext: *mut c_void,
5902    pub externalMemoryRDMA: VkBool32,
5903}
5904
5905#[derive(Clone, Copy)]
5906#[repr(C)]
5907pub struct VkPhysicalDeviceExternalSemaphoreInfo {
5908    pub sType: VkStructureType,
5909    pub pNext: *const c_void,
5910    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
5911}
5912
5913#[derive(Clone, Copy)]
5914#[repr(C)]
5915pub struct VkPhysicalDeviceExternalTensorInfoARM {
5916    pub sType: VkStructureType,
5917    pub pNext: *const c_void,
5918    pub flags: VkTensorCreateFlagsARM,
5919    pub pDescription: *const VkTensorDescriptionARM,
5920    pub handleType: VkExternalMemoryHandleTypeFlagBits,
5921}
5922
5923#[derive(Clone, Copy)]
5924#[repr(C)]
5925pub struct VkPhysicalDeviceFaultFeaturesEXT {
5926    pub sType: VkStructureType,
5927    pub pNext: *mut c_void,
5928    pub deviceFault: VkBool32,
5929    pub deviceFaultVendorBinary: VkBool32,
5930}
5931
5932#[derive(Clone, Copy)]
5933#[repr(C)]
5934pub struct VkPhysicalDeviceFeatures {
5935    pub robustBufferAccess: VkBool32,
5936    pub fullDrawIndexUint32: VkBool32,
5937    pub imageCubeArray: VkBool32,
5938    pub independentBlend: VkBool32,
5939    pub geometryShader: VkBool32,
5940    pub tessellationShader: VkBool32,
5941    pub sampleRateShading: VkBool32,
5942    pub dualSrcBlend: VkBool32,
5943    pub logicOp: VkBool32,
5944    pub multiDrawIndirect: VkBool32,
5945    pub drawIndirectFirstInstance: VkBool32,
5946    pub depthClamp: VkBool32,
5947    pub depthBiasClamp: VkBool32,
5948    pub fillModeNonSolid: VkBool32,
5949    pub depthBounds: VkBool32,
5950    pub wideLines: VkBool32,
5951    pub largePoints: VkBool32,
5952    pub alphaToOne: VkBool32,
5953    pub multiViewport: VkBool32,
5954    pub samplerAnisotropy: VkBool32,
5955    pub textureCompressionETC2: VkBool32,
5956    pub textureCompressionASTC_LDR: VkBool32,
5957    pub textureCompressionBC: VkBool32,
5958    pub occlusionQueryPrecise: VkBool32,
5959    pub pipelineStatisticsQuery: VkBool32,
5960    pub vertexPipelineStoresAndAtomics: VkBool32,
5961    pub fragmentStoresAndAtomics: VkBool32,
5962    pub shaderTessellationAndGeometryPointSize: VkBool32,
5963    pub shaderImageGatherExtended: VkBool32,
5964    pub shaderStorageImageExtendedFormats: VkBool32,
5965    pub shaderStorageImageMultisample: VkBool32,
5966    pub shaderStorageImageReadWithoutFormat: VkBool32,
5967    pub shaderStorageImageWriteWithoutFormat: VkBool32,
5968    pub shaderUniformBufferArrayDynamicIndexing: VkBool32,
5969    pub shaderSampledImageArrayDynamicIndexing: VkBool32,
5970    pub shaderStorageBufferArrayDynamicIndexing: VkBool32,
5971    pub shaderStorageImageArrayDynamicIndexing: VkBool32,
5972    pub shaderClipDistance: VkBool32,
5973    pub shaderCullDistance: VkBool32,
5974    pub shaderFloat64: VkBool32,
5975    pub shaderInt64: VkBool32,
5976    pub shaderInt16: VkBool32,
5977    pub shaderResourceResidency: VkBool32,
5978    pub shaderResourceMinLod: VkBool32,
5979    pub sparseBinding: VkBool32,
5980    pub sparseResidencyBuffer: VkBool32,
5981    pub sparseResidencyImage2D: VkBool32,
5982    pub sparseResidencyImage3D: VkBool32,
5983    pub sparseResidency2Samples: VkBool32,
5984    pub sparseResidency4Samples: VkBool32,
5985    pub sparseResidency8Samples: VkBool32,
5986    pub sparseResidency16Samples: VkBool32,
5987    pub sparseResidencyAliased: VkBool32,
5988    pub variableMultisampleRate: VkBool32,
5989    pub inheritedQueries: VkBool32,
5990}
5991
5992#[derive(Clone, Copy)]
5993#[repr(C)]
5994pub struct VkPhysicalDeviceFeatures2 {
5995    pub sType: VkStructureType,
5996    pub pNext: *mut c_void,
5997    pub features: VkPhysicalDeviceFeatures,
5998}
5999
6000#[derive(Clone, Copy)]
6001#[repr(C)]
6002pub struct VkPhysicalDeviceFloatControlsProperties {
6003    pub sType: VkStructureType,
6004    pub pNext: *mut c_void,
6005    pub denormBehaviorIndependence: VkShaderFloatControlsIndependence,
6006    pub roundingModeIndependence: VkShaderFloatControlsIndependence,
6007    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
6008    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
6009    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
6010    pub shaderDenormPreserveFloat16: VkBool32,
6011    pub shaderDenormPreserveFloat32: VkBool32,
6012    pub shaderDenormPreserveFloat64: VkBool32,
6013    pub shaderDenormFlushToZeroFloat16: VkBool32,
6014    pub shaderDenormFlushToZeroFloat32: VkBool32,
6015    pub shaderDenormFlushToZeroFloat64: VkBool32,
6016    pub shaderRoundingModeRTEFloat16: VkBool32,
6017    pub shaderRoundingModeRTEFloat32: VkBool32,
6018    pub shaderRoundingModeRTEFloat64: VkBool32,
6019    pub shaderRoundingModeRTZFloat16: VkBool32,
6020    pub shaderRoundingModeRTZFloat32: VkBool32,
6021    pub shaderRoundingModeRTZFloat64: VkBool32,
6022}
6023
6024#[derive(Clone, Copy)]
6025#[repr(C)]
6026pub struct VkPhysicalDeviceFormatPackFeaturesARM {
6027    pub sType: VkStructureType,
6028    pub pNext: *mut c_void,
6029    pub formatPack: VkBool32,
6030}
6031
6032#[derive(Clone, Copy)]
6033#[repr(C)]
6034pub struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT {
6035    pub sType: VkStructureType,
6036    pub pNext: *mut c_void,
6037    pub fragmentDensityMapDeferred: VkBool32,
6038}
6039
6040#[derive(Clone, Copy)]
6041#[repr(C)]
6042pub struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT {
6043    pub sType: VkStructureType,
6044    pub pNext: *mut c_void,
6045    pub subsampledLoads: VkBool32,
6046    pub subsampledCoarseReconstructionEarlyAccess: VkBool32,
6047    pub maxSubsampledArrayLayers: u32,
6048    pub maxDescriptorSetSubsampledSamplers: u32,
6049}
6050
6051#[derive(Clone, Copy)]
6052#[repr(C)]
6053pub struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT {
6054    pub sType: VkStructureType,
6055    pub pNext: *mut c_void,
6056    pub fragmentDensityMap: VkBool32,
6057    pub fragmentDensityMapDynamic: VkBool32,
6058    pub fragmentDensityMapNonSubsampledImages: VkBool32,
6059}
6060
6061#[derive(Clone, Copy)]
6062#[repr(C)]
6063pub struct VkPhysicalDeviceFragmentDensityMapLayeredFeaturesVALVE {
6064    pub sType: VkStructureType,
6065    pub pNext: *mut c_void,
6066    pub fragmentDensityMapLayered: VkBool32,
6067}
6068
6069#[derive(Clone, Copy)]
6070#[repr(C)]
6071pub struct VkPhysicalDeviceFragmentDensityMapLayeredPropertiesVALVE {
6072    pub sType: VkStructureType,
6073    pub pNext: *mut c_void,
6074    pub maxFragmentDensityMapLayers: u32,
6075}
6076
6077#[derive(Clone, Copy)]
6078#[repr(C)]
6079pub struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT {
6080    pub sType: VkStructureType,
6081    pub pNext: *mut c_void,
6082    pub fragmentDensityMapOffset: VkBool32,
6083}
6084
6085#[derive(Clone, Copy)]
6086#[repr(C)]
6087pub struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT {
6088    pub sType: VkStructureType,
6089    pub pNext: *mut c_void,
6090    pub fragmentDensityOffsetGranularity: VkExtent2D,
6091}
6092
6093#[derive(Clone, Copy)]
6094#[repr(C)]
6095pub struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT {
6096    pub sType: VkStructureType,
6097    pub pNext: *mut c_void,
6098    pub minFragmentDensityTexelSize: VkExtent2D,
6099    pub maxFragmentDensityTexelSize: VkExtent2D,
6100    pub fragmentDensityInvocations: VkBool32,
6101}
6102
6103#[derive(Clone, Copy)]
6104#[repr(C)]
6105pub struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
6106    pub sType: VkStructureType,
6107    pub pNext: *mut c_void,
6108    pub fragmentShaderBarycentric: VkBool32,
6109}
6110
6111#[derive(Clone, Copy)]
6112#[repr(C)]
6113pub struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
6114    pub sType: VkStructureType,
6115    pub pNext: *mut c_void,
6116    pub triStripVertexOrderIndependentOfProvokingVertex: VkBool32,
6117}
6118
6119#[derive(Clone, Copy)]
6120#[repr(C)]
6121pub struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT {
6122    pub sType: VkStructureType,
6123    pub pNext: *mut c_void,
6124    pub fragmentShaderSampleInterlock: VkBool32,
6125    pub fragmentShaderPixelInterlock: VkBool32,
6126    pub fragmentShaderShadingRateInterlock: VkBool32,
6127}
6128
6129#[derive(Clone, Copy)]
6130#[repr(C)]
6131pub struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
6132    pub sType: VkStructureType,
6133    pub pNext: *mut c_void,
6134    pub fragmentShadingRateEnums: VkBool32,
6135    pub supersampleFragmentShadingRates: VkBool32,
6136    pub noInvocationFragmentShadingRates: VkBool32,
6137}
6138
6139#[derive(Clone, Copy)]
6140#[repr(C)]
6141pub struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
6142    pub sType: VkStructureType,
6143    pub pNext: *mut c_void,
6144    pub maxFragmentShadingRateInvocationCount: VkSampleCountFlagBits,
6145}
6146
6147#[derive(Clone, Copy)]
6148#[repr(C)]
6149pub struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR {
6150    pub sType: VkStructureType,
6151    pub pNext: *mut c_void,
6152    pub pipelineFragmentShadingRate: VkBool32,
6153    pub primitiveFragmentShadingRate: VkBool32,
6154    pub attachmentFragmentShadingRate: VkBool32,
6155}
6156
6157#[derive(Clone, Copy)]
6158#[repr(C)]
6159pub struct VkPhysicalDeviceFragmentShadingRateKHR {
6160    pub sType: VkStructureType,
6161    pub pNext: *mut c_void,
6162    pub sampleCounts: VkSampleCountFlags,
6163    pub fragmentSize: VkExtent2D,
6164}
6165
6166#[derive(Clone, Copy)]
6167#[repr(C)]
6168pub struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR {
6169    pub sType: VkStructureType,
6170    pub pNext: *mut c_void,
6171    pub minFragmentShadingRateAttachmentTexelSize: VkExtent2D,
6172    pub maxFragmentShadingRateAttachmentTexelSize: VkExtent2D,
6173    pub maxFragmentShadingRateAttachmentTexelSizeAspectRatio: u32,
6174    pub primitiveFragmentShadingRateWithMultipleViewports: VkBool32,
6175    pub layeredShadingRateAttachments: VkBool32,
6176    pub fragmentShadingRateNonTrivialCombinerOps: VkBool32,
6177    pub maxFragmentSize: VkExtent2D,
6178    pub maxFragmentSizeAspectRatio: u32,
6179    pub maxFragmentShadingRateCoverageSamples: u32,
6180    pub maxFragmentShadingRateRasterizationSamples: VkSampleCountFlagBits,
6181    pub fragmentShadingRateWithShaderDepthStencilWrites: VkBool32,
6182    pub fragmentShadingRateWithSampleMask: VkBool32,
6183    pub fragmentShadingRateWithShaderSampleMask: VkBool32,
6184    pub fragmentShadingRateWithConservativeRasterization: VkBool32,
6185    pub fragmentShadingRateWithFragmentShaderInterlock: VkBool32,
6186    pub fragmentShadingRateWithCustomSampleLocations: VkBool32,
6187    pub fragmentShadingRateStrictMultiplyCombiner: VkBool32,
6188}
6189
6190#[derive(Clone, Copy)]
6191#[repr(C)]
6192pub struct VkPhysicalDeviceFrameBoundaryFeaturesEXT {
6193    pub sType: VkStructureType,
6194    pub pNext: *mut c_void,
6195    pub frameBoundary: VkBool32,
6196}
6197
6198#[derive(Clone, Copy)]
6199#[repr(C)]
6200pub struct VkPhysicalDeviceGlobalPriorityQueryFeatures {
6201    pub sType: VkStructureType,
6202    pub pNext: *mut c_void,
6203    pub globalPriorityQuery: VkBool32,
6204}
6205
6206#[derive(Clone, Copy)]
6207#[repr(C)]
6208pub struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
6209    pub sType: VkStructureType,
6210    pub pNext: *mut c_void,
6211    pub graphicsPipelineLibrary: VkBool32,
6212}
6213
6214#[derive(Clone, Copy)]
6215#[repr(C)]
6216pub struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
6217    pub sType: VkStructureType,
6218    pub pNext: *mut c_void,
6219    pub graphicsPipelineLibraryFastLinking: VkBool32,
6220    pub graphicsPipelineLibraryIndependentInterpolationDecoration: VkBool32,
6221}
6222
6223#[derive(Clone, Copy)]
6224#[repr(C)]
6225pub struct VkPhysicalDeviceGroupProperties {
6226    pub sType: VkStructureType,
6227    pub pNext: *mut c_void,
6228    pub physicalDeviceCount: u32,
6229    pub physicalDevices: [VkPhysicalDevice; VK_MAX_DEVICE_GROUP_SIZE as usize],
6230    pub subsetAllocation: VkBool32,
6231}
6232
6233#[derive(Clone, Copy)]
6234#[repr(C)]
6235pub struct VkPhysicalDeviceHdrVividFeaturesHUAWEI {
6236    pub sType: VkStructureType,
6237    pub pNext: *mut c_void,
6238    pub hdrVivid: VkBool32,
6239}
6240
6241#[derive(Clone, Copy)]
6242#[repr(C)]
6243pub struct VkPhysicalDeviceHostImageCopyFeatures {
6244    pub sType: VkStructureType,
6245    pub pNext: *mut c_void,
6246    pub hostImageCopy: VkBool32,
6247}
6248
6249#[derive(Clone, Copy)]
6250#[repr(C)]
6251pub struct VkPhysicalDeviceHostImageCopyProperties {
6252    pub sType: VkStructureType,
6253    pub pNext: *mut c_void,
6254    pub copySrcLayoutCount: u32,
6255    pub pCopySrcLayouts: *mut VkImageLayout,
6256    pub copyDstLayoutCount: u32,
6257    pub pCopyDstLayouts: *mut VkImageLayout,
6258    pub optimalTilingLayoutUUID: [u8; VK_UUID_SIZE as usize],
6259    pub identicalMemoryTypeRequirements: VkBool32,
6260}
6261
6262#[derive(Clone, Copy)]
6263#[repr(C)]
6264pub struct VkPhysicalDeviceHostQueryResetFeatures {
6265    pub sType: VkStructureType,
6266    pub pNext: *mut c_void,
6267    pub hostQueryReset: VkBool32,
6268}
6269
6270#[derive(Clone, Copy)]
6271#[repr(C)]
6272pub struct VkPhysicalDeviceIDProperties {
6273    pub sType: VkStructureType,
6274    pub pNext: *mut c_void,
6275    pub deviceUUID: [u8; VK_UUID_SIZE as usize],
6276    pub driverUUID: [u8; VK_UUID_SIZE as usize],
6277    pub deviceLUID: [u8; VK_LUID_SIZE as usize],
6278    pub deviceNodeMask: u32,
6279    pub deviceLUIDValid: VkBool32,
6280}
6281
6282#[derive(Clone, Copy)]
6283#[repr(C)]
6284pub struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT {
6285    pub sType: VkStructureType,
6286    pub pNext: *mut c_void,
6287    pub image2DViewOf3D: VkBool32,
6288    pub sampler2DViewOf3D: VkBool32,
6289}
6290
6291#[derive(Clone, Copy)]
6292#[repr(C)]
6293pub struct VkPhysicalDeviceImageAlignmentControlFeaturesMESA {
6294    pub sType: VkStructureType,
6295    pub pNext: *mut c_void,
6296    pub imageAlignmentControl: VkBool32,
6297}
6298
6299#[derive(Clone, Copy)]
6300#[repr(C)]
6301pub struct VkPhysicalDeviceImageAlignmentControlPropertiesMESA {
6302    pub sType: VkStructureType,
6303    pub pNext: *mut c_void,
6304    pub supportedImageAlignmentMask: u32,
6305}
6306
6307#[derive(Clone, Copy)]
6308#[repr(C)]
6309pub struct VkPhysicalDeviceImageCompressionControlFeaturesEXT {
6310    pub sType: VkStructureType,
6311    pub pNext: *mut c_void,
6312    pub imageCompressionControl: VkBool32,
6313}
6314
6315#[derive(Clone, Copy)]
6316#[repr(C)]
6317pub struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
6318    pub sType: VkStructureType,
6319    pub pNext: *mut c_void,
6320    pub imageCompressionControlSwapchain: VkBool32,
6321}
6322
6323#[derive(Clone, Copy)]
6324#[repr(C)]
6325pub struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT {
6326    pub sType: VkStructureType,
6327    pub pNext: *const c_void,
6328    pub drmFormatModifier: u64,
6329    pub sharingMode: VkSharingMode,
6330    pub queueFamilyIndexCount: u32,
6331    pub pQueueFamilyIndices: *const u32,
6332}
6333
6334#[derive(Clone, Copy)]
6335#[repr(C)]
6336pub struct VkPhysicalDeviceImageFormatInfo2 {
6337    pub sType: VkStructureType,
6338    pub pNext: *const c_void,
6339    pub format: VkFormat,
6340    pub typ: VkImageType,
6341    pub tiling: VkImageTiling,
6342    pub usage: VkImageUsageFlags,
6343    pub flags: VkImageCreateFlags,
6344}
6345
6346#[derive(Clone, Copy)]
6347#[repr(C)]
6348pub struct VkPhysicalDeviceImageProcessing2FeaturesQCOM {
6349    pub sType: VkStructureType,
6350    pub pNext: *mut c_void,
6351    pub textureBlockMatch2: VkBool32,
6352}
6353
6354#[derive(Clone, Copy)]
6355#[repr(C)]
6356pub struct VkPhysicalDeviceImageProcessing2PropertiesQCOM {
6357    pub sType: VkStructureType,
6358    pub pNext: *mut c_void,
6359    pub maxBlockMatchWindow: VkExtent2D,
6360}
6361
6362#[derive(Clone, Copy)]
6363#[repr(C)]
6364pub struct VkPhysicalDeviceImageProcessingFeaturesQCOM {
6365    pub sType: VkStructureType,
6366    pub pNext: *mut c_void,
6367    pub textureSampleWeighted: VkBool32,
6368    pub textureBoxFilter: VkBool32,
6369    pub textureBlockMatch: VkBool32,
6370}
6371
6372#[derive(Clone, Copy)]
6373#[repr(C)]
6374pub struct VkPhysicalDeviceImageProcessingPropertiesQCOM {
6375    pub sType: VkStructureType,
6376    pub pNext: *mut c_void,
6377    pub maxWeightFilterPhases: u32,
6378    pub maxWeightFilterDimension: VkExtent2D,
6379    pub maxBlockMatchRegion: VkExtent2D,
6380    pub maxBoxFilterBlockSize: VkExtent2D,
6381}
6382
6383#[derive(Clone, Copy)]
6384#[repr(C)]
6385pub struct VkPhysicalDeviceImageRobustnessFeatures {
6386    pub sType: VkStructureType,
6387    pub pNext: *mut c_void,
6388    pub robustImageAccess: VkBool32,
6389}
6390
6391#[derive(Clone, Copy)]
6392#[repr(C)]
6393pub struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
6394    pub sType: VkStructureType,
6395    pub pNext: *mut c_void,
6396    pub imageSlicedViewOf3D: VkBool32,
6397}
6398
6399#[derive(Clone, Copy)]
6400#[repr(C)]
6401pub struct VkPhysicalDeviceImageViewImageFormatInfoEXT {
6402    pub sType: VkStructureType,
6403    pub pNext: *mut c_void,
6404    pub imageViewType: VkImageViewType,
6405}
6406
6407#[derive(Clone, Copy)]
6408#[repr(C)]
6409pub struct VkPhysicalDeviceImageViewMinLodFeaturesEXT {
6410    pub sType: VkStructureType,
6411    pub pNext: *mut c_void,
6412    pub minLod: VkBool32,
6413}
6414
6415#[derive(Clone, Copy)]
6416#[repr(C)]
6417pub struct VkPhysicalDeviceImagelessFramebufferFeatures {
6418    pub sType: VkStructureType,
6419    pub pNext: *mut c_void,
6420    pub imagelessFramebuffer: VkBool32,
6421}
6422
6423#[derive(Clone, Copy)]
6424#[repr(C)]
6425pub struct VkPhysicalDeviceIndexTypeUint8Features {
6426    pub sType: VkStructureType,
6427    pub pNext: *mut c_void,
6428    pub indexTypeUint8: VkBool32,
6429}
6430
6431#[derive(Clone, Copy)]
6432#[repr(C)]
6433pub struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV {
6434    pub sType: VkStructureType,
6435    pub pNext: *mut c_void,
6436    pub inheritedViewportScissor2D: VkBool32,
6437}
6438
6439#[derive(Clone, Copy)]
6440#[repr(C)]
6441pub struct VkPhysicalDeviceInlineUniformBlockFeatures {
6442    pub sType: VkStructureType,
6443    pub pNext: *mut c_void,
6444    pub inlineUniformBlock: VkBool32,
6445    pub descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
6446}
6447
6448#[derive(Clone, Copy)]
6449#[repr(C)]
6450pub struct VkPhysicalDeviceInlineUniformBlockProperties {
6451    pub sType: VkStructureType,
6452    pub pNext: *mut c_void,
6453    pub maxInlineUniformBlockSize: u32,
6454    pub maxPerStageDescriptorInlineUniformBlocks: u32,
6455    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
6456    pub maxDescriptorSetInlineUniformBlocks: u32,
6457    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32,
6458}
6459
6460#[derive(Clone, Copy)]
6461#[repr(C)]
6462pub struct VkPhysicalDeviceInternallySynchronizedQueuesFeaturesKHR {
6463    pub sType: VkStructureType,
6464    pub pNext: *mut c_void,
6465    pub internallySynchronizedQueues: VkBool32,
6466}
6467
6468#[derive(Clone, Copy)]
6469#[repr(C)]
6470pub struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI {
6471    pub sType: VkStructureType,
6472    pub pNext: *mut c_void,
6473    pub invocationMask: VkBool32,
6474}
6475
6476#[derive(Clone, Copy)]
6477#[repr(C)]
6478pub struct VkPhysicalDeviceLayeredApiPropertiesKHR {
6479    pub sType: VkStructureType,
6480    pub pNext: *mut c_void,
6481    pub vendorID: u32,
6482    pub deviceID: u32,
6483    pub layeredAPI: VkPhysicalDeviceLayeredApiKHR,
6484    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
6485}
6486
6487#[derive(Clone, Copy)]
6488#[repr(C)]
6489pub struct VkPhysicalDeviceLayeredApiPropertiesListKHR {
6490    pub sType: VkStructureType,
6491    pub pNext: *mut c_void,
6492    pub layeredApiCount: u32,
6493    pub pLayeredApis: *mut VkPhysicalDeviceLayeredApiPropertiesKHR,
6494}
6495
6496#[derive(Clone, Copy)]
6497#[repr(C)]
6498pub struct VkPhysicalDeviceLayeredApiVulkanPropertiesKHR {
6499    pub sType: VkStructureType,
6500    pub pNext: *mut c_void,
6501    pub properties: VkPhysicalDeviceProperties2,
6502}
6503
6504#[derive(Clone, Copy)]
6505#[repr(C)]
6506pub struct VkPhysicalDeviceLayeredDriverPropertiesMSFT {
6507    pub sType: VkStructureType,
6508    pub pNext: *mut c_void,
6509    pub underlyingAPI: VkLayeredDriverUnderlyingApiMSFT,
6510}
6511
6512#[derive(Clone, Copy)]
6513#[repr(C)]
6514pub struct VkPhysicalDeviceLegacyDitheringFeaturesEXT {
6515    pub sType: VkStructureType,
6516    pub pNext: *mut c_void,
6517    pub legacyDithering: VkBool32,
6518}
6519
6520#[derive(Clone, Copy)]
6521#[repr(C)]
6522pub struct VkPhysicalDeviceLegacyVertexAttributesFeaturesEXT {
6523    pub sType: VkStructureType,
6524    pub pNext: *mut c_void,
6525    pub legacyVertexAttributes: VkBool32,
6526}
6527
6528#[derive(Clone, Copy)]
6529#[repr(C)]
6530pub struct VkPhysicalDeviceLegacyVertexAttributesPropertiesEXT {
6531    pub sType: VkStructureType,
6532    pub pNext: *mut c_void,
6533    pub nativeUnalignedPerformance: VkBool32,
6534}
6535
6536#[derive(Clone, Copy)]
6537#[repr(C)]
6538pub struct VkPhysicalDeviceLimits {
6539    pub maxImageDimension1D: u32,
6540    pub maxImageDimension2D: u32,
6541    pub maxImageDimension3D: u32,
6542    pub maxImageDimensionCube: u32,
6543    pub maxImageArrayLayers: u32,
6544    pub maxTexelBufferElements: u32,
6545    pub maxUniformBufferRange: u32,
6546    pub maxStorageBufferRange: u32,
6547    pub maxPushConstantsSize: u32,
6548    pub maxMemoryAllocationCount: u32,
6549    pub maxSamplerAllocationCount: u32,
6550    pub bufferImageGranularity: VkDeviceSize,
6551    pub sparseAddressSpaceSize: VkDeviceSize,
6552    pub maxBoundDescriptorSets: u32,
6553    pub maxPerStageDescriptorSamplers: u32,
6554    pub maxPerStageDescriptorUniformBuffers: u32,
6555    pub maxPerStageDescriptorStorageBuffers: u32,
6556    pub maxPerStageDescriptorSampledImages: u32,
6557    pub maxPerStageDescriptorStorageImages: u32,
6558    pub maxPerStageDescriptorInputAttachments: u32,
6559    pub maxPerStageResources: u32,
6560    pub maxDescriptorSetSamplers: u32,
6561    pub maxDescriptorSetUniformBuffers: u32,
6562    pub maxDescriptorSetUniformBuffersDynamic: u32,
6563    pub maxDescriptorSetStorageBuffers: u32,
6564    pub maxDescriptorSetStorageBuffersDynamic: u32,
6565    pub maxDescriptorSetSampledImages: u32,
6566    pub maxDescriptorSetStorageImages: u32,
6567    pub maxDescriptorSetInputAttachments: u32,
6568    pub maxVertexInputAttributes: u32,
6569    pub maxVertexInputBindings: u32,
6570    pub maxVertexInputAttributeOffset: u32,
6571    pub maxVertexInputBindingStride: u32,
6572    pub maxVertexOutputComponents: u32,
6573    pub maxTessellationGenerationLevel: u32,
6574    pub maxTessellationPatchSize: u32,
6575    pub maxTessellationControlPerVertexInputComponents: u32,
6576    pub maxTessellationControlPerVertexOutputComponents: u32,
6577    pub maxTessellationControlPerPatchOutputComponents: u32,
6578    pub maxTessellationControlTotalOutputComponents: u32,
6579    pub maxTessellationEvaluationInputComponents: u32,
6580    pub maxTessellationEvaluationOutputComponents: u32,
6581    pub maxGeometryShaderInvocations: u32,
6582    pub maxGeometryInputComponents: u32,
6583    pub maxGeometryOutputComponents: u32,
6584    pub maxGeometryOutputVertices: u32,
6585    pub maxGeometryTotalOutputComponents: u32,
6586    pub maxFragmentInputComponents: u32,
6587    pub maxFragmentOutputAttachments: u32,
6588    pub maxFragmentDualSrcAttachments: u32,
6589    pub maxFragmentCombinedOutputResources: u32,
6590    pub maxComputeSharedMemorySize: u32,
6591    pub maxComputeWorkGroupCount: [u32; 3 as usize],
6592    pub maxComputeWorkGroupInvocations: u32,
6593    pub maxComputeWorkGroupSize: [u32; 3 as usize],
6594    pub subPixelPrecisionBits: u32,
6595    pub subTexelPrecisionBits: u32,
6596    pub mipmapPrecisionBits: u32,
6597    pub maxDrawIndexedIndexValue: u32,
6598    pub maxDrawIndirectCount: u32,
6599    pub maxSamplerLodBias: f32,
6600    pub maxSamplerAnisotropy: f32,
6601    pub maxViewports: u32,
6602    pub maxViewportDimensions: [u32; 2 as usize],
6603    pub viewportBoundsRange: [f32; 2 as usize],
6604    pub viewportSubPixelBits: u32,
6605    pub minMemoryMapAlignment: usize,
6606    pub minTexelBufferOffsetAlignment: VkDeviceSize,
6607    pub minUniformBufferOffsetAlignment: VkDeviceSize,
6608    pub minStorageBufferOffsetAlignment: VkDeviceSize,
6609    pub minTexelOffset: i32,
6610    pub maxTexelOffset: u32,
6611    pub minTexelGatherOffset: i32,
6612    pub maxTexelGatherOffset: u32,
6613    pub minInterpolationOffset: f32,
6614    pub maxInterpolationOffset: f32,
6615    pub subPixelInterpolationOffsetBits: u32,
6616    pub maxFramebufferWidth: u32,
6617    pub maxFramebufferHeight: u32,
6618    pub maxFramebufferLayers: u32,
6619    pub framebufferColorSampleCounts: VkSampleCountFlags,
6620    pub framebufferDepthSampleCounts: VkSampleCountFlags,
6621    pub framebufferStencilSampleCounts: VkSampleCountFlags,
6622    pub framebufferNoAttachmentsSampleCounts: VkSampleCountFlags,
6623    pub maxColorAttachments: u32,
6624    pub sampledImageColorSampleCounts: VkSampleCountFlags,
6625    pub sampledImageIntegerSampleCounts: VkSampleCountFlags,
6626    pub sampledImageDepthSampleCounts: VkSampleCountFlags,
6627    pub sampledImageStencilSampleCounts: VkSampleCountFlags,
6628    pub storageImageSampleCounts: VkSampleCountFlags,
6629    pub maxSampleMaskWords: u32,
6630    pub timestampComputeAndGraphics: VkBool32,
6631    pub timestampPeriod: f32,
6632    pub maxClipDistances: u32,
6633    pub maxCullDistances: u32,
6634    pub maxCombinedClipAndCullDistances: u32,
6635    pub discreteQueuePriorities: u32,
6636    pub pointSizeRange: [f32; 2 as usize],
6637    pub lineWidthRange: [f32; 2 as usize],
6638    pub pointSizeGranularity: f32,
6639    pub lineWidthGranularity: f32,
6640    pub strictLines: VkBool32,
6641    pub standardSampleLocations: VkBool32,
6642    pub optimalBufferCopyOffsetAlignment: VkDeviceSize,
6643    pub optimalBufferCopyRowPitchAlignment: VkDeviceSize,
6644    pub nonCoherentAtomSize: VkDeviceSize,
6645}
6646
6647#[derive(Clone, Copy)]
6648#[repr(C)]
6649pub struct VkPhysicalDeviceLineRasterizationFeatures {
6650    pub sType: VkStructureType,
6651    pub pNext: *mut c_void,
6652    pub rectangularLines: VkBool32,
6653    pub bresenhamLines: VkBool32,
6654    pub smoothLines: VkBool32,
6655    pub stippledRectangularLines: VkBool32,
6656    pub stippledBresenhamLines: VkBool32,
6657    pub stippledSmoothLines: VkBool32,
6658}
6659
6660#[derive(Clone, Copy)]
6661#[repr(C)]
6662pub struct VkPhysicalDeviceLineRasterizationProperties {
6663    pub sType: VkStructureType,
6664    pub pNext: *mut c_void,
6665    pub lineSubPixelPrecisionBits: u32,
6666}
6667
6668#[derive(Clone, Copy)]
6669#[repr(C)]
6670pub struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV {
6671    pub sType: VkStructureType,
6672    pub pNext: *mut c_void,
6673    pub linearColorAttachment: VkBool32,
6674}
6675
6676#[derive(Clone, Copy)]
6677#[repr(C)]
6678pub struct VkPhysicalDeviceMaintenance10FeaturesKHR {
6679    pub sType: VkStructureType,
6680    pub pNext: *mut c_void,
6681    pub maintenance10: VkBool32,
6682}
6683
6684#[derive(Clone, Copy)]
6685#[repr(C)]
6686pub struct VkPhysicalDeviceMaintenance10PropertiesKHR {
6687    pub sType: VkStructureType,
6688    pub pNext: *mut c_void,
6689    pub rgba4OpaqueBlackSwizzled: VkBool32,
6690    pub resolveSrgbFormatAppliesTransferFunction: VkBool32,
6691    pub resolveSrgbFormatSupportsTransferFunctionControl: VkBool32,
6692}
6693
6694#[derive(Clone, Copy)]
6695#[repr(C)]
6696pub struct VkPhysicalDeviceMaintenance3Properties {
6697    pub sType: VkStructureType,
6698    pub pNext: *mut c_void,
6699    pub maxPerSetDescriptors: u32,
6700    pub maxMemoryAllocationSize: VkDeviceSize,
6701}
6702
6703#[derive(Clone, Copy)]
6704#[repr(C)]
6705pub struct VkPhysicalDeviceMaintenance4Features {
6706    pub sType: VkStructureType,
6707    pub pNext: *mut c_void,
6708    pub maintenance4: VkBool32,
6709}
6710
6711#[derive(Clone, Copy)]
6712#[repr(C)]
6713pub struct VkPhysicalDeviceMaintenance4Properties {
6714    pub sType: VkStructureType,
6715    pub pNext: *mut c_void,
6716    pub maxBufferSize: VkDeviceSize,
6717}
6718
6719#[derive(Clone, Copy)]
6720#[repr(C)]
6721pub struct VkPhysicalDeviceMaintenance5Features {
6722    pub sType: VkStructureType,
6723    pub pNext: *mut c_void,
6724    pub maintenance5: VkBool32,
6725}
6726
6727#[derive(Clone, Copy)]
6728#[repr(C)]
6729pub struct VkPhysicalDeviceMaintenance5Properties {
6730    pub sType: VkStructureType,
6731    pub pNext: *mut c_void,
6732    pub earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
6733    pub earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
6734    pub depthStencilSwizzleOneSupport: VkBool32,
6735    pub polygonModePointSize: VkBool32,
6736    pub nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
6737    pub nonStrictWideLinesUseParallelogram: VkBool32,
6738}
6739
6740#[derive(Clone, Copy)]
6741#[repr(C)]
6742pub struct VkPhysicalDeviceMaintenance6Features {
6743    pub sType: VkStructureType,
6744    pub pNext: *mut c_void,
6745    pub maintenance6: VkBool32,
6746}
6747
6748#[derive(Clone, Copy)]
6749#[repr(C)]
6750pub struct VkPhysicalDeviceMaintenance6Properties {
6751    pub sType: VkStructureType,
6752    pub pNext: *mut c_void,
6753    pub blockTexelViewCompatibleMultipleLayers: VkBool32,
6754    pub maxCombinedImageSamplerDescriptorCount: u32,
6755    pub fragmentShadingRateClampCombinerInputs: VkBool32,
6756}
6757
6758#[derive(Clone, Copy)]
6759#[repr(C)]
6760pub struct VkPhysicalDeviceMaintenance7FeaturesKHR {
6761    pub sType: VkStructureType,
6762    pub pNext: *mut c_void,
6763    pub maintenance7: VkBool32,
6764}
6765
6766#[derive(Clone, Copy)]
6767#[repr(C)]
6768pub struct VkPhysicalDeviceMaintenance7PropertiesKHR {
6769    pub sType: VkStructureType,
6770    pub pNext: *mut c_void,
6771    pub robustFragmentShadingRateAttachmentAccess: VkBool32,
6772    pub separateDepthStencilAttachmentAccess: VkBool32,
6773    pub maxDescriptorSetTotalUniformBuffersDynamic: u32,
6774    pub maxDescriptorSetTotalStorageBuffersDynamic: u32,
6775    pub maxDescriptorSetTotalBuffersDynamic: u32,
6776    pub maxDescriptorSetUpdateAfterBindTotalUniformBuffersDynamic: u32,
6777    pub maxDescriptorSetUpdateAfterBindTotalStorageBuffersDynamic: u32,
6778    pub maxDescriptorSetUpdateAfterBindTotalBuffersDynamic: u32,
6779}
6780
6781#[derive(Clone, Copy)]
6782#[repr(C)]
6783pub struct VkPhysicalDeviceMaintenance8FeaturesKHR {
6784    pub sType: VkStructureType,
6785    pub pNext: *mut c_void,
6786    pub maintenance8: VkBool32,
6787}
6788
6789#[derive(Clone, Copy)]
6790#[repr(C)]
6791pub struct VkPhysicalDeviceMaintenance9FeaturesKHR {
6792    pub sType: VkStructureType,
6793    pub pNext: *mut c_void,
6794    pub maintenance9: VkBool32,
6795}
6796
6797#[derive(Clone, Copy)]
6798#[repr(C)]
6799pub struct VkPhysicalDeviceMaintenance9PropertiesKHR {
6800    pub sType: VkStructureType,
6801    pub pNext: *mut c_void,
6802    pub image2DViewOf3DSparse: VkBool32,
6803    pub defaultVertexAttributeValue: VkDefaultVertexAttributeValueKHR,
6804}
6805
6806#[derive(Clone, Copy)]
6807#[repr(C)]
6808pub struct VkPhysicalDeviceMapMemoryPlacedFeaturesEXT {
6809    pub sType: VkStructureType,
6810    pub pNext: *mut c_void,
6811    pub memoryMapPlaced: VkBool32,
6812    pub memoryMapRangePlaced: VkBool32,
6813    pub memoryUnmapReserve: VkBool32,
6814}
6815
6816#[derive(Clone, Copy)]
6817#[repr(C)]
6818pub struct VkPhysicalDeviceMapMemoryPlacedPropertiesEXT {
6819    pub sType: VkStructureType,
6820    pub pNext: *mut c_void,
6821    pub minPlacedMemoryMapAlignment: VkDeviceSize,
6822}
6823
6824#[derive(Clone, Copy)]
6825#[repr(C)]
6826pub struct VkPhysicalDeviceMemoryBudgetPropertiesEXT {
6827    pub sType: VkStructureType,
6828    pub pNext: *mut c_void,
6829    pub heapBudget: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
6830    pub heapUsage: [VkDeviceSize; VK_MAX_MEMORY_HEAPS as usize],
6831}
6832
6833#[derive(Clone, Copy)]
6834#[repr(C)]
6835pub struct VkPhysicalDeviceMemoryDecompressionFeaturesEXT {
6836    pub sType: VkStructureType,
6837    pub pNext: *mut c_void,
6838    pub memoryDecompression: VkBool32,
6839}
6840
6841#[derive(Clone, Copy)]
6842#[repr(C)]
6843pub struct VkPhysicalDeviceMemoryDecompressionPropertiesEXT {
6844    pub sType: VkStructureType,
6845    pub pNext: *mut c_void,
6846    pub decompressionMethods: VkMemoryDecompressionMethodFlagsEXT,
6847    pub maxDecompressionIndirectCount: u64,
6848}
6849
6850#[derive(Clone, Copy)]
6851#[repr(C)]
6852pub struct VkPhysicalDeviceMemoryPriorityFeaturesEXT {
6853    pub sType: VkStructureType,
6854    pub pNext: *mut c_void,
6855    pub memoryPriority: VkBool32,
6856}
6857
6858#[derive(Clone, Copy)]
6859#[repr(C)]
6860pub struct VkPhysicalDeviceMemoryProperties {
6861    pub memoryTypeCount: u32,
6862    pub memoryTypes: [VkMemoryType; VK_MAX_MEMORY_TYPES as usize],
6863    pub memoryHeapCount: u32,
6864    pub memoryHeaps: [VkMemoryHeap; VK_MAX_MEMORY_HEAPS as usize],
6865}
6866
6867#[derive(Clone, Copy)]
6868#[repr(C)]
6869pub struct VkPhysicalDeviceMemoryProperties2 {
6870    pub sType: VkStructureType,
6871    pub pNext: *mut c_void,
6872    pub memoryProperties: VkPhysicalDeviceMemoryProperties,
6873}
6874
6875#[derive(Clone, Copy)]
6876#[repr(C)]
6877pub struct VkPhysicalDeviceMeshShaderFeaturesEXT {
6878    pub sType: VkStructureType,
6879    pub pNext: *mut c_void,
6880    pub taskShader: VkBool32,
6881    pub meshShader: VkBool32,
6882    pub multiviewMeshShader: VkBool32,
6883    pub primitiveFragmentShadingRateMeshShader: VkBool32,
6884    pub meshShaderQueries: VkBool32,
6885}
6886
6887#[derive(Clone, Copy)]
6888#[repr(C)]
6889pub struct VkPhysicalDeviceMeshShaderFeaturesNV {
6890    pub sType: VkStructureType,
6891    pub pNext: *mut c_void,
6892    pub taskShader: VkBool32,
6893    pub meshShader: VkBool32,
6894}
6895
6896#[derive(Clone, Copy)]
6897#[repr(C)]
6898pub struct VkPhysicalDeviceMeshShaderPropertiesEXT {
6899    pub sType: VkStructureType,
6900    pub pNext: *mut c_void,
6901    pub maxTaskWorkGroupTotalCount: u32,
6902    pub maxTaskWorkGroupCount: [u32; 3 as usize],
6903    pub maxTaskWorkGroupInvocations: u32,
6904    pub maxTaskWorkGroupSize: [u32; 3 as usize],
6905    pub maxTaskPayloadSize: u32,
6906    pub maxTaskSharedMemorySize: u32,
6907    pub maxTaskPayloadAndSharedMemorySize: u32,
6908    pub maxMeshWorkGroupTotalCount: u32,
6909    pub maxMeshWorkGroupCount: [u32; 3 as usize],
6910    pub maxMeshWorkGroupInvocations: u32,
6911    pub maxMeshWorkGroupSize: [u32; 3 as usize],
6912    pub maxMeshSharedMemorySize: u32,
6913    pub maxMeshPayloadAndSharedMemorySize: u32,
6914    pub maxMeshOutputMemorySize: u32,
6915    pub maxMeshPayloadAndOutputMemorySize: u32,
6916    pub maxMeshOutputComponents: u32,
6917    pub maxMeshOutputVertices: u32,
6918    pub maxMeshOutputPrimitives: u32,
6919    pub maxMeshOutputLayers: u32,
6920    pub maxMeshMultiviewViewCount: u32,
6921    pub meshOutputPerVertexGranularity: u32,
6922    pub meshOutputPerPrimitiveGranularity: u32,
6923    pub maxPreferredTaskWorkGroupInvocations: u32,
6924    pub maxPreferredMeshWorkGroupInvocations: u32,
6925    pub prefersLocalInvocationVertexOutput: VkBool32,
6926    pub prefersLocalInvocationPrimitiveOutput: VkBool32,
6927    pub prefersCompactVertexOutput: VkBool32,
6928    pub prefersCompactPrimitiveOutput: VkBool32,
6929}
6930
6931#[derive(Clone, Copy)]
6932#[repr(C)]
6933pub struct VkPhysicalDeviceMeshShaderPropertiesNV {
6934    pub sType: VkStructureType,
6935    pub pNext: *mut c_void,
6936    pub maxDrawMeshTasksCount: u32,
6937    pub maxTaskWorkGroupInvocations: u32,
6938    pub maxTaskWorkGroupSize: [u32; 3 as usize],
6939    pub maxTaskTotalMemorySize: u32,
6940    pub maxTaskOutputCount: u32,
6941    pub maxMeshWorkGroupInvocations: u32,
6942    pub maxMeshWorkGroupSize: [u32; 3 as usize],
6943    pub maxMeshTotalMemorySize: u32,
6944    pub maxMeshOutputVertices: u32,
6945    pub maxMeshOutputPrimitives: u32,
6946    pub maxMeshMultiviewViewCount: u32,
6947    pub meshOutputPerVertexGranularity: u32,
6948    pub meshOutputPerPrimitiveGranularity: u32,
6949}
6950
6951#[derive(Clone, Copy)]
6952#[repr(C)]
6953pub struct VkPhysicalDeviceMultiDrawFeaturesEXT {
6954    pub sType: VkStructureType,
6955    pub pNext: *mut c_void,
6956    pub multiDraw: VkBool32,
6957}
6958
6959#[derive(Clone, Copy)]
6960#[repr(C)]
6961pub struct VkPhysicalDeviceMultiDrawPropertiesEXT {
6962    pub sType: VkStructureType,
6963    pub pNext: *mut c_void,
6964    pub maxMultiDrawCount: u32,
6965}
6966
6967#[derive(Clone, Copy)]
6968#[repr(C)]
6969pub struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
6970    pub sType: VkStructureType,
6971    pub pNext: *mut c_void,
6972    pub multisampledRenderToSingleSampled: VkBool32,
6973}
6974
6975#[derive(Clone, Copy)]
6976#[repr(C)]
6977pub struct VkPhysicalDeviceMultiviewFeatures {
6978    pub sType: VkStructureType,
6979    pub pNext: *mut c_void,
6980    pub multiview: VkBool32,
6981    pub multiviewGeometryShader: VkBool32,
6982    pub multiviewTessellationShader: VkBool32,
6983}
6984
6985#[derive(Clone, Copy)]
6986#[repr(C)]
6987pub struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
6988    pub sType: VkStructureType,
6989    pub pNext: *mut c_void,
6990    pub perViewPositionAllComponents: VkBool32,
6991}
6992
6993#[derive(Clone, Copy)]
6994#[repr(C)]
6995pub struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
6996    pub sType: VkStructureType,
6997    pub pNext: *mut c_void,
6998    pub multiviewPerViewRenderAreas: VkBool32,
6999}
7000
7001#[derive(Clone, Copy)]
7002#[repr(C)]
7003pub struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
7004    pub sType: VkStructureType,
7005    pub pNext: *mut c_void,
7006    pub multiviewPerViewViewports: VkBool32,
7007}
7008
7009#[derive(Clone, Copy)]
7010#[repr(C)]
7011pub struct VkPhysicalDeviceMultiviewProperties {
7012    pub sType: VkStructureType,
7013    pub pNext: *mut c_void,
7014    pub maxMultiviewViewCount: u32,
7015    pub maxMultiviewInstanceIndex: u32,
7016}
7017
7018#[derive(Clone, Copy)]
7019#[repr(C)]
7020pub struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT {
7021    pub sType: VkStructureType,
7022    pub pNext: *mut c_void,
7023    pub mutableDescriptorType: VkBool32,
7024}
7025
7026#[derive(Clone, Copy)]
7027#[repr(C)]
7028pub struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT {
7029    pub sType: VkStructureType,
7030    pub pNext: *mut c_void,
7031    pub nestedCommandBuffer: VkBool32,
7032    pub nestedCommandBufferRendering: VkBool32,
7033    pub nestedCommandBufferSimultaneousUse: VkBool32,
7034}
7035
7036#[derive(Clone, Copy)]
7037#[repr(C)]
7038pub struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT {
7039    pub sType: VkStructureType,
7040    pub pNext: *mut c_void,
7041    pub maxCommandBufferNestingLevel: u32,
7042}
7043
7044#[derive(Clone, Copy)]
7045#[repr(C)]
7046pub struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
7047    pub sType: VkStructureType,
7048    pub pNext: *mut c_void,
7049    pub nonSeamlessCubeMap: VkBool32,
7050}
7051
7052#[derive(Clone, Copy)]
7053#[repr(C)]
7054pub struct VkPhysicalDeviceOpacityMicromapFeaturesEXT {
7055    pub sType: VkStructureType,
7056    pub pNext: *mut c_void,
7057    pub micromap: VkBool32,
7058    pub micromapCaptureReplay: VkBool32,
7059    pub micromapHostCommands: VkBool32,
7060}
7061
7062#[derive(Clone, Copy)]
7063#[repr(C)]
7064pub struct VkPhysicalDeviceOpacityMicromapPropertiesEXT {
7065    pub sType: VkStructureType,
7066    pub pNext: *mut c_void,
7067    pub maxOpacity2StateSubdivisionLevel: u32,
7068    pub maxOpacity4StateSubdivisionLevel: u32,
7069}
7070
7071#[derive(Clone, Copy)]
7072#[repr(C)]
7073pub struct VkPhysicalDeviceOpticalFlowFeaturesNV {
7074    pub sType: VkStructureType,
7075    pub pNext: *mut c_void,
7076    pub opticalFlow: VkBool32,
7077}
7078
7079#[derive(Clone, Copy)]
7080#[repr(C)]
7081pub struct VkPhysicalDeviceOpticalFlowPropertiesNV {
7082    pub sType: VkStructureType,
7083    pub pNext: *mut c_void,
7084    pub supportedOutputGridSizes: VkOpticalFlowGridSizeFlagsNV,
7085    pub supportedHintGridSizes: VkOpticalFlowGridSizeFlagsNV,
7086    pub hintSupported: VkBool32,
7087    pub costSupported: VkBool32,
7088    pub bidirectionalFlowSupported: VkBool32,
7089    pub globalFlowSupported: VkBool32,
7090    pub minWidth: u32,
7091    pub minHeight: u32,
7092    pub maxWidth: u32,
7093    pub maxHeight: u32,
7094    pub maxNumRegionsOfInterest: u32,
7095}
7096
7097#[derive(Clone, Copy)]
7098#[repr(C)]
7099pub struct VkPhysicalDevicePCIBusInfoPropertiesEXT {
7100    pub sType: VkStructureType,
7101    pub pNext: *mut c_void,
7102    pub pciDomain: u32,
7103    pub pciBus: u32,
7104    pub pciDevice: u32,
7105    pub pciFunction: u32,
7106}
7107
7108#[derive(Clone, Copy)]
7109#[repr(C)]
7110pub struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
7111    pub sType: VkStructureType,
7112    pub pNext: *mut c_void,
7113    pub pageableDeviceLocalMemory: VkBool32,
7114}
7115
7116#[derive(Clone, Copy)]
7117#[repr(C)]
7118pub struct VkPhysicalDevicePartitionedAccelerationStructureFeaturesNV {
7119    pub sType: VkStructureType,
7120    pub pNext: *mut c_void,
7121    pub partitionedAccelerationStructure: VkBool32,
7122}
7123
7124#[derive(Clone, Copy)]
7125#[repr(C)]
7126pub struct VkPhysicalDevicePartitionedAccelerationStructurePropertiesNV {
7127    pub sType: VkStructureType,
7128    pub pNext: *mut c_void,
7129    pub maxPartitionCount: u32,
7130}
7131
7132#[derive(Clone, Copy)]
7133#[repr(C)]
7134pub struct VkPhysicalDevicePerStageDescriptorSetFeaturesNV {
7135    pub sType: VkStructureType,
7136    pub pNext: *mut c_void,
7137    pub perStageDescriptorSet: VkBool32,
7138    pub dynamicPipelineLayout: VkBool32,
7139}
7140
7141#[derive(Clone, Copy)]
7142#[repr(C)]
7143pub struct VkPhysicalDevicePerformanceCountersByRegionFeaturesARM {
7144    pub sType: VkStructureType,
7145    pub pNext: *mut c_void,
7146    pub performanceCountersByRegion: VkBool32,
7147}
7148
7149#[derive(Clone, Copy)]
7150#[repr(C)]
7151pub struct VkPhysicalDevicePerformanceCountersByRegionPropertiesARM {
7152    pub sType: VkStructureType,
7153    pub pNext: *mut c_void,
7154    pub maxPerRegionPerformanceCounters: u32,
7155    pub performanceCounterRegionSize: VkExtent2D,
7156    pub rowStrideAlignment: u32,
7157    pub regionAlignment: u32,
7158    pub identityTransformOrder: VkBool32,
7159}
7160
7161#[derive(Clone, Copy)]
7162#[repr(C)]
7163pub struct VkPhysicalDevicePerformanceQueryFeaturesKHR {
7164    pub sType: VkStructureType,
7165    pub pNext: *mut c_void,
7166    pub performanceCounterQueryPools: VkBool32,
7167    pub performanceCounterMultipleQueryPools: VkBool32,
7168}
7169
7170#[derive(Clone, Copy)]
7171#[repr(C)]
7172pub struct VkPhysicalDevicePerformanceQueryPropertiesKHR {
7173    pub sType: VkStructureType,
7174    pub pNext: *mut c_void,
7175    pub allowCommandBufferQueryCopies: VkBool32,
7176}
7177
7178#[derive(Clone, Copy)]
7179#[repr(C)]
7180pub struct VkPhysicalDevicePipelineBinaryFeaturesKHR {
7181    pub sType: VkStructureType,
7182    pub pNext: *mut c_void,
7183    pub pipelineBinaries: VkBool32,
7184}
7185
7186#[derive(Clone, Copy)]
7187#[repr(C)]
7188pub struct VkPhysicalDevicePipelineBinaryPropertiesKHR {
7189    pub sType: VkStructureType,
7190    pub pNext: *mut c_void,
7191    pub pipelineBinaryInternalCache: VkBool32,
7192    pub pipelineBinaryInternalCacheControl: VkBool32,
7193    pub pipelineBinaryPrefersInternalCache: VkBool32,
7194    pub pipelineBinaryPrecompiledInternalCache: VkBool32,
7195    pub pipelineBinaryCompressedData: VkBool32,
7196}
7197
7198#[derive(Clone, Copy)]
7199#[repr(C)]
7200pub struct VkPhysicalDevicePipelineCacheIncrementalModeFeaturesSEC {
7201    pub sType: VkStructureType,
7202    pub pNext: *mut c_void,
7203    pub pipelineCacheIncrementalMode: VkBool32,
7204}
7205
7206#[derive(Clone, Copy)]
7207#[repr(C)]
7208pub struct VkPhysicalDevicePipelineCreationCacheControlFeatures {
7209    pub sType: VkStructureType,
7210    pub pNext: *mut c_void,
7211    pub pipelineCreationCacheControl: VkBool32,
7212}
7213
7214#[derive(Clone, Copy)]
7215#[repr(C)]
7216pub struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
7217    pub sType: VkStructureType,
7218    pub pNext: *mut c_void,
7219    pub pipelineExecutableInfo: VkBool32,
7220}
7221
7222#[derive(Clone, Copy)]
7223#[repr(C)]
7224pub struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
7225    pub sType: VkStructureType,
7226    pub pNext: *mut c_void,
7227    pub pipelineLibraryGroupHandles: VkBool32,
7228}
7229
7230#[derive(Clone, Copy)]
7231#[repr(C)]
7232pub struct VkPhysicalDevicePipelineOpacityMicromapFeaturesARM {
7233    pub sType: VkStructureType,
7234    pub pNext: *mut c_void,
7235    pub pipelineOpacityMicromap: VkBool32,
7236}
7237
7238#[derive(Clone, Copy)]
7239#[repr(C)]
7240pub struct VkPhysicalDevicePipelinePropertiesFeaturesEXT {
7241    pub sType: VkStructureType,
7242    pub pNext: *mut c_void,
7243    pub pipelinePropertiesIdentifier: VkBool32,
7244}
7245
7246#[derive(Clone, Copy)]
7247#[repr(C)]
7248pub struct VkPhysicalDevicePipelineProtectedAccessFeatures {
7249    pub sType: VkStructureType,
7250    pub pNext: *mut c_void,
7251    pub pipelineProtectedAccess: VkBool32,
7252}
7253
7254#[derive(Clone, Copy)]
7255#[repr(C)]
7256pub struct VkPhysicalDevicePipelineRobustnessFeatures {
7257    pub sType: VkStructureType,
7258    pub pNext: *mut c_void,
7259    pub pipelineRobustness: VkBool32,
7260}
7261
7262#[derive(Clone, Copy)]
7263#[repr(C)]
7264pub struct VkPhysicalDevicePipelineRobustnessProperties {
7265    pub sType: VkStructureType,
7266    pub pNext: *mut c_void,
7267    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
7268    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
7269    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
7270    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
7271}
7272
7273#[derive(Clone, Copy)]
7274#[repr(C)]
7275pub struct VkPhysicalDevicePointClippingProperties {
7276    pub sType: VkStructureType,
7277    pub pNext: *mut c_void,
7278    pub pointClippingBehavior: VkPointClippingBehavior,
7279}
7280
7281#[derive(Clone, Copy)]
7282#[repr(C)]
7283pub struct VkPhysicalDevicePresentBarrierFeaturesNV {
7284    pub sType: VkStructureType,
7285    pub pNext: *mut c_void,
7286    pub presentBarrier: VkBool32,
7287}
7288
7289#[derive(Clone, Copy)]
7290#[repr(C)]
7291pub struct VkPhysicalDevicePresentId2FeaturesKHR {
7292    pub sType: VkStructureType,
7293    pub pNext: *mut c_void,
7294    pub presentId2: VkBool32,
7295}
7296
7297#[derive(Clone, Copy)]
7298#[repr(C)]
7299pub struct VkPhysicalDevicePresentIdFeaturesKHR {
7300    pub sType: VkStructureType,
7301    pub pNext: *mut c_void,
7302    pub presentId: VkBool32,
7303}
7304
7305#[derive(Clone, Copy)]
7306#[repr(C)]
7307pub struct VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR {
7308    pub sType: VkStructureType,
7309    pub pNext: *mut c_void,
7310    pub presentModeFifoLatestReady: VkBool32,
7311}
7312
7313#[derive(Clone, Copy)]
7314#[repr(C)]
7315pub struct VkPhysicalDevicePresentTimingFeaturesEXT {
7316    pub sType: VkStructureType,
7317    pub pNext: *mut c_void,
7318    pub presentTiming: VkBool32,
7319    pub presentAtAbsoluteTime: VkBool32,
7320    pub presentAtRelativeTime: VkBool32,
7321}
7322
7323#[derive(Clone, Copy)]
7324#[repr(C)]
7325pub struct VkPhysicalDevicePresentWait2FeaturesKHR {
7326    pub sType: VkStructureType,
7327    pub pNext: *mut c_void,
7328    pub presentWait2: VkBool32,
7329}
7330
7331#[derive(Clone, Copy)]
7332#[repr(C)]
7333pub struct VkPhysicalDevicePresentWaitFeaturesKHR {
7334    pub sType: VkStructureType,
7335    pub pNext: *mut c_void,
7336    pub presentWait: VkBool32,
7337}
7338
7339#[derive(Clone, Copy)]
7340#[repr(C)]
7341pub struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
7342    pub sType: VkStructureType,
7343    pub pNext: *mut c_void,
7344    pub primitiveTopologyListRestart: VkBool32,
7345    pub primitiveTopologyPatchListRestart: VkBool32,
7346}
7347
7348#[derive(Clone, Copy)]
7349#[repr(C)]
7350pub struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
7351    pub sType: VkStructureType,
7352    pub pNext: *mut c_void,
7353    pub primitivesGeneratedQuery: VkBool32,
7354    pub primitivesGeneratedQueryWithRasterizerDiscard: VkBool32,
7355    pub primitivesGeneratedQueryWithNonZeroStreams: VkBool32,
7356}
7357
7358#[derive(Clone, Copy)]
7359#[repr(C)]
7360pub struct VkPhysicalDevicePrivateDataFeatures {
7361    pub sType: VkStructureType,
7362    pub pNext: *mut c_void,
7363    pub privateData: VkBool32,
7364}
7365
7366#[derive(Clone, Copy)]
7367#[repr(C)]
7368pub struct VkPhysicalDeviceProperties {
7369    pub apiVersion: u32,
7370    pub driverVersion: u32,
7371    pub vendorID: u32,
7372    pub deviceID: u32,
7373    pub deviceType: VkPhysicalDeviceType,
7374    pub deviceName: [c_char; VK_MAX_PHYSICAL_DEVICE_NAME_SIZE as usize],
7375    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
7376    pub limits: VkPhysicalDeviceLimits,
7377    pub sparseProperties: VkPhysicalDeviceSparseProperties,
7378}
7379
7380#[derive(Clone, Copy)]
7381#[repr(C)]
7382pub struct VkPhysicalDeviceProperties2 {
7383    pub sType: VkStructureType,
7384    pub pNext: *mut c_void,
7385    pub properties: VkPhysicalDeviceProperties,
7386}
7387
7388#[derive(Clone, Copy)]
7389#[repr(C)]
7390pub struct VkPhysicalDeviceProtectedMemoryFeatures {
7391    pub sType: VkStructureType,
7392    pub pNext: *mut c_void,
7393    pub protectedMemory: VkBool32,
7394}
7395
7396#[derive(Clone, Copy)]
7397#[repr(C)]
7398pub struct VkPhysicalDeviceProtectedMemoryProperties {
7399    pub sType: VkStructureType,
7400    pub pNext: *mut c_void,
7401    pub protectedNoFault: VkBool32,
7402}
7403
7404#[derive(Clone, Copy)]
7405#[repr(C)]
7406pub struct VkPhysicalDeviceProvokingVertexFeaturesEXT {
7407    pub sType: VkStructureType,
7408    pub pNext: *mut c_void,
7409    pub provokingVertexLast: VkBool32,
7410    pub transformFeedbackPreservesProvokingVertex: VkBool32,
7411}
7412
7413#[derive(Clone, Copy)]
7414#[repr(C)]
7415pub struct VkPhysicalDeviceProvokingVertexPropertiesEXT {
7416    pub sType: VkStructureType,
7417    pub pNext: *mut c_void,
7418    pub provokingVertexModePerPipeline: VkBool32,
7419    pub transformFeedbackPreservesTriangleFanProvokingVertex: VkBool32,
7420}
7421
7422#[derive(Clone, Copy)]
7423#[repr(C)]
7424pub struct VkPhysicalDevicePushConstantBankFeaturesNV {
7425    pub sType: VkStructureType,
7426    pub pNext: *mut c_void,
7427    pub pushConstantBank: VkBool32,
7428}
7429
7430#[derive(Clone, Copy)]
7431#[repr(C)]
7432pub struct VkPhysicalDevicePushConstantBankPropertiesNV {
7433    pub sType: VkStructureType,
7434    pub pNext: *mut c_void,
7435    pub maxGraphicsPushConstantBanks: u32,
7436    pub maxComputePushConstantBanks: u32,
7437    pub maxGraphicsPushDataBanks: u32,
7438    pub maxComputePushDataBanks: u32,
7439}
7440
7441#[derive(Clone, Copy)]
7442#[repr(C)]
7443pub struct VkPhysicalDevicePushDescriptorProperties {
7444    pub sType: VkStructureType,
7445    pub pNext: *mut c_void,
7446    pub maxPushDescriptors: u32,
7447}
7448
7449#[derive(Clone, Copy)]
7450#[repr(C)]
7451pub struct VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM {
7452    pub sType: VkStructureType,
7453    pub pNext: *const c_void,
7454    pub queueFamilyIndex: u32,
7455    pub engineType: VkPhysicalDeviceDataGraphProcessingEngineTypeARM,
7456}
7457
7458#[derive(Clone, Copy)]
7459#[repr(C)]
7460pub struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT {
7461    pub sType: VkStructureType,
7462    pub pNext: *mut c_void,
7463    pub formatRgba10x6WithoutYCbCrSampler: VkBool32,
7464}
7465
7466#[derive(Clone, Copy)]
7467#[repr(C)]
7468pub struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
7469    pub sType: VkStructureType,
7470    pub pNext: *mut c_void,
7471    pub rasterizationOrderColorAttachmentAccess: VkBool32,
7472    pub rasterizationOrderDepthAttachmentAccess: VkBool32,
7473    pub rasterizationOrderStencilAttachmentAccess: VkBool32,
7474}
7475
7476#[derive(Clone, Copy)]
7477#[repr(C)]
7478pub struct VkPhysicalDeviceRawAccessChainsFeaturesNV {
7479    pub sType: VkStructureType,
7480    pub pNext: *mut c_void,
7481    pub shaderRawAccessChains: VkBool32,
7482}
7483
7484#[derive(Clone, Copy)]
7485#[repr(C)]
7486pub struct VkPhysicalDeviceRayQueryFeaturesKHR {
7487    pub sType: VkStructureType,
7488    pub pNext: *mut c_void,
7489    pub rayQuery: VkBool32,
7490}
7491
7492#[derive(Clone, Copy)]
7493#[repr(C)]
7494pub struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesEXT {
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 VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV {
7503    pub sType: VkStructureType,
7504    pub pNext: *mut c_void,
7505    pub rayTracingInvocationReorder: VkBool32,
7506}
7507
7508#[derive(Clone, Copy)]
7509#[repr(C)]
7510pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesEXT {
7511    pub sType: VkStructureType,
7512    pub pNext: *mut c_void,
7513    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
7514    pub maxShaderBindingTableRecordIndex: u32,
7515}
7516
7517#[derive(Clone, Copy)]
7518#[repr(C)]
7519pub struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV {
7520    pub sType: VkStructureType,
7521    pub pNext: *mut c_void,
7522    pub rayTracingInvocationReorderReorderingHint: VkRayTracingInvocationReorderModeEXT,
7523}
7524
7525#[derive(Clone, Copy)]
7526#[repr(C)]
7527pub struct VkPhysicalDeviceRayTracingLinearSweptSpheresFeaturesNV {
7528    pub sType: VkStructureType,
7529    pub pNext: *mut c_void,
7530    pub spheres: VkBool32,
7531    pub linearSweptSpheres: VkBool32,
7532}
7533
7534#[derive(Clone, Copy)]
7535#[repr(C)]
7536pub struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR {
7537    pub sType: VkStructureType,
7538    pub pNext: *mut c_void,
7539    pub rayTracingMaintenance1: VkBool32,
7540    pub rayTracingPipelineTraceRaysIndirect2: VkBool32,
7541}
7542
7543#[derive(Clone, Copy)]
7544#[repr(C)]
7545pub struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV {
7546    pub sType: VkStructureType,
7547    pub pNext: *mut c_void,
7548    pub rayTracingMotionBlur: VkBool32,
7549    pub rayTracingMotionBlurPipelineTraceRaysIndirect: VkBool32,
7550}
7551
7552#[derive(Clone, Copy)]
7553#[repr(C)]
7554pub struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR {
7555    pub sType: VkStructureType,
7556    pub pNext: *mut c_void,
7557    pub rayTracingPipeline: VkBool32,
7558    pub rayTracingPipelineShaderGroupHandleCaptureReplay: VkBool32,
7559    pub rayTracingPipelineShaderGroupHandleCaptureReplayMixed: VkBool32,
7560    pub rayTracingPipelineTraceRaysIndirect: VkBool32,
7561    pub rayTraversalPrimitiveCulling: VkBool32,
7562}
7563
7564#[derive(Clone, Copy)]
7565#[repr(C)]
7566pub struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR {
7567    pub sType: VkStructureType,
7568    pub pNext: *mut c_void,
7569    pub shaderGroupHandleSize: u32,
7570    pub maxRayRecursionDepth: u32,
7571    pub maxShaderGroupStride: u32,
7572    pub shaderGroupBaseAlignment: u32,
7573    pub shaderGroupHandleCaptureReplaySize: u32,
7574    pub maxRayDispatchInvocationCount: u32,
7575    pub shaderGroupHandleAlignment: u32,
7576    pub maxRayHitAttributeSize: u32,
7577}
7578
7579#[derive(Clone, Copy)]
7580#[repr(C)]
7581pub struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR {
7582    pub sType: VkStructureType,
7583    pub pNext: *mut c_void,
7584    pub rayTracingPositionFetch: VkBool32,
7585}
7586
7587#[derive(Clone, Copy)]
7588#[repr(C)]
7589pub struct VkPhysicalDeviceRayTracingPropertiesNV {
7590    pub sType: VkStructureType,
7591    pub pNext: *mut c_void,
7592    pub shaderGroupHandleSize: u32,
7593    pub maxRecursionDepth: u32,
7594    pub maxShaderGroupStride: u32,
7595    pub shaderGroupBaseAlignment: u32,
7596    pub maxGeometryCount: u64,
7597    pub maxInstanceCount: u64,
7598    pub maxTriangleCount: u64,
7599    pub maxDescriptorSetAccelerationStructures: u32,
7600}
7601
7602#[derive(Clone, Copy)]
7603#[repr(C)]
7604pub struct VkPhysicalDeviceRayTracingValidationFeaturesNV {
7605    pub sType: VkStructureType,
7606    pub pNext: *mut c_void,
7607    pub rayTracingValidation: VkBool32,
7608}
7609
7610#[derive(Clone, Copy)]
7611#[repr(C)]
7612pub struct VkPhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
7613    pub sType: VkStructureType,
7614    pub pNext: *mut c_void,
7615    pub relaxedLineRasterization: VkBool32,
7616}
7617
7618#[derive(Clone, Copy)]
7619#[repr(C)]
7620pub struct VkPhysicalDeviceRenderPassStripedFeaturesARM {
7621    pub sType: VkStructureType,
7622    pub pNext: *mut c_void,
7623    pub renderPassStriped: VkBool32,
7624}
7625
7626#[derive(Clone, Copy)]
7627#[repr(C)]
7628pub struct VkPhysicalDeviceRenderPassStripedPropertiesARM {
7629    pub sType: VkStructureType,
7630    pub pNext: *mut c_void,
7631    pub renderPassStripeGranularity: VkExtent2D,
7632    pub maxRenderPassStripes: u32,
7633}
7634
7635#[derive(Clone, Copy)]
7636#[repr(C)]
7637pub struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV {
7638    pub sType: VkStructureType,
7639    pub pNext: *mut c_void,
7640    pub representativeFragmentTest: VkBool32,
7641}
7642
7643#[derive(Clone, Copy)]
7644#[repr(C)]
7645pub struct VkPhysicalDeviceRobustness2FeaturesKHR {
7646    pub sType: VkStructureType,
7647    pub pNext: *mut c_void,
7648    pub robustBufferAccess2: VkBool32,
7649    pub robustImageAccess2: VkBool32,
7650    pub nullDescriptor: VkBool32,
7651}
7652
7653#[derive(Clone, Copy)]
7654#[repr(C)]
7655pub struct VkPhysicalDeviceRobustness2PropertiesKHR {
7656    pub sType: VkStructureType,
7657    pub pNext: *mut c_void,
7658    pub robustStorageBufferAccessSizeAlignment: VkDeviceSize,
7659    pub robustUniformBufferAccessSizeAlignment: VkDeviceSize,
7660}
7661
7662#[derive(Clone, Copy)]
7663#[repr(C)]
7664pub struct VkPhysicalDeviceSampleLocationsPropertiesEXT {
7665    pub sType: VkStructureType,
7666    pub pNext: *mut c_void,
7667    pub sampleLocationSampleCounts: VkSampleCountFlags,
7668    pub maxSampleLocationGridSize: VkExtent2D,
7669    pub sampleLocationCoordinateRange: [f32; 2 as usize],
7670    pub sampleLocationSubPixelBits: u32,
7671    pub variableSampleLocations: VkBool32,
7672}
7673
7674#[derive(Clone, Copy)]
7675#[repr(C)]
7676pub struct VkPhysicalDeviceSamplerFilterMinmaxProperties {
7677    pub sType: VkStructureType,
7678    pub pNext: *mut c_void,
7679    pub filterMinmaxSingleComponentFormats: VkBool32,
7680    pub filterMinmaxImageComponentMapping: VkBool32,
7681}
7682
7683#[derive(Clone, Copy)]
7684#[repr(C)]
7685pub struct VkPhysicalDeviceSamplerYcbcrConversionFeatures {
7686    pub sType: VkStructureType,
7687    pub pNext: *mut c_void,
7688    pub samplerYcbcrConversion: VkBool32,
7689}
7690
7691#[derive(Clone, Copy)]
7692#[repr(C)]
7693pub struct VkPhysicalDeviceScalarBlockLayoutFeatures {
7694    pub sType: VkStructureType,
7695    pub pNext: *mut c_void,
7696    pub scalarBlockLayout: VkBool32,
7697}
7698
7699#[derive(Clone, Copy)]
7700#[repr(C)]
7701pub struct VkPhysicalDeviceSchedulingControlsFeaturesARM {
7702    pub sType: VkStructureType,
7703    pub pNext: *mut c_void,
7704    pub schedulingControls: VkBool32,
7705}
7706
7707#[derive(Clone, Copy)]
7708#[repr(C)]
7709pub struct VkPhysicalDeviceSchedulingControlsPropertiesARM {
7710    pub sType: VkStructureType,
7711    pub pNext: *mut c_void,
7712    pub schedulingControlsFlags: VkPhysicalDeviceSchedulingControlsFlagsARM,
7713}
7714
7715#[derive(Clone, Copy)]
7716#[repr(C)]
7717pub struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures {
7718    pub sType: VkStructureType,
7719    pub pNext: *mut c_void,
7720    pub separateDepthStencilLayouts: VkBool32,
7721}
7722
7723#[derive(Clone, Copy)]
7724#[repr(C)]
7725pub struct VkPhysicalDeviceShader64BitIndexingFeaturesEXT {
7726    pub sType: VkStructureType,
7727    pub pNext: *mut c_void,
7728    pub shader64BitIndexing: VkBool32,
7729}
7730
7731#[derive(Clone, Copy)]
7732#[repr(C)]
7733pub struct VkPhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
7734    pub sType: VkStructureType,
7735    pub pNext: *mut c_void,
7736    pub shaderFloat16VectorAtomics: VkBool32,
7737}
7738
7739#[derive(Clone, Copy)]
7740#[repr(C)]
7741pub struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT {
7742    pub sType: VkStructureType,
7743    pub pNext: *mut c_void,
7744    pub shaderBufferFloat16Atomics: VkBool32,
7745    pub shaderBufferFloat16AtomicAdd: VkBool32,
7746    pub shaderBufferFloat16AtomicMinMax: VkBool32,
7747    pub shaderBufferFloat32AtomicMinMax: VkBool32,
7748    pub shaderBufferFloat64AtomicMinMax: VkBool32,
7749    pub shaderSharedFloat16Atomics: VkBool32,
7750    pub shaderSharedFloat16AtomicAdd: VkBool32,
7751    pub shaderSharedFloat16AtomicMinMax: VkBool32,
7752    pub shaderSharedFloat32AtomicMinMax: VkBool32,
7753    pub shaderSharedFloat64AtomicMinMax: VkBool32,
7754    pub shaderImageFloat32AtomicMinMax: VkBool32,
7755    pub sparseImageFloat32AtomicMinMax: VkBool32,
7756}
7757
7758#[derive(Clone, Copy)]
7759#[repr(C)]
7760pub struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT {
7761    pub sType: VkStructureType,
7762    pub pNext: *mut c_void,
7763    pub shaderBufferFloat32Atomics: VkBool32,
7764    pub shaderBufferFloat32AtomicAdd: VkBool32,
7765    pub shaderBufferFloat64Atomics: VkBool32,
7766    pub shaderBufferFloat64AtomicAdd: VkBool32,
7767    pub shaderSharedFloat32Atomics: VkBool32,
7768    pub shaderSharedFloat32AtomicAdd: VkBool32,
7769    pub shaderSharedFloat64Atomics: VkBool32,
7770    pub shaderSharedFloat64AtomicAdd: VkBool32,
7771    pub shaderImageFloat32Atomics: VkBool32,
7772    pub shaderImageFloat32AtomicAdd: VkBool32,
7773    pub sparseImageFloat32Atomics: VkBool32,
7774    pub sparseImageFloat32AtomicAdd: VkBool32,
7775}
7776
7777#[derive(Clone, Copy)]
7778#[repr(C)]
7779pub struct VkPhysicalDeviceShaderAtomicInt64Features {
7780    pub sType: VkStructureType,
7781    pub pNext: *mut c_void,
7782    pub shaderBufferInt64Atomics: VkBool32,
7783    pub shaderSharedInt64Atomics: VkBool32,
7784}
7785
7786#[derive(Clone, Copy)]
7787#[repr(C)]
7788pub struct VkPhysicalDeviceShaderBfloat16FeaturesKHR {
7789    pub sType: VkStructureType,
7790    pub pNext: *mut c_void,
7791    pub shaderBFloat16Type: VkBool32,
7792    pub shaderBFloat16DotProduct: VkBool32,
7793    pub shaderBFloat16CooperativeMatrix: VkBool32,
7794}
7795
7796#[derive(Clone, Copy)]
7797#[repr(C)]
7798pub struct VkPhysicalDeviceShaderClockFeaturesKHR {
7799    pub sType: VkStructureType,
7800    pub pNext: *mut c_void,
7801    pub shaderSubgroupClock: VkBool32,
7802    pub shaderDeviceClock: VkBool32,
7803}
7804
7805#[derive(Clone, Copy)]
7806#[repr(C)]
7807pub struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM {
7808    pub sType: VkStructureType,
7809    pub pNext: *mut c_void,
7810    pub shaderCoreBuiltins: VkBool32,
7811}
7812
7813#[derive(Clone, Copy)]
7814#[repr(C)]
7815pub struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM {
7816    pub sType: VkStructureType,
7817    pub pNext: *mut c_void,
7818    pub shaderCoreMask: u64,
7819    pub shaderCoreCount: u32,
7820    pub shaderWarpsPerCore: u32,
7821}
7822
7823#[derive(Clone, Copy)]
7824#[repr(C)]
7825pub struct VkPhysicalDeviceShaderCoreProperties2AMD {
7826    pub sType: VkStructureType,
7827    pub pNext: *mut c_void,
7828    pub shaderCoreFeatures: VkShaderCorePropertiesFlagsAMD,
7829    pub activeComputeUnitCount: u32,
7830}
7831
7832#[derive(Clone, Copy)]
7833#[repr(C)]
7834pub struct VkPhysicalDeviceShaderCorePropertiesAMD {
7835    pub sType: VkStructureType,
7836    pub pNext: *mut c_void,
7837    pub shaderEngineCount: u32,
7838    pub shaderArraysPerEngineCount: u32,
7839    pub computeUnitsPerShaderArray: u32,
7840    pub simdPerComputeUnit: u32,
7841    pub wavefrontsPerSimd: u32,
7842    pub wavefrontSize: u32,
7843    pub sgprsPerSimd: u32,
7844    pub minSgprAllocation: u32,
7845    pub maxSgprAllocation: u32,
7846    pub sgprAllocationGranularity: u32,
7847    pub vgprsPerSimd: u32,
7848    pub minVgprAllocation: u32,
7849    pub maxVgprAllocation: u32,
7850    pub vgprAllocationGranularity: u32,
7851}
7852
7853#[derive(Clone, Copy)]
7854#[repr(C)]
7855pub struct VkPhysicalDeviceShaderCorePropertiesARM {
7856    pub sType: VkStructureType,
7857    pub pNext: *mut c_void,
7858    pub pixelRate: u32,
7859    pub texelRate: u32,
7860    pub fmaRate: u32,
7861}
7862
7863#[derive(Clone, Copy)]
7864#[repr(C)]
7865pub struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures {
7866    pub sType: VkStructureType,
7867    pub pNext: *mut c_void,
7868    pub shaderDemoteToHelperInvocation: VkBool32,
7869}
7870
7871#[derive(Clone, Copy)]
7872#[repr(C)]
7873pub struct VkPhysicalDeviceShaderDrawParametersFeatures {
7874    pub sType: VkStructureType,
7875    pub pNext: *mut c_void,
7876    pub shaderDrawParameters: VkBool32,
7877}
7878
7879#[derive(Clone, Copy)]
7880#[repr(C)]
7881pub struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
7882    pub sType: VkStructureType,
7883    pub pNext: *mut c_void,
7884    pub shaderEarlyAndLateFragmentTests: VkBool32,
7885}
7886
7887#[derive(Clone, Copy)]
7888#[repr(C)]
7889pub struct VkPhysicalDeviceShaderExpectAssumeFeatures {
7890    pub sType: VkStructureType,
7891    pub pNext: *mut c_void,
7892    pub shaderExpectAssume: VkBool32,
7893}
7894
7895#[derive(Clone, Copy)]
7896#[repr(C)]
7897pub struct VkPhysicalDeviceShaderFloat16Int8Features {
7898    pub sType: VkStructureType,
7899    pub pNext: *mut c_void,
7900    pub shaderFloat16: VkBool32,
7901    pub shaderInt8: VkBool32,
7902}
7903
7904#[derive(Clone, Copy)]
7905#[repr(C)]
7906pub struct VkPhysicalDeviceShaderFloat8FeaturesEXT {
7907    pub sType: VkStructureType,
7908    pub pNext: *mut c_void,
7909    pub shaderFloat8: VkBool32,
7910    pub shaderFloat8CooperativeMatrix: VkBool32,
7911}
7912
7913#[derive(Clone, Copy)]
7914#[repr(C)]
7915pub struct VkPhysicalDeviceShaderFloatControls2Features {
7916    pub sType: VkStructureType,
7917    pub pNext: *mut c_void,
7918    pub shaderFloatControls2: VkBool32,
7919}
7920
7921#[derive(Clone, Copy)]
7922#[repr(C)]
7923pub struct VkPhysicalDeviceShaderFmaFeaturesKHR {
7924    pub sType: VkStructureType,
7925    pub pNext: *mut c_void,
7926    pub shaderFmaFloat16: VkBool32,
7927    pub shaderFmaFloat32: VkBool32,
7928    pub shaderFmaFloat64: VkBool32,
7929}
7930
7931#[derive(Clone, Copy)]
7932#[repr(C)]
7933pub struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
7934    pub sType: VkStructureType,
7935    pub pNext: *mut c_void,
7936    pub shaderImageInt64Atomics: VkBool32,
7937    pub sparseImageInt64Atomics: VkBool32,
7938}
7939
7940#[derive(Clone, Copy)]
7941#[repr(C)]
7942pub struct VkPhysicalDeviceShaderImageFootprintFeaturesNV {
7943    pub sType: VkStructureType,
7944    pub pNext: *mut c_void,
7945    pub imageFootprint: VkBool32,
7946}
7947
7948#[derive(Clone, Copy)]
7949#[repr(C)]
7950pub struct VkPhysicalDeviceShaderIntegerDotProductFeatures {
7951    pub sType: VkStructureType,
7952    pub pNext: *mut c_void,
7953    pub shaderIntegerDotProduct: VkBool32,
7954}
7955
7956#[derive(Clone, Copy)]
7957#[repr(C)]
7958pub struct VkPhysicalDeviceShaderIntegerDotProductProperties {
7959    pub sType: VkStructureType,
7960    pub pNext: *mut c_void,
7961    pub integerDotProduct8BitUnsignedAccelerated: VkBool32,
7962    pub integerDotProduct8BitSignedAccelerated: VkBool32,
7963    pub integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
7964    pub integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
7965    pub integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
7966    pub integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
7967    pub integerDotProduct16BitUnsignedAccelerated: VkBool32,
7968    pub integerDotProduct16BitSignedAccelerated: VkBool32,
7969    pub integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
7970    pub integerDotProduct32BitUnsignedAccelerated: VkBool32,
7971    pub integerDotProduct32BitSignedAccelerated: VkBool32,
7972    pub integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
7973    pub integerDotProduct64BitUnsignedAccelerated: VkBool32,
7974    pub integerDotProduct64BitSignedAccelerated: VkBool32,
7975    pub integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
7976    pub integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
7977    pub integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
7978    pub integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
7979    pub integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
7980    pub integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
7981    pub integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
7982    pub integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
7983    pub integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
7984    pub integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
7985    pub integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
7986    pub integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
7987    pub integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
7988    pub integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
7989    pub integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
7990    pub integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
7991}
7992
7993#[derive(Clone, Copy)]
7994#[repr(C)]
7995pub struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
7996    pub sType: VkStructureType,
7997    pub pNext: *mut c_void,
7998    pub shaderIntegerFunctions2: VkBool32,
7999}
8000
8001#[derive(Clone, Copy)]
8002#[repr(C)]
8003pub struct VkPhysicalDeviceShaderLongVectorFeaturesEXT {
8004    pub sType: VkStructureType,
8005    pub pNext: *mut c_void,
8006    pub longVector: VkBool32,
8007}
8008
8009#[derive(Clone, Copy)]
8010#[repr(C)]
8011pub struct VkPhysicalDeviceShaderLongVectorPropertiesEXT {
8012    pub sType: VkStructureType,
8013    pub pNext: *mut c_void,
8014    pub maxVectorComponents: u32,
8015}
8016
8017#[derive(Clone, Copy)]
8018#[repr(C)]
8019pub struct VkPhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
8020    pub sType: VkStructureType,
8021    pub pNext: *mut c_void,
8022    pub shaderMaximalReconvergence: VkBool32,
8023}
8024
8025#[derive(Clone, Copy)]
8026#[repr(C)]
8027pub struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT {
8028    pub sType: VkStructureType,
8029    pub pNext: *mut c_void,
8030    pub shaderModuleIdentifier: VkBool32,
8031}
8032
8033#[derive(Clone, Copy)]
8034#[repr(C)]
8035pub struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT {
8036    pub sType: VkStructureType,
8037    pub pNext: *mut c_void,
8038    pub shaderModuleIdentifierAlgorithmUUID: [u8; VK_UUID_SIZE as usize],
8039}
8040
8041#[derive(Clone, Copy)]
8042#[repr(C)]
8043pub struct VkPhysicalDeviceShaderObjectFeaturesEXT {
8044    pub sType: VkStructureType,
8045    pub pNext: *mut c_void,
8046    pub shaderObject: VkBool32,
8047}
8048
8049#[derive(Clone, Copy)]
8050#[repr(C)]
8051pub struct VkPhysicalDeviceShaderObjectPropertiesEXT {
8052    pub sType: VkStructureType,
8053    pub pNext: *mut c_void,
8054    pub shaderBinaryUUID: [u8; VK_UUID_SIZE as usize],
8055    pub shaderBinaryVersion: u32,
8056}
8057
8058#[derive(Clone, Copy)]
8059#[repr(C)]
8060pub struct VkPhysicalDeviceShaderQuadControlFeaturesKHR {
8061    pub sType: VkStructureType,
8062    pub pNext: *mut c_void,
8063    pub shaderQuadControl: VkBool32,
8064}
8065
8066#[derive(Clone, Copy)]
8067#[repr(C)]
8068pub struct VkPhysicalDeviceShaderRelaxedExtendedInstructionFeaturesKHR {
8069    pub sType: VkStructureType,
8070    pub pNext: *mut c_void,
8071    pub shaderRelaxedExtendedInstruction: VkBool32,
8072}
8073
8074#[derive(Clone, Copy)]
8075#[repr(C)]
8076pub struct VkPhysicalDeviceShaderReplicatedCompositesFeaturesEXT {
8077    pub sType: VkStructureType,
8078    pub pNext: *mut c_void,
8079    pub shaderReplicatedComposites: VkBool32,
8080}
8081
8082#[derive(Clone, Copy)]
8083#[repr(C)]
8084pub struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV {
8085    pub sType: VkStructureType,
8086    pub pNext: *mut c_void,
8087    pub shaderSMBuiltins: VkBool32,
8088}
8089
8090#[derive(Clone, Copy)]
8091#[repr(C)]
8092pub struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV {
8093    pub sType: VkStructureType,
8094    pub pNext: *mut c_void,
8095    pub shaderSMCount: u32,
8096    pub shaderWarpsPerSM: u32,
8097}
8098
8099#[derive(Clone, Copy)]
8100#[repr(C)]
8101pub struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures {
8102    pub sType: VkStructureType,
8103    pub pNext: *mut c_void,
8104    pub shaderSubgroupExtendedTypes: VkBool32,
8105}
8106
8107#[derive(Clone, Copy)]
8108#[repr(C)]
8109pub struct VkPhysicalDeviceShaderSubgroupPartitionedFeaturesEXT {
8110    pub sType: VkStructureType,
8111    pub pNext: *mut c_void,
8112    pub shaderSubgroupPartitioned: VkBool32,
8113}
8114
8115#[derive(Clone, Copy)]
8116#[repr(C)]
8117pub struct VkPhysicalDeviceShaderSubgroupRotateFeatures {
8118    pub sType: VkStructureType,
8119    pub pNext: *mut c_void,
8120    pub shaderSubgroupRotate: VkBool32,
8121    pub shaderSubgroupRotateClustered: VkBool32,
8122}
8123
8124#[derive(Clone, Copy)]
8125#[repr(C)]
8126pub struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
8127    pub sType: VkStructureType,
8128    pub pNext: *mut c_void,
8129    pub shaderSubgroupUniformControlFlow: VkBool32,
8130}
8131
8132#[derive(Clone, Copy)]
8133#[repr(C)]
8134pub struct VkPhysicalDeviceShaderTerminateInvocationFeatures {
8135    pub sType: VkStructureType,
8136    pub pNext: *mut c_void,
8137    pub shaderTerminateInvocation: VkBool32,
8138}
8139
8140#[derive(Clone, Copy)]
8141#[repr(C)]
8142pub struct VkPhysicalDeviceShaderTileImageFeaturesEXT {
8143    pub sType: VkStructureType,
8144    pub pNext: *mut c_void,
8145    pub shaderTileImageColorReadAccess: VkBool32,
8146    pub shaderTileImageDepthReadAccess: VkBool32,
8147    pub shaderTileImageStencilReadAccess: VkBool32,
8148}
8149
8150#[derive(Clone, Copy)]
8151#[repr(C)]
8152pub struct VkPhysicalDeviceShaderTileImagePropertiesEXT {
8153    pub sType: VkStructureType,
8154    pub pNext: *mut c_void,
8155    pub shaderTileImageCoherentReadAccelerated: VkBool32,
8156    pub shaderTileImageReadSampleFromPixelRateInvocation: VkBool32,
8157    pub shaderTileImageReadFromHelperInvocation: VkBool32,
8158}
8159
8160#[derive(Clone, Copy)]
8161#[repr(C)]
8162pub struct VkPhysicalDeviceShaderUniformBufferUnsizedArrayFeaturesEXT {
8163    pub sType: VkStructureType,
8164    pub pNext: *mut c_void,
8165    pub shaderUniformBufferUnsizedArray: VkBool32,
8166}
8167
8168#[derive(Clone, Copy)]
8169#[repr(C)]
8170pub struct VkPhysicalDeviceShaderUntypedPointersFeaturesKHR {
8171    pub sType: VkStructureType,
8172    pub pNext: *mut c_void,
8173    pub shaderUntypedPointers: VkBool32,
8174}
8175
8176#[derive(Clone, Copy)]
8177#[repr(C)]
8178pub struct VkPhysicalDeviceShadingRateImageFeaturesNV {
8179    pub sType: VkStructureType,
8180    pub pNext: *mut c_void,
8181    pub shadingRateImage: VkBool32,
8182    pub shadingRateCoarseSampleOrder: VkBool32,
8183}
8184
8185#[derive(Clone, Copy)]
8186#[repr(C)]
8187pub struct VkPhysicalDeviceShadingRateImagePropertiesNV {
8188    pub sType: VkStructureType,
8189    pub pNext: *mut c_void,
8190    pub shadingRateTexelSize: VkExtent2D,
8191    pub shadingRatePaletteSize: u32,
8192    pub shadingRateMaxCoarseSamples: u32,
8193}
8194
8195#[derive(Clone, Copy)]
8196#[repr(C)]
8197pub struct VkPhysicalDeviceSparseImageFormatInfo2 {
8198    pub sType: VkStructureType,
8199    pub pNext: *const c_void,
8200    pub format: VkFormat,
8201    pub typ: VkImageType,
8202    pub samples: VkSampleCountFlagBits,
8203    pub usage: VkImageUsageFlags,
8204    pub tiling: VkImageTiling,
8205}
8206
8207#[derive(Clone, Copy)]
8208#[repr(C)]
8209pub struct VkPhysicalDeviceSparseProperties {
8210    pub residencyStandard2DBlockShape: VkBool32,
8211    pub residencyStandard2DMultisampleBlockShape: VkBool32,
8212    pub residencyStandard3DBlockShape: VkBool32,
8213    pub residencyAlignedMipSize: VkBool32,
8214    pub residencyNonResidentStrict: VkBool32,
8215}
8216
8217#[derive(Clone, Copy)]
8218#[repr(C)]
8219pub struct VkPhysicalDeviceSubgroupProperties {
8220    pub sType: VkStructureType,
8221    pub pNext: *mut c_void,
8222    pub subgroupSize: u32,
8223    pub supportedStages: VkShaderStageFlags,
8224    pub supportedOperations: VkSubgroupFeatureFlags,
8225    pub quadOperationsInAllStages: VkBool32,
8226}
8227
8228#[derive(Clone, Copy)]
8229#[repr(C)]
8230pub struct VkPhysicalDeviceSubgroupSizeControlFeatures {
8231    pub sType: VkStructureType,
8232    pub pNext: *mut c_void,
8233    pub subgroupSizeControl: VkBool32,
8234    pub computeFullSubgroups: VkBool32,
8235}
8236
8237#[derive(Clone, Copy)]
8238#[repr(C)]
8239pub struct VkPhysicalDeviceSubgroupSizeControlProperties {
8240    pub sType: VkStructureType,
8241    pub pNext: *mut c_void,
8242    pub minSubgroupSize: u32,
8243    pub maxSubgroupSize: u32,
8244    pub maxComputeWorkgroupSubgroups: u32,
8245    pub requiredSubgroupSizeStages: VkShaderStageFlags,
8246}
8247
8248#[derive(Clone, Copy)]
8249#[repr(C)]
8250pub struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
8251    pub sType: VkStructureType,
8252    pub pNext: *mut c_void,
8253    pub subpassMergeFeedback: VkBool32,
8254}
8255
8256#[derive(Clone, Copy)]
8257#[repr(C)]
8258pub struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI {
8259    pub sType: VkStructureType,
8260    pub pNext: *mut c_void,
8261    pub subpassShading: VkBool32,
8262}
8263
8264#[derive(Clone, Copy)]
8265#[repr(C)]
8266pub struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI {
8267    pub sType: VkStructureType,
8268    pub pNext: *mut c_void,
8269    pub maxSubpassShadingWorkgroupSizeAspectRatio: u32,
8270}
8271
8272#[derive(Clone, Copy)]
8273#[repr(C)]
8274pub struct VkPhysicalDeviceSurfaceInfo2KHR {
8275    pub sType: VkStructureType,
8276    pub pNext: *const c_void,
8277    pub surface: VkSurfaceKHR,
8278}
8279
8280#[derive(Clone, Copy)]
8281#[repr(C)]
8282pub struct VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR {
8283    pub sType: VkStructureType,
8284    pub pNext: *mut c_void,
8285    pub swapchainMaintenance1: VkBool32,
8286}
8287
8288#[derive(Clone, Copy)]
8289#[repr(C)]
8290pub struct VkPhysicalDeviceSynchronization2Features {
8291    pub sType: VkStructureType,
8292    pub pNext: *mut c_void,
8293    pub synchronization2: VkBool32,
8294}
8295
8296#[derive(Clone, Copy)]
8297#[repr(C)]
8298pub struct VkPhysicalDeviceTensorFeaturesARM {
8299    pub sType: VkStructureType,
8300    pub pNext: *mut c_void,
8301    pub tensorNonPacked: VkBool32,
8302    pub shaderTensorAccess: VkBool32,
8303    pub shaderStorageTensorArrayDynamicIndexing: VkBool32,
8304    pub shaderStorageTensorArrayNonUniformIndexing: VkBool32,
8305    pub descriptorBindingStorageTensorUpdateAfterBind: VkBool32,
8306    pub tensors: VkBool32,
8307}
8308
8309#[derive(Clone, Copy)]
8310#[repr(C)]
8311pub struct VkPhysicalDeviceTensorPropertiesARM {
8312    pub sType: VkStructureType,
8313    pub pNext: *mut c_void,
8314    pub maxTensorDimensionCount: u32,
8315    pub maxTensorElements: u64,
8316    pub maxPerDimensionTensorElements: u64,
8317    pub maxTensorStride: i64,
8318    pub maxTensorSize: u64,
8319    pub maxTensorShaderAccessArrayLength: u32,
8320    pub maxTensorShaderAccessSize: u32,
8321    pub maxDescriptorSetStorageTensors: u32,
8322    pub maxPerStageDescriptorSetStorageTensors: u32,
8323    pub maxDescriptorSetUpdateAfterBindStorageTensors: u32,
8324    pub maxPerStageDescriptorUpdateAfterBindStorageTensors: u32,
8325    pub shaderStorageTensorArrayNonUniformIndexingNative: VkBool32,
8326    pub shaderTensorSupportedStages: VkShaderStageFlags,
8327}
8328
8329#[derive(Clone, Copy)]
8330#[repr(C)]
8331pub struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT {
8332    pub sType: VkStructureType,
8333    pub pNext: *mut c_void,
8334    pub texelBufferAlignment: VkBool32,
8335}
8336
8337#[derive(Clone, Copy)]
8338#[repr(C)]
8339pub struct VkPhysicalDeviceTexelBufferAlignmentProperties {
8340    pub sType: VkStructureType,
8341    pub pNext: *mut c_void,
8342    pub storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8343    pub storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
8344    pub uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8345    pub uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
8346}
8347
8348#[derive(Clone, Copy)]
8349#[repr(C)]
8350pub struct VkPhysicalDeviceTextureCompressionASTC3DFeaturesEXT {
8351    pub sType: VkStructureType,
8352    pub pNext: *mut c_void,
8353    pub textureCompressionASTC_3D: VkBool32,
8354}
8355
8356#[derive(Clone, Copy)]
8357#[repr(C)]
8358pub struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures {
8359    pub sType: VkStructureType,
8360    pub pNext: *mut c_void,
8361    pub textureCompressionASTC_HDR: VkBool32,
8362}
8363
8364#[derive(Clone, Copy)]
8365#[repr(C)]
8366pub struct VkPhysicalDeviceTileMemoryHeapFeaturesQCOM {
8367    pub sType: VkStructureType,
8368    pub pNext: *mut c_void,
8369    pub tileMemoryHeap: VkBool32,
8370}
8371
8372#[derive(Clone, Copy)]
8373#[repr(C)]
8374pub struct VkPhysicalDeviceTileMemoryHeapPropertiesQCOM {
8375    pub sType: VkStructureType,
8376    pub pNext: *mut c_void,
8377    pub queueSubmitBoundary: VkBool32,
8378    pub tileBufferTransfers: VkBool32,
8379}
8380
8381#[derive(Clone, Copy)]
8382#[repr(C)]
8383pub struct VkPhysicalDeviceTilePropertiesFeaturesQCOM {
8384    pub sType: VkStructureType,
8385    pub pNext: *mut c_void,
8386    pub tileProperties: VkBool32,
8387}
8388
8389#[derive(Clone, Copy)]
8390#[repr(C)]
8391pub struct VkPhysicalDeviceTileShadingFeaturesQCOM {
8392    pub sType: VkStructureType,
8393    pub pNext: *mut c_void,
8394    pub tileShading: VkBool32,
8395    pub tileShadingFragmentStage: VkBool32,
8396    pub tileShadingColorAttachments: VkBool32,
8397    pub tileShadingDepthAttachments: VkBool32,
8398    pub tileShadingStencilAttachments: VkBool32,
8399    pub tileShadingInputAttachments: VkBool32,
8400    pub tileShadingSampledAttachments: VkBool32,
8401    pub tileShadingPerTileDraw: VkBool32,
8402    pub tileShadingPerTileDispatch: VkBool32,
8403    pub tileShadingDispatchTile: VkBool32,
8404    pub tileShadingApron: VkBool32,
8405    pub tileShadingAnisotropicApron: VkBool32,
8406    pub tileShadingAtomicOps: VkBool32,
8407    pub tileShadingImageProcessing: VkBool32,
8408}
8409
8410#[derive(Clone, Copy)]
8411#[repr(C)]
8412pub struct VkPhysicalDeviceTileShadingPropertiesQCOM {
8413    pub sType: VkStructureType,
8414    pub pNext: *mut c_void,
8415    pub maxApronSize: u32,
8416    pub preferNonCoherent: VkBool32,
8417    pub tileGranularity: VkExtent2D,
8418    pub maxTileShadingRate: VkExtent2D,
8419}
8420
8421#[derive(Clone, Copy)]
8422#[repr(C)]
8423pub struct VkPhysicalDeviceTimelineSemaphoreFeatures {
8424    pub sType: VkStructureType,
8425    pub pNext: *mut c_void,
8426    pub timelineSemaphore: VkBool32,
8427}
8428
8429#[derive(Clone, Copy)]
8430#[repr(C)]
8431pub struct VkPhysicalDeviceTimelineSemaphoreProperties {
8432    pub sType: VkStructureType,
8433    pub pNext: *mut c_void,
8434    pub maxTimelineSemaphoreValueDifference: u64,
8435}
8436
8437#[derive(Clone, Copy)]
8438#[repr(C)]
8439pub struct VkPhysicalDeviceToolProperties {
8440    pub sType: VkStructureType,
8441    pub pNext: *mut c_void,
8442    pub name: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
8443    pub version: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
8444    pub purposes: VkToolPurposeFlags,
8445    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
8446    pub layer: [c_char; VK_MAX_EXTENSION_NAME_SIZE as usize],
8447}
8448
8449#[derive(Clone, Copy)]
8450#[repr(C)]
8451pub struct VkPhysicalDeviceTransformFeedbackFeaturesEXT {
8452    pub sType: VkStructureType,
8453    pub pNext: *mut c_void,
8454    pub transformFeedback: VkBool32,
8455    pub geometryStreams: VkBool32,
8456}
8457
8458#[derive(Clone, Copy)]
8459#[repr(C)]
8460pub struct VkPhysicalDeviceTransformFeedbackPropertiesEXT {
8461    pub sType: VkStructureType,
8462    pub pNext: *mut c_void,
8463    pub maxTransformFeedbackStreams: u32,
8464    pub maxTransformFeedbackBuffers: u32,
8465    pub maxTransformFeedbackBufferSize: VkDeviceSize,
8466    pub maxTransformFeedbackStreamDataSize: u32,
8467    pub maxTransformFeedbackBufferDataSize: u32,
8468    pub maxTransformFeedbackBufferDataStride: u32,
8469    pub transformFeedbackQueries: VkBool32,
8470    pub transformFeedbackStreamsLinesTriangles: VkBool32,
8471    pub transformFeedbackRasterizationStreamSelect: VkBool32,
8472    pub transformFeedbackDraw: VkBool32,
8473}
8474
8475#[derive(Clone, Copy)]
8476#[repr(C)]
8477pub struct VkPhysicalDeviceUnifiedImageLayoutsFeaturesKHR {
8478    pub sType: VkStructureType,
8479    pub pNext: *mut c_void,
8480    pub unifiedImageLayouts: VkBool32,
8481    pub unifiedImageLayoutsVideo: VkBool32,
8482}
8483
8484#[derive(Clone, Copy)]
8485#[repr(C)]
8486pub struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures {
8487    pub sType: VkStructureType,
8488    pub pNext: *mut c_void,
8489    pub uniformBufferStandardLayout: VkBool32,
8490}
8491
8492#[derive(Clone, Copy)]
8493#[repr(C)]
8494pub struct VkPhysicalDeviceVariablePointersFeatures {
8495    pub sType: VkStructureType,
8496    pub pNext: *mut c_void,
8497    pub variablePointersStorageBuffer: VkBool32,
8498    pub variablePointers: VkBool32,
8499}
8500
8501#[derive(Clone, Copy)]
8502#[repr(C)]
8503pub struct VkPhysicalDeviceVertexAttributeDivisorFeatures {
8504    pub sType: VkStructureType,
8505    pub pNext: *mut c_void,
8506    pub vertexAttributeInstanceRateDivisor: VkBool32,
8507    pub vertexAttributeInstanceRateZeroDivisor: VkBool32,
8508}
8509
8510#[derive(Clone, Copy)]
8511#[repr(C)]
8512pub struct VkPhysicalDeviceVertexAttributeDivisorProperties {
8513    pub sType: VkStructureType,
8514    pub pNext: *mut c_void,
8515    pub maxVertexAttribDivisor: u32,
8516    pub supportsNonZeroFirstInstance: VkBool32,
8517}
8518
8519#[derive(Clone, Copy)]
8520#[repr(C)]
8521pub struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT {
8522    pub sType: VkStructureType,
8523    pub pNext: *mut c_void,
8524    pub maxVertexAttribDivisor: u32,
8525}
8526
8527#[derive(Clone, Copy)]
8528#[repr(C)]
8529pub struct VkPhysicalDeviceVertexAttributeRobustnessFeaturesEXT {
8530    pub sType: VkStructureType,
8531    pub pNext: *mut c_void,
8532    pub vertexAttributeRobustness: VkBool32,
8533}
8534
8535#[derive(Clone, Copy)]
8536#[repr(C)]
8537pub struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT {
8538    pub sType: VkStructureType,
8539    pub pNext: *mut c_void,
8540    pub vertexInputDynamicState: VkBool32,
8541}
8542
8543#[derive(Clone, Copy)]
8544#[repr(C)]
8545pub struct VkPhysicalDeviceVideoDecodeVP9FeaturesKHR {
8546    pub sType: VkStructureType,
8547    pub pNext: *mut c_void,
8548    pub videoDecodeVP9: VkBool32,
8549}
8550
8551#[derive(Clone, Copy)]
8552#[repr(C)]
8553pub struct VkPhysicalDeviceVideoEncodeAV1FeaturesKHR {
8554    pub sType: VkStructureType,
8555    pub pNext: *mut c_void,
8556    pub videoEncodeAV1: VkBool32,
8557}
8558
8559#[derive(Clone, Copy)]
8560#[repr(C)]
8561pub struct VkPhysicalDeviceVideoEncodeIntraRefreshFeaturesKHR {
8562    pub sType: VkStructureType,
8563    pub pNext: *mut c_void,
8564    pub videoEncodeIntraRefresh: VkBool32,
8565}
8566
8567#[derive(Clone, Copy)]
8568#[repr(C)]
8569pub struct VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR {
8570    pub sType: VkStructureType,
8571    pub pNext: *const c_void,
8572    pub pVideoProfile: *const VkVideoProfileInfoKHR,
8573    pub qualityLevel: u32,
8574}
8575
8576#[derive(Clone, Copy)]
8577#[repr(C)]
8578pub struct VkPhysicalDeviceVideoEncodeQuantizationMapFeaturesKHR {
8579    pub sType: VkStructureType,
8580    pub pNext: *mut c_void,
8581    pub videoEncodeQuantizationMap: VkBool32,
8582}
8583
8584#[derive(Clone, Copy)]
8585#[repr(C)]
8586pub struct VkPhysicalDeviceVideoEncodeRgbConversionFeaturesVALVE {
8587    pub sType: VkStructureType,
8588    pub pNext: *mut c_void,
8589    pub videoEncodeRgbConversion: VkBool32,
8590}
8591
8592#[derive(Clone, Copy)]
8593#[repr(C)]
8594pub struct VkPhysicalDeviceVideoFormatInfoKHR {
8595    pub sType: VkStructureType,
8596    pub pNext: *const c_void,
8597    pub imageUsage: VkImageUsageFlags,
8598}
8599
8600#[derive(Clone, Copy)]
8601#[repr(C)]
8602pub struct VkPhysicalDeviceVideoMaintenance1FeaturesKHR {
8603    pub sType: VkStructureType,
8604    pub pNext: *mut c_void,
8605    pub videoMaintenance1: VkBool32,
8606}
8607
8608#[derive(Clone, Copy)]
8609#[repr(C)]
8610pub struct VkPhysicalDeviceVideoMaintenance2FeaturesKHR {
8611    pub sType: VkStructureType,
8612    pub pNext: *mut c_void,
8613    pub videoMaintenance2: VkBool32,
8614}
8615
8616#[derive(Clone, Copy)]
8617#[repr(C)]
8618pub struct VkPhysicalDeviceVulkan11Features {
8619    pub sType: VkStructureType,
8620    pub pNext: *mut c_void,
8621    pub storageBuffer16BitAccess: VkBool32,
8622    pub uniformAndStorageBuffer16BitAccess: VkBool32,
8623    pub storagePushConstant16: VkBool32,
8624    pub storageInputOutput16: VkBool32,
8625    pub multiview: VkBool32,
8626    pub multiviewGeometryShader: VkBool32,
8627    pub multiviewTessellationShader: VkBool32,
8628    pub variablePointersStorageBuffer: VkBool32,
8629    pub variablePointers: VkBool32,
8630    pub protectedMemory: VkBool32,
8631    pub samplerYcbcrConversion: VkBool32,
8632    pub shaderDrawParameters: VkBool32,
8633}
8634
8635#[derive(Clone, Copy)]
8636#[repr(C)]
8637pub struct VkPhysicalDeviceVulkan11Properties {
8638    pub sType: VkStructureType,
8639    pub pNext: *mut c_void,
8640    pub deviceUUID: [u8; VK_UUID_SIZE as usize],
8641    pub driverUUID: [u8; VK_UUID_SIZE as usize],
8642    pub deviceLUID: [u8; VK_LUID_SIZE as usize],
8643    pub deviceNodeMask: u32,
8644    pub deviceLUIDValid: VkBool32,
8645    pub subgroupSize: u32,
8646    pub subgroupSupportedStages: VkShaderStageFlags,
8647    pub subgroupSupportedOperations: VkSubgroupFeatureFlags,
8648    pub subgroupQuadOperationsInAllStages: VkBool32,
8649    pub pointClippingBehavior: VkPointClippingBehavior,
8650    pub maxMultiviewViewCount: u32,
8651    pub maxMultiviewInstanceIndex: u32,
8652    pub protectedNoFault: VkBool32,
8653    pub maxPerSetDescriptors: u32,
8654    pub maxMemoryAllocationSize: VkDeviceSize,
8655}
8656
8657#[derive(Clone, Copy)]
8658#[repr(C)]
8659pub struct VkPhysicalDeviceVulkan12Features {
8660    pub sType: VkStructureType,
8661    pub pNext: *mut c_void,
8662    pub samplerMirrorClampToEdge: VkBool32,
8663    pub drawIndirectCount: VkBool32,
8664    pub storageBuffer8BitAccess: VkBool32,
8665    pub uniformAndStorageBuffer8BitAccess: VkBool32,
8666    pub storagePushConstant8: VkBool32,
8667    pub shaderBufferInt64Atomics: VkBool32,
8668    pub shaderSharedInt64Atomics: VkBool32,
8669    pub shaderFloat16: VkBool32,
8670    pub shaderInt8: VkBool32,
8671    pub descriptorIndexing: VkBool32,
8672    pub shaderInputAttachmentArrayDynamicIndexing: VkBool32,
8673    pub shaderUniformTexelBufferArrayDynamicIndexing: VkBool32,
8674    pub shaderStorageTexelBufferArrayDynamicIndexing: VkBool32,
8675    pub shaderUniformBufferArrayNonUniformIndexing: VkBool32,
8676    pub shaderSampledImageArrayNonUniformIndexing: VkBool32,
8677    pub shaderStorageBufferArrayNonUniformIndexing: VkBool32,
8678    pub shaderStorageImageArrayNonUniformIndexing: VkBool32,
8679    pub shaderInputAttachmentArrayNonUniformIndexing: VkBool32,
8680    pub shaderUniformTexelBufferArrayNonUniformIndexing: VkBool32,
8681    pub shaderStorageTexelBufferArrayNonUniformIndexing: VkBool32,
8682    pub descriptorBindingUniformBufferUpdateAfterBind: VkBool32,
8683    pub descriptorBindingSampledImageUpdateAfterBind: VkBool32,
8684    pub descriptorBindingStorageImageUpdateAfterBind: VkBool32,
8685    pub descriptorBindingStorageBufferUpdateAfterBind: VkBool32,
8686    pub descriptorBindingUniformTexelBufferUpdateAfterBind: VkBool32,
8687    pub descriptorBindingStorageTexelBufferUpdateAfterBind: VkBool32,
8688    pub descriptorBindingUpdateUnusedWhilePending: VkBool32,
8689    pub descriptorBindingPartiallyBound: VkBool32,
8690    pub descriptorBindingVariableDescriptorCount: VkBool32,
8691    pub runtimeDescriptorArray: VkBool32,
8692    pub samplerFilterMinmax: VkBool32,
8693    pub scalarBlockLayout: VkBool32,
8694    pub imagelessFramebuffer: VkBool32,
8695    pub uniformBufferStandardLayout: VkBool32,
8696    pub shaderSubgroupExtendedTypes: VkBool32,
8697    pub separateDepthStencilLayouts: VkBool32,
8698    pub hostQueryReset: VkBool32,
8699    pub timelineSemaphore: VkBool32,
8700    pub bufferDeviceAddress: VkBool32,
8701    pub bufferDeviceAddressCaptureReplay: VkBool32,
8702    pub bufferDeviceAddressMultiDevice: VkBool32,
8703    pub vulkanMemoryModel: VkBool32,
8704    pub vulkanMemoryModelDeviceScope: VkBool32,
8705    pub vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
8706    pub shaderOutputViewportIndex: VkBool32,
8707    pub shaderOutputLayer: VkBool32,
8708    pub subgroupBroadcastDynamicId: VkBool32,
8709}
8710
8711#[derive(Clone, Copy)]
8712#[repr(C)]
8713pub struct VkPhysicalDeviceVulkan12Properties {
8714    pub sType: VkStructureType,
8715    pub pNext: *mut c_void,
8716    pub driverID: VkDriverId,
8717    pub driverName: [c_char; VK_MAX_DRIVER_NAME_SIZE as usize],
8718    pub driverInfo: [c_char; VK_MAX_DRIVER_INFO_SIZE as usize],
8719    pub conformanceVersion: VkConformanceVersion,
8720    pub denormBehaviorIndependence: VkShaderFloatControlsIndependence,
8721    pub roundingModeIndependence: VkShaderFloatControlsIndependence,
8722    pub shaderSignedZeroInfNanPreserveFloat16: VkBool32,
8723    pub shaderSignedZeroInfNanPreserveFloat32: VkBool32,
8724    pub shaderSignedZeroInfNanPreserveFloat64: VkBool32,
8725    pub shaderDenormPreserveFloat16: VkBool32,
8726    pub shaderDenormPreserveFloat32: VkBool32,
8727    pub shaderDenormPreserveFloat64: VkBool32,
8728    pub shaderDenormFlushToZeroFloat16: VkBool32,
8729    pub shaderDenormFlushToZeroFloat32: VkBool32,
8730    pub shaderDenormFlushToZeroFloat64: VkBool32,
8731    pub shaderRoundingModeRTEFloat16: VkBool32,
8732    pub shaderRoundingModeRTEFloat32: VkBool32,
8733    pub shaderRoundingModeRTEFloat64: VkBool32,
8734    pub shaderRoundingModeRTZFloat16: VkBool32,
8735    pub shaderRoundingModeRTZFloat32: VkBool32,
8736    pub shaderRoundingModeRTZFloat64: VkBool32,
8737    pub maxUpdateAfterBindDescriptorsInAllPools: u32,
8738    pub shaderUniformBufferArrayNonUniformIndexingNative: VkBool32,
8739    pub shaderSampledImageArrayNonUniformIndexingNative: VkBool32,
8740    pub shaderStorageBufferArrayNonUniformIndexingNative: VkBool32,
8741    pub shaderStorageImageArrayNonUniformIndexingNative: VkBool32,
8742    pub shaderInputAttachmentArrayNonUniformIndexingNative: VkBool32,
8743    pub robustBufferAccessUpdateAfterBind: VkBool32,
8744    pub quadDivergentImplicitLod: VkBool32,
8745    pub maxPerStageDescriptorUpdateAfterBindSamplers: u32,
8746    pub maxPerStageDescriptorUpdateAfterBindUniformBuffers: u32,
8747    pub maxPerStageDescriptorUpdateAfterBindStorageBuffers: u32,
8748    pub maxPerStageDescriptorUpdateAfterBindSampledImages: u32,
8749    pub maxPerStageDescriptorUpdateAfterBindStorageImages: u32,
8750    pub maxPerStageDescriptorUpdateAfterBindInputAttachments: u32,
8751    pub maxPerStageUpdateAfterBindResources: u32,
8752    pub maxDescriptorSetUpdateAfterBindSamplers: u32,
8753    pub maxDescriptorSetUpdateAfterBindUniformBuffers: u32,
8754    pub maxDescriptorSetUpdateAfterBindUniformBuffersDynamic: u32,
8755    pub maxDescriptorSetUpdateAfterBindStorageBuffers: u32,
8756    pub maxDescriptorSetUpdateAfterBindStorageBuffersDynamic: u32,
8757    pub maxDescriptorSetUpdateAfterBindSampledImages: u32,
8758    pub maxDescriptorSetUpdateAfterBindStorageImages: u32,
8759    pub maxDescriptorSetUpdateAfterBindInputAttachments: u32,
8760    pub supportedDepthResolveModes: VkResolveModeFlags,
8761    pub supportedStencilResolveModes: VkResolveModeFlags,
8762    pub independentResolveNone: VkBool32,
8763    pub independentResolve: VkBool32,
8764    pub filterMinmaxSingleComponentFormats: VkBool32,
8765    pub filterMinmaxImageComponentMapping: VkBool32,
8766    pub maxTimelineSemaphoreValueDifference: u64,
8767    pub framebufferIntegerColorSampleCounts: VkSampleCountFlags,
8768}
8769
8770#[derive(Clone, Copy)]
8771#[repr(C)]
8772pub struct VkPhysicalDeviceVulkan13Features {
8773    pub sType: VkStructureType,
8774    pub pNext: *mut c_void,
8775    pub robustImageAccess: VkBool32,
8776    pub inlineUniformBlock: VkBool32,
8777    pub descriptorBindingInlineUniformBlockUpdateAfterBind: VkBool32,
8778    pub pipelineCreationCacheControl: VkBool32,
8779    pub privateData: VkBool32,
8780    pub shaderDemoteToHelperInvocation: VkBool32,
8781    pub shaderTerminateInvocation: VkBool32,
8782    pub subgroupSizeControl: VkBool32,
8783    pub computeFullSubgroups: VkBool32,
8784    pub synchronization2: VkBool32,
8785    pub textureCompressionASTC_HDR: VkBool32,
8786    pub shaderZeroInitializeWorkgroupMemory: VkBool32,
8787    pub dynamicRendering: VkBool32,
8788    pub shaderIntegerDotProduct: VkBool32,
8789    pub maintenance4: VkBool32,
8790}
8791
8792#[derive(Clone, Copy)]
8793#[repr(C)]
8794pub struct VkPhysicalDeviceVulkan13Properties {
8795    pub sType: VkStructureType,
8796    pub pNext: *mut c_void,
8797    pub minSubgroupSize: u32,
8798    pub maxSubgroupSize: u32,
8799    pub maxComputeWorkgroupSubgroups: u32,
8800    pub requiredSubgroupSizeStages: VkShaderStageFlags,
8801    pub maxInlineUniformBlockSize: u32,
8802    pub maxPerStageDescriptorInlineUniformBlocks: u32,
8803    pub maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks: u32,
8804    pub maxDescriptorSetInlineUniformBlocks: u32,
8805    pub maxDescriptorSetUpdateAfterBindInlineUniformBlocks: u32,
8806    pub maxInlineUniformTotalSize: u32,
8807    pub integerDotProduct8BitUnsignedAccelerated: VkBool32,
8808    pub integerDotProduct8BitSignedAccelerated: VkBool32,
8809    pub integerDotProduct8BitMixedSignednessAccelerated: VkBool32,
8810    pub integerDotProduct4x8BitPackedUnsignedAccelerated: VkBool32,
8811    pub integerDotProduct4x8BitPackedSignedAccelerated: VkBool32,
8812    pub integerDotProduct4x8BitPackedMixedSignednessAccelerated: VkBool32,
8813    pub integerDotProduct16BitUnsignedAccelerated: VkBool32,
8814    pub integerDotProduct16BitSignedAccelerated: VkBool32,
8815    pub integerDotProduct16BitMixedSignednessAccelerated: VkBool32,
8816    pub integerDotProduct32BitUnsignedAccelerated: VkBool32,
8817    pub integerDotProduct32BitSignedAccelerated: VkBool32,
8818    pub integerDotProduct32BitMixedSignednessAccelerated: VkBool32,
8819    pub integerDotProduct64BitUnsignedAccelerated: VkBool32,
8820    pub integerDotProduct64BitSignedAccelerated: VkBool32,
8821    pub integerDotProduct64BitMixedSignednessAccelerated: VkBool32,
8822    pub integerDotProductAccumulatingSaturating8BitUnsignedAccelerated: VkBool32,
8823    pub integerDotProductAccumulatingSaturating8BitSignedAccelerated: VkBool32,
8824    pub integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated: VkBool32,
8825    pub integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated: VkBool32,
8826    pub integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated: VkBool32,
8827    pub integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated: VkBool32,
8828    pub integerDotProductAccumulatingSaturating16BitUnsignedAccelerated: VkBool32,
8829    pub integerDotProductAccumulatingSaturating16BitSignedAccelerated: VkBool32,
8830    pub integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated: VkBool32,
8831    pub integerDotProductAccumulatingSaturating32BitUnsignedAccelerated: VkBool32,
8832    pub integerDotProductAccumulatingSaturating32BitSignedAccelerated: VkBool32,
8833    pub integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated: VkBool32,
8834    pub integerDotProductAccumulatingSaturating64BitUnsignedAccelerated: VkBool32,
8835    pub integerDotProductAccumulatingSaturating64BitSignedAccelerated: VkBool32,
8836    pub integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated: VkBool32,
8837    pub storageTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8838    pub storageTexelBufferOffsetSingleTexelAlignment: VkBool32,
8839    pub uniformTexelBufferOffsetAlignmentBytes: VkDeviceSize,
8840    pub uniformTexelBufferOffsetSingleTexelAlignment: VkBool32,
8841    pub maxBufferSize: VkDeviceSize,
8842}
8843
8844#[derive(Clone, Copy)]
8845#[repr(C)]
8846pub struct VkPhysicalDeviceVulkan14Features {
8847    pub sType: VkStructureType,
8848    pub pNext: *mut c_void,
8849    pub globalPriorityQuery: VkBool32,
8850    pub shaderSubgroupRotate: VkBool32,
8851    pub shaderSubgroupRotateClustered: VkBool32,
8852    pub shaderFloatControls2: VkBool32,
8853    pub shaderExpectAssume: VkBool32,
8854    pub rectangularLines: VkBool32,
8855    pub bresenhamLines: VkBool32,
8856    pub smoothLines: VkBool32,
8857    pub stippledRectangularLines: VkBool32,
8858    pub stippledBresenhamLines: VkBool32,
8859    pub stippledSmoothLines: VkBool32,
8860    pub vertexAttributeInstanceRateDivisor: VkBool32,
8861    pub vertexAttributeInstanceRateZeroDivisor: VkBool32,
8862    pub indexTypeUint8: VkBool32,
8863    pub dynamicRenderingLocalRead: VkBool32,
8864    pub maintenance5: VkBool32,
8865    pub maintenance6: VkBool32,
8866    pub pipelineProtectedAccess: VkBool32,
8867    pub pipelineRobustness: VkBool32,
8868    pub hostImageCopy: VkBool32,
8869    pub pushDescriptor: VkBool32,
8870}
8871
8872#[derive(Clone, Copy)]
8873#[repr(C)]
8874pub struct VkPhysicalDeviceVulkan14Properties {
8875    pub sType: VkStructureType,
8876    pub pNext: *mut c_void,
8877    pub lineSubPixelPrecisionBits: u32,
8878    pub maxVertexAttribDivisor: u32,
8879    pub supportsNonZeroFirstInstance: VkBool32,
8880    pub maxPushDescriptors: u32,
8881    pub dynamicRenderingLocalReadDepthStencilAttachments: VkBool32,
8882    pub dynamicRenderingLocalReadMultisampledAttachments: VkBool32,
8883    pub earlyFragmentMultisampleCoverageAfterSampleCounting: VkBool32,
8884    pub earlyFragmentSampleMaskTestBeforeSampleCounting: VkBool32,
8885    pub depthStencilSwizzleOneSupport: VkBool32,
8886    pub polygonModePointSize: VkBool32,
8887    pub nonStrictSinglePixelWideLinesUseParallelogram: VkBool32,
8888    pub nonStrictWideLinesUseParallelogram: VkBool32,
8889    pub blockTexelViewCompatibleMultipleLayers: VkBool32,
8890    pub maxCombinedImageSamplerDescriptorCount: u32,
8891    pub fragmentShadingRateClampCombinerInputs: VkBool32,
8892    pub defaultRobustnessStorageBuffers: VkPipelineRobustnessBufferBehavior,
8893    pub defaultRobustnessUniformBuffers: VkPipelineRobustnessBufferBehavior,
8894    pub defaultRobustnessVertexInputs: VkPipelineRobustnessBufferBehavior,
8895    pub defaultRobustnessImages: VkPipelineRobustnessImageBehavior,
8896    pub copySrcLayoutCount: u32,
8897    pub pCopySrcLayouts: *mut VkImageLayout,
8898    pub copyDstLayoutCount: u32,
8899    pub pCopyDstLayouts: *mut VkImageLayout,
8900    pub optimalTilingLayoutUUID: [u8; VK_UUID_SIZE as usize],
8901    pub identicalMemoryTypeRequirements: VkBool32,
8902}
8903
8904#[derive(Clone, Copy)]
8905#[repr(C)]
8906pub struct VkPhysicalDeviceVulkanMemoryModelFeatures {
8907    pub sType: VkStructureType,
8908    pub pNext: *mut c_void,
8909    pub vulkanMemoryModel: VkBool32,
8910    pub vulkanMemoryModelDeviceScope: VkBool32,
8911    pub vulkanMemoryModelAvailabilityVisibilityChains: VkBool32,
8912}
8913
8914#[derive(Clone, Copy)]
8915#[repr(C)]
8916pub struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
8917    pub sType: VkStructureType,
8918    pub pNext: *mut c_void,
8919    pub workgroupMemoryExplicitLayout: VkBool32,
8920    pub workgroupMemoryExplicitLayoutScalarBlockLayout: VkBool32,
8921    pub workgroupMemoryExplicitLayout8BitAccess: VkBool32,
8922    pub workgroupMemoryExplicitLayout16BitAccess: VkBool32,
8923}
8924
8925#[derive(Clone, Copy)]
8926#[repr(C)]
8927pub struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
8928    pub sType: VkStructureType,
8929    pub pNext: *mut c_void,
8930    pub ycbcr2plane444Formats: VkBool32,
8931}
8932
8933#[derive(Clone, Copy)]
8934#[repr(C)]
8935pub struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM {
8936    pub sType: VkStructureType,
8937    pub pNext: *mut c_void,
8938    pub ycbcrDegamma: VkBool32,
8939}
8940
8941#[derive(Clone, Copy)]
8942#[repr(C)]
8943pub struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT {
8944    pub sType: VkStructureType,
8945    pub pNext: *mut c_void,
8946    pub ycbcrImageArrays: VkBool32,
8947}
8948
8949#[derive(Clone, Copy)]
8950#[repr(C)]
8951pub struct VkPhysicalDeviceZeroInitializeDeviceMemoryFeaturesEXT {
8952    pub sType: VkStructureType,
8953    pub pNext: *mut c_void,
8954    pub zeroInitializeDeviceMemory: VkBool32,
8955}
8956
8957#[derive(Clone, Copy)]
8958#[repr(C)]
8959pub struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
8960    pub sType: VkStructureType,
8961    pub pNext: *mut c_void,
8962    pub shaderZeroInitializeWorkgroupMemory: VkBool32,
8963}
8964
8965#[repr(C)]
8966pub struct VkPhysicalDevice_T {
8967    _data: (),
8968    _marker: PhantomData<(*mut u8, PhantomPinned)>,
8969}
8970
8971#[derive(Clone, Copy)]
8972#[repr(C)]
8973pub struct VkPipelineBinaryCreateInfoKHR {
8974    pub sType: VkStructureType,
8975    pub pNext: *const c_void,
8976    pub pKeysAndDataInfo: *const VkPipelineBinaryKeysAndDataKHR,
8977    pub pipeline: VkPipeline,
8978    pub pPipelineCreateInfo: *const VkPipelineCreateInfoKHR,
8979}
8980
8981#[derive(Clone, Copy)]
8982#[repr(C)]
8983pub struct VkPipelineBinaryDataInfoKHR {
8984    pub sType: VkStructureType,
8985    pub pNext: *mut c_void,
8986    pub pipelineBinary: VkPipelineBinaryKHR,
8987}
8988
8989#[derive(Clone, Copy)]
8990#[repr(C)]
8991pub struct VkPipelineBinaryDataKHR {
8992    pub dataSize: usize,
8993    pub pData: *mut c_void,
8994}
8995
8996#[derive(Clone, Copy)]
8997#[repr(C)]
8998pub struct VkPipelineBinaryHandlesInfoKHR {
8999    pub sType: VkStructureType,
9000    pub pNext: *const c_void,
9001    pub pipelineBinaryCount: u32,
9002    pub pPipelineBinaries: *mut VkPipelineBinaryKHR,
9003}
9004
9005#[derive(Clone, Copy)]
9006#[repr(C)]
9007pub struct VkPipelineBinaryInfoKHR {
9008    pub sType: VkStructureType,
9009    pub pNext: *const c_void,
9010    pub binaryCount: u32,
9011    pub pPipelineBinaries: *const VkPipelineBinaryKHR,
9012}
9013
9014#[repr(C)]
9015pub struct VkPipelineBinaryKHR_T {
9016    _data: (),
9017    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9018}
9019
9020#[derive(Clone, Copy)]
9021#[repr(C)]
9022pub struct VkPipelineBinaryKeyKHR {
9023    pub sType: VkStructureType,
9024    pub pNext: *mut c_void,
9025    pub keySize: u32,
9026    pub key: [u8; VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR as usize],
9027}
9028
9029#[derive(Clone, Copy)]
9030#[repr(C)]
9031pub struct VkPipelineBinaryKeysAndDataKHR {
9032    pub binaryCount: u32,
9033    pub pPipelineBinaryKeys: *const VkPipelineBinaryKeyKHR,
9034    pub pPipelineBinaryData: *const VkPipelineBinaryDataKHR,
9035}
9036
9037#[derive(Clone, Copy)]
9038#[repr(C)]
9039pub struct VkPipelineCacheCreateInfo {
9040    pub sType: VkStructureType,
9041    pub pNext: *const c_void,
9042    pub flags: VkPipelineCacheCreateFlags,
9043    pub initialDataSize: usize,
9044    pub pInitialData: *const c_void,
9045}
9046
9047#[derive(Clone, Copy)]
9048#[repr(C)]
9049pub struct VkPipelineCacheHeaderVersionDataGraphQCOM {
9050    pub headerSize: u32,
9051    pub headerVersion: VkPipelineCacheHeaderVersion,
9052    pub cacheType: VkDataGraphModelCacheTypeQCOM,
9053    pub cacheVersion: u32,
9054    pub toolchainVersion: [u32; VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM as usize],
9055}
9056
9057#[derive(Clone, Copy)]
9058#[repr(C)]
9059pub struct VkPipelineCacheHeaderVersionOne {
9060    pub headerSize: u32,
9061    pub headerVersion: VkPipelineCacheHeaderVersion,
9062    pub vendorID: u32,
9063    pub deviceID: u32,
9064    pub pipelineCacheUUID: [u8; VK_UUID_SIZE as usize],
9065}
9066
9067#[repr(C)]
9068pub struct VkPipelineCache_T {
9069    _data: (),
9070    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9071}
9072
9073#[derive(Clone, Copy)]
9074#[repr(C)]
9075pub struct VkPipelineColorBlendAdvancedStateCreateInfoEXT {
9076    pub sType: VkStructureType,
9077    pub pNext: *const c_void,
9078    pub srcPremultiplied: VkBool32,
9079    pub dstPremultiplied: VkBool32,
9080    pub blendOverlap: VkBlendOverlapEXT,
9081}
9082
9083#[derive(Clone, Copy)]
9084#[repr(C)]
9085pub struct VkPipelineColorBlendAttachmentState {
9086    pub blendEnable: VkBool32,
9087    pub srcColorBlendFactor: VkBlendFactor,
9088    pub dstColorBlendFactor: VkBlendFactor,
9089    pub colorBlendOp: VkBlendOp,
9090    pub srcAlphaBlendFactor: VkBlendFactor,
9091    pub dstAlphaBlendFactor: VkBlendFactor,
9092    pub alphaBlendOp: VkBlendOp,
9093    pub colorWriteMask: VkColorComponentFlags,
9094}
9095
9096#[derive(Clone, Copy)]
9097#[repr(C)]
9098pub struct VkPipelineColorBlendStateCreateInfo {
9099    pub sType: VkStructureType,
9100    pub pNext: *const c_void,
9101    pub flags: VkPipelineColorBlendStateCreateFlags,
9102    pub logicOpEnable: VkBool32,
9103    pub logicOp: VkLogicOp,
9104    pub attachmentCount: u32,
9105    pub pAttachments: *const VkPipelineColorBlendAttachmentState,
9106    pub blendConstants: [f32; 4 as usize],
9107}
9108
9109#[derive(Clone, Copy)]
9110#[repr(C)]
9111pub struct VkPipelineColorWriteCreateInfoEXT {
9112    pub sType: VkStructureType,
9113    pub pNext: *const c_void,
9114    pub attachmentCount: u32,
9115    pub pColorWriteEnables: *const VkBool32,
9116}
9117
9118#[derive(Clone, Copy)]
9119#[repr(C)]
9120pub struct VkPipelineCompilerControlCreateInfoAMD {
9121    pub sType: VkStructureType,
9122    pub pNext: *const c_void,
9123    pub compilerControlFlags: VkPipelineCompilerControlFlagsAMD,
9124}
9125
9126#[derive(Clone, Copy)]
9127#[repr(C)]
9128pub struct VkPipelineCoverageModulationStateCreateInfoNV {
9129    pub sType: VkStructureType,
9130    pub pNext: *const c_void,
9131    pub flags: VkPipelineCoverageModulationStateCreateFlagsNV,
9132    pub coverageModulationMode: VkCoverageModulationModeNV,
9133    pub coverageModulationTableEnable: VkBool32,
9134    pub coverageModulationTableCount: u32,
9135    pub pCoverageModulationTable: *const f32,
9136}
9137
9138#[derive(Clone, Copy)]
9139#[repr(C)]
9140pub struct VkPipelineCoverageReductionStateCreateInfoNV {
9141    pub sType: VkStructureType,
9142    pub pNext: *const c_void,
9143    pub flags: VkPipelineCoverageReductionStateCreateFlagsNV,
9144    pub coverageReductionMode: VkCoverageReductionModeNV,
9145}
9146
9147#[derive(Clone, Copy)]
9148#[repr(C)]
9149pub struct VkPipelineCoverageToColorStateCreateInfoNV {
9150    pub sType: VkStructureType,
9151    pub pNext: *const c_void,
9152    pub flags: VkPipelineCoverageToColorStateCreateFlagsNV,
9153    pub coverageToColorEnable: VkBool32,
9154    pub coverageToColorLocation: u32,
9155}
9156
9157#[derive(Clone, Copy)]
9158#[repr(C)]
9159pub struct VkPipelineCreateFlags2CreateInfo {
9160    pub sType: VkStructureType,
9161    pub pNext: *const c_void,
9162    pub flags: VkPipelineCreateFlags2,
9163}
9164
9165#[derive(Clone, Copy)]
9166#[repr(C)]
9167pub struct VkPipelineCreateInfoKHR {
9168    pub sType: VkStructureType,
9169    pub pNext: *mut c_void,
9170}
9171
9172#[derive(Clone, Copy)]
9173#[repr(C)]
9174pub struct VkPipelineCreationFeedback {
9175    pub flags: VkPipelineCreationFeedbackFlags,
9176    pub duration: u64,
9177}
9178
9179#[derive(Clone, Copy)]
9180#[repr(C)]
9181pub struct VkPipelineCreationFeedbackCreateInfo {
9182    pub sType: VkStructureType,
9183    pub pNext: *const c_void,
9184    pub pPipelineCreationFeedback: *mut VkPipelineCreationFeedback,
9185    pub pipelineStageCreationFeedbackCount: u32,
9186    pub pPipelineStageCreationFeedbacks: *mut VkPipelineCreationFeedback,
9187}
9188
9189#[derive(Clone, Copy)]
9190#[repr(C)]
9191pub struct VkPipelineDepthStencilStateCreateInfo {
9192    pub sType: VkStructureType,
9193    pub pNext: *const c_void,
9194    pub flags: VkPipelineDepthStencilStateCreateFlags,
9195    pub depthTestEnable: VkBool32,
9196    pub depthWriteEnable: VkBool32,
9197    pub depthCompareOp: VkCompareOp,
9198    pub depthBoundsTestEnable: VkBool32,
9199    pub stencilTestEnable: VkBool32,
9200    pub front: VkStencilOpState,
9201    pub back: VkStencilOpState,
9202    pub minDepthBounds: f32,
9203    pub maxDepthBounds: f32,
9204}
9205
9206#[derive(Clone, Copy)]
9207#[repr(C)]
9208pub struct VkPipelineDiscardRectangleStateCreateInfoEXT {
9209    pub sType: VkStructureType,
9210    pub pNext: *const c_void,
9211    pub flags: VkPipelineDiscardRectangleStateCreateFlagsEXT,
9212    pub discardRectangleMode: VkDiscardRectangleModeEXT,
9213    pub discardRectangleCount: u32,
9214    pub pDiscardRectangles: *const VkRect2D,
9215}
9216
9217#[derive(Clone, Copy)]
9218#[repr(C)]
9219pub struct VkPipelineDynamicStateCreateInfo {
9220    pub sType: VkStructureType,
9221    pub pNext: *const c_void,
9222    pub flags: VkPipelineDynamicStateCreateFlags,
9223    pub dynamicStateCount: u32,
9224    pub pDynamicStates: *const VkDynamicState,
9225}
9226
9227#[derive(Clone, Copy)]
9228#[repr(C)]
9229pub struct VkPipelineExecutableInfoKHR {
9230    pub sType: VkStructureType,
9231    pub pNext: *const c_void,
9232    pub pipeline: VkPipeline,
9233    pub executableIndex: u32,
9234}
9235
9236#[derive(Clone, Copy)]
9237#[repr(C)]
9238pub struct VkPipelineExecutableInternalRepresentationKHR {
9239    pub sType: VkStructureType,
9240    pub pNext: *mut c_void,
9241    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9242    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9243    pub isText: VkBool32,
9244    pub dataSize: usize,
9245    pub pData: *mut c_void,
9246}
9247
9248#[derive(Clone, Copy)]
9249#[repr(C)]
9250pub struct VkPipelineExecutablePropertiesKHR {
9251    pub sType: VkStructureType,
9252    pub pNext: *mut c_void,
9253    pub stages: VkShaderStageFlags,
9254    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9255    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9256    pub subgroupSize: u32,
9257}
9258
9259#[derive(Clone, Copy)]
9260#[repr(C)]
9261pub struct VkPipelineExecutableStatisticKHR {
9262    pub sType: VkStructureType,
9263    pub pNext: *mut c_void,
9264    pub name: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9265    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
9266    pub format: VkPipelineExecutableStatisticFormatKHR,
9267    pub value: VkPipelineExecutableStatisticValueKHR,
9268}
9269
9270#[derive(Clone, Copy)]
9271#[repr(C)]
9272pub struct VkPipelineFragmentDensityMapLayeredCreateInfoVALVE {
9273    pub sType: VkStructureType,
9274    pub pNext: *const c_void,
9275    pub maxFragmentDensityMapLayers: u32,
9276}
9277
9278#[derive(Clone, Copy)]
9279#[repr(C)]
9280pub struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV {
9281    pub sType: VkStructureType,
9282    pub pNext: *const c_void,
9283    pub shadingRateType: VkFragmentShadingRateTypeNV,
9284    pub shadingRate: VkFragmentShadingRateNV,
9285    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
9286}
9287
9288#[derive(Clone, Copy)]
9289#[repr(C)]
9290pub struct VkPipelineFragmentShadingRateStateCreateInfoKHR {
9291    pub sType: VkStructureType,
9292    pub pNext: *const c_void,
9293    pub fragmentSize: VkExtent2D,
9294    pub combinerOps: [VkFragmentShadingRateCombinerOpKHR; 2 as usize],
9295}
9296
9297#[derive(Clone, Copy)]
9298#[repr(C)]
9299pub struct VkPipelineIndirectDeviceAddressInfoNV {
9300    pub sType: VkStructureType,
9301    pub pNext: *const c_void,
9302    pub pipelineBindPoint: VkPipelineBindPoint,
9303    pub pipeline: VkPipeline,
9304}
9305
9306#[derive(Clone, Copy)]
9307#[repr(C)]
9308pub struct VkPipelineInfoKHR {
9309    pub sType: VkStructureType,
9310    pub pNext: *const c_void,
9311    pub pipeline: VkPipeline,
9312}
9313
9314#[derive(Clone, Copy)]
9315#[repr(C)]
9316pub struct VkPipelineInputAssemblyStateCreateInfo {
9317    pub sType: VkStructureType,
9318    pub pNext: *const c_void,
9319    pub flags: VkPipelineInputAssemblyStateCreateFlags,
9320    pub topology: VkPrimitiveTopology,
9321    pub primitiveRestartEnable: VkBool32,
9322}
9323
9324#[derive(Clone, Copy)]
9325#[repr(C)]
9326pub struct VkPipelineLayoutCreateInfo {
9327    pub sType: VkStructureType,
9328    pub pNext: *const c_void,
9329    pub flags: VkPipelineLayoutCreateFlags,
9330    pub setLayoutCount: u32,
9331    pub pSetLayouts: *const VkDescriptorSetLayout,
9332    pub pushConstantRangeCount: u32,
9333    pub pPushConstantRanges: *const VkPushConstantRange,
9334}
9335
9336#[repr(C)]
9337pub struct VkPipelineLayout_T {
9338    _data: (),
9339    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9340}
9341
9342#[derive(Clone, Copy)]
9343#[repr(C)]
9344pub struct VkPipelineLibraryCreateInfoKHR {
9345    pub sType: VkStructureType,
9346    pub pNext: *const c_void,
9347    pub libraryCount: u32,
9348    pub pLibraries: *const VkPipeline,
9349}
9350
9351#[derive(Clone, Copy)]
9352#[repr(C)]
9353pub struct VkPipelineMultisampleStateCreateInfo {
9354    pub sType: VkStructureType,
9355    pub pNext: *const c_void,
9356    pub flags: VkPipelineMultisampleStateCreateFlags,
9357    pub rasterizationSamples: VkSampleCountFlagBits,
9358    pub sampleShadingEnable: VkBool32,
9359    pub minSampleShading: f32,
9360    pub pSampleMask: *const VkSampleMask,
9361    pub alphaToCoverageEnable: VkBool32,
9362    pub alphaToOneEnable: VkBool32,
9363}
9364
9365#[derive(Clone, Copy)]
9366#[repr(C)]
9367pub struct VkPipelinePropertiesIdentifierEXT {
9368    pub sType: VkStructureType,
9369    pub pNext: *mut c_void,
9370    pub pipelineIdentifier: [u8; VK_UUID_SIZE as usize],
9371}
9372
9373#[derive(Clone, Copy)]
9374#[repr(C)]
9375pub struct VkPipelineRasterizationConservativeStateCreateInfoEXT {
9376    pub sType: VkStructureType,
9377    pub pNext: *const c_void,
9378    pub flags: VkPipelineRasterizationConservativeStateCreateFlagsEXT,
9379    pub conservativeRasterizationMode: VkConservativeRasterizationModeEXT,
9380    pub extraPrimitiveOverestimationSize: f32,
9381}
9382
9383#[derive(Clone, Copy)]
9384#[repr(C)]
9385pub struct VkPipelineRasterizationDepthClipStateCreateInfoEXT {
9386    pub sType: VkStructureType,
9387    pub pNext: *const c_void,
9388    pub flags: VkPipelineRasterizationDepthClipStateCreateFlagsEXT,
9389    pub depthClipEnable: VkBool32,
9390}
9391
9392#[derive(Clone, Copy)]
9393#[repr(C)]
9394pub struct VkPipelineRasterizationLineStateCreateInfo {
9395    pub sType: VkStructureType,
9396    pub pNext: *const c_void,
9397    pub lineRasterizationMode: VkLineRasterizationMode,
9398    pub stippledLineEnable: VkBool32,
9399    pub lineStippleFactor: u32,
9400    pub lineStipplePattern: u16,
9401}
9402
9403#[derive(Clone, Copy)]
9404#[repr(C)]
9405pub struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT {
9406    pub sType: VkStructureType,
9407    pub pNext: *const c_void,
9408    pub provokingVertexMode: VkProvokingVertexModeEXT,
9409}
9410
9411#[derive(Clone, Copy)]
9412#[repr(C)]
9413pub struct VkPipelineRasterizationStateCreateInfo {
9414    pub sType: VkStructureType,
9415    pub pNext: *const c_void,
9416    pub flags: VkPipelineRasterizationStateCreateFlags,
9417    pub depthClampEnable: VkBool32,
9418    pub rasterizerDiscardEnable: VkBool32,
9419    pub polygonMode: VkPolygonMode,
9420    pub cullMode: VkCullModeFlags,
9421    pub frontFace: VkFrontFace,
9422    pub depthBiasEnable: VkBool32,
9423    pub depthBiasConstantFactor: f32,
9424    pub depthBiasClamp: f32,
9425    pub depthBiasSlopeFactor: f32,
9426    pub lineWidth: f32,
9427}
9428
9429#[derive(Clone, Copy)]
9430#[repr(C)]
9431pub struct VkPipelineRasterizationStateRasterizationOrderAMD {
9432    pub sType: VkStructureType,
9433    pub pNext: *const c_void,
9434    pub rasterizationOrder: VkRasterizationOrderAMD,
9435}
9436
9437#[derive(Clone, Copy)]
9438#[repr(C)]
9439pub struct VkPipelineRasterizationStateStreamCreateInfoEXT {
9440    pub sType: VkStructureType,
9441    pub pNext: *const c_void,
9442    pub flags: VkPipelineRasterizationStateStreamCreateFlagsEXT,
9443    pub rasterizationStream: u32,
9444}
9445
9446#[derive(Clone, Copy)]
9447#[repr(C)]
9448pub struct VkPipelineRenderingCreateInfo {
9449    pub sType: VkStructureType,
9450    pub pNext: *const c_void,
9451    pub viewMask: u32,
9452    pub colorAttachmentCount: u32,
9453    pub pColorAttachmentFormats: *const VkFormat,
9454    pub depthAttachmentFormat: VkFormat,
9455    pub stencilAttachmentFormat: VkFormat,
9456}
9457
9458#[derive(Clone, Copy)]
9459#[repr(C)]
9460pub struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV {
9461    pub sType: VkStructureType,
9462    pub pNext: *const c_void,
9463    pub representativeFragmentTestEnable: VkBool32,
9464}
9465
9466#[derive(Clone, Copy)]
9467#[repr(C)]
9468pub struct VkPipelineRobustnessCreateInfo {
9469    pub sType: VkStructureType,
9470    pub pNext: *const c_void,
9471    pub storageBuffers: VkPipelineRobustnessBufferBehavior,
9472    pub uniformBuffers: VkPipelineRobustnessBufferBehavior,
9473    pub vertexInputs: VkPipelineRobustnessBufferBehavior,
9474    pub images: VkPipelineRobustnessImageBehavior,
9475}
9476
9477#[derive(Clone, Copy)]
9478#[repr(C)]
9479pub struct VkPipelineSampleLocationsStateCreateInfoEXT {
9480    pub sType: VkStructureType,
9481    pub pNext: *const c_void,
9482    pub sampleLocationsEnable: VkBool32,
9483    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
9484}
9485
9486#[derive(Clone, Copy)]
9487#[repr(C)]
9488pub struct VkPipelineShaderStageCreateInfo {
9489    pub sType: VkStructureType,
9490    pub pNext: *const c_void,
9491    pub flags: VkPipelineShaderStageCreateFlags,
9492    pub stage: VkShaderStageFlagBits,
9493    pub module: VkShaderModule,
9494    pub pName: *const c_char,
9495    pub pSpecializationInfo: *const VkSpecializationInfo,
9496}
9497
9498#[derive(Clone, Copy)]
9499#[repr(C)]
9500pub struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT {
9501    pub sType: VkStructureType,
9502    pub pNext: *const c_void,
9503    pub identifierSize: u32,
9504    pub pIdentifier: *const u8,
9505}
9506
9507#[derive(Clone, Copy)]
9508#[repr(C)]
9509pub struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo {
9510    pub sType: VkStructureType,
9511    pub pNext: *const c_void,
9512    pub requiredSubgroupSize: u32,
9513}
9514
9515#[derive(Clone, Copy)]
9516#[repr(C)]
9517pub struct VkPipelineTessellationDomainOriginStateCreateInfo {
9518    pub sType: VkStructureType,
9519    pub pNext: *const c_void,
9520    pub domainOrigin: VkTessellationDomainOrigin,
9521}
9522
9523#[derive(Clone, Copy)]
9524#[repr(C)]
9525pub struct VkPipelineTessellationStateCreateInfo {
9526    pub sType: VkStructureType,
9527    pub pNext: *const c_void,
9528    pub flags: VkPipelineTessellationStateCreateFlags,
9529    pub patchControlPoints: u32,
9530}
9531
9532#[derive(Clone, Copy)]
9533#[repr(C)]
9534pub struct VkPipelineVertexInputDivisorStateCreateInfo {
9535    pub sType: VkStructureType,
9536    pub pNext: *const c_void,
9537    pub vertexBindingDivisorCount: u32,
9538    pub pVertexBindingDivisors: *const VkVertexInputBindingDivisorDescription,
9539}
9540
9541#[derive(Clone, Copy)]
9542#[repr(C)]
9543pub struct VkPipelineVertexInputStateCreateInfo {
9544    pub sType: VkStructureType,
9545    pub pNext: *const c_void,
9546    pub flags: VkPipelineVertexInputStateCreateFlags,
9547    pub vertexBindingDescriptionCount: u32,
9548    pub pVertexBindingDescriptions: *const VkVertexInputBindingDescription,
9549    pub vertexAttributeDescriptionCount: u32,
9550    pub pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription,
9551}
9552
9553#[derive(Clone, Copy)]
9554#[repr(C)]
9555pub struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV {
9556    pub sType: VkStructureType,
9557    pub pNext: *const c_void,
9558    pub sampleOrderType: VkCoarseSampleOrderTypeNV,
9559    pub customSampleOrderCount: u32,
9560    pub pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV,
9561}
9562
9563#[derive(Clone, Copy)]
9564#[repr(C)]
9565pub struct VkPipelineViewportDepthClampControlCreateInfoEXT {
9566    pub sType: VkStructureType,
9567    pub pNext: *const c_void,
9568    pub depthClampMode: VkDepthClampModeEXT,
9569    pub pDepthClampRange: *const VkDepthClampRangeEXT,
9570}
9571
9572#[derive(Clone, Copy)]
9573#[repr(C)]
9574pub struct VkPipelineViewportDepthClipControlCreateInfoEXT {
9575    pub sType: VkStructureType,
9576    pub pNext: *const c_void,
9577    pub negativeOneToOne: VkBool32,
9578}
9579
9580#[derive(Clone, Copy)]
9581#[repr(C)]
9582pub struct VkPipelineViewportExclusiveScissorStateCreateInfoNV {
9583    pub sType: VkStructureType,
9584    pub pNext: *const c_void,
9585    pub exclusiveScissorCount: u32,
9586    pub pExclusiveScissors: *const VkRect2D,
9587}
9588
9589#[derive(Clone, Copy)]
9590#[repr(C)]
9591pub struct VkPipelineViewportShadingRateImageStateCreateInfoNV {
9592    pub sType: VkStructureType,
9593    pub pNext: *const c_void,
9594    pub shadingRateImageEnable: VkBool32,
9595    pub viewportCount: u32,
9596    pub pShadingRatePalettes: *const VkShadingRatePaletteNV,
9597}
9598
9599#[derive(Clone, Copy)]
9600#[repr(C)]
9601pub struct VkPipelineViewportStateCreateInfo {
9602    pub sType: VkStructureType,
9603    pub pNext: *const c_void,
9604    pub flags: VkPipelineViewportStateCreateFlags,
9605    pub viewportCount: u32,
9606    pub pViewports: *const VkViewport,
9607    pub scissorCount: u32,
9608    pub pScissors: *const VkRect2D,
9609}
9610
9611#[derive(Clone, Copy)]
9612#[repr(C)]
9613pub struct VkPipelineViewportSwizzleStateCreateInfoNV {
9614    pub sType: VkStructureType,
9615    pub pNext: *const c_void,
9616    pub flags: VkPipelineViewportSwizzleStateCreateFlagsNV,
9617    pub viewportCount: u32,
9618    pub pViewportSwizzles: *const VkViewportSwizzleNV,
9619}
9620
9621#[derive(Clone, Copy)]
9622#[repr(C)]
9623pub struct VkPipelineViewportWScalingStateCreateInfoNV {
9624    pub sType: VkStructureType,
9625    pub pNext: *const c_void,
9626    pub viewportWScalingEnable: VkBool32,
9627    pub viewportCount: u32,
9628    pub pViewportWScalings: *const VkViewportWScalingNV,
9629}
9630
9631#[repr(C)]
9632pub struct VkPipeline_T {
9633    _data: (),
9634    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9635}
9636
9637#[derive(Clone, Copy)]
9638#[repr(C)]
9639pub struct VkPresentId2KHR {
9640    pub sType: VkStructureType,
9641    pub pNext: *const c_void,
9642    pub swapchainCount: u32,
9643    pub pPresentIds: *const u64,
9644}
9645
9646#[derive(Clone, Copy)]
9647#[repr(C)]
9648pub struct VkPresentIdKHR {
9649    pub sType: VkStructureType,
9650    pub pNext: *const c_void,
9651    pub swapchainCount: u32,
9652    pub pPresentIds: *const u64,
9653}
9654
9655#[derive(Clone, Copy)]
9656#[repr(C)]
9657pub struct VkPresentInfoKHR {
9658    pub sType: VkStructureType,
9659    pub pNext: *const c_void,
9660    pub waitSemaphoreCount: u32,
9661    pub pWaitSemaphores: *const VkSemaphore,
9662    pub swapchainCount: u32,
9663    pub pSwapchains: *const VkSwapchainKHR,
9664    pub pImageIndices: *const u32,
9665    pub pResults: *mut VkResult,
9666}
9667
9668#[derive(Clone, Copy)]
9669#[repr(C)]
9670pub struct VkPresentRegionKHR {
9671    pub rectangleCount: u32,
9672    pub pRectangles: *const VkRectLayerKHR,
9673}
9674
9675#[derive(Clone, Copy)]
9676#[repr(C)]
9677pub struct VkPresentRegionsKHR {
9678    pub sType: VkStructureType,
9679    pub pNext: *const c_void,
9680    pub swapchainCount: u32,
9681    pub pRegions: *const VkPresentRegionKHR,
9682}
9683
9684#[derive(Clone, Copy)]
9685#[repr(C)]
9686pub struct VkPresentStageTimeEXT {
9687    pub stage: VkPresentStageFlagsEXT,
9688    pub time: u64,
9689}
9690
9691#[derive(Clone, Copy)]
9692#[repr(C)]
9693pub struct VkPresentTimeGOOGLE {
9694    pub presentID: u32,
9695    pub desiredPresentTime: u64,
9696}
9697
9698#[derive(Clone, Copy)]
9699#[repr(C)]
9700pub struct VkPresentTimesInfoGOOGLE {
9701    pub sType: VkStructureType,
9702    pub pNext: *const c_void,
9703    pub swapchainCount: u32,
9704    pub pTimes: *const VkPresentTimeGOOGLE,
9705}
9706
9707#[derive(Clone, Copy)]
9708#[repr(C)]
9709pub struct VkPresentTimingInfoEXT {
9710    pub sType: VkStructureType,
9711    pub pNext: *const c_void,
9712    pub flags: VkPresentTimingInfoFlagsEXT,
9713    pub targetTime: u64,
9714    pub timeDomainId: u64,
9715    pub presentStageQueries: VkPresentStageFlagsEXT,
9716    pub targetTimeDomainPresentStage: VkPresentStageFlagsEXT,
9717}
9718
9719#[derive(Clone, Copy)]
9720#[repr(C)]
9721pub struct VkPresentTimingSurfaceCapabilitiesEXT {
9722    pub sType: VkStructureType,
9723    pub pNext: *mut c_void,
9724    pub presentTimingSupported: VkBool32,
9725    pub presentAtAbsoluteTimeSupported: VkBool32,
9726    pub presentAtRelativeTimeSupported: VkBool32,
9727    pub presentStageQueries: VkPresentStageFlagsEXT,
9728}
9729
9730#[derive(Clone, Copy)]
9731#[repr(C)]
9732pub struct VkPresentTimingsInfoEXT {
9733    pub sType: VkStructureType,
9734    pub pNext: *const c_void,
9735    pub swapchainCount: u32,
9736    pub pTimingInfos: *const VkPresentTimingInfoEXT,
9737}
9738
9739#[derive(Clone, Copy)]
9740#[repr(C)]
9741pub struct VkPresentWait2InfoKHR {
9742    pub sType: VkStructureType,
9743    pub pNext: *const c_void,
9744    pub presentId: u64,
9745    pub timeout: u64,
9746}
9747
9748#[derive(Clone, Copy)]
9749#[repr(C)]
9750pub struct VkPrivateDataSlotCreateInfo {
9751    pub sType: VkStructureType,
9752    pub pNext: *const c_void,
9753    pub flags: VkPrivateDataSlotCreateFlags,
9754}
9755
9756#[repr(C)]
9757pub struct VkPrivateDataSlot_T {
9758    _data: (),
9759    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9760}
9761
9762#[derive(Clone, Copy)]
9763#[repr(C)]
9764pub struct VkProtectedSubmitInfo {
9765    pub sType: VkStructureType,
9766    pub pNext: *const c_void,
9767    pub protectedSubmit: VkBool32,
9768}
9769
9770#[derive(Clone, Copy)]
9771#[repr(C)]
9772pub struct VkPushConstantBankInfoNV {
9773    pub sType: VkStructureType,
9774    pub pNext: *const c_void,
9775    pub bank: u32,
9776}
9777
9778#[derive(Clone, Copy)]
9779#[repr(C)]
9780pub struct VkPushConstantRange {
9781    pub stageFlags: VkShaderStageFlags,
9782    pub offset: u32,
9783    pub size: u32,
9784}
9785
9786#[derive(Clone, Copy)]
9787#[repr(C)]
9788pub struct VkPushConstantsInfo {
9789    pub sType: VkStructureType,
9790    pub pNext: *const c_void,
9791    pub layout: VkPipelineLayout,
9792    pub stageFlags: VkShaderStageFlags,
9793    pub offset: u32,
9794    pub size: u32,
9795    pub pValues: *const c_void,
9796}
9797
9798#[derive(Clone, Copy)]
9799#[repr(C)]
9800pub struct VkPushDataInfoEXT {
9801    pub sType: VkStructureType,
9802    pub pNext: *const c_void,
9803    pub offset: u32,
9804    pub data: VkHostAddressRangeConstEXT,
9805}
9806
9807#[derive(Clone, Copy)]
9808#[repr(C)]
9809pub struct VkPushDescriptorSetInfo {
9810    pub sType: VkStructureType,
9811    pub pNext: *const c_void,
9812    pub stageFlags: VkShaderStageFlags,
9813    pub layout: VkPipelineLayout,
9814    pub set: u32,
9815    pub descriptorWriteCount: u32,
9816    pub pDescriptorWrites: *const VkWriteDescriptorSet,
9817}
9818
9819#[derive(Clone, Copy)]
9820#[repr(C)]
9821pub struct VkPushDescriptorSetWithTemplateInfo {
9822    pub sType: VkStructureType,
9823    pub pNext: *const c_void,
9824    pub descriptorUpdateTemplate: VkDescriptorUpdateTemplate,
9825    pub layout: VkPipelineLayout,
9826    pub set: u32,
9827    pub pData: *const c_void,
9828}
9829
9830#[derive(Clone, Copy)]
9831#[repr(C)]
9832pub struct VkQueryLowLatencySupportNV {
9833    pub sType: VkStructureType,
9834    pub pNext: *const c_void,
9835    pub pQueriedLowLatencyData: *mut c_void,
9836}
9837
9838#[derive(Clone, Copy)]
9839#[repr(C)]
9840pub struct VkQueryPoolCreateInfo {
9841    pub sType: VkStructureType,
9842    pub pNext: *const c_void,
9843    pub flags: VkQueryPoolCreateFlags,
9844    pub queryType: VkQueryType,
9845    pub queryCount: u32,
9846    pub pipelineStatistics: VkQueryPipelineStatisticFlags,
9847}
9848
9849#[derive(Clone, Copy)]
9850#[repr(C)]
9851pub struct VkQueryPoolPerformanceCreateInfoKHR {
9852    pub sType: VkStructureType,
9853    pub pNext: *const c_void,
9854    pub queueFamilyIndex: u32,
9855    pub counterIndexCount: u32,
9856    pub pCounterIndices: *const u32,
9857}
9858
9859#[derive(Clone, Copy)]
9860#[repr(C)]
9861pub struct VkQueryPoolPerformanceQueryCreateInfoINTEL {
9862    pub sType: VkStructureType,
9863    pub pNext: *const c_void,
9864    pub performanceCountersSampling: VkQueryPoolSamplingModeINTEL,
9865}
9866
9867#[derive(Clone, Copy)]
9868#[repr(C)]
9869pub struct VkQueryPoolVideoEncodeFeedbackCreateInfoKHR {
9870    pub sType: VkStructureType,
9871    pub pNext: *const c_void,
9872    pub encodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
9873}
9874
9875#[repr(C)]
9876pub struct VkQueryPool_T {
9877    _data: (),
9878    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9879}
9880
9881#[derive(Clone, Copy)]
9882#[repr(C)]
9883pub struct VkQueueFamilyCheckpointProperties2NV {
9884    pub sType: VkStructureType,
9885    pub pNext: *mut c_void,
9886    pub checkpointExecutionStageMask: VkPipelineStageFlags2,
9887}
9888
9889#[derive(Clone, Copy)]
9890#[repr(C)]
9891pub struct VkQueueFamilyCheckpointPropertiesNV {
9892    pub sType: VkStructureType,
9893    pub pNext: *mut c_void,
9894    pub checkpointExecutionStageMask: VkPipelineStageFlags,
9895}
9896
9897#[derive(Clone, Copy)]
9898#[repr(C)]
9899pub struct VkQueueFamilyDataGraphProcessingEnginePropertiesARM {
9900    pub sType: VkStructureType,
9901    pub pNext: *mut c_void,
9902    pub foreignSemaphoreHandleTypes: VkExternalSemaphoreHandleTypeFlags,
9903    pub foreignMemoryHandleTypes: VkExternalMemoryHandleTypeFlags,
9904}
9905
9906#[derive(Clone, Copy)]
9907#[repr(C)]
9908pub struct VkQueueFamilyDataGraphPropertiesARM {
9909    pub sType: VkStructureType,
9910    pub pNext: *mut c_void,
9911    pub engine: VkPhysicalDeviceDataGraphProcessingEngineARM,
9912    pub operation: VkPhysicalDeviceDataGraphOperationSupportARM,
9913}
9914
9915#[derive(Clone, Copy)]
9916#[repr(C)]
9917pub struct VkQueueFamilyGlobalPriorityProperties {
9918    pub sType: VkStructureType,
9919    pub pNext: *mut c_void,
9920    pub priorityCount: u32,
9921    pub priorities: [VkQueueGlobalPriority; VK_MAX_GLOBAL_PRIORITY_SIZE as usize],
9922}
9923
9924#[derive(Clone, Copy)]
9925#[repr(C)]
9926pub struct VkQueueFamilyOwnershipTransferPropertiesKHR {
9927    pub sType: VkStructureType,
9928    pub pNext: *mut c_void,
9929    pub optimalImageTransferToQueueFamilies: u32,
9930}
9931
9932#[derive(Clone, Copy)]
9933#[repr(C)]
9934pub struct VkQueueFamilyProperties {
9935    pub queueFlags: VkQueueFlags,
9936    pub queueCount: u32,
9937    pub timestampValidBits: u32,
9938    pub minImageTransferGranularity: VkExtent3D,
9939}
9940
9941#[derive(Clone, Copy)]
9942#[repr(C)]
9943pub struct VkQueueFamilyProperties2 {
9944    pub sType: VkStructureType,
9945    pub pNext: *mut c_void,
9946    pub queueFamilyProperties: VkQueueFamilyProperties,
9947}
9948
9949#[derive(Clone, Copy)]
9950#[repr(C)]
9951pub struct VkQueueFamilyQueryResultStatusPropertiesKHR {
9952    pub sType: VkStructureType,
9953    pub pNext: *mut c_void,
9954    pub queryResultStatusSupport: VkBool32,
9955}
9956
9957#[derive(Clone, Copy)]
9958#[repr(C)]
9959pub struct VkQueueFamilyVideoPropertiesKHR {
9960    pub sType: VkStructureType,
9961    pub pNext: *mut c_void,
9962    pub videoCodecOperations: VkVideoCodecOperationFlagsKHR,
9963}
9964
9965#[repr(C)]
9966pub struct VkQueue_T {
9967    _data: (),
9968    _marker: PhantomData<(*mut u8, PhantomPinned)>,
9969}
9970
9971#[derive(Clone, Copy)]
9972#[repr(C)]
9973pub struct VkRayTracingPipelineClusterAccelerationStructureCreateInfoNV {
9974    pub sType: VkStructureType,
9975    pub pNext: *mut c_void,
9976    pub allowClusterAccelerationStructure: VkBool32,
9977}
9978
9979#[derive(Clone, Copy)]
9980#[repr(C)]
9981pub struct VkRayTracingPipelineCreateInfoKHR {
9982    pub sType: VkStructureType,
9983    pub pNext: *const c_void,
9984    pub flags: VkPipelineCreateFlags,
9985    pub stageCount: u32,
9986    pub pStages: *const VkPipelineShaderStageCreateInfo,
9987    pub groupCount: u32,
9988    pub pGroups: *const VkRayTracingShaderGroupCreateInfoKHR,
9989    pub maxPipelineRayRecursionDepth: u32,
9990    pub pLibraryInfo: *const VkPipelineLibraryCreateInfoKHR,
9991    pub pLibraryInterface: *const VkRayTracingPipelineInterfaceCreateInfoKHR,
9992    pub pDynamicState: *const VkPipelineDynamicStateCreateInfo,
9993    pub layout: VkPipelineLayout,
9994    pub basePipelineHandle: VkPipeline,
9995    pub basePipelineIndex: i32,
9996}
9997
9998#[derive(Clone, Copy)]
9999#[repr(C)]
10000pub struct VkRayTracingPipelineCreateInfoNV {
10001    pub sType: VkStructureType,
10002    pub pNext: *const c_void,
10003    pub flags: VkPipelineCreateFlags,
10004    pub stageCount: u32,
10005    pub pStages: *const VkPipelineShaderStageCreateInfo,
10006    pub groupCount: u32,
10007    pub pGroups: *const VkRayTracingShaderGroupCreateInfoNV,
10008    pub maxRecursionDepth: u32,
10009    pub layout: VkPipelineLayout,
10010    pub basePipelineHandle: VkPipeline,
10011    pub basePipelineIndex: i32,
10012}
10013
10014#[derive(Clone, Copy)]
10015#[repr(C)]
10016pub struct VkRayTracingPipelineInterfaceCreateInfoKHR {
10017    pub sType: VkStructureType,
10018    pub pNext: *const c_void,
10019    pub maxPipelineRayPayloadSize: u32,
10020    pub maxPipelineRayHitAttributeSize: u32,
10021}
10022
10023#[derive(Clone, Copy)]
10024#[repr(C)]
10025pub struct VkRayTracingShaderGroupCreateInfoKHR {
10026    pub sType: VkStructureType,
10027    pub pNext: *const c_void,
10028    pub typ: VkRayTracingShaderGroupTypeKHR,
10029    pub generalShader: u32,
10030    pub closestHitShader: u32,
10031    pub anyHitShader: u32,
10032    pub intersectionShader: u32,
10033    pub pShaderGroupCaptureReplayHandle: *const c_void,
10034}
10035
10036#[derive(Clone, Copy)]
10037#[repr(C)]
10038pub struct VkRayTracingShaderGroupCreateInfoNV {
10039    pub sType: VkStructureType,
10040    pub pNext: *const c_void,
10041    pub typ: VkRayTracingShaderGroupTypeKHR,
10042    pub generalShader: u32,
10043    pub closestHitShader: u32,
10044    pub anyHitShader: u32,
10045    pub intersectionShader: u32,
10046}
10047
10048#[derive(Clone, Copy)]
10049#[repr(C)]
10050pub struct VkRect2D {
10051    pub offset: VkOffset2D,
10052    pub extent: VkExtent2D,
10053}
10054
10055#[derive(Clone, Copy)]
10056#[repr(C)]
10057pub struct VkRectLayerKHR {
10058    pub offset: VkOffset2D,
10059    pub extent: VkExtent2D,
10060    pub layer: u32,
10061}
10062
10063#[derive(Clone, Copy)]
10064#[repr(C)]
10065pub struct VkRefreshCycleDurationGOOGLE {
10066    pub refreshDuration: u64,
10067}
10068
10069#[derive(Clone, Copy)]
10070#[repr(C)]
10071pub struct VkReleaseCapturedPipelineDataInfoKHR {
10072    pub sType: VkStructureType,
10073    pub pNext: *mut c_void,
10074    pub pipeline: VkPipeline,
10075}
10076
10077#[derive(Clone, Copy)]
10078#[repr(C)]
10079pub struct VkReleaseSwapchainImagesInfoKHR {
10080    pub sType: VkStructureType,
10081    pub pNext: *const c_void,
10082    pub swapchain: VkSwapchainKHR,
10083    pub imageIndexCount: u32,
10084    pub pImageIndices: *const u32,
10085}
10086
10087#[derive(Clone, Copy)]
10088#[repr(C)]
10089pub struct VkRenderPassAttachmentBeginInfo {
10090    pub sType: VkStructureType,
10091    pub pNext: *const c_void,
10092    pub attachmentCount: u32,
10093    pub pAttachments: *const VkImageView,
10094}
10095
10096#[derive(Clone, Copy)]
10097#[repr(C)]
10098pub struct VkRenderPassBeginInfo {
10099    pub sType: VkStructureType,
10100    pub pNext: *const c_void,
10101    pub renderPass: VkRenderPass,
10102    pub framebuffer: VkFramebuffer,
10103    pub renderArea: VkRect2D,
10104    pub clearValueCount: u32,
10105    pub pClearValues: *const VkClearValue,
10106}
10107
10108#[derive(Clone, Copy)]
10109#[repr(C)]
10110pub struct VkRenderPassCreateInfo {
10111    pub sType: VkStructureType,
10112    pub pNext: *const c_void,
10113    pub flags: VkRenderPassCreateFlags,
10114    pub attachmentCount: u32,
10115    pub pAttachments: *const VkAttachmentDescription,
10116    pub subpassCount: u32,
10117    pub pSubpasses: *const VkSubpassDescription,
10118    pub dependencyCount: u32,
10119    pub pDependencies: *const VkSubpassDependency,
10120}
10121
10122#[derive(Clone, Copy)]
10123#[repr(C)]
10124pub struct VkRenderPassCreateInfo2 {
10125    pub sType: VkStructureType,
10126    pub pNext: *const c_void,
10127    pub flags: VkRenderPassCreateFlags,
10128    pub attachmentCount: u32,
10129    pub pAttachments: *const VkAttachmentDescription2,
10130    pub subpassCount: u32,
10131    pub pSubpasses: *const VkSubpassDescription2,
10132    pub dependencyCount: u32,
10133    pub pDependencies: *const VkSubpassDependency2,
10134    pub correlatedViewMaskCount: u32,
10135    pub pCorrelatedViewMasks: *const u32,
10136}
10137
10138#[derive(Clone, Copy)]
10139#[repr(C)]
10140pub struct VkRenderPassCreationControlEXT {
10141    pub sType: VkStructureType,
10142    pub pNext: *const c_void,
10143    pub disallowMerging: VkBool32,
10144}
10145
10146#[derive(Clone, Copy)]
10147#[repr(C)]
10148pub struct VkRenderPassCreationFeedbackCreateInfoEXT {
10149    pub sType: VkStructureType,
10150    pub pNext: *const c_void,
10151    pub pRenderPassFeedback: *mut VkRenderPassCreationFeedbackInfoEXT,
10152}
10153
10154#[derive(Clone, Copy)]
10155#[repr(C)]
10156pub struct VkRenderPassCreationFeedbackInfoEXT {
10157    pub postMergeSubpassCount: u32,
10158}
10159
10160#[derive(Clone, Copy)]
10161#[repr(C)]
10162pub struct VkRenderPassFragmentDensityMapCreateInfoEXT {
10163    pub sType: VkStructureType,
10164    pub pNext: *const c_void,
10165    pub fragmentDensityMapAttachment: VkAttachmentReference,
10166}
10167
10168#[derive(Clone, Copy)]
10169#[repr(C)]
10170pub struct VkRenderPassFragmentDensityMapOffsetEndInfoEXT {
10171    pub sType: VkStructureType,
10172    pub pNext: *const c_void,
10173    pub fragmentDensityOffsetCount: u32,
10174    pub pFragmentDensityOffsets: *const VkOffset2D,
10175}
10176
10177#[derive(Clone, Copy)]
10178#[repr(C)]
10179pub struct VkRenderPassInputAttachmentAspectCreateInfo {
10180    pub sType: VkStructureType,
10181    pub pNext: *const c_void,
10182    pub aspectReferenceCount: u32,
10183    pub pAspectReferences: *const VkInputAttachmentAspectReference,
10184}
10185
10186#[derive(Clone, Copy)]
10187#[repr(C)]
10188pub struct VkRenderPassMultiviewCreateInfo {
10189    pub sType: VkStructureType,
10190    pub pNext: *const c_void,
10191    pub subpassCount: u32,
10192    pub pViewMasks: *const u32,
10193    pub dependencyCount: u32,
10194    pub pViewOffsets: *const i32,
10195    pub correlationMaskCount: u32,
10196    pub pCorrelationMasks: *const u32,
10197}
10198
10199#[derive(Clone, Copy)]
10200#[repr(C)]
10201pub struct VkRenderPassPerformanceCountersByRegionBeginInfoARM {
10202    pub sType: VkStructureType,
10203    pub pNext: *mut c_void,
10204    pub counterAddressCount: u32,
10205    pub pCounterAddresses: *const VkDeviceAddress,
10206    pub serializeRegions: VkBool32,
10207    pub counterIndexCount: u32,
10208    pub pCounterIndices: *mut u32,
10209}
10210
10211#[derive(Clone, Copy)]
10212#[repr(C)]
10213pub struct VkRenderPassSampleLocationsBeginInfoEXT {
10214    pub sType: VkStructureType,
10215    pub pNext: *const c_void,
10216    pub attachmentInitialSampleLocationsCount: u32,
10217    pub pAttachmentInitialSampleLocations: *const VkAttachmentSampleLocationsEXT,
10218    pub postSubpassSampleLocationsCount: u32,
10219    pub pPostSubpassSampleLocations: *const VkSubpassSampleLocationsEXT,
10220}
10221
10222#[derive(Clone, Copy)]
10223#[repr(C)]
10224pub struct VkRenderPassStripeBeginInfoARM {
10225    pub sType: VkStructureType,
10226    pub pNext: *const c_void,
10227    pub stripeInfoCount: u32,
10228    pub pStripeInfos: *const VkRenderPassStripeInfoARM,
10229}
10230
10231#[derive(Clone, Copy)]
10232#[repr(C)]
10233pub struct VkRenderPassStripeInfoARM {
10234    pub sType: VkStructureType,
10235    pub pNext: *const c_void,
10236    pub stripeArea: VkRect2D,
10237}
10238
10239#[derive(Clone, Copy)]
10240#[repr(C)]
10241pub struct VkRenderPassStripeSubmitInfoARM {
10242    pub sType: VkStructureType,
10243    pub pNext: *const c_void,
10244    pub stripeSemaphoreInfoCount: u32,
10245    pub pStripeSemaphoreInfos: *const VkSemaphoreSubmitInfo,
10246}
10247
10248#[derive(Clone, Copy)]
10249#[repr(C)]
10250pub struct VkRenderPassSubpassFeedbackCreateInfoEXT {
10251    pub sType: VkStructureType,
10252    pub pNext: *const c_void,
10253    pub pSubpassFeedback: *mut VkRenderPassSubpassFeedbackInfoEXT,
10254}
10255
10256#[derive(Clone, Copy)]
10257#[repr(C)]
10258pub struct VkRenderPassSubpassFeedbackInfoEXT {
10259    pub subpassMergeStatus: VkSubpassMergeStatusEXT,
10260    pub description: [c_char; VK_MAX_DESCRIPTION_SIZE as usize],
10261    pub postMergeIndex: u32,
10262}
10263
10264#[derive(Clone, Copy)]
10265#[repr(C)]
10266pub struct VkRenderPassTileShadingCreateInfoQCOM {
10267    pub sType: VkStructureType,
10268    pub pNext: *const c_void,
10269    pub flags: VkTileShadingRenderPassFlagsQCOM,
10270    pub tileApronSize: VkExtent2D,
10271}
10272
10273#[derive(Clone, Copy)]
10274#[repr(C)]
10275pub struct VkRenderPassTransformBeginInfoQCOM {
10276    pub sType: VkStructureType,
10277    pub pNext: *const c_void,
10278    pub transform: VkSurfaceTransformFlagBitsKHR,
10279}
10280
10281#[repr(C)]
10282pub struct VkRenderPass_T {
10283    _data: (),
10284    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10285}
10286
10287#[derive(Clone, Copy)]
10288#[repr(C)]
10289pub struct VkRenderingAreaInfo {
10290    pub sType: VkStructureType,
10291    pub pNext: *const c_void,
10292    pub viewMask: u32,
10293    pub colorAttachmentCount: u32,
10294    pub pColorAttachmentFormats: *const VkFormat,
10295    pub depthAttachmentFormat: VkFormat,
10296    pub stencilAttachmentFormat: VkFormat,
10297}
10298
10299#[derive(Clone, Copy)]
10300#[repr(C)]
10301pub struct VkRenderingAttachmentFlagsInfoKHR {
10302    pub sType: VkStructureType,
10303    pub pNext: *const c_void,
10304    pub flags: VkRenderingAttachmentFlagsKHR,
10305}
10306
10307#[derive(Clone, Copy)]
10308#[repr(C)]
10309pub struct VkRenderingAttachmentInfo {
10310    pub sType: VkStructureType,
10311    pub pNext: *const c_void,
10312    pub imageView: VkImageView,
10313    pub imageLayout: VkImageLayout,
10314    pub resolveMode: VkResolveModeFlagBits,
10315    pub resolveImageView: VkImageView,
10316    pub resolveImageLayout: VkImageLayout,
10317    pub loadOp: VkAttachmentLoadOp,
10318    pub storeOp: VkAttachmentStoreOp,
10319    pub clearValue: VkClearValue,
10320}
10321
10322#[derive(Clone, Copy)]
10323#[repr(C)]
10324pub struct VkRenderingAttachmentLocationInfo {
10325    pub sType: VkStructureType,
10326    pub pNext: *const c_void,
10327    pub colorAttachmentCount: u32,
10328    pub pColorAttachmentLocations: *const u32,
10329}
10330
10331#[derive(Clone, Copy)]
10332#[repr(C)]
10333pub struct VkRenderingEndInfoKHR {
10334    pub sType: VkStructureType,
10335    pub pNext: *const c_void,
10336}
10337
10338#[derive(Clone, Copy)]
10339#[repr(C)]
10340pub struct VkRenderingFragmentDensityMapAttachmentInfoEXT {
10341    pub sType: VkStructureType,
10342    pub pNext: *const c_void,
10343    pub imageView: VkImageView,
10344    pub imageLayout: VkImageLayout,
10345}
10346
10347#[derive(Clone, Copy)]
10348#[repr(C)]
10349pub struct VkRenderingFragmentShadingRateAttachmentInfoKHR {
10350    pub sType: VkStructureType,
10351    pub pNext: *const c_void,
10352    pub imageView: VkImageView,
10353    pub imageLayout: VkImageLayout,
10354    pub shadingRateAttachmentTexelSize: VkExtent2D,
10355}
10356
10357#[derive(Clone, Copy)]
10358#[repr(C)]
10359pub struct VkRenderingInfo {
10360    pub sType: VkStructureType,
10361    pub pNext: *const c_void,
10362    pub flags: VkRenderingFlags,
10363    pub renderArea: VkRect2D,
10364    pub layerCount: u32,
10365    pub viewMask: u32,
10366    pub colorAttachmentCount: u32,
10367    pub pColorAttachments: *const VkRenderingAttachmentInfo,
10368    pub pDepthAttachment: *const VkRenderingAttachmentInfo,
10369    pub pStencilAttachment: *const VkRenderingAttachmentInfo,
10370}
10371
10372#[derive(Clone, Copy)]
10373#[repr(C)]
10374pub struct VkRenderingInputAttachmentIndexInfo {
10375    pub sType: VkStructureType,
10376    pub pNext: *const c_void,
10377    pub colorAttachmentCount: u32,
10378    pub pColorAttachmentInputIndices: *const u32,
10379    pub pDepthInputAttachmentIndex: *const u32,
10380    pub pStencilInputAttachmentIndex: *const u32,
10381}
10382
10383#[derive(Clone, Copy)]
10384#[repr(C)]
10385pub struct VkResolveImageInfo2 {
10386    pub sType: VkStructureType,
10387    pub pNext: *const c_void,
10388    pub srcImage: VkImage,
10389    pub srcImageLayout: VkImageLayout,
10390    pub dstImage: VkImage,
10391    pub dstImageLayout: VkImageLayout,
10392    pub regionCount: u32,
10393    pub pRegions: *const VkImageResolve2,
10394}
10395
10396#[derive(Clone, Copy)]
10397#[repr(C)]
10398pub struct VkResolveImageModeInfoKHR {
10399    pub sType: VkStructureType,
10400    pub pNext: *const c_void,
10401    pub flags: VkResolveImageFlagsKHR,
10402    pub resolveMode: VkResolveModeFlagBits,
10403    pub stencilResolveMode: VkResolveModeFlagBits,
10404}
10405
10406#[derive(Clone, Copy)]
10407#[repr(C)]
10408pub struct VkResourceDescriptorInfoEXT {
10409    pub sType: VkStructureType,
10410    pub pNext: *const c_void,
10411    pub typ: VkDescriptorType,
10412    pub data: VkResourceDescriptorDataEXT,
10413}
10414
10415#[derive(Clone, Copy)]
10416#[repr(C)]
10417pub struct VkSRTDataNV {
10418    pub sx: f32,
10419    pub a: f32,
10420    pub b: f32,
10421    pub pvx: f32,
10422    pub sy: f32,
10423    pub c: f32,
10424    pub pvy: f32,
10425    pub sz: f32,
10426    pub pvz: f32,
10427    pub qx: f32,
10428    pub qy: f32,
10429    pub qz: f32,
10430    pub qw: f32,
10431    pub tx: f32,
10432    pub ty: f32,
10433    pub tz: f32,
10434}
10435
10436#[derive(Clone, Copy)]
10437#[repr(C)]
10438pub struct VkSampleLocationEXT {
10439    pub x: f32,
10440    pub y: f32,
10441}
10442
10443#[derive(Clone, Copy)]
10444#[repr(C)]
10445pub struct VkSampleLocationsInfoEXT {
10446    pub sType: VkStructureType,
10447    pub pNext: *const c_void,
10448    pub sampleLocationsPerPixel: VkSampleCountFlagBits,
10449    pub sampleLocationGridSize: VkExtent2D,
10450    pub sampleLocationsCount: u32,
10451    pub pSampleLocations: *const VkSampleLocationEXT,
10452}
10453
10454#[derive(Clone, Copy)]
10455#[repr(C)]
10456pub struct VkSamplerBlockMatchWindowCreateInfoQCOM {
10457    pub sType: VkStructureType,
10458    pub pNext: *const c_void,
10459    pub windowExtent: VkExtent2D,
10460    pub windowCompareMode: VkBlockMatchWindowCompareModeQCOM,
10461}
10462
10463#[derive(Clone, Copy)]
10464#[repr(C)]
10465pub struct VkSamplerBorderColorComponentMappingCreateInfoEXT {
10466    pub sType: VkStructureType,
10467    pub pNext: *const c_void,
10468    pub components: VkComponentMapping,
10469    pub srgb: VkBool32,
10470}
10471
10472#[derive(Clone, Copy)]
10473#[repr(C)]
10474pub struct VkSamplerCaptureDescriptorDataInfoEXT {
10475    pub sType: VkStructureType,
10476    pub pNext: *const c_void,
10477    pub sampler: VkSampler,
10478}
10479
10480#[derive(Clone, Copy)]
10481#[repr(C)]
10482pub struct VkSamplerCreateInfo {
10483    pub sType: VkStructureType,
10484    pub pNext: *const c_void,
10485    pub flags: VkSamplerCreateFlags,
10486    pub magFilter: VkFilter,
10487    pub minFilter: VkFilter,
10488    pub mipmapMode: VkSamplerMipmapMode,
10489    pub addressModeU: VkSamplerAddressMode,
10490    pub addressModeV: VkSamplerAddressMode,
10491    pub addressModeW: VkSamplerAddressMode,
10492    pub mipLodBias: f32,
10493    pub anisotropyEnable: VkBool32,
10494    pub maxAnisotropy: f32,
10495    pub compareEnable: VkBool32,
10496    pub compareOp: VkCompareOp,
10497    pub minLod: f32,
10498    pub maxLod: f32,
10499    pub borderColor: VkBorderColor,
10500    pub unnormalizedCoordinates: VkBool32,
10501}
10502
10503#[derive(Clone, Copy)]
10504#[repr(C)]
10505pub struct VkSamplerCubicWeightsCreateInfoQCOM {
10506    pub sType: VkStructureType,
10507    pub pNext: *const c_void,
10508    pub cubicWeights: VkCubicFilterWeightsQCOM,
10509}
10510
10511#[derive(Clone, Copy)]
10512#[repr(C)]
10513pub struct VkSamplerCustomBorderColorCreateInfoEXT {
10514    pub sType: VkStructureType,
10515    pub pNext: *const c_void,
10516    pub customBorderColor: VkClearColorValue,
10517    pub format: VkFormat,
10518}
10519
10520#[derive(Clone, Copy)]
10521#[repr(C)]
10522pub struct VkSamplerCustomBorderColorIndexCreateInfoEXT {
10523    pub sType: VkStructureType,
10524    pub pNext: *const c_void,
10525    pub index: u32,
10526}
10527
10528#[derive(Clone, Copy)]
10529#[repr(C)]
10530pub struct VkSamplerReductionModeCreateInfo {
10531    pub sType: VkStructureType,
10532    pub pNext: *const c_void,
10533    pub reductionMode: VkSamplerReductionMode,
10534}
10535
10536#[derive(Clone, Copy)]
10537#[repr(C)]
10538pub struct VkSamplerYcbcrConversionCreateInfo {
10539    pub sType: VkStructureType,
10540    pub pNext: *const c_void,
10541    pub format: VkFormat,
10542    pub ycbcrModel: VkSamplerYcbcrModelConversion,
10543    pub ycbcrRange: VkSamplerYcbcrRange,
10544    pub components: VkComponentMapping,
10545    pub xChromaOffset: VkChromaLocation,
10546    pub yChromaOffset: VkChromaLocation,
10547    pub chromaFilter: VkFilter,
10548    pub forceExplicitReconstruction: VkBool32,
10549}
10550
10551#[derive(Clone, Copy)]
10552#[repr(C)]
10553pub struct VkSamplerYcbcrConversionImageFormatProperties {
10554    pub sType: VkStructureType,
10555    pub pNext: *mut c_void,
10556    pub combinedImageSamplerDescriptorCount: u32,
10557}
10558
10559#[derive(Clone, Copy)]
10560#[repr(C)]
10561pub struct VkSamplerYcbcrConversionInfo {
10562    pub sType: VkStructureType,
10563    pub pNext: *const c_void,
10564    pub conversion: VkSamplerYcbcrConversion,
10565}
10566
10567#[derive(Clone, Copy)]
10568#[repr(C)]
10569pub struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
10570    pub sType: VkStructureType,
10571    pub pNext: *mut c_void,
10572    pub enableYDegamma: VkBool32,
10573    pub enableCbCrDegamma: VkBool32,
10574}
10575
10576#[repr(C)]
10577pub struct VkSamplerYcbcrConversion_T {
10578    _data: (),
10579    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10580}
10581
10582#[repr(C)]
10583pub struct VkSampler_T {
10584    _data: (),
10585    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10586}
10587
10588#[derive(Clone, Copy)]
10589#[repr(C)]
10590pub struct VkSemaphoreCreateInfo {
10591    pub sType: VkStructureType,
10592    pub pNext: *const c_void,
10593    pub flags: VkSemaphoreCreateFlags,
10594}
10595
10596#[derive(Clone, Copy)]
10597#[repr(C)]
10598pub struct VkSemaphoreGetFdInfoKHR {
10599    pub sType: VkStructureType,
10600    pub pNext: *const c_void,
10601    pub semaphore: VkSemaphore,
10602    pub handleType: VkExternalSemaphoreHandleTypeFlagBits,
10603}
10604
10605#[derive(Clone, Copy)]
10606#[repr(C)]
10607pub struct VkSemaphoreSignalInfo {
10608    pub sType: VkStructureType,
10609    pub pNext: *const c_void,
10610    pub semaphore: VkSemaphore,
10611    pub value: u64,
10612}
10613
10614#[derive(Clone, Copy)]
10615#[repr(C)]
10616pub struct VkSemaphoreSubmitInfo {
10617    pub sType: VkStructureType,
10618    pub pNext: *const c_void,
10619    pub semaphore: VkSemaphore,
10620    pub value: u64,
10621    pub stageMask: VkPipelineStageFlags2,
10622    pub deviceIndex: u32,
10623}
10624
10625#[derive(Clone, Copy)]
10626#[repr(C)]
10627pub struct VkSemaphoreTypeCreateInfo {
10628    pub sType: VkStructureType,
10629    pub pNext: *const c_void,
10630    pub semaphoreType: VkSemaphoreType,
10631    pub initialValue: u64,
10632}
10633
10634#[derive(Clone, Copy)]
10635#[repr(C)]
10636pub struct VkSemaphoreWaitInfo {
10637    pub sType: VkStructureType,
10638    pub pNext: *const c_void,
10639    pub flags: VkSemaphoreWaitFlags,
10640    pub semaphoreCount: u32,
10641    pub pSemaphores: *const VkSemaphore,
10642    pub pValues: *const u64,
10643}
10644
10645#[repr(C)]
10646pub struct VkSemaphore_T {
10647    _data: (),
10648    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10649}
10650
10651#[derive(Clone, Copy)]
10652#[repr(C)]
10653pub struct VkSetDescriptorBufferOffsetsInfoEXT {
10654    pub sType: VkStructureType,
10655    pub pNext: *const c_void,
10656    pub stageFlags: VkShaderStageFlags,
10657    pub layout: VkPipelineLayout,
10658    pub firstSet: u32,
10659    pub setCount: u32,
10660    pub pBufferIndices: *const u32,
10661    pub pOffsets: *const VkDeviceSize,
10662}
10663
10664#[derive(Clone, Copy)]
10665#[repr(C)]
10666pub struct VkSetLatencyMarkerInfoNV {
10667    pub sType: VkStructureType,
10668    pub pNext: *const c_void,
10669    pub presentID: u64,
10670    pub marker: VkLatencyMarkerNV,
10671}
10672
10673#[derive(Clone, Copy)]
10674#[repr(C)]
10675pub struct VkSetStateFlagsIndirectCommandNV {
10676    pub data: u32,
10677}
10678
10679#[derive(Clone, Copy)]
10680#[repr(C)]
10681pub struct VkShaderCreateInfoEXT {
10682    pub sType: VkStructureType,
10683    pub pNext: *const c_void,
10684    pub flags: VkShaderCreateFlagsEXT,
10685    pub stage: VkShaderStageFlagBits,
10686    pub nextStage: VkShaderStageFlags,
10687    pub codeType: VkShaderCodeTypeEXT,
10688    pub codeSize: usize,
10689    pub pCode: *const c_void,
10690    pub pName: *const c_char,
10691    pub setLayoutCount: u32,
10692    pub pSetLayouts: *const VkDescriptorSetLayout,
10693    pub pushConstantRangeCount: u32,
10694    pub pPushConstantRanges: *const VkPushConstantRange,
10695    pub pSpecializationInfo: *const VkSpecializationInfo,
10696}
10697
10698#[derive(Clone, Copy)]
10699#[repr(C)]
10700pub struct VkShaderDescriptorSetAndBindingMappingInfoEXT {
10701    pub sType: VkStructureType,
10702    pub pNext: *const c_void,
10703    pub mappingCount: u32,
10704    pub pMappings: *const VkDescriptorSetAndBindingMappingEXT,
10705}
10706
10707#[repr(C)]
10708pub struct VkShaderEXT_T {
10709    _data: (),
10710    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10711}
10712
10713#[derive(Clone, Copy)]
10714#[repr(C)]
10715pub struct VkShaderModuleCreateInfo {
10716    pub sType: VkStructureType,
10717    pub pNext: *const c_void,
10718    pub flags: VkShaderModuleCreateFlags,
10719    pub codeSize: usize,
10720    pub pCode: *const u32,
10721}
10722
10723#[derive(Clone, Copy)]
10724#[repr(C)]
10725pub struct VkShaderModuleIdentifierEXT {
10726    pub sType: VkStructureType,
10727    pub pNext: *mut c_void,
10728    pub identifierSize: u32,
10729    pub identifier: [u8; VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT as usize],
10730}
10731
10732#[derive(Clone, Copy)]
10733#[repr(C)]
10734pub struct VkShaderModuleValidationCacheCreateInfoEXT {
10735    pub sType: VkStructureType,
10736    pub pNext: *const c_void,
10737    pub validationCache: VkValidationCacheEXT,
10738}
10739
10740#[repr(C)]
10741pub struct VkShaderModule_T {
10742    _data: (),
10743    _marker: PhantomData<(*mut u8, PhantomPinned)>,
10744}
10745
10746#[derive(Clone, Copy)]
10747#[repr(C)]
10748pub struct VkShaderResourceUsageAMD {
10749    pub numUsedVgprs: u32,
10750    pub numUsedSgprs: u32,
10751    pub ldsSizePerLocalWorkGroup: u32,
10752    pub ldsUsageSizeInBytes: usize,
10753    pub scratchMemUsageInBytes: usize,
10754}
10755
10756#[derive(Clone, Copy)]
10757#[repr(C)]
10758pub struct VkShaderStatisticsInfoAMD {
10759    pub shaderStageMask: VkShaderStageFlags,
10760    pub resourceUsage: VkShaderResourceUsageAMD,
10761    pub numPhysicalVgprs: u32,
10762    pub numPhysicalSgprs: u32,
10763    pub numAvailableVgprs: u32,
10764    pub numAvailableSgprs: u32,
10765    pub computeWorkGroupSize: [u32; 3 as usize],
10766}
10767
10768#[derive(Clone, Copy)]
10769#[repr(C)]
10770pub struct VkShadingRatePaletteNV {
10771    pub shadingRatePaletteEntryCount: u32,
10772    pub pShadingRatePaletteEntries: *const VkShadingRatePaletteEntryNV,
10773}
10774
10775#[derive(Clone, Copy)]
10776#[repr(C)]
10777pub struct VkSharedPresentSurfaceCapabilitiesKHR {
10778    pub sType: VkStructureType,
10779    pub pNext: *mut c_void,
10780    pub sharedPresentSupportedUsageFlags: VkImageUsageFlags,
10781}
10782
10783#[derive(Clone, Copy)]
10784#[repr(C)]
10785pub struct VkSparseBufferMemoryBindInfo {
10786    pub buffer: VkBuffer,
10787    pub bindCount: u32,
10788    pub pBinds: *const VkSparseMemoryBind,
10789}
10790
10791#[derive(Clone, Copy)]
10792#[repr(C)]
10793pub struct VkSparseImageFormatProperties {
10794    pub aspectMask: VkImageAspectFlags,
10795    pub imageGranularity: VkExtent3D,
10796    pub flags: VkSparseImageFormatFlags,
10797}
10798
10799#[derive(Clone, Copy)]
10800#[repr(C)]
10801pub struct VkSparseImageFormatProperties2 {
10802    pub sType: VkStructureType,
10803    pub pNext: *mut c_void,
10804    pub properties: VkSparseImageFormatProperties,
10805}
10806
10807#[derive(Clone, Copy)]
10808#[repr(C)]
10809pub struct VkSparseImageMemoryBind {
10810    pub subresource: VkImageSubresource,
10811    pub offset: VkOffset3D,
10812    pub extent: VkExtent3D,
10813    pub memory: VkDeviceMemory,
10814    pub memoryOffset: VkDeviceSize,
10815    pub flags: VkSparseMemoryBindFlags,
10816}
10817
10818#[derive(Clone, Copy)]
10819#[repr(C)]
10820pub struct VkSparseImageMemoryBindInfo {
10821    pub image: VkImage,
10822    pub bindCount: u32,
10823    pub pBinds: *const VkSparseImageMemoryBind,
10824}
10825
10826#[derive(Clone, Copy)]
10827#[repr(C)]
10828pub struct VkSparseImageMemoryRequirements {
10829    pub formatProperties: VkSparseImageFormatProperties,
10830    pub imageMipTailFirstLod: u32,
10831    pub imageMipTailSize: VkDeviceSize,
10832    pub imageMipTailOffset: VkDeviceSize,
10833    pub imageMipTailStride: VkDeviceSize,
10834}
10835
10836#[derive(Clone, Copy)]
10837#[repr(C)]
10838pub struct VkSparseImageMemoryRequirements2 {
10839    pub sType: VkStructureType,
10840    pub pNext: *mut c_void,
10841    pub memoryRequirements: VkSparseImageMemoryRequirements,
10842}
10843
10844#[derive(Clone, Copy)]
10845#[repr(C)]
10846pub struct VkSparseImageOpaqueMemoryBindInfo {
10847    pub image: VkImage,
10848    pub bindCount: u32,
10849    pub pBinds: *const VkSparseMemoryBind,
10850}
10851
10852#[derive(Clone, Copy)]
10853#[repr(C)]
10854pub struct VkSparseMemoryBind {
10855    pub resourceOffset: VkDeviceSize,
10856    pub size: VkDeviceSize,
10857    pub memory: VkDeviceMemory,
10858    pub memoryOffset: VkDeviceSize,
10859    pub flags: VkSparseMemoryBindFlags,
10860}
10861
10862#[derive(Clone, Copy)]
10863#[repr(C)]
10864pub struct VkSpecializationInfo {
10865    pub mapEntryCount: u32,
10866    pub pMapEntries: *const VkSpecializationMapEntry,
10867    pub dataSize: usize,
10868    pub pData: *const c_void,
10869}
10870
10871#[derive(Clone, Copy)]
10872#[repr(C)]
10873pub struct VkSpecializationMapEntry {
10874    pub constantID: u32,
10875    pub offset: u32,
10876    pub size: usize,
10877}
10878
10879#[derive(Clone, Copy)]
10880#[repr(C)]
10881pub struct VkStencilOpState {
10882    pub failOp: VkStencilOp,
10883    pub passOp: VkStencilOp,
10884    pub depthFailOp: VkStencilOp,
10885    pub compareOp: VkCompareOp,
10886    pub compareMask: u32,
10887    pub writeMask: u32,
10888    pub reference: u32,
10889}
10890
10891#[derive(Clone, Copy)]
10892#[repr(C)]
10893pub struct VkStridedDeviceAddressNV {
10894    pub startAddress: VkDeviceAddress,
10895    pub strideInBytes: VkDeviceSize,
10896}
10897
10898#[derive(Clone, Copy)]
10899#[repr(C)]
10900pub struct VkStridedDeviceAddressRangeKHR {
10901    pub address: VkDeviceAddress,
10902    pub size: VkDeviceSize,
10903    pub stride: VkDeviceSize,
10904}
10905
10906#[derive(Clone, Copy)]
10907#[repr(C)]
10908pub struct VkStridedDeviceAddressRegionKHR {
10909    pub deviceAddress: VkDeviceAddress,
10910    pub stride: VkDeviceSize,
10911    pub size: VkDeviceSize,
10912}
10913
10914#[derive(Clone, Copy)]
10915#[repr(C)]
10916pub struct VkSubmitInfo {
10917    pub sType: VkStructureType,
10918    pub pNext: *const c_void,
10919    pub waitSemaphoreCount: u32,
10920    pub pWaitSemaphores: *const VkSemaphore,
10921    pub pWaitDstStageMask: *const VkPipelineStageFlags,
10922    pub commandBufferCount: u32,
10923    pub pCommandBuffers: *const VkCommandBuffer,
10924    pub signalSemaphoreCount: u32,
10925    pub pSignalSemaphores: *const VkSemaphore,
10926}
10927
10928#[derive(Clone, Copy)]
10929#[repr(C)]
10930pub struct VkSubmitInfo2 {
10931    pub sType: VkStructureType,
10932    pub pNext: *const c_void,
10933    pub flags: VkSubmitFlags,
10934    pub waitSemaphoreInfoCount: u32,
10935    pub pWaitSemaphoreInfos: *const VkSemaphoreSubmitInfo,
10936    pub commandBufferInfoCount: u32,
10937    pub pCommandBufferInfos: *const VkCommandBufferSubmitInfo,
10938    pub signalSemaphoreInfoCount: u32,
10939    pub pSignalSemaphoreInfos: *const VkSemaphoreSubmitInfo,
10940}
10941
10942#[derive(Clone, Copy)]
10943#[repr(C)]
10944pub struct VkSubpassBeginInfo {
10945    pub sType: VkStructureType,
10946    pub pNext: *const c_void,
10947    pub contents: VkSubpassContents,
10948}
10949
10950#[derive(Clone, Copy)]
10951#[repr(C)]
10952pub struct VkSubpassDependency {
10953    pub srcSubpass: u32,
10954    pub dstSubpass: u32,
10955    pub srcStageMask: VkPipelineStageFlags,
10956    pub dstStageMask: VkPipelineStageFlags,
10957    pub srcAccessMask: VkAccessFlags,
10958    pub dstAccessMask: VkAccessFlags,
10959    pub dependencyFlags: VkDependencyFlags,
10960}
10961
10962#[derive(Clone, Copy)]
10963#[repr(C)]
10964pub struct VkSubpassDependency2 {
10965    pub sType: VkStructureType,
10966    pub pNext: *const c_void,
10967    pub srcSubpass: u32,
10968    pub dstSubpass: u32,
10969    pub srcStageMask: VkPipelineStageFlags,
10970    pub dstStageMask: VkPipelineStageFlags,
10971    pub srcAccessMask: VkAccessFlags,
10972    pub dstAccessMask: VkAccessFlags,
10973    pub dependencyFlags: VkDependencyFlags,
10974    pub viewOffset: i32,
10975}
10976
10977#[derive(Clone, Copy)]
10978#[repr(C)]
10979pub struct VkSubpassDescription {
10980    pub flags: VkSubpassDescriptionFlags,
10981    pub pipelineBindPoint: VkPipelineBindPoint,
10982    pub inputAttachmentCount: u32,
10983    pub pInputAttachments: *const VkAttachmentReference,
10984    pub colorAttachmentCount: u32,
10985    pub pColorAttachments: *const VkAttachmentReference,
10986    pub pResolveAttachments: *const VkAttachmentReference,
10987    pub pDepthStencilAttachment: *const VkAttachmentReference,
10988    pub preserveAttachmentCount: u32,
10989    pub pPreserveAttachments: *const u32,
10990}
10991
10992#[derive(Clone, Copy)]
10993#[repr(C)]
10994pub struct VkSubpassDescription2 {
10995    pub sType: VkStructureType,
10996    pub pNext: *const c_void,
10997    pub flags: VkSubpassDescriptionFlags,
10998    pub pipelineBindPoint: VkPipelineBindPoint,
10999    pub viewMask: u32,
11000    pub inputAttachmentCount: u32,
11001    pub pInputAttachments: *const VkAttachmentReference2,
11002    pub colorAttachmentCount: u32,
11003    pub pColorAttachments: *const VkAttachmentReference2,
11004    pub pResolveAttachments: *const VkAttachmentReference2,
11005    pub pDepthStencilAttachment: *const VkAttachmentReference2,
11006    pub preserveAttachmentCount: u32,
11007    pub pPreserveAttachments: *const u32,
11008}
11009
11010#[derive(Clone, Copy)]
11011#[repr(C)]
11012pub struct VkSubpassDescriptionDepthStencilResolve {
11013    pub sType: VkStructureType,
11014    pub pNext: *const c_void,
11015    pub depthResolveMode: VkResolveModeFlagBits,
11016    pub stencilResolveMode: VkResolveModeFlagBits,
11017    pub pDepthStencilResolveAttachment: *const VkAttachmentReference2,
11018}
11019
11020#[derive(Clone, Copy)]
11021#[repr(C)]
11022pub struct VkSubpassEndInfo {
11023    pub sType: VkStructureType,
11024    pub pNext: *const c_void,
11025}
11026
11027#[derive(Clone, Copy)]
11028#[repr(C)]
11029pub struct VkSubpassResolvePerformanceQueryEXT {
11030    pub sType: VkStructureType,
11031    pub pNext: *mut c_void,
11032    pub optimal: VkBool32,
11033}
11034
11035#[derive(Clone, Copy)]
11036#[repr(C)]
11037pub struct VkSubpassSampleLocationsEXT {
11038    pub subpassIndex: u32,
11039    pub sampleLocationsInfo: VkSampleLocationsInfoEXT,
11040}
11041
11042#[derive(Clone, Copy)]
11043#[repr(C)]
11044pub struct VkSubpassShadingPipelineCreateInfoHUAWEI {
11045    pub sType: VkStructureType,
11046    pub pNext: *mut c_void,
11047    pub renderPass: VkRenderPass,
11048    pub subpass: u32,
11049}
11050
11051#[derive(Clone, Copy)]
11052#[repr(C)]
11053pub struct VkSubresourceHostMemcpySize {
11054    pub sType: VkStructureType,
11055    pub pNext: *mut c_void,
11056    pub size: VkDeviceSize,
11057}
11058
11059#[derive(Clone, Copy)]
11060#[repr(C)]
11061pub struct VkSubresourceLayout {
11062    pub offset: VkDeviceSize,
11063    pub size: VkDeviceSize,
11064    pub rowPitch: VkDeviceSize,
11065    pub arrayPitch: VkDeviceSize,
11066    pub depthPitch: VkDeviceSize,
11067}
11068
11069#[derive(Clone, Copy)]
11070#[repr(C)]
11071pub struct VkSubresourceLayout2 {
11072    pub sType: VkStructureType,
11073    pub pNext: *mut c_void,
11074    pub subresourceLayout: VkSubresourceLayout,
11075}
11076
11077#[derive(Clone, Copy)]
11078#[repr(C)]
11079pub struct VkSubsampledImageFormatPropertiesEXT {
11080    pub sType: VkStructureType,
11081    pub pNext: *const c_void,
11082    pub subsampledImageDescriptorCount: u32,
11083}
11084
11085#[derive(Clone, Copy)]
11086#[repr(C)]
11087pub struct VkSurfaceCapabilities2EXT {
11088    pub sType: VkStructureType,
11089    pub pNext: *mut c_void,
11090    pub minImageCount: u32,
11091    pub maxImageCount: u32,
11092    pub currentExtent: VkExtent2D,
11093    pub minImageExtent: VkExtent2D,
11094    pub maxImageExtent: VkExtent2D,
11095    pub maxImageArrayLayers: u32,
11096    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
11097    pub currentTransform: VkSurfaceTransformFlagBitsKHR,
11098    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
11099    pub supportedUsageFlags: VkImageUsageFlags,
11100    pub supportedSurfaceCounters: VkSurfaceCounterFlagsEXT,
11101}
11102
11103#[derive(Clone, Copy)]
11104#[repr(C)]
11105pub struct VkSurfaceCapabilities2KHR {
11106    pub sType: VkStructureType,
11107    pub pNext: *mut c_void,
11108    pub surfaceCapabilities: VkSurfaceCapabilitiesKHR,
11109}
11110
11111#[derive(Clone, Copy)]
11112#[repr(C)]
11113pub struct VkSurfaceCapabilitiesKHR {
11114    pub minImageCount: u32,
11115    pub maxImageCount: u32,
11116    pub currentExtent: VkExtent2D,
11117    pub minImageExtent: VkExtent2D,
11118    pub maxImageExtent: VkExtent2D,
11119    pub maxImageArrayLayers: u32,
11120    pub supportedTransforms: VkSurfaceTransformFlagsKHR,
11121    pub currentTransform: VkSurfaceTransformFlagBitsKHR,
11122    pub supportedCompositeAlpha: VkCompositeAlphaFlagsKHR,
11123    pub supportedUsageFlags: VkImageUsageFlags,
11124}
11125
11126#[derive(Clone, Copy)]
11127#[repr(C)]
11128pub struct VkSurfaceCapabilitiesPresentBarrierNV {
11129    pub sType: VkStructureType,
11130    pub pNext: *mut c_void,
11131    pub presentBarrierSupported: VkBool32,
11132}
11133
11134#[derive(Clone, Copy)]
11135#[repr(C)]
11136pub struct VkSurfaceCapabilitiesPresentId2KHR {
11137    pub sType: VkStructureType,
11138    pub pNext: *mut c_void,
11139    pub presentId2Supported: VkBool32,
11140}
11141
11142#[derive(Clone, Copy)]
11143#[repr(C)]
11144pub struct VkSurfaceCapabilitiesPresentWait2KHR {
11145    pub sType: VkStructureType,
11146    pub pNext: *mut c_void,
11147    pub presentWait2Supported: VkBool32,
11148}
11149
11150#[derive(Clone, Copy)]
11151#[repr(C)]
11152pub struct VkSurfaceFormat2KHR {
11153    pub sType: VkStructureType,
11154    pub pNext: *mut c_void,
11155    pub surfaceFormat: VkSurfaceFormatKHR,
11156}
11157
11158#[derive(Clone, Copy)]
11159#[repr(C)]
11160pub struct VkSurfaceFormatKHR {
11161    pub format: VkFormat,
11162    pub colorSpace: VkColorSpaceKHR,
11163}
11164
11165#[repr(C)]
11166pub struct VkSurfaceKHR_T {
11167    _data: (),
11168    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11169}
11170
11171#[derive(Clone, Copy)]
11172#[repr(C)]
11173pub struct VkSurfacePresentModeCompatibilityKHR {
11174    pub sType: VkStructureType,
11175    pub pNext: *mut c_void,
11176    pub presentModeCount: u32,
11177    pub pPresentModes: *mut VkPresentModeKHR,
11178}
11179
11180#[derive(Clone, Copy)]
11181#[repr(C)]
11182pub struct VkSurfacePresentModeKHR {
11183    pub sType: VkStructureType,
11184    pub pNext: *mut c_void,
11185    pub presentMode: VkPresentModeKHR,
11186}
11187
11188#[derive(Clone, Copy)]
11189#[repr(C)]
11190pub struct VkSurfacePresentScalingCapabilitiesKHR {
11191    pub sType: VkStructureType,
11192    pub pNext: *mut c_void,
11193    pub supportedPresentScaling: VkPresentScalingFlagsKHR,
11194    pub supportedPresentGravityX: VkPresentGravityFlagsKHR,
11195    pub supportedPresentGravityY: VkPresentGravityFlagsKHR,
11196    pub minScaledImageExtent: VkExtent2D,
11197    pub maxScaledImageExtent: VkExtent2D,
11198}
11199
11200#[derive(Clone, Copy)]
11201#[repr(C)]
11202pub struct VkSurfaceProtectedCapabilitiesKHR {
11203    pub sType: VkStructureType,
11204    pub pNext: *mut c_void,
11205    pub supportsProtected: VkBool32,
11206}
11207
11208#[derive(Clone, Copy)]
11209#[repr(C)]
11210pub struct VkSwapchainCalibratedTimestampInfoEXT {
11211    pub sType: VkStructureType,
11212    pub pNext: *const c_void,
11213    pub swapchain: VkSwapchainKHR,
11214    pub presentStage: VkPresentStageFlagsEXT,
11215    pub timeDomainId: u64,
11216}
11217
11218#[derive(Clone, Copy)]
11219#[repr(C)]
11220pub struct VkSwapchainCounterCreateInfoEXT {
11221    pub sType: VkStructureType,
11222    pub pNext: *const c_void,
11223    pub surfaceCounters: VkSurfaceCounterFlagsEXT,
11224}
11225
11226#[derive(Clone, Copy)]
11227#[repr(C)]
11228pub struct VkSwapchainCreateInfoKHR {
11229    pub sType: VkStructureType,
11230    pub pNext: *const c_void,
11231    pub flags: VkSwapchainCreateFlagsKHR,
11232    pub surface: VkSurfaceKHR,
11233    pub minImageCount: u32,
11234    pub imageFormat: VkFormat,
11235    pub imageColorSpace: VkColorSpaceKHR,
11236    pub imageExtent: VkExtent2D,
11237    pub imageArrayLayers: u32,
11238    pub imageUsage: VkImageUsageFlags,
11239    pub imageSharingMode: VkSharingMode,
11240    pub queueFamilyIndexCount: u32,
11241    pub pQueueFamilyIndices: *const u32,
11242    pub preTransform: VkSurfaceTransformFlagBitsKHR,
11243    pub compositeAlpha: VkCompositeAlphaFlagBitsKHR,
11244    pub presentMode: VkPresentModeKHR,
11245    pub clipped: VkBool32,
11246    pub oldSwapchain: VkSwapchainKHR,
11247}
11248
11249#[derive(Clone, Copy)]
11250#[repr(C)]
11251pub struct VkSwapchainDisplayNativeHdrCreateInfoAMD {
11252    pub sType: VkStructureType,
11253    pub pNext: *const c_void,
11254    pub localDimmingEnable: VkBool32,
11255}
11256
11257#[repr(C)]
11258pub struct VkSwapchainKHR_T {
11259    _data: (),
11260    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11261}
11262
11263#[derive(Clone, Copy)]
11264#[repr(C)]
11265pub struct VkSwapchainLatencyCreateInfoNV {
11266    pub sType: VkStructureType,
11267    pub pNext: *const c_void,
11268    pub latencyModeEnable: VkBool32,
11269}
11270
11271#[derive(Clone, Copy)]
11272#[repr(C)]
11273pub struct VkSwapchainPresentBarrierCreateInfoNV {
11274    pub sType: VkStructureType,
11275    pub pNext: *mut c_void,
11276    pub presentBarrierEnable: VkBool32,
11277}
11278
11279#[derive(Clone, Copy)]
11280#[repr(C)]
11281pub struct VkSwapchainPresentFenceInfoKHR {
11282    pub sType: VkStructureType,
11283    pub pNext: *const c_void,
11284    pub swapchainCount: u32,
11285    pub pFences: *const VkFence,
11286}
11287
11288#[derive(Clone, Copy)]
11289#[repr(C)]
11290pub struct VkSwapchainPresentModeInfoKHR {
11291    pub sType: VkStructureType,
11292    pub pNext: *const c_void,
11293    pub swapchainCount: u32,
11294    pub pPresentModes: *const VkPresentModeKHR,
11295}
11296
11297#[derive(Clone, Copy)]
11298#[repr(C)]
11299pub struct VkSwapchainPresentModesCreateInfoKHR {
11300    pub sType: VkStructureType,
11301    pub pNext: *const c_void,
11302    pub presentModeCount: u32,
11303    pub pPresentModes: *const VkPresentModeKHR,
11304}
11305
11306#[derive(Clone, Copy)]
11307#[repr(C)]
11308pub struct VkSwapchainPresentScalingCreateInfoKHR {
11309    pub sType: VkStructureType,
11310    pub pNext: *const c_void,
11311    pub scalingBehavior: VkPresentScalingFlagsKHR,
11312    pub presentGravityX: VkPresentGravityFlagsKHR,
11313    pub presentGravityY: VkPresentGravityFlagsKHR,
11314}
11315
11316#[derive(Clone, Copy)]
11317#[repr(C)]
11318pub struct VkSwapchainTimeDomainPropertiesEXT {
11319    pub sType: VkStructureType,
11320    pub pNext: *mut c_void,
11321    pub timeDomainCount: u32,
11322    pub pTimeDomains: *mut VkTimeDomainKHR,
11323    pub pTimeDomainIds: *mut u64,
11324}
11325
11326#[derive(Clone, Copy)]
11327#[repr(C)]
11328pub struct VkSwapchainTimingPropertiesEXT {
11329    pub sType: VkStructureType,
11330    pub pNext: *mut c_void,
11331    pub refreshDuration: u64,
11332    pub refreshInterval: u64,
11333}
11334
11335#[repr(C)]
11336pub struct VkTensorARM_T {
11337    _data: (),
11338    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11339}
11340
11341#[derive(Clone, Copy)]
11342#[repr(C)]
11343pub struct VkTensorCaptureDescriptorDataInfoARM {
11344    pub sType: VkStructureType,
11345    pub pNext: *const c_void,
11346    pub tensor: VkTensorARM,
11347}
11348
11349#[derive(Clone, Copy)]
11350#[repr(C)]
11351pub struct VkTensorCopyARM {
11352    pub sType: VkStructureType,
11353    pub pNext: *const c_void,
11354    pub dimensionCount: u32,
11355    pub pSrcOffset: *const u64,
11356    pub pDstOffset: *const u64,
11357    pub pExtent: *const u64,
11358}
11359
11360#[derive(Clone, Copy)]
11361#[repr(C)]
11362pub struct VkTensorCreateInfoARM {
11363    pub sType: VkStructureType,
11364    pub pNext: *const c_void,
11365    pub flags: VkTensorCreateFlagsARM,
11366    pub pDescription: *const VkTensorDescriptionARM,
11367    pub sharingMode: VkSharingMode,
11368    pub queueFamilyIndexCount: u32,
11369    pub pQueueFamilyIndices: *const u32,
11370}
11371
11372#[derive(Clone, Copy)]
11373#[repr(C)]
11374pub struct VkTensorDependencyInfoARM {
11375    pub sType: VkStructureType,
11376    pub pNext: *const c_void,
11377    pub tensorMemoryBarrierCount: u32,
11378    pub pTensorMemoryBarriers: *const VkTensorMemoryBarrierARM,
11379}
11380
11381#[derive(Clone, Copy)]
11382#[repr(C)]
11383pub struct VkTensorDescriptionARM {
11384    pub sType: VkStructureType,
11385    pub pNext: *const c_void,
11386    pub tiling: VkTensorTilingARM,
11387    pub format: VkFormat,
11388    pub dimensionCount: u32,
11389    pub pDimensions: *const i64,
11390    pub pStrides: *const i64,
11391    pub usage: VkTensorUsageFlagsARM,
11392}
11393
11394#[derive(Clone, Copy)]
11395#[repr(C)]
11396pub struct VkTensorFormatPropertiesARM {
11397    pub sType: VkStructureType,
11398    pub pNext: *mut c_void,
11399    pub optimalTilingTensorFeatures: VkFormatFeatureFlags2,
11400    pub linearTilingTensorFeatures: VkFormatFeatureFlags2,
11401}
11402
11403#[derive(Clone, Copy)]
11404#[repr(C)]
11405pub struct VkTensorMemoryBarrierARM {
11406    pub sType: VkStructureType,
11407    pub pNext: *const c_void,
11408    pub srcStageMask: VkPipelineStageFlags2,
11409    pub srcAccessMask: VkAccessFlags2,
11410    pub dstStageMask: VkPipelineStageFlags2,
11411    pub dstAccessMask: VkAccessFlags2,
11412    pub srcQueueFamilyIndex: u32,
11413    pub dstQueueFamilyIndex: u32,
11414    pub tensor: VkTensorARM,
11415}
11416
11417#[derive(Clone, Copy)]
11418#[repr(C)]
11419pub struct VkTensorMemoryRequirementsInfoARM {
11420    pub sType: VkStructureType,
11421    pub pNext: *const c_void,
11422    pub tensor: VkTensorARM,
11423}
11424
11425#[repr(C)]
11426pub struct VkTensorViewARM_T {
11427    _data: (),
11428    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11429}
11430
11431#[derive(Clone, Copy)]
11432#[repr(C)]
11433pub struct VkTensorViewCaptureDescriptorDataInfoARM {
11434    pub sType: VkStructureType,
11435    pub pNext: *const c_void,
11436    pub tensorView: VkTensorViewARM,
11437}
11438
11439#[derive(Clone, Copy)]
11440#[repr(C)]
11441pub struct VkTensorViewCreateInfoARM {
11442    pub sType: VkStructureType,
11443    pub pNext: *const c_void,
11444    pub flags: VkTensorViewCreateFlagsARM,
11445    pub tensor: VkTensorARM,
11446    pub format: VkFormat,
11447}
11448
11449#[derive(Clone, Copy)]
11450#[repr(C)]
11451pub struct VkTexelBufferDescriptorInfoEXT {
11452    pub sType: VkStructureType,
11453    pub pNext: *const c_void,
11454    pub format: VkFormat,
11455    pub addressRange: VkDeviceAddressRangeEXT,
11456}
11457
11458#[derive(Clone, Copy)]
11459#[repr(C)]
11460pub struct VkTextureLODGatherFormatPropertiesAMD {
11461    pub sType: VkStructureType,
11462    pub pNext: *mut c_void,
11463    pub supportsTextureGatherLODBiasAMD: VkBool32,
11464}
11465
11466#[derive(Clone, Copy)]
11467#[repr(C)]
11468pub struct VkTileMemoryBindInfoQCOM {
11469    pub sType: VkStructureType,
11470    pub pNext: *const c_void,
11471    pub memory: VkDeviceMemory,
11472}
11473
11474#[derive(Clone, Copy)]
11475#[repr(C)]
11476pub struct VkTileMemoryRequirementsQCOM {
11477    pub sType: VkStructureType,
11478    pub pNext: *mut c_void,
11479    pub size: VkDeviceSize,
11480    pub alignment: VkDeviceSize,
11481}
11482
11483#[derive(Clone, Copy)]
11484#[repr(C)]
11485pub struct VkTileMemorySizeInfoQCOM {
11486    pub sType: VkStructureType,
11487    pub pNext: *const c_void,
11488    pub size: VkDeviceSize,
11489}
11490
11491#[derive(Clone, Copy)]
11492#[repr(C)]
11493pub struct VkTilePropertiesQCOM {
11494    pub sType: VkStructureType,
11495    pub pNext: *mut c_void,
11496    pub tileSize: VkExtent3D,
11497    pub apronSize: VkExtent2D,
11498    pub origin: VkOffset2D,
11499}
11500
11501#[derive(Clone, Copy)]
11502#[repr(C)]
11503pub struct VkTimelineSemaphoreSubmitInfo {
11504    pub sType: VkStructureType,
11505    pub pNext: *const c_void,
11506    pub waitSemaphoreValueCount: u32,
11507    pub pWaitSemaphoreValues: *const u64,
11508    pub signalSemaphoreValueCount: u32,
11509    pub pSignalSemaphoreValues: *const u64,
11510}
11511
11512#[derive(Clone, Copy)]
11513#[repr(C)]
11514pub struct VkTraceRaysIndirectCommand2KHR {
11515    pub raygenShaderRecordAddress: VkDeviceAddress,
11516    pub raygenShaderRecordSize: VkDeviceSize,
11517    pub missShaderBindingTableAddress: VkDeviceAddress,
11518    pub missShaderBindingTableSize: VkDeviceSize,
11519    pub missShaderBindingTableStride: VkDeviceSize,
11520    pub hitShaderBindingTableAddress: VkDeviceAddress,
11521    pub hitShaderBindingTableSize: VkDeviceSize,
11522    pub hitShaderBindingTableStride: VkDeviceSize,
11523    pub callableShaderBindingTableAddress: VkDeviceAddress,
11524    pub callableShaderBindingTableSize: VkDeviceSize,
11525    pub callableShaderBindingTableStride: VkDeviceSize,
11526    pub width: u32,
11527    pub height: u32,
11528    pub depth: u32,
11529}
11530
11531#[derive(Clone, Copy)]
11532#[repr(C)]
11533pub struct VkTraceRaysIndirectCommandKHR {
11534    pub width: u32,
11535    pub height: u32,
11536    pub depth: u32,
11537}
11538
11539#[derive(Clone, Copy)]
11540#[repr(C)]
11541pub struct VkTransformMatrixKHR {
11542    pub matrix: [[f32; 4 as usize]; 3 as usize],
11543}
11544
11545#[derive(Clone, Copy)]
11546#[repr(C)]
11547pub struct VkValidationCacheCreateInfoEXT {
11548    pub sType: VkStructureType,
11549    pub pNext: *const c_void,
11550    pub flags: VkValidationCacheCreateFlagsEXT,
11551    pub initialDataSize: usize,
11552    pub pInitialData: *const c_void,
11553}
11554
11555#[repr(C)]
11556pub struct VkValidationCacheEXT_T {
11557    _data: (),
11558    _marker: PhantomData<(*mut u8, PhantomPinned)>,
11559}
11560
11561#[derive(Clone, Copy)]
11562#[repr(C)]
11563pub struct VkValidationFeaturesEXT {
11564    pub sType: VkStructureType,
11565    pub pNext: *const c_void,
11566    pub enabledValidationFeatureCount: u32,
11567    pub pEnabledValidationFeatures: *const VkValidationFeatureEnableEXT,
11568    pub disabledValidationFeatureCount: u32,
11569    pub pDisabledValidationFeatures: *const VkValidationFeatureDisableEXT,
11570}
11571
11572#[derive(Clone, Copy)]
11573#[repr(C)]
11574pub struct VkValidationFlagsEXT {
11575    pub sType: VkStructureType,
11576    pub pNext: *const c_void,
11577    pub disabledValidationCheckCount: u32,
11578    pub pDisabledValidationChecks: *const VkValidationCheckEXT,
11579}
11580
11581#[derive(Clone, Copy)]
11582#[repr(C)]
11583pub struct VkVertexInputAttributeDescription {
11584    pub location: u32,
11585    pub binding: u32,
11586    pub format: VkFormat,
11587    pub offset: u32,
11588}
11589
11590#[derive(Clone, Copy)]
11591#[repr(C)]
11592pub struct VkVertexInputAttributeDescription2EXT {
11593    pub sType: VkStructureType,
11594    pub pNext: *mut c_void,
11595    pub location: u32,
11596    pub binding: u32,
11597    pub format: VkFormat,
11598    pub offset: u32,
11599}
11600
11601#[derive(Clone, Copy)]
11602#[repr(C)]
11603pub struct VkVertexInputBindingDescription {
11604    pub binding: u32,
11605    pub stride: u32,
11606    pub inputRate: VkVertexInputRate,
11607}
11608
11609#[derive(Clone, Copy)]
11610#[repr(C)]
11611pub struct VkVertexInputBindingDescription2EXT {
11612    pub sType: VkStructureType,
11613    pub pNext: *mut c_void,
11614    pub binding: u32,
11615    pub stride: u32,
11616    pub inputRate: VkVertexInputRate,
11617    pub divisor: u32,
11618}
11619
11620#[derive(Clone, Copy)]
11621#[repr(C)]
11622pub struct VkVertexInputBindingDivisorDescription {
11623    pub binding: u32,
11624    pub divisor: u32,
11625}
11626
11627#[derive(Clone, Copy)]
11628#[repr(C)]
11629pub struct VkVideoBeginCodingInfoKHR {
11630    pub sType: VkStructureType,
11631    pub pNext: *const c_void,
11632    pub flags: VkVideoBeginCodingFlagsKHR,
11633    pub videoSession: VkVideoSessionKHR,
11634    pub videoSessionParameters: VkVideoSessionParametersKHR,
11635    pub referenceSlotCount: u32,
11636    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
11637}
11638
11639#[derive(Clone, Copy)]
11640#[repr(C)]
11641pub struct VkVideoCapabilitiesKHR {
11642    pub sType: VkStructureType,
11643    pub pNext: *mut c_void,
11644    pub flags: VkVideoCapabilityFlagsKHR,
11645    pub minBitstreamBufferOffsetAlignment: VkDeviceSize,
11646    pub minBitstreamBufferSizeAlignment: VkDeviceSize,
11647    pub pictureAccessGranularity: VkExtent2D,
11648    pub minCodedExtent: VkExtent2D,
11649    pub maxCodedExtent: VkExtent2D,
11650    pub maxDpbSlots: u32,
11651    pub maxActiveReferencePictures: u32,
11652    pub stdHeaderVersion: VkExtensionProperties,
11653}
11654
11655#[derive(Clone, Copy)]
11656#[repr(C)]
11657pub struct VkVideoCodingControlInfoKHR {
11658    pub sType: VkStructureType,
11659    pub pNext: *const c_void,
11660    pub flags: VkVideoCodingControlFlagsKHR,
11661}
11662
11663#[derive(Clone, Copy)]
11664#[repr(C)]
11665pub struct VkVideoDecodeAV1CapabilitiesKHR {
11666    pub sType: VkStructureType,
11667    pub pNext: *mut c_void,
11668    pub maxLevel: StdVideoAV1Level,
11669}
11670
11671#[derive(Clone, Copy)]
11672#[repr(C)]
11673pub struct VkVideoDecodeAV1DpbSlotInfoKHR {
11674    pub sType: VkStructureType,
11675    pub pNext: *const c_void,
11676    pub pStdReferenceInfo: *const StdVideoDecodeAV1ReferenceInfo,
11677}
11678
11679#[derive(Clone, Copy)]
11680#[repr(C)]
11681pub struct VkVideoDecodeAV1InlineSessionParametersInfoKHR {
11682    pub sType: VkStructureType,
11683    pub pNext: *const c_void,
11684    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
11685}
11686
11687#[derive(Clone, Copy)]
11688#[repr(C)]
11689pub struct VkVideoDecodeAV1PictureInfoKHR {
11690    pub sType: VkStructureType,
11691    pub pNext: *const c_void,
11692    pub pStdPictureInfo: *const StdVideoDecodeAV1PictureInfo,
11693    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
11694    pub frameHeaderOffset: u32,
11695    pub tileCount: u32,
11696    pub pTileOffsets: *const u32,
11697    pub pTileSizes: *const u32,
11698}
11699
11700#[derive(Clone, Copy)]
11701#[repr(C)]
11702pub struct VkVideoDecodeAV1ProfileInfoKHR {
11703    pub sType: VkStructureType,
11704    pub pNext: *const c_void,
11705    pub stdProfile: StdVideoAV1Profile,
11706    pub filmGrainSupport: VkBool32,
11707}
11708
11709#[derive(Clone, Copy)]
11710#[repr(C)]
11711pub struct VkVideoDecodeAV1SessionParametersCreateInfoKHR {
11712    pub sType: VkStructureType,
11713    pub pNext: *const c_void,
11714    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
11715}
11716
11717#[derive(Clone, Copy)]
11718#[repr(C)]
11719pub struct VkVideoDecodeCapabilitiesKHR {
11720    pub sType: VkStructureType,
11721    pub pNext: *mut c_void,
11722    pub flags: VkVideoDecodeCapabilityFlagsKHR,
11723}
11724
11725#[derive(Clone, Copy)]
11726#[repr(C)]
11727pub struct VkVideoDecodeH264CapabilitiesKHR {
11728    pub sType: VkStructureType,
11729    pub pNext: *mut c_void,
11730    pub maxLevelIdc: StdVideoH264LevelIdc,
11731    pub fieldOffsetGranularity: VkOffset2D,
11732}
11733
11734#[derive(Clone, Copy)]
11735#[repr(C)]
11736pub struct VkVideoDecodeH264DpbSlotInfoKHR {
11737    pub sType: VkStructureType,
11738    pub pNext: *const c_void,
11739    pub pStdReferenceInfo: *const StdVideoDecodeH264ReferenceInfo,
11740}
11741
11742#[derive(Clone, Copy)]
11743#[repr(C)]
11744pub struct VkVideoDecodeH264InlineSessionParametersInfoKHR {
11745    pub sType: VkStructureType,
11746    pub pNext: *const c_void,
11747    pub pStdSPS: *const StdVideoH264SequenceParameterSet,
11748    pub pStdPPS: *const StdVideoH264PictureParameterSet,
11749}
11750
11751#[derive(Clone, Copy)]
11752#[repr(C)]
11753pub struct VkVideoDecodeH264PictureInfoKHR {
11754    pub sType: VkStructureType,
11755    pub pNext: *const c_void,
11756    pub pStdPictureInfo: *const StdVideoDecodeH264PictureInfo,
11757    pub sliceCount: u32,
11758    pub pSliceOffsets: *const u32,
11759}
11760
11761#[derive(Clone, Copy)]
11762#[repr(C)]
11763pub struct VkVideoDecodeH264ProfileInfoKHR {
11764    pub sType: VkStructureType,
11765    pub pNext: *const c_void,
11766    pub stdProfileIdc: StdVideoH264ProfileIdc,
11767    pub pictureLayout: VkVideoDecodeH264PictureLayoutFlagBitsKHR,
11768}
11769
11770#[derive(Clone, Copy)]
11771#[repr(C)]
11772pub struct VkVideoDecodeH264SessionParametersAddInfoKHR {
11773    pub sType: VkStructureType,
11774    pub pNext: *const c_void,
11775    pub stdSPSCount: u32,
11776    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
11777    pub stdPPSCount: u32,
11778    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
11779}
11780
11781#[derive(Clone, Copy)]
11782#[repr(C)]
11783pub struct VkVideoDecodeH264SessionParametersCreateInfoKHR {
11784    pub sType: VkStructureType,
11785    pub pNext: *const c_void,
11786    pub maxStdSPSCount: u32,
11787    pub maxStdPPSCount: u32,
11788    pub pParametersAddInfo: *const VkVideoDecodeH264SessionParametersAddInfoKHR,
11789}
11790
11791#[derive(Clone, Copy)]
11792#[repr(C)]
11793pub struct VkVideoDecodeH265CapabilitiesKHR {
11794    pub sType: VkStructureType,
11795    pub pNext: *mut c_void,
11796    pub maxLevelIdc: StdVideoH265LevelIdc,
11797}
11798
11799#[derive(Clone, Copy)]
11800#[repr(C)]
11801pub struct VkVideoDecodeH265DpbSlotInfoKHR {
11802    pub sType: VkStructureType,
11803    pub pNext: *const c_void,
11804    pub pStdReferenceInfo: *const StdVideoDecodeH265ReferenceInfo,
11805}
11806
11807#[derive(Clone, Copy)]
11808#[repr(C)]
11809pub struct VkVideoDecodeH265InlineSessionParametersInfoKHR {
11810    pub sType: VkStructureType,
11811    pub pNext: *const c_void,
11812    pub pStdVPS: *const StdVideoH265VideoParameterSet,
11813    pub pStdSPS: *const StdVideoH265SequenceParameterSet,
11814    pub pStdPPS: *const StdVideoH265PictureParameterSet,
11815}
11816
11817#[derive(Clone, Copy)]
11818#[repr(C)]
11819pub struct VkVideoDecodeH265PictureInfoKHR {
11820    pub sType: VkStructureType,
11821    pub pNext: *const c_void,
11822    pub pStdPictureInfo: *const StdVideoDecodeH265PictureInfo,
11823    pub sliceSegmentCount: u32,
11824    pub pSliceSegmentOffsets: *const u32,
11825}
11826
11827#[derive(Clone, Copy)]
11828#[repr(C)]
11829pub struct VkVideoDecodeH265ProfileInfoKHR {
11830    pub sType: VkStructureType,
11831    pub pNext: *const c_void,
11832    pub stdProfileIdc: StdVideoH265ProfileIdc,
11833}
11834
11835#[derive(Clone, Copy)]
11836#[repr(C)]
11837pub struct VkVideoDecodeH265SessionParametersAddInfoKHR {
11838    pub sType: VkStructureType,
11839    pub pNext: *const c_void,
11840    pub stdVPSCount: u32,
11841    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
11842    pub stdSPSCount: u32,
11843    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
11844    pub stdPPSCount: u32,
11845    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
11846}
11847
11848#[derive(Clone, Copy)]
11849#[repr(C)]
11850pub struct VkVideoDecodeH265SessionParametersCreateInfoKHR {
11851    pub sType: VkStructureType,
11852    pub pNext: *const c_void,
11853    pub maxStdVPSCount: u32,
11854    pub maxStdSPSCount: u32,
11855    pub maxStdPPSCount: u32,
11856    pub pParametersAddInfo: *const VkVideoDecodeH265SessionParametersAddInfoKHR,
11857}
11858
11859#[derive(Clone, Copy)]
11860#[repr(C)]
11861pub struct VkVideoDecodeInfoKHR {
11862    pub sType: VkStructureType,
11863    pub pNext: *const c_void,
11864    pub flags: VkVideoDecodeFlagsKHR,
11865    pub srcBuffer: VkBuffer,
11866    pub srcBufferOffset: VkDeviceSize,
11867    pub srcBufferRange: VkDeviceSize,
11868    pub dstPictureResource: VkVideoPictureResourceInfoKHR,
11869    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
11870    pub referenceSlotCount: u32,
11871    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
11872}
11873
11874#[derive(Clone, Copy)]
11875#[repr(C)]
11876pub struct VkVideoDecodeUsageInfoKHR {
11877    pub sType: VkStructureType,
11878    pub pNext: *const c_void,
11879    pub videoUsageHints: VkVideoDecodeUsageFlagsKHR,
11880}
11881
11882#[derive(Clone, Copy)]
11883#[repr(C)]
11884pub struct VkVideoDecodeVP9CapabilitiesKHR {
11885    pub sType: VkStructureType,
11886    pub pNext: *mut c_void,
11887    pub maxLevel: StdVideoVP9Level,
11888}
11889
11890#[derive(Clone, Copy)]
11891#[repr(C)]
11892pub struct VkVideoDecodeVP9PictureInfoKHR {
11893    pub sType: VkStructureType,
11894    pub pNext: *const c_void,
11895    pub pStdPictureInfo: *const StdVideoDecodeVP9PictureInfo,
11896    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR as usize],
11897    pub uncompressedHeaderOffset: u32,
11898    pub compressedHeaderOffset: u32,
11899    pub tilesOffset: u32,
11900}
11901
11902#[derive(Clone, Copy)]
11903#[repr(C)]
11904pub struct VkVideoDecodeVP9ProfileInfoKHR {
11905    pub sType: VkStructureType,
11906    pub pNext: *const c_void,
11907    pub stdProfile: StdVideoVP9Profile,
11908}
11909
11910#[derive(Clone, Copy)]
11911#[repr(C)]
11912pub struct VkVideoEncodeAV1CapabilitiesKHR {
11913    pub sType: VkStructureType,
11914    pub pNext: *mut c_void,
11915    pub flags: VkVideoEncodeAV1CapabilityFlagsKHR,
11916    pub maxLevel: StdVideoAV1Level,
11917    pub codedPictureAlignment: VkExtent2D,
11918    pub maxTiles: VkExtent2D,
11919    pub minTileSize: VkExtent2D,
11920    pub maxTileSize: VkExtent2D,
11921    pub superblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
11922    pub maxSingleReferenceCount: u32,
11923    pub singleReferenceNameMask: u32,
11924    pub maxUnidirectionalCompoundReferenceCount: u32,
11925    pub maxUnidirectionalCompoundGroup1ReferenceCount: u32,
11926    pub unidirectionalCompoundReferenceNameMask: u32,
11927    pub maxBidirectionalCompoundReferenceCount: u32,
11928    pub maxBidirectionalCompoundGroup1ReferenceCount: u32,
11929    pub maxBidirectionalCompoundGroup2ReferenceCount: u32,
11930    pub bidirectionalCompoundReferenceNameMask: u32,
11931    pub maxTemporalLayerCount: u32,
11932    pub maxSpatialLayerCount: u32,
11933    pub maxOperatingPoints: u32,
11934    pub minQIndex: u32,
11935    pub maxQIndex: u32,
11936    pub prefersGopRemainingFrames: VkBool32,
11937    pub requiresGopRemainingFrames: VkBool32,
11938    pub stdSyntaxFlags: VkVideoEncodeAV1StdFlagsKHR,
11939}
11940
11941#[derive(Clone, Copy)]
11942#[repr(C)]
11943pub struct VkVideoEncodeAV1DpbSlotInfoKHR {
11944    pub sType: VkStructureType,
11945    pub pNext: *const c_void,
11946    pub pStdReferenceInfo: *const StdVideoEncodeAV1ReferenceInfo,
11947}
11948
11949#[derive(Clone, Copy)]
11950#[repr(C)]
11951pub struct VkVideoEncodeAV1FrameSizeKHR {
11952    pub intraFrameSize: u32,
11953    pub predictiveFrameSize: u32,
11954    pub bipredictiveFrameSize: u32,
11955}
11956
11957#[derive(Clone, Copy)]
11958#[repr(C)]
11959pub struct VkVideoEncodeAV1GopRemainingFrameInfoKHR {
11960    pub sType: VkStructureType,
11961    pub pNext: *const c_void,
11962    pub useGopRemainingFrames: VkBool32,
11963    pub gopRemainingIntra: u32,
11964    pub gopRemainingPredictive: u32,
11965    pub gopRemainingBipredictive: u32,
11966}
11967
11968#[derive(Clone, Copy)]
11969#[repr(C)]
11970pub struct VkVideoEncodeAV1PictureInfoKHR {
11971    pub sType: VkStructureType,
11972    pub pNext: *const c_void,
11973    pub predictionMode: VkVideoEncodeAV1PredictionModeKHR,
11974    pub rateControlGroup: VkVideoEncodeAV1RateControlGroupKHR,
11975    pub constantQIndex: u32,
11976    pub pStdPictureInfo: *const StdVideoEncodeAV1PictureInfo,
11977    pub referenceNameSlotIndices: [i32; VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR as usize],
11978    pub primaryReferenceCdfOnly: VkBool32,
11979    pub generateObuExtensionHeader: VkBool32,
11980}
11981
11982#[derive(Clone, Copy)]
11983#[repr(C)]
11984pub struct VkVideoEncodeAV1ProfileInfoKHR {
11985    pub sType: VkStructureType,
11986    pub pNext: *const c_void,
11987    pub stdProfile: StdVideoAV1Profile,
11988}
11989
11990#[derive(Clone, Copy)]
11991#[repr(C)]
11992pub struct VkVideoEncodeAV1QIndexKHR {
11993    pub intraQIndex: u32,
11994    pub predictiveQIndex: u32,
11995    pub bipredictiveQIndex: u32,
11996}
11997
11998#[derive(Clone, Copy)]
11999#[repr(C)]
12000pub struct VkVideoEncodeAV1QualityLevelPropertiesKHR {
12001    pub sType: VkStructureType,
12002    pub pNext: *mut c_void,
12003    pub preferredRateControlFlags: VkVideoEncodeAV1RateControlFlagsKHR,
12004    pub preferredGopFrameCount: u32,
12005    pub preferredKeyFramePeriod: u32,
12006    pub preferredConsecutiveBipredictiveFrameCount: u32,
12007    pub preferredTemporalLayerCount: u32,
12008    pub preferredConstantQIndex: VkVideoEncodeAV1QIndexKHR,
12009    pub preferredMaxSingleReferenceCount: u32,
12010    pub preferredSingleReferenceNameMask: u32,
12011    pub preferredMaxUnidirectionalCompoundReferenceCount: u32,
12012    pub preferredMaxUnidirectionalCompoundGroup1ReferenceCount: u32,
12013    pub preferredUnidirectionalCompoundReferenceNameMask: u32,
12014    pub preferredMaxBidirectionalCompoundReferenceCount: u32,
12015    pub preferredMaxBidirectionalCompoundGroup1ReferenceCount: u32,
12016    pub preferredMaxBidirectionalCompoundGroup2ReferenceCount: u32,
12017    pub preferredBidirectionalCompoundReferenceNameMask: u32,
12018}
12019
12020#[derive(Clone, Copy)]
12021#[repr(C)]
12022pub struct VkVideoEncodeAV1QuantizationMapCapabilitiesKHR {
12023    pub sType: VkStructureType,
12024    pub pNext: *mut c_void,
12025    pub minQIndexDelta: i32,
12026    pub maxQIndexDelta: i32,
12027}
12028
12029#[derive(Clone, Copy)]
12030#[repr(C)]
12031pub struct VkVideoEncodeAV1RateControlInfoKHR {
12032    pub sType: VkStructureType,
12033    pub pNext: *const c_void,
12034    pub flags: VkVideoEncodeAV1RateControlFlagsKHR,
12035    pub gopFrameCount: u32,
12036    pub keyFramePeriod: u32,
12037    pub consecutiveBipredictiveFrameCount: u32,
12038    pub temporalLayerCount: u32,
12039}
12040
12041#[derive(Clone, Copy)]
12042#[repr(C)]
12043pub struct VkVideoEncodeAV1RateControlLayerInfoKHR {
12044    pub sType: VkStructureType,
12045    pub pNext: *const c_void,
12046    pub useMinQIndex: VkBool32,
12047    pub minQIndex: VkVideoEncodeAV1QIndexKHR,
12048    pub useMaxQIndex: VkBool32,
12049    pub maxQIndex: VkVideoEncodeAV1QIndexKHR,
12050    pub useMaxFrameSize: VkBool32,
12051    pub maxFrameSize: VkVideoEncodeAV1FrameSizeKHR,
12052}
12053
12054#[derive(Clone, Copy)]
12055#[repr(C)]
12056pub struct VkVideoEncodeAV1SessionCreateInfoKHR {
12057    pub sType: VkStructureType,
12058    pub pNext: *const c_void,
12059    pub useMaxLevel: VkBool32,
12060    pub maxLevel: StdVideoAV1Level,
12061}
12062
12063#[derive(Clone, Copy)]
12064#[repr(C)]
12065pub struct VkVideoEncodeAV1SessionParametersCreateInfoKHR {
12066    pub sType: VkStructureType,
12067    pub pNext: *const c_void,
12068    pub pStdSequenceHeader: *const StdVideoAV1SequenceHeader,
12069    pub pStdDecoderModelInfo: *const StdVideoEncodeAV1DecoderModelInfo,
12070    pub stdOperatingPointCount: u32,
12071    pub pStdOperatingPoints: *const StdVideoEncodeAV1OperatingPointInfo,
12072}
12073
12074#[derive(Clone, Copy)]
12075#[repr(C)]
12076pub struct VkVideoEncodeCapabilitiesKHR {
12077    pub sType: VkStructureType,
12078    pub pNext: *mut c_void,
12079    pub flags: VkVideoEncodeCapabilityFlagsKHR,
12080    pub rateControlModes: VkVideoEncodeRateControlModeFlagsKHR,
12081    pub maxRateControlLayers: u32,
12082    pub maxBitrate: u64,
12083    pub maxQualityLevels: u32,
12084    pub encodeInputPictureGranularity: VkExtent2D,
12085    pub supportedEncodeFeedbackFlags: VkVideoEncodeFeedbackFlagsKHR,
12086}
12087
12088#[derive(Clone, Copy)]
12089#[repr(C)]
12090pub struct VkVideoEncodeH264CapabilitiesKHR {
12091    pub sType: VkStructureType,
12092    pub pNext: *mut c_void,
12093    pub flags: VkVideoEncodeH264CapabilityFlagsKHR,
12094    pub maxLevelIdc: StdVideoH264LevelIdc,
12095    pub maxSliceCount: u32,
12096    pub maxPPictureL0ReferenceCount: u32,
12097    pub maxBPictureL0ReferenceCount: u32,
12098    pub maxL1ReferenceCount: u32,
12099    pub maxTemporalLayerCount: u32,
12100    pub expectDyadicTemporalLayerPattern: VkBool32,
12101    pub minQp: i32,
12102    pub maxQp: i32,
12103    pub prefersGopRemainingFrames: VkBool32,
12104    pub requiresGopRemainingFrames: VkBool32,
12105    pub stdSyntaxFlags: VkVideoEncodeH264StdFlagsKHR,
12106}
12107
12108#[derive(Clone, Copy)]
12109#[repr(C)]
12110pub struct VkVideoEncodeH264DpbSlotInfoKHR {
12111    pub sType: VkStructureType,
12112    pub pNext: *const c_void,
12113    pub pStdReferenceInfo: *const StdVideoEncodeH264ReferenceInfo,
12114}
12115
12116#[derive(Clone, Copy)]
12117#[repr(C)]
12118pub struct VkVideoEncodeH264FrameSizeKHR {
12119    pub frameISize: u32,
12120    pub framePSize: u32,
12121    pub frameBSize: u32,
12122}
12123
12124#[derive(Clone, Copy)]
12125#[repr(C)]
12126pub struct VkVideoEncodeH264GopRemainingFrameInfoKHR {
12127    pub sType: VkStructureType,
12128    pub pNext: *const c_void,
12129    pub useGopRemainingFrames: VkBool32,
12130    pub gopRemainingI: u32,
12131    pub gopRemainingP: u32,
12132    pub gopRemainingB: u32,
12133}
12134
12135#[derive(Clone, Copy)]
12136#[repr(C)]
12137pub struct VkVideoEncodeH264NaluSliceInfoKHR {
12138    pub sType: VkStructureType,
12139    pub pNext: *const c_void,
12140    pub constantQp: i32,
12141    pub pStdSliceHeader: *const StdVideoEncodeH264SliceHeader,
12142}
12143
12144#[derive(Clone, Copy)]
12145#[repr(C)]
12146pub struct VkVideoEncodeH264PictureInfoKHR {
12147    pub sType: VkStructureType,
12148    pub pNext: *const c_void,
12149    pub naluSliceEntryCount: u32,
12150    pub pNaluSliceEntries: *const VkVideoEncodeH264NaluSliceInfoKHR,
12151    pub pStdPictureInfo: *const StdVideoEncodeH264PictureInfo,
12152    pub generatePrefixNalu: VkBool32,
12153}
12154
12155#[derive(Clone, Copy)]
12156#[repr(C)]
12157pub struct VkVideoEncodeH264ProfileInfoKHR {
12158    pub sType: VkStructureType,
12159    pub pNext: *const c_void,
12160    pub stdProfileIdc: StdVideoH264ProfileIdc,
12161}
12162
12163#[derive(Clone, Copy)]
12164#[repr(C)]
12165pub struct VkVideoEncodeH264QpKHR {
12166    pub qpI: i32,
12167    pub qpP: i32,
12168    pub qpB: i32,
12169}
12170
12171#[derive(Clone, Copy)]
12172#[repr(C)]
12173pub struct VkVideoEncodeH264QualityLevelPropertiesKHR {
12174    pub sType: VkStructureType,
12175    pub pNext: *mut c_void,
12176    pub preferredRateControlFlags: VkVideoEncodeH264RateControlFlagsKHR,
12177    pub preferredGopFrameCount: u32,
12178    pub preferredIdrPeriod: u32,
12179    pub preferredConsecutiveBFrameCount: u32,
12180    pub preferredTemporalLayerCount: u32,
12181    pub preferredConstantQp: VkVideoEncodeH264QpKHR,
12182    pub preferredMaxL0ReferenceCount: u32,
12183    pub preferredMaxL1ReferenceCount: u32,
12184    pub preferredStdEntropyCodingModeFlag: VkBool32,
12185}
12186
12187#[derive(Clone, Copy)]
12188#[repr(C)]
12189pub struct VkVideoEncodeH264QuantizationMapCapabilitiesKHR {
12190    pub sType: VkStructureType,
12191    pub pNext: *mut c_void,
12192    pub minQpDelta: i32,
12193    pub maxQpDelta: i32,
12194}
12195
12196#[derive(Clone, Copy)]
12197#[repr(C)]
12198pub struct VkVideoEncodeH264RateControlInfoKHR {
12199    pub sType: VkStructureType,
12200    pub pNext: *const c_void,
12201    pub flags: VkVideoEncodeH264RateControlFlagsKHR,
12202    pub gopFrameCount: u32,
12203    pub idrPeriod: u32,
12204    pub consecutiveBFrameCount: u32,
12205    pub temporalLayerCount: u32,
12206}
12207
12208#[derive(Clone, Copy)]
12209#[repr(C)]
12210pub struct VkVideoEncodeH264RateControlLayerInfoKHR {
12211    pub sType: VkStructureType,
12212    pub pNext: *const c_void,
12213    pub useMinQp: VkBool32,
12214    pub minQp: VkVideoEncodeH264QpKHR,
12215    pub useMaxQp: VkBool32,
12216    pub maxQp: VkVideoEncodeH264QpKHR,
12217    pub useMaxFrameSize: VkBool32,
12218    pub maxFrameSize: VkVideoEncodeH264FrameSizeKHR,
12219}
12220
12221#[derive(Clone, Copy)]
12222#[repr(C)]
12223pub struct VkVideoEncodeH264SessionCreateInfoKHR {
12224    pub sType: VkStructureType,
12225    pub pNext: *const c_void,
12226    pub useMaxLevelIdc: VkBool32,
12227    pub maxLevelIdc: StdVideoH264LevelIdc,
12228}
12229
12230#[derive(Clone, Copy)]
12231#[repr(C)]
12232pub struct VkVideoEncodeH264SessionParametersAddInfoKHR {
12233    pub sType: VkStructureType,
12234    pub pNext: *const c_void,
12235    pub stdSPSCount: u32,
12236    pub pStdSPSs: *const StdVideoH264SequenceParameterSet,
12237    pub stdPPSCount: u32,
12238    pub pStdPPSs: *const StdVideoH264PictureParameterSet,
12239}
12240
12241#[derive(Clone, Copy)]
12242#[repr(C)]
12243pub struct VkVideoEncodeH264SessionParametersCreateInfoKHR {
12244    pub sType: VkStructureType,
12245    pub pNext: *const c_void,
12246    pub maxStdSPSCount: u32,
12247    pub maxStdPPSCount: u32,
12248    pub pParametersAddInfo: *const VkVideoEncodeH264SessionParametersAddInfoKHR,
12249}
12250
12251#[derive(Clone, Copy)]
12252#[repr(C)]
12253pub struct VkVideoEncodeH264SessionParametersFeedbackInfoKHR {
12254    pub sType: VkStructureType,
12255    pub pNext: *mut c_void,
12256    pub hasStdSPSOverrides: VkBool32,
12257    pub hasStdPPSOverrides: VkBool32,
12258}
12259
12260#[derive(Clone, Copy)]
12261#[repr(C)]
12262pub struct VkVideoEncodeH264SessionParametersGetInfoKHR {
12263    pub sType: VkStructureType,
12264    pub pNext: *const c_void,
12265    pub writeStdSPS: VkBool32,
12266    pub writeStdPPS: VkBool32,
12267    pub stdSPSId: u32,
12268    pub stdPPSId: u32,
12269}
12270
12271#[derive(Clone, Copy)]
12272#[repr(C)]
12273pub struct VkVideoEncodeH265CapabilitiesKHR {
12274    pub sType: VkStructureType,
12275    pub pNext: *mut c_void,
12276    pub flags: VkVideoEncodeH265CapabilityFlagsKHR,
12277    pub maxLevelIdc: StdVideoH265LevelIdc,
12278    pub maxSliceSegmentCount: u32,
12279    pub maxTiles: VkExtent2D,
12280    pub ctbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
12281    pub transformBlockSizes: VkVideoEncodeH265TransformBlockSizeFlagsKHR,
12282    pub maxPPictureL0ReferenceCount: u32,
12283    pub maxBPictureL0ReferenceCount: u32,
12284    pub maxL1ReferenceCount: u32,
12285    pub maxSubLayerCount: u32,
12286    pub expectDyadicTemporalSubLayerPattern: VkBool32,
12287    pub minQp: i32,
12288    pub maxQp: i32,
12289    pub prefersGopRemainingFrames: VkBool32,
12290    pub requiresGopRemainingFrames: VkBool32,
12291    pub stdSyntaxFlags: VkVideoEncodeH265StdFlagsKHR,
12292}
12293
12294#[derive(Clone, Copy)]
12295#[repr(C)]
12296pub struct VkVideoEncodeH265DpbSlotInfoKHR {
12297    pub sType: VkStructureType,
12298    pub pNext: *const c_void,
12299    pub pStdReferenceInfo: *const StdVideoEncodeH265ReferenceInfo,
12300}
12301
12302#[derive(Clone, Copy)]
12303#[repr(C)]
12304pub struct VkVideoEncodeH265FrameSizeKHR {
12305    pub frameISize: u32,
12306    pub framePSize: u32,
12307    pub frameBSize: u32,
12308}
12309
12310#[derive(Clone, Copy)]
12311#[repr(C)]
12312pub struct VkVideoEncodeH265GopRemainingFrameInfoKHR {
12313    pub sType: VkStructureType,
12314    pub pNext: *const c_void,
12315    pub useGopRemainingFrames: VkBool32,
12316    pub gopRemainingI: u32,
12317    pub gopRemainingP: u32,
12318    pub gopRemainingB: u32,
12319}
12320
12321#[derive(Clone, Copy)]
12322#[repr(C)]
12323pub struct VkVideoEncodeH265NaluSliceSegmentInfoKHR {
12324    pub sType: VkStructureType,
12325    pub pNext: *const c_void,
12326    pub constantQp: i32,
12327    pub pStdSliceSegmentHeader: *const StdVideoEncodeH265SliceSegmentHeader,
12328}
12329
12330#[derive(Clone, Copy)]
12331#[repr(C)]
12332pub struct VkVideoEncodeH265PictureInfoKHR {
12333    pub sType: VkStructureType,
12334    pub pNext: *const c_void,
12335    pub naluSliceSegmentEntryCount: u32,
12336    pub pNaluSliceSegmentEntries: *const VkVideoEncodeH265NaluSliceSegmentInfoKHR,
12337    pub pStdPictureInfo: *const StdVideoEncodeH265PictureInfo,
12338}
12339
12340#[derive(Clone, Copy)]
12341#[repr(C)]
12342pub struct VkVideoEncodeH265ProfileInfoKHR {
12343    pub sType: VkStructureType,
12344    pub pNext: *const c_void,
12345    pub stdProfileIdc: StdVideoH265ProfileIdc,
12346}
12347
12348#[derive(Clone, Copy)]
12349#[repr(C)]
12350pub struct VkVideoEncodeH265QpKHR {
12351    pub qpI: i32,
12352    pub qpP: i32,
12353    pub qpB: i32,
12354}
12355
12356#[derive(Clone, Copy)]
12357#[repr(C)]
12358pub struct VkVideoEncodeH265QualityLevelPropertiesKHR {
12359    pub sType: VkStructureType,
12360    pub pNext: *mut c_void,
12361    pub preferredRateControlFlags: VkVideoEncodeH265RateControlFlagsKHR,
12362    pub preferredGopFrameCount: u32,
12363    pub preferredIdrPeriod: u32,
12364    pub preferredConsecutiveBFrameCount: u32,
12365    pub preferredSubLayerCount: u32,
12366    pub preferredConstantQp: VkVideoEncodeH265QpKHR,
12367    pub preferredMaxL0ReferenceCount: u32,
12368    pub preferredMaxL1ReferenceCount: u32,
12369}
12370
12371#[derive(Clone, Copy)]
12372#[repr(C)]
12373pub struct VkVideoEncodeH265QuantizationMapCapabilitiesKHR {
12374    pub sType: VkStructureType,
12375    pub pNext: *mut c_void,
12376    pub minQpDelta: i32,
12377    pub maxQpDelta: i32,
12378}
12379
12380#[derive(Clone, Copy)]
12381#[repr(C)]
12382pub struct VkVideoEncodeH265RateControlInfoKHR {
12383    pub sType: VkStructureType,
12384    pub pNext: *const c_void,
12385    pub flags: VkVideoEncodeH265RateControlFlagsKHR,
12386    pub gopFrameCount: u32,
12387    pub idrPeriod: u32,
12388    pub consecutiveBFrameCount: u32,
12389    pub subLayerCount: u32,
12390}
12391
12392#[derive(Clone, Copy)]
12393#[repr(C)]
12394pub struct VkVideoEncodeH265RateControlLayerInfoKHR {
12395    pub sType: VkStructureType,
12396    pub pNext: *const c_void,
12397    pub useMinQp: VkBool32,
12398    pub minQp: VkVideoEncodeH265QpKHR,
12399    pub useMaxQp: VkBool32,
12400    pub maxQp: VkVideoEncodeH265QpKHR,
12401    pub useMaxFrameSize: VkBool32,
12402    pub maxFrameSize: VkVideoEncodeH265FrameSizeKHR,
12403}
12404
12405#[derive(Clone, Copy)]
12406#[repr(C)]
12407pub struct VkVideoEncodeH265SessionCreateInfoKHR {
12408    pub sType: VkStructureType,
12409    pub pNext: *const c_void,
12410    pub useMaxLevelIdc: VkBool32,
12411    pub maxLevelIdc: StdVideoH265LevelIdc,
12412}
12413
12414#[derive(Clone, Copy)]
12415#[repr(C)]
12416pub struct VkVideoEncodeH265SessionParametersAddInfoKHR {
12417    pub sType: VkStructureType,
12418    pub pNext: *const c_void,
12419    pub stdVPSCount: u32,
12420    pub pStdVPSs: *const StdVideoH265VideoParameterSet,
12421    pub stdSPSCount: u32,
12422    pub pStdSPSs: *const StdVideoH265SequenceParameterSet,
12423    pub stdPPSCount: u32,
12424    pub pStdPPSs: *const StdVideoH265PictureParameterSet,
12425}
12426
12427#[derive(Clone, Copy)]
12428#[repr(C)]
12429pub struct VkVideoEncodeH265SessionParametersCreateInfoKHR {
12430    pub sType: VkStructureType,
12431    pub pNext: *const c_void,
12432    pub maxStdVPSCount: u32,
12433    pub maxStdSPSCount: u32,
12434    pub maxStdPPSCount: u32,
12435    pub pParametersAddInfo: *const VkVideoEncodeH265SessionParametersAddInfoKHR,
12436}
12437
12438#[derive(Clone, Copy)]
12439#[repr(C)]
12440pub struct VkVideoEncodeH265SessionParametersFeedbackInfoKHR {
12441    pub sType: VkStructureType,
12442    pub pNext: *mut c_void,
12443    pub hasStdVPSOverrides: VkBool32,
12444    pub hasStdSPSOverrides: VkBool32,
12445    pub hasStdPPSOverrides: VkBool32,
12446}
12447
12448#[derive(Clone, Copy)]
12449#[repr(C)]
12450pub struct VkVideoEncodeH265SessionParametersGetInfoKHR {
12451    pub sType: VkStructureType,
12452    pub pNext: *const c_void,
12453    pub writeStdVPS: VkBool32,
12454    pub writeStdSPS: VkBool32,
12455    pub writeStdPPS: VkBool32,
12456    pub stdVPSId: u32,
12457    pub stdSPSId: u32,
12458    pub stdPPSId: u32,
12459}
12460
12461#[derive(Clone, Copy)]
12462#[repr(C)]
12463pub struct VkVideoEncodeInfoKHR {
12464    pub sType: VkStructureType,
12465    pub pNext: *const c_void,
12466    pub flags: VkVideoEncodeFlagsKHR,
12467    pub dstBuffer: VkBuffer,
12468    pub dstBufferOffset: VkDeviceSize,
12469    pub dstBufferRange: VkDeviceSize,
12470    pub srcPictureResource: VkVideoPictureResourceInfoKHR,
12471    pub pSetupReferenceSlot: *const VkVideoReferenceSlotInfoKHR,
12472    pub referenceSlotCount: u32,
12473    pub pReferenceSlots: *const VkVideoReferenceSlotInfoKHR,
12474    pub precedingExternallyEncodedBytes: u32,
12475}
12476
12477#[derive(Clone, Copy)]
12478#[repr(C)]
12479pub struct VkVideoEncodeIntraRefreshCapabilitiesKHR {
12480    pub sType: VkStructureType,
12481    pub pNext: *mut c_void,
12482    pub intraRefreshModes: VkVideoEncodeIntraRefreshModeFlagsKHR,
12483    pub maxIntraRefreshCycleDuration: u32,
12484    pub maxIntraRefreshActiveReferencePictures: u32,
12485    pub partitionIndependentIntraRefreshRegions: VkBool32,
12486    pub nonRectangularIntraRefreshRegions: VkBool32,
12487}
12488
12489#[derive(Clone, Copy)]
12490#[repr(C)]
12491pub struct VkVideoEncodeIntraRefreshInfoKHR {
12492    pub sType: VkStructureType,
12493    pub pNext: *const c_void,
12494    pub intraRefreshCycleDuration: u32,
12495    pub intraRefreshIndex: u32,
12496}
12497
12498#[derive(Clone, Copy)]
12499#[repr(C)]
12500pub struct VkVideoEncodeProfileRgbConversionInfoVALVE {
12501    pub sType: VkStructureType,
12502    pub pNext: *const c_void,
12503    pub performEncodeRgbConversion: VkBool32,
12504}
12505
12506#[derive(Clone, Copy)]
12507#[repr(C)]
12508pub struct VkVideoEncodeQualityLevelInfoKHR {
12509    pub sType: VkStructureType,
12510    pub pNext: *const c_void,
12511    pub qualityLevel: u32,
12512}
12513
12514#[derive(Clone, Copy)]
12515#[repr(C)]
12516pub struct VkVideoEncodeQualityLevelPropertiesKHR {
12517    pub sType: VkStructureType,
12518    pub pNext: *mut c_void,
12519    pub preferredRateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
12520    pub preferredRateControlLayerCount: u32,
12521}
12522
12523#[derive(Clone, Copy)]
12524#[repr(C)]
12525pub struct VkVideoEncodeQuantizationMapCapabilitiesKHR {
12526    pub sType: VkStructureType,
12527    pub pNext: *mut c_void,
12528    pub maxQuantizationMapExtent: VkExtent2D,
12529}
12530
12531#[derive(Clone, Copy)]
12532#[repr(C)]
12533pub struct VkVideoEncodeQuantizationMapInfoKHR {
12534    pub sType: VkStructureType,
12535    pub pNext: *const c_void,
12536    pub quantizationMap: VkImageView,
12537    pub quantizationMapExtent: VkExtent2D,
12538}
12539
12540#[derive(Clone, Copy)]
12541#[repr(C)]
12542pub struct VkVideoEncodeQuantizationMapSessionParametersCreateInfoKHR {
12543    pub sType: VkStructureType,
12544    pub pNext: *const c_void,
12545    pub quantizationMapTexelSize: VkExtent2D,
12546}
12547
12548#[derive(Clone, Copy)]
12549#[repr(C)]
12550pub struct VkVideoEncodeRateControlInfoKHR {
12551    pub sType: VkStructureType,
12552    pub pNext: *const c_void,
12553    pub flags: VkVideoEncodeRateControlFlagsKHR,
12554    pub rateControlMode: VkVideoEncodeRateControlModeFlagBitsKHR,
12555    pub layerCount: u32,
12556    pub pLayers: *const VkVideoEncodeRateControlLayerInfoKHR,
12557    pub virtualBufferSizeInMs: u32,
12558    pub initialVirtualBufferSizeInMs: u32,
12559}
12560
12561#[derive(Clone, Copy)]
12562#[repr(C)]
12563pub struct VkVideoEncodeRateControlLayerInfoKHR {
12564    pub sType: VkStructureType,
12565    pub pNext: *const c_void,
12566    pub averageBitrate: u64,
12567    pub maxBitrate: u64,
12568    pub frameRateNumerator: u32,
12569    pub frameRateDenominator: u32,
12570}
12571
12572#[derive(Clone, Copy)]
12573#[repr(C)]
12574pub struct VkVideoEncodeRgbConversionCapabilitiesVALVE {
12575    pub sType: VkStructureType,
12576    pub pNext: *mut c_void,
12577    pub rgbModels: VkVideoEncodeRgbModelConversionFlagsVALVE,
12578    pub rgbRanges: VkVideoEncodeRgbRangeCompressionFlagsVALVE,
12579    pub xChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
12580    pub yChromaOffsets: VkVideoEncodeRgbChromaOffsetFlagsVALVE,
12581}
12582
12583#[derive(Clone, Copy)]
12584#[repr(C)]
12585pub struct VkVideoEncodeSessionIntraRefreshCreateInfoKHR {
12586    pub sType: VkStructureType,
12587    pub pNext: *const c_void,
12588    pub intraRefreshMode: VkVideoEncodeIntraRefreshModeFlagBitsKHR,
12589}
12590
12591#[derive(Clone, Copy)]
12592#[repr(C)]
12593pub struct VkVideoEncodeSessionParametersFeedbackInfoKHR {
12594    pub sType: VkStructureType,
12595    pub pNext: *mut c_void,
12596    pub hasOverrides: VkBool32,
12597}
12598
12599#[derive(Clone, Copy)]
12600#[repr(C)]
12601pub struct VkVideoEncodeSessionParametersGetInfoKHR {
12602    pub sType: VkStructureType,
12603    pub pNext: *const c_void,
12604    pub videoSessionParameters: VkVideoSessionParametersKHR,
12605}
12606
12607#[derive(Clone, Copy)]
12608#[repr(C)]
12609pub struct VkVideoEncodeSessionRgbConversionCreateInfoVALVE {
12610    pub sType: VkStructureType,
12611    pub pNext: *const c_void,
12612    pub rgbModel: VkVideoEncodeRgbModelConversionFlagBitsVALVE,
12613    pub rgbRange: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE,
12614    pub xChromaOffset: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE,
12615    pub yChromaOffset: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE,
12616}
12617
12618#[derive(Clone, Copy)]
12619#[repr(C)]
12620pub struct VkVideoEncodeUsageInfoKHR {
12621    pub sType: VkStructureType,
12622    pub pNext: *const c_void,
12623    pub videoUsageHints: VkVideoEncodeUsageFlagsKHR,
12624    pub videoContentHints: VkVideoEncodeContentFlagsKHR,
12625    pub tuningMode: VkVideoEncodeTuningModeKHR,
12626}
12627
12628#[derive(Clone, Copy)]
12629#[repr(C)]
12630pub struct VkVideoEndCodingInfoKHR {
12631    pub sType: VkStructureType,
12632    pub pNext: *const c_void,
12633    pub flags: VkVideoEndCodingFlagsKHR,
12634}
12635
12636#[derive(Clone, Copy)]
12637#[repr(C)]
12638pub struct VkVideoFormatAV1QuantizationMapPropertiesKHR {
12639    pub sType: VkStructureType,
12640    pub pNext: *mut c_void,
12641    pub compatibleSuperblockSizes: VkVideoEncodeAV1SuperblockSizeFlagsKHR,
12642}
12643
12644#[derive(Clone, Copy)]
12645#[repr(C)]
12646pub struct VkVideoFormatH265QuantizationMapPropertiesKHR {
12647    pub sType: VkStructureType,
12648    pub pNext: *mut c_void,
12649    pub compatibleCtbSizes: VkVideoEncodeH265CtbSizeFlagsKHR,
12650}
12651
12652#[derive(Clone, Copy)]
12653#[repr(C)]
12654pub struct VkVideoFormatPropertiesKHR {
12655    pub sType: VkStructureType,
12656    pub pNext: *mut c_void,
12657    pub format: VkFormat,
12658    pub componentMapping: VkComponentMapping,
12659    pub imageCreateFlags: VkImageCreateFlags,
12660    pub imageType: VkImageType,
12661    pub imageTiling: VkImageTiling,
12662    pub imageUsageFlags: VkImageUsageFlags,
12663}
12664
12665#[derive(Clone, Copy)]
12666#[repr(C)]
12667pub struct VkVideoFormatQuantizationMapPropertiesKHR {
12668    pub sType: VkStructureType,
12669    pub pNext: *mut c_void,
12670    pub quantizationMapTexelSize: VkExtent2D,
12671}
12672
12673#[derive(Clone, Copy)]
12674#[repr(C)]
12675pub struct VkVideoInlineQueryInfoKHR {
12676    pub sType: VkStructureType,
12677    pub pNext: *const c_void,
12678    pub queryPool: VkQueryPool,
12679    pub firstQuery: u32,
12680    pub queryCount: u32,
12681}
12682
12683#[derive(Clone, Copy)]
12684#[repr(C)]
12685pub struct VkVideoPictureResourceInfoKHR {
12686    pub sType: VkStructureType,
12687    pub pNext: *const c_void,
12688    pub codedOffset: VkOffset2D,
12689    pub codedExtent: VkExtent2D,
12690    pub baseArrayLayer: u32,
12691    pub imageViewBinding: VkImageView,
12692}
12693
12694#[derive(Clone, Copy)]
12695#[repr(C)]
12696pub struct VkVideoProfileInfoKHR {
12697    pub sType: VkStructureType,
12698    pub pNext: *const c_void,
12699    pub videoCodecOperation: VkVideoCodecOperationFlagBitsKHR,
12700    pub chromaSubsampling: VkVideoChromaSubsamplingFlagsKHR,
12701    pub lumaBitDepth: VkVideoComponentBitDepthFlagsKHR,
12702    pub chromaBitDepth: VkVideoComponentBitDepthFlagsKHR,
12703}
12704
12705#[derive(Clone, Copy)]
12706#[repr(C)]
12707pub struct VkVideoProfileListInfoKHR {
12708    pub sType: VkStructureType,
12709    pub pNext: *const c_void,
12710    pub profileCount: u32,
12711    pub pProfiles: *const VkVideoProfileInfoKHR,
12712}
12713
12714#[derive(Clone, Copy)]
12715#[repr(C)]
12716pub struct VkVideoReferenceIntraRefreshInfoKHR {
12717    pub sType: VkStructureType,
12718    pub pNext: *const c_void,
12719    pub dirtyIntraRefreshRegions: u32,
12720}
12721
12722#[derive(Clone, Copy)]
12723#[repr(C)]
12724pub struct VkVideoReferenceSlotInfoKHR {
12725    pub sType: VkStructureType,
12726    pub pNext: *const c_void,
12727    pub slotIndex: i32,
12728    pub pPictureResource: *const VkVideoPictureResourceInfoKHR,
12729}
12730
12731#[derive(Clone, Copy)]
12732#[repr(C)]
12733pub struct VkVideoSessionCreateInfoKHR {
12734    pub sType: VkStructureType,
12735    pub pNext: *const c_void,
12736    pub queueFamilyIndex: u32,
12737    pub flags: VkVideoSessionCreateFlagsKHR,
12738    pub pVideoProfile: *const VkVideoProfileInfoKHR,
12739    pub pictureFormat: VkFormat,
12740    pub maxCodedExtent: VkExtent2D,
12741    pub referencePictureFormat: VkFormat,
12742    pub maxDpbSlots: u32,
12743    pub maxActiveReferencePictures: u32,
12744    pub pStdHeaderVersion: *const VkExtensionProperties,
12745}
12746
12747#[repr(C)]
12748pub struct VkVideoSessionKHR_T {
12749    _data: (),
12750    _marker: PhantomData<(*mut u8, PhantomPinned)>,
12751}
12752
12753#[derive(Clone, Copy)]
12754#[repr(C)]
12755pub struct VkVideoSessionMemoryRequirementsKHR {
12756    pub sType: VkStructureType,
12757    pub pNext: *mut c_void,
12758    pub memoryBindIndex: u32,
12759    pub memoryRequirements: VkMemoryRequirements,
12760}
12761
12762#[derive(Clone, Copy)]
12763#[repr(C)]
12764pub struct VkVideoSessionParametersCreateInfoKHR {
12765    pub sType: VkStructureType,
12766    pub pNext: *const c_void,
12767    pub flags: VkVideoSessionParametersCreateFlagsKHR,
12768    pub videoSessionParametersTemplate: VkVideoSessionParametersKHR,
12769    pub videoSession: VkVideoSessionKHR,
12770}
12771
12772#[repr(C)]
12773pub struct VkVideoSessionParametersKHR_T {
12774    _data: (),
12775    _marker: PhantomData<(*mut u8, PhantomPinned)>,
12776}
12777
12778#[derive(Clone, Copy)]
12779#[repr(C)]
12780pub struct VkVideoSessionParametersUpdateInfoKHR {
12781    pub sType: VkStructureType,
12782    pub pNext: *const c_void,
12783    pub updateSequenceCount: u32,
12784}
12785
12786#[derive(Clone, Copy)]
12787#[repr(C)]
12788pub struct VkViewport {
12789    pub x: f32,
12790    pub y: f32,
12791    pub width: f32,
12792    pub height: f32,
12793    pub minDepth: f32,
12794    pub maxDepth: f32,
12795}
12796
12797#[derive(Clone, Copy)]
12798#[repr(C)]
12799pub struct VkViewportSwizzleNV {
12800    pub x: VkViewportCoordinateSwizzleNV,
12801    pub y: VkViewportCoordinateSwizzleNV,
12802    pub z: VkViewportCoordinateSwizzleNV,
12803    pub w: VkViewportCoordinateSwizzleNV,
12804}
12805
12806#[derive(Clone, Copy)]
12807#[repr(C)]
12808pub struct VkViewportWScalingNV {
12809    pub xcoeff: f32,
12810    pub ycoeff: f32,
12811}
12812
12813#[derive(Clone, Copy)]
12814#[repr(C)]
12815pub struct VkWriteDescriptorSet {
12816    pub sType: VkStructureType,
12817    pub pNext: *const c_void,
12818    pub dstSet: VkDescriptorSet,
12819    pub dstBinding: u32,
12820    pub dstArrayElement: u32,
12821    pub descriptorCount: u32,
12822    pub descriptorType: VkDescriptorType,
12823    pub pImageInfo: *const VkDescriptorImageInfo,
12824    pub pBufferInfo: *const VkDescriptorBufferInfo,
12825    pub pTexelBufferView: *const VkBufferView,
12826}
12827
12828#[derive(Clone, Copy)]
12829#[repr(C)]
12830pub struct VkWriteDescriptorSetAccelerationStructureKHR {
12831    pub sType: VkStructureType,
12832    pub pNext: *const c_void,
12833    pub accelerationStructureCount: u32,
12834    pub pAccelerationStructures: *const VkAccelerationStructureKHR,
12835}
12836
12837#[derive(Clone, Copy)]
12838#[repr(C)]
12839pub struct VkWriteDescriptorSetAccelerationStructureNV {
12840    pub sType: VkStructureType,
12841    pub pNext: *const c_void,
12842    pub accelerationStructureCount: u32,
12843    pub pAccelerationStructures: *const VkAccelerationStructureNV,
12844}
12845
12846#[derive(Clone, Copy)]
12847#[repr(C)]
12848pub struct VkWriteDescriptorSetInlineUniformBlock {
12849    pub sType: VkStructureType,
12850    pub pNext: *const c_void,
12851    pub dataSize: u32,
12852    pub pData: *const c_void,
12853}
12854
12855#[derive(Clone, Copy)]
12856#[repr(C)]
12857pub struct VkWriteDescriptorSetPartitionedAccelerationStructureNV {
12858    pub sType: VkStructureType,
12859    pub pNext: *mut c_void,
12860    pub accelerationStructureCount: u32,
12861    pub pAccelerationStructures: *const VkDeviceAddress,
12862}
12863
12864#[derive(Clone, Copy)]
12865#[repr(C)]
12866pub struct VkWriteDescriptorSetTensorARM {
12867    pub sType: VkStructureType,
12868    pub pNext: *const c_void,
12869    pub tensorViewCount: u32,
12870    pub pTensorViews: *const VkTensorViewARM,
12871}
12872
12873#[derive(Clone, Copy)]
12874#[repr(C)]
12875pub struct VkWriteIndirectExecutionSetPipelineEXT {
12876    pub sType: VkStructureType,
12877    pub pNext: *const c_void,
12878    pub index: u32,
12879    pub pipeline: VkPipeline,
12880}
12881
12882#[derive(Clone, Copy)]
12883#[repr(C)]
12884pub struct VkWriteIndirectExecutionSetShaderEXT {
12885    pub sType: VkStructureType,
12886    pub pNext: *const c_void,
12887    pub index: u32,
12888    pub shader: VkShaderEXT,
12889}
12890
12891#[derive(Clone, Copy)]
12892#[repr(C)]
12893pub struct VkXYColorEXT {
12894    pub x: f32,
12895    pub y: f32,
12896}
12897
12898pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = 1;
12899pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR: VkAccelerationStructureBuildTypeKHR = 0;
12900pub const VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR: VkAccelerationStructureBuildTypeKHR = 2;
12901pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = 0;
12902pub const VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR: VkAccelerationStructureCompatibilityKHR = 1;
12903pub const VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkAccelerationStructureCreateFlagBitsKHR = 1 << 3;
12904pub const VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkAccelerationStructureCreateFlagBitsKHR = 1 << 0;
12905pub const VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV: VkAccelerationStructureCreateFlagBitsKHR = 1 << 2;
12906pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 1;
12907pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 0;
12908pub const VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV: VkAccelerationStructureMemoryRequirementsTypeNV = 2;
12909pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = 1;
12910pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV: VkAccelerationStructureMotionInstanceTypeNV = 2;
12911pub const VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV: VkAccelerationStructureMotionInstanceTypeNV = 0;
12912pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR: VkAccelerationStructureTypeKHR = 1;
12913pub const VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR;
12914pub const VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR: VkAccelerationStructureTypeKHR = 2;
12915pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR: VkAccelerationStructureTypeKHR = 0;
12916pub const VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV: VkAccelerationStructureTypeKHR = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR;
12917pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 21;
12918pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR;
12919pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 22;
12920pub const VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
12921pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 7;
12922pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT;
12923pub const VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlagBits2 = 1 << 19;
12924pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2 = 1 << 8;
12925pub const VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT;
12926pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 17;
12927pub const VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_EXT;
12928pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 18;
12929pub const VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_EXT;
12930pub const VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 20;
12931pub const VK_ACCESS_2_DATA_GRAPH_READ_BIT_ARM: VkAccessFlagBits2 = 1 << 47;
12932pub const VK_ACCESS_2_DATA_GRAPH_WRITE_BIT_ARM: VkAccessFlagBits2 = 1 << 48;
12933pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 9;
12934pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
12935pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits2 = 1 << 10;
12936pub const VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
12937pub const VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 41;
12938pub const VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 24;
12939pub const VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 23;
12940pub const VK_ACCESS_2_HOST_READ_BIT: VkAccessFlagBits2 = 1 << 13;
12941pub const VK_ACCESS_2_HOST_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_HOST_READ_BIT;
12942pub const VK_ACCESS_2_HOST_WRITE_BIT: VkAccessFlagBits2 = 1 << 14;
12943pub const VK_ACCESS_2_HOST_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_HOST_WRITE_BIT;
12944pub const VK_ACCESS_2_INDEX_READ_BIT: VkAccessFlagBits2 = 1 << 1;
12945pub const VK_ACCESS_2_INDEX_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INDEX_READ_BIT;
12946pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits2 = 1 << 0;
12947pub const VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT;
12948pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits2 = 1 << 4;
12949pub const VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT;
12950pub const VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI: VkAccessFlagBits2 = 1 << 39;
12951pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 55;
12952pub const VK_ACCESS_2_MEMORY_DECOMPRESSION_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 56;
12953pub const VK_ACCESS_2_MEMORY_READ_BIT: VkAccessFlagBits2 = 1 << 15;
12954pub const VK_ACCESS_2_MEMORY_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_MEMORY_READ_BIT;
12955pub const VK_ACCESS_2_MEMORY_WRITE_BIT: VkAccessFlagBits2 = 1 << 16;
12956pub const VK_ACCESS_2_MEMORY_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_MEMORY_WRITE_BIT;
12957pub const VK_ACCESS_2_MICROMAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 44;
12958pub const VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 45;
12959pub const VK_ACCESS_2_NONE: VkAccessFlagBits2 = 0;
12960pub const VK_ACCESS_2_NONE_KHR: VkAccessFlagBits2 = VK_ACCESS_2_NONE;
12961pub const VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV: VkAccessFlagBits2 = 1 << 42;
12962pub const VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV: VkAccessFlagBits2 = 1 << 43;
12963pub const VK_ACCESS_2_RESOURCE_HEAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 58;
12964pub const VK_ACCESS_2_SAMPLER_HEAP_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 57;
12965pub const VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 40;
12966pub const VK_ACCESS_2_SHADER_READ_BIT: VkAccessFlagBits2 = 1 << 5;
12967pub const VK_ACCESS_2_SHADER_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_READ_BIT;
12968pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT: VkAccessFlagBits2 = 1 << 32;
12969pub const VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_SAMPLED_READ_BIT;
12970pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT: VkAccessFlagBits2 = 1 << 33;
12971pub const VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_STORAGE_READ_BIT;
12972pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT: VkAccessFlagBits2 = 1 << 34;
12973pub const VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT;
12974pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_READ_BIT_QCOM: VkAccessFlagBits2 = 1 << 51;
12975pub const VK_ACCESS_2_SHADER_TILE_ATTACHMENT_WRITE_BIT_QCOM: VkAccessFlagBits2 = 1 << 52;
12976pub const VK_ACCESS_2_SHADER_WRITE_BIT: VkAccessFlagBits2 = 1 << 6;
12977pub const VK_ACCESS_2_SHADER_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_SHADER_WRITE_BIT;
12978pub const VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlagBits2 = VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
12979pub const VK_ACCESS_2_TRANSFER_READ_BIT: VkAccessFlagBits2 = 1 << 11;
12980pub const VK_ACCESS_2_TRANSFER_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_TRANSFER_READ_BIT;
12981pub const VK_ACCESS_2_TRANSFER_WRITE_BIT: VkAccessFlagBits2 = 1 << 12;
12982pub const VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_TRANSFER_WRITE_BIT;
12983pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlagBits2 = 1 << 26;
12984pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 27;
12985pub const VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlagBits2 = 1 << 25;
12986pub const VK_ACCESS_2_UNIFORM_READ_BIT: VkAccessFlagBits2 = 1 << 3;
12987pub const VK_ACCESS_2_UNIFORM_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_UNIFORM_READ_BIT;
12988pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits2 = 1 << 2;
12989pub const VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR: VkAccessFlagBits2 = VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT;
12990pub const VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 35;
12991pub const VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 36;
12992pub const VK_ACCESS_2_VIDEO_ENCODE_READ_BIT_KHR: VkAccessFlagBits2 = 1 << 37;
12993pub const VK_ACCESS_2_VIDEO_ENCODE_WRITE_BIT_KHR: VkAccessFlagBits2 = 1 << 38;
12994pub const VK_ACCESS_3_NONE_KHR: VkAccessFlagBits3KHR = 0;
12995pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR: VkAccessFlagBits = 1 << 21;
12996pub const VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR;
12997pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR: VkAccessFlagBits = 1 << 22;
12998pub const VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV: VkAccessFlagBits = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR;
12999pub const VK_ACCESS_COLOR_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 7;
13000pub const VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT: VkAccessFlagBits = 1 << 19;
13001pub const VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 1 << 8;
13002pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT: VkAccessFlagBits = 1 << 17;
13003pub const VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_EXT;
13004pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 18;
13005pub const VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV: VkAccessFlagBits = VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_EXT;
13006pub const VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT: VkAccessFlagBits = 1 << 20;
13007pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 9;
13008pub const VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT: VkAccessFlagBits = 1 << 10;
13009pub const VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT: VkAccessFlagBits = 1 << 24;
13010pub const VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR: VkAccessFlagBits = 1 << 23;
13011pub const VK_ACCESS_HOST_READ_BIT: VkAccessFlagBits = 1 << 13;
13012pub const VK_ACCESS_HOST_WRITE_BIT: VkAccessFlagBits = 1 << 14;
13013pub const VK_ACCESS_INDEX_READ_BIT: VkAccessFlagBits = 1 << 1;
13014pub const VK_ACCESS_INDIRECT_COMMAND_READ_BIT: VkAccessFlagBits = 1 << 0;
13015pub const VK_ACCESS_INPUT_ATTACHMENT_READ_BIT: VkAccessFlagBits = 1 << 4;
13016pub const VK_ACCESS_MEMORY_READ_BIT: VkAccessFlagBits = 1 << 15;
13017pub const VK_ACCESS_MEMORY_WRITE_BIT: VkAccessFlagBits = 1 << 16;
13018pub const VK_ACCESS_NONE: VkAccessFlagBits = 0;
13019pub const VK_ACCESS_NONE_KHR: VkAccessFlagBits = VK_ACCESS_NONE;
13020pub const VK_ACCESS_SHADER_READ_BIT: VkAccessFlagBits = 1 << 5;
13021pub const VK_ACCESS_SHADER_WRITE_BIT: VkAccessFlagBits = 1 << 6;
13022pub const VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV: VkAccessFlagBits = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR;
13023pub const VK_ACCESS_TRANSFER_READ_BIT: VkAccessFlagBits = 1 << 11;
13024pub const VK_ACCESS_TRANSFER_WRITE_BIT: VkAccessFlagBits = 1 << 12;
13025pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT: VkAccessFlagBits = 1 << 26;
13026pub const VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 27;
13027pub const VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT: VkAccessFlagBits = 1 << 25;
13028pub const VK_ACCESS_UNIFORM_READ_BIT: VkAccessFlagBits = 1 << 3;
13029pub const VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT: VkAccessFlagBits = 1 << 2;
13030pub const VK_ADDRESS_COPY_DEVICE_LOCAL_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 0;
13031pub const VK_ADDRESS_COPY_PROTECTED_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 2;
13032pub const VK_ADDRESS_COPY_SPARSE_BIT_KHR: VkAddressCopyFlagBitsKHR = 1 << 1;
13033pub const VK_AMD_ANTI_LAG_EXTENSION_NAME: &CStr = c"VK_AMD_anti_lag";
13034pub const VK_AMD_ANTI_LAG_SPEC_VERSION: u32 = 1;
13035pub const VK_AMD_BUFFER_MARKER_EXTENSION_NAME: &CStr = c"VK_AMD_buffer_marker";
13036pub const VK_AMD_BUFFER_MARKER_SPEC_VERSION: u32 = 1;
13037pub const VK_AMD_DEVICE_COHERENT_MEMORY_EXTENSION_NAME: &CStr = c"VK_AMD_device_coherent_memory";
13038pub const VK_AMD_DEVICE_COHERENT_MEMORY_SPEC_VERSION: u32 = 1;
13039pub const VK_AMD_DISPLAY_NATIVE_HDR_EXTENSION_NAME: &CStr = c"VK_AMD_display_native_hdr";
13040pub const VK_AMD_DISPLAY_NATIVE_HDR_SPEC_VERSION: u32 = 1;
13041pub const VK_AMD_DRAW_INDIRECT_COUNT_EXTENSION_NAME: &CStr = c"VK_AMD_draw_indirect_count";
13042pub const VK_AMD_DRAW_INDIRECT_COUNT_SPEC_VERSION: u32 = 2;
13043pub const VK_AMD_GCN_SHADER_EXTENSION_NAME: &CStr = c"VK_AMD_gcn_shader";
13044pub const VK_AMD_GCN_SHADER_SPEC_VERSION: u32 = 1;
13045pub const VK_AMD_GPU_SHADER_HALF_FLOAT_EXTENSION_NAME: &CStr = c"VK_AMD_gpu_shader_half_float";
13046pub const VK_AMD_GPU_SHADER_HALF_FLOAT_SPEC_VERSION: u32 = 2;
13047pub const VK_AMD_GPU_SHADER_INT16_EXTENSION_NAME: &CStr = c"VK_AMD_gpu_shader_int16";
13048pub const VK_AMD_GPU_SHADER_INT16_SPEC_VERSION: u32 = 2;
13049pub const VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_EXTENSION_NAME: &CStr = c"VK_AMD_memory_overallocation_behavior";
13050pub const VK_AMD_MEMORY_OVERALLOCATION_BEHAVIOR_SPEC_VERSION: u32 = 1;
13051pub const VK_AMD_MIXED_ATTACHMENT_SAMPLES_EXTENSION_NAME: &CStr = c"VK_AMD_mixed_attachment_samples";
13052pub const VK_AMD_MIXED_ATTACHMENT_SAMPLES_SPEC_VERSION: u32 = 1;
13053pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_EXTENSION_NAME: &CStr = c"VK_AMD_negative_viewport_height";
13054pub const VK_AMD_NEGATIVE_VIEWPORT_HEIGHT_SPEC_VERSION: u32 = 1;
13055pub const VK_AMD_PIPELINE_COMPILER_CONTROL_EXTENSION_NAME: &CStr = c"VK_AMD_pipeline_compiler_control";
13056pub const VK_AMD_PIPELINE_COMPILER_CONTROL_SPEC_VERSION: u32 = 1;
13057pub const VK_AMD_RASTERIZATION_ORDER_EXTENSION_NAME: &CStr = c"VK_AMD_rasterization_order";
13058pub const VK_AMD_RASTERIZATION_ORDER_SPEC_VERSION: u32 = 1;
13059pub const VK_AMD_SHADER_BALLOT_EXTENSION_NAME: &CStr = c"VK_AMD_shader_ballot";
13060pub const VK_AMD_SHADER_BALLOT_SPEC_VERSION: u32 = 1;
13061pub const VK_AMD_SHADER_CORE_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_AMD_shader_core_properties2";
13062pub const VK_AMD_SHADER_CORE_PROPERTIES_2_SPEC_VERSION: u32 = 1;
13063pub const VK_AMD_SHADER_CORE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_AMD_shader_core_properties";
13064pub const VK_AMD_SHADER_CORE_PROPERTIES_SPEC_VERSION: u32 = 2;
13065pub const VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_EXTENSION_NAME: &CStr = c"VK_AMD_shader_early_and_late_fragment_tests";
13066pub const VK_AMD_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_SPEC_VERSION: u32 = 1;
13067pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_EXTENSION_NAME: &CStr = c"VK_AMD_shader_explicit_vertex_parameter";
13068pub const VK_AMD_SHADER_EXPLICIT_VERTEX_PARAMETER_SPEC_VERSION: u32 = 1;
13069pub const VK_AMD_SHADER_FRAGMENT_MASK_EXTENSION_NAME: &CStr = c"VK_AMD_shader_fragment_mask";
13070pub const VK_AMD_SHADER_FRAGMENT_MASK_SPEC_VERSION: u32 = 1;
13071pub const VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_EXTENSION_NAME: &CStr = c"VK_AMD_shader_image_load_store_lod";
13072pub const VK_AMD_SHADER_IMAGE_LOAD_STORE_LOD_SPEC_VERSION: u32 = 1;
13073pub const VK_AMD_SHADER_INFO_EXTENSION_NAME: &CStr = c"VK_AMD_shader_info";
13074pub const VK_AMD_SHADER_INFO_SPEC_VERSION: u32 = 1;
13075pub const VK_AMD_SHADER_TRINARY_MINMAX_EXTENSION_NAME: &CStr = c"VK_AMD_shader_trinary_minmax";
13076pub const VK_AMD_SHADER_TRINARY_MINMAX_SPEC_VERSION: u32 = 1;
13077pub const VK_AMD_TEXTURE_GATHER_BIAS_LOD_EXTENSION_NAME: &CStr = c"VK_AMD_texture_gather_bias_lod";
13078pub const VK_AMD_TEXTURE_GATHER_BIAS_LOD_SPEC_VERSION: u32 = 1;
13079pub const VK_ANTI_LAG_MODE_DRIVER_CONTROL_AMD: VkAntiLagModeAMD = 0;
13080pub const VK_ANTI_LAG_MODE_OFF_AMD: VkAntiLagModeAMD = 2;
13081pub const VK_ANTI_LAG_MODE_ON_AMD: VkAntiLagModeAMD = 1;
13082pub const VK_ANTI_LAG_STAGE_INPUT_AMD: VkAntiLagStageAMD = 0;
13083pub const VK_ANTI_LAG_STAGE_PRESENT_AMD: VkAntiLagStageAMD = 1;
13084pub const VK_API_VERSION_1_0: u32 = VK_MAKE_API_VERSION(0, 1, 0, 0);
13085pub const VK_API_VERSION_1_1: u32 = VK_MAKE_API_VERSION(0, 1, 1, 0);
13086pub const VK_API_VERSION_1_2: u32 = VK_MAKE_API_VERSION(0, 1, 2, 0);
13087pub const VK_API_VERSION_1_3: u32 = VK_MAKE_API_VERSION(0, 1, 3, 0);
13088pub const VK_API_VERSION_1_4: u32 = VK_MAKE_API_VERSION(0, 1, 4, 0);
13089pub const VK_ARM_DATA_GRAPH_EXTENSION_NAME: &CStr = c"VK_ARM_data_graph";
13090pub const VK_ARM_DATA_GRAPH_SPEC_VERSION: u32 = 1;
13091pub const VK_ARM_FORMAT_PACK_EXTENSION_NAME: &CStr = c"VK_ARM_format_pack";
13092pub const VK_ARM_FORMAT_PACK_SPEC_VERSION: u32 = 1;
13093pub const VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_EXTENSION_NAME: &CStr = c"VK_ARM_performance_counters_by_region";
13094pub const VK_ARM_PERFORMANCE_COUNTERS_BY_REGION_SPEC_VERSION: u32 = 1;
13095pub const VK_ARM_PIPELINE_OPACITY_MICROMAP_EXTENSION_NAME: &CStr = c"VK_ARM_pipeline_opacity_micromap";
13096pub const VK_ARM_PIPELINE_OPACITY_MICROMAP_SPEC_VERSION: u32 = 1;
13097pub const VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME: &CStr = c"VK_ARM_rasterization_order_attachment_access";
13098pub const VK_ARM_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION: u32 = 1;
13099pub const VK_ARM_RENDER_PASS_STRIPED_EXTENSION_NAME: &CStr = c"VK_ARM_render_pass_striped";
13100pub const VK_ARM_RENDER_PASS_STRIPED_SPEC_VERSION: u32 = 1;
13101pub const VK_ARM_SCHEDULING_CONTROLS_EXTENSION_NAME: &CStr = c"VK_ARM_scheduling_controls";
13102pub const VK_ARM_SCHEDULING_CONTROLS_SPEC_VERSION: u32 = 1;
13103pub const VK_ARM_SHADER_CORE_BUILTINS_EXTENSION_NAME: &CStr = c"VK_ARM_shader_core_builtins";
13104pub const VK_ARM_SHADER_CORE_BUILTINS_SPEC_VERSION: u32 = 2;
13105pub const VK_ARM_SHADER_CORE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_ARM_shader_core_properties";
13106pub const VK_ARM_SHADER_CORE_PROPERTIES_SPEC_VERSION: u32 = 1;
13107pub const VK_ARM_TENSORS_EXTENSION_NAME: &CStr = c"VK_ARM_tensors";
13108pub const VK_ARM_TENSORS_SPEC_VERSION: u32 = 1;
13109pub const VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT: VkAttachmentDescriptionFlagBits = 1 << 0;
13110pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlagBits = 1 << 2;
13111pub const VK_ATTACHMENT_DESCRIPTION_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkAttachmentDescriptionFlagBits = 1 << 1;
13112pub const VK_ATTACHMENT_LOAD_OP_CLEAR: VkAttachmentLoadOp = 1;
13113pub const VK_ATTACHMENT_LOAD_OP_DONT_CARE: VkAttachmentLoadOp = 2;
13114pub const VK_ATTACHMENT_LOAD_OP_LOAD: VkAttachmentLoadOp = 0;
13115pub const VK_ATTACHMENT_LOAD_OP_NONE: VkAttachmentLoadOp = 1000400000;
13116pub const VK_ATTACHMENT_LOAD_OP_NONE_EXT: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;
13117pub const VK_ATTACHMENT_LOAD_OP_NONE_KHR: VkAttachmentLoadOp = VK_ATTACHMENT_LOAD_OP_NONE;
13118pub const VK_ATTACHMENT_STORE_OP_DONT_CARE: VkAttachmentStoreOp = 1;
13119pub const VK_ATTACHMENT_STORE_OP_NONE: VkAttachmentStoreOp = 1000301000;
13120pub const VK_ATTACHMENT_STORE_OP_NONE_EXT: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
13121pub const VK_ATTACHMENT_STORE_OP_NONE_KHR: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
13122pub const VK_ATTACHMENT_STORE_OP_NONE_QCOM: VkAttachmentStoreOp = VK_ATTACHMENT_STORE_OP_NONE;
13123pub const VK_ATTACHMENT_STORE_OP_STORE: VkAttachmentStoreOp = 0;
13124pub const VK_ATTACHMENT_UNUSED: u32 = !0;
13125pub const VK_BLEND_FACTOR_CONSTANT_ALPHA: VkBlendFactor = 12;
13126pub const VK_BLEND_FACTOR_CONSTANT_COLOR: VkBlendFactor = 10;
13127pub const VK_BLEND_FACTOR_DST_ALPHA: VkBlendFactor = 8;
13128pub const VK_BLEND_FACTOR_DST_COLOR: VkBlendFactor = 4;
13129pub const VK_BLEND_FACTOR_ONE: VkBlendFactor = 1;
13130pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA: VkBlendFactor = 13;
13131pub const VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR: VkBlendFactor = 11;
13132pub const VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA: VkBlendFactor = 9;
13133pub const VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR: VkBlendFactor = 5;
13134pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA: VkBlendFactor = 18;
13135pub const VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR: VkBlendFactor = 16;
13136pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA: VkBlendFactor = 7;
13137pub const VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR: VkBlendFactor = 3;
13138pub const VK_BLEND_FACTOR_SRC1_ALPHA: VkBlendFactor = 17;
13139pub const VK_BLEND_FACTOR_SRC1_COLOR: VkBlendFactor = 15;
13140pub const VK_BLEND_FACTOR_SRC_ALPHA: VkBlendFactor = 6;
13141pub const VK_BLEND_FACTOR_SRC_ALPHA_SATURATE: VkBlendFactor = 14;
13142pub const VK_BLEND_FACTOR_SRC_COLOR: VkBlendFactor = 2;
13143pub const VK_BLEND_FACTOR_ZERO: VkBlendFactor = 0;
13144pub const VK_BLEND_OP_ADD: VkBlendOp = 0;
13145pub const VK_BLEND_OP_BLUE_EXT: VkBlendOp = 1000148045;
13146pub const VK_BLEND_OP_COLORBURN_EXT: VkBlendOp = 1000148018;
13147pub const VK_BLEND_OP_COLORDODGE_EXT: VkBlendOp = 1000148017;
13148pub const VK_BLEND_OP_CONTRAST_EXT: VkBlendOp = 1000148041;
13149pub const VK_BLEND_OP_DARKEN_EXT: VkBlendOp = 1000148015;
13150pub const VK_BLEND_OP_DIFFERENCE_EXT: VkBlendOp = 1000148021;
13151pub const VK_BLEND_OP_DST_ATOP_EXT: VkBlendOp = 1000148010;
13152pub const VK_BLEND_OP_DST_EXT: VkBlendOp = 1000148002;
13153pub const VK_BLEND_OP_DST_IN_EXT: VkBlendOp = 1000148006;
13154pub const VK_BLEND_OP_DST_OUT_EXT: VkBlendOp = 1000148008;
13155pub const VK_BLEND_OP_DST_OVER_EXT: VkBlendOp = 1000148004;
13156pub const VK_BLEND_OP_EXCLUSION_EXT: VkBlendOp = 1000148022;
13157pub const VK_BLEND_OP_GREEN_EXT: VkBlendOp = 1000148044;
13158pub const VK_BLEND_OP_HARDLIGHT_EXT: VkBlendOp = 1000148019;
13159pub const VK_BLEND_OP_HARDMIX_EXT: VkBlendOp = 1000148030;
13160pub const VK_BLEND_OP_HSL_COLOR_EXT: VkBlendOp = 1000148033;
13161pub const VK_BLEND_OP_HSL_HUE_EXT: VkBlendOp = 1000148031;
13162pub const VK_BLEND_OP_HSL_LUMINOSITY_EXT: VkBlendOp = 1000148034;
13163pub const VK_BLEND_OP_HSL_SATURATION_EXT: VkBlendOp = 1000148032;
13164pub const VK_BLEND_OP_INVERT_EXT: VkBlendOp = 1000148023;
13165pub const VK_BLEND_OP_INVERT_OVG_EXT: VkBlendOp = 1000148042;
13166pub const VK_BLEND_OP_INVERT_RGB_EXT: VkBlendOp = 1000148024;
13167pub const VK_BLEND_OP_LIGHTEN_EXT: VkBlendOp = 1000148016;
13168pub const VK_BLEND_OP_LINEARBURN_EXT: VkBlendOp = 1000148026;
13169pub const VK_BLEND_OP_LINEARDODGE_EXT: VkBlendOp = 1000148025;
13170pub const VK_BLEND_OP_LINEARLIGHT_EXT: VkBlendOp = 1000148028;
13171pub const VK_BLEND_OP_MAX: VkBlendOp = 4;
13172pub const VK_BLEND_OP_MIN: VkBlendOp = 3;
13173pub const VK_BLEND_OP_MINUS_CLAMPED_EXT: VkBlendOp = 1000148040;
13174pub const VK_BLEND_OP_MINUS_EXT: VkBlendOp = 1000148039;
13175pub const VK_BLEND_OP_MULTIPLY_EXT: VkBlendOp = 1000148012;
13176pub const VK_BLEND_OP_OVERLAY_EXT: VkBlendOp = 1000148014;
13177pub const VK_BLEND_OP_PINLIGHT_EXT: VkBlendOp = 1000148029;
13178pub const VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT: VkBlendOp = 1000148037;
13179pub const VK_BLEND_OP_PLUS_CLAMPED_EXT: VkBlendOp = 1000148036;
13180pub const VK_BLEND_OP_PLUS_DARKER_EXT: VkBlendOp = 1000148038;
13181pub const VK_BLEND_OP_PLUS_EXT: VkBlendOp = 1000148035;
13182pub const VK_BLEND_OP_RED_EXT: VkBlendOp = 1000148043;
13183pub const VK_BLEND_OP_REVERSE_SUBTRACT: VkBlendOp = 2;
13184pub const VK_BLEND_OP_SCREEN_EXT: VkBlendOp = 1000148013;
13185pub const VK_BLEND_OP_SOFTLIGHT_EXT: VkBlendOp = 1000148020;
13186pub const VK_BLEND_OP_SRC_ATOP_EXT: VkBlendOp = 1000148009;
13187pub const VK_BLEND_OP_SRC_EXT: VkBlendOp = 1000148001;
13188pub const VK_BLEND_OP_SRC_IN_EXT: VkBlendOp = 1000148005;
13189pub const VK_BLEND_OP_SRC_OUT_EXT: VkBlendOp = 1000148007;
13190pub const VK_BLEND_OP_SRC_OVER_EXT: VkBlendOp = 1000148003;
13191pub const VK_BLEND_OP_SUBTRACT: VkBlendOp = 1;
13192pub const VK_BLEND_OP_VIVIDLIGHT_EXT: VkBlendOp = 1000148027;
13193pub const VK_BLEND_OP_XOR_EXT: VkBlendOp = 1000148011;
13194pub const VK_BLEND_OP_ZERO_EXT: VkBlendOp = 1000148000;
13195pub const VK_BLEND_OVERLAP_CONJOINT_EXT: VkBlendOverlapEXT = 2;
13196pub const VK_BLEND_OVERLAP_DISJOINT_EXT: VkBlendOverlapEXT = 1;
13197pub const VK_BLEND_OVERLAP_UNCORRELATED_EXT: VkBlendOverlapEXT = 0;
13198pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM: VkBlockMatchWindowCompareModeQCOM = 1;
13199pub const VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM: VkBlockMatchWindowCompareModeQCOM = 0;
13200pub const VK_BORDER_COLOR_FLOAT_CUSTOM_EXT: VkBorderColor = 1000287003;
13201pub const VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK: VkBorderColor = 2;
13202pub const VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE: VkBorderColor = 4;
13203pub const VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK: VkBorderColor = 0;
13204pub const VK_BORDER_COLOR_INT_CUSTOM_EXT: VkBorderColor = 1000287004;
13205pub const VK_BORDER_COLOR_INT_OPAQUE_BLACK: VkBorderColor = 3;
13206pub const VK_BORDER_COLOR_INT_OPAQUE_WHITE: VkBorderColor = 5;
13207pub const VK_BORDER_COLOR_INT_TRANSPARENT_BLACK: VkBorderColor = 1;
13208pub const VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlagBits = 1 << 5;
13209pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkBufferCreateFlagBits = 1 << 4;
13210pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkBufferCreateFlagBits = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
13211pub const VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkBufferCreateFlagBits = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
13212pub const VK_BUFFER_CREATE_PROTECTED_BIT: VkBufferCreateFlagBits = 1 << 3;
13213pub const VK_BUFFER_CREATE_SPARSE_ALIASED_BIT: VkBufferCreateFlagBits = 1 << 2;
13214pub const VK_BUFFER_CREATE_SPARSE_BINDING_BIT: VkBufferCreateFlagBits = 1 << 0;
13215pub const VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT: VkBufferCreateFlagBits = 1 << 1;
13216pub const VK_BUFFER_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkBufferCreateFlagBits = 1 << 6;
13217pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 19;
13218pub const VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 20;
13219pub const VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 9;
13220pub const VK_BUFFER_USAGE_2_DATA_GRAPH_FOREIGN_DESCRIPTOR_BIT_ARM: VkBufferUsageFlagBits2 = 1 << 29;
13221pub const VK_BUFFER_USAGE_2_DESCRIPTOR_HEAP_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 28;
13222pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 6;
13223pub const VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT;
13224pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 8;
13225pub const VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT;
13226pub const VK_BUFFER_USAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 32;
13227pub const VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 23;
13228pub const VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 24;
13229pub const VK_BUFFER_USAGE_2_PREPROCESS_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 31;
13230pub const VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 26;
13231pub const VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR;
13232pub const VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 22;
13233pub const VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 21;
13234pub const VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 10;
13235pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlagBits2 = 1 << 17;
13236pub const VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT;
13237pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 5;
13238pub const VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT;
13239pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 3;
13240pub const VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT;
13241pub const VK_BUFFER_USAGE_2_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlagBits2 = 1 << 27;
13242pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT: VkBufferUsageFlagBits2 = 1 << 1;
13243pub const VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_TRANSFER_DST_BIT;
13244pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT: VkBufferUsageFlagBits2 = 1 << 0;
13245pub const VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT;
13246pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 11;
13247pub const VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlagBits2 = 1 << 12;
13248pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 4;
13249pub const VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT;
13250pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 2;
13251pub const VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT;
13252pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT: VkBufferUsageFlagBits2 = 1 << 7;
13253pub const VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR: VkBufferUsageFlagBits2 = VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT;
13254pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 14;
13255pub const VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 13;
13256pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 15;
13257pub const VK_BUFFER_USAGE_2_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlagBits2 = 1 << 16;
13258pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR: VkBufferUsageFlagBits = 1 << 19;
13259pub const VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR: VkBufferUsageFlagBits = 1 << 20;
13260pub const VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT: VkBufferUsageFlagBits = 1 << 9;
13261pub const VK_BUFFER_USAGE_DESCRIPTOR_HEAP_BIT_EXT: VkBufferUsageFlagBits = 1 << 28;
13262pub const VK_BUFFER_USAGE_INDEX_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 6;
13263pub const VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 8;
13264pub const VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT: VkBufferUsageFlagBits = 1 << 23;
13265pub const VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT: VkBufferUsageFlagBits = 1 << 24;
13266pub const VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 26;
13267pub const VK_BUFFER_USAGE_RAY_TRACING_BIT_NV: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR;
13268pub const VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 22;
13269pub const VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 21;
13270pub const VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR: VkBufferUsageFlagBits = 1 << 10;
13271pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT: VkBufferUsageFlagBits = 1 << 17;
13272pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
13273pub const VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR: VkBufferUsageFlagBits = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
13274pub const VK_BUFFER_USAGE_STORAGE_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 5;
13275pub const VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 3;
13276pub const VK_BUFFER_USAGE_TILE_MEMORY_BIT_QCOM: VkBufferUsageFlagBits = 1 << 27;
13277pub const VK_BUFFER_USAGE_TRANSFER_DST_BIT: VkBufferUsageFlagBits = 1 << 1;
13278pub const VK_BUFFER_USAGE_TRANSFER_SRC_BIT: VkBufferUsageFlagBits = 1 << 0;
13279pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 11;
13280pub const VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT: VkBufferUsageFlagBits = 1 << 12;
13281pub const VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 4;
13282pub const VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 2;
13283pub const VK_BUFFER_USAGE_VERTEX_BUFFER_BIT: VkBufferUsageFlagBits = 1 << 7;
13284pub const VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkBufferUsageFlagBits = 1 << 14;
13285pub const VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkBufferUsageFlagBits = 1 << 13;
13286pub const VK_BUFFER_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkBufferUsageFlagBits = 1 << 15;
13287pub const VK_BUFFER_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkBufferUsageFlagBits = 1 << 16;
13288pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_CLUSTER_OPACITY_MICROMAPS_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = 1 << 12;
13289pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 1;
13290pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR;
13291pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 11;
13292pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_BIT_KHR;
13293pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 7;
13294pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_BIT_EXT;
13295pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 8;
13296pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_BIT_EXT;
13297pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT: VkBuildAccelerationStructureFlagBitsKHR = 1 << 6;
13298pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_BIT_EXT;
13299pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 0;
13300pub const VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR;
13301pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 4;
13302pub const VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR;
13303pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR: VkBuildAccelerationStructureModeKHR = 0;
13304pub const VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR: VkBuildAccelerationStructureModeKHR = 1;
13305pub const VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = 1 << 5;
13306pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 3;
13307pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR;
13308pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR: VkBuildAccelerationStructureFlagBitsKHR = 1 << 2;
13309pub const VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV: VkBuildAccelerationStructureFlagBitsKHR = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR;
13310pub const VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 2;
13311pub const VK_BUILD_MICROMAP_MODE_BUILD_EXT: VkBuildMicromapModeEXT = 0;
13312pub const VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 1;
13313pub const VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT: VkBuildMicromapFlagBitsEXT = 1 << 0;
13314pub const VK_CHROMA_LOCATION_COSITED_EVEN: VkChromaLocation = 0;
13315pub const VK_CHROMA_LOCATION_COSITED_EVEN_KHR: VkChromaLocation = VK_CHROMA_LOCATION_COSITED_EVEN;
13316pub const VK_CHROMA_LOCATION_MIDPOINT: VkChromaLocation = 1;
13317pub const VK_CHROMA_LOCATION_MIDPOINT_KHR: VkChromaLocation = VK_CHROMA_LOCATION_MIDPOINT;
13318pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_ADDRESS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 2;
13319pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_IMPLICIT_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 0;
13320pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_DST_SIZES_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 3;
13321pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SCRATCH_DATA_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 1;
13322pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_ARRAY_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 4;
13323pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_INDIRECTED_SRC_INFOS_COUNT_BIT_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 1 << 5;
13324pub const VK_CLUSTER_ACCELERATION_STRUCTURE_ADDRESS_RESOLUTION_NONE_NV: VkClusterAccelerationStructureAddressResolutionFlagBitsNV = 0;
13325pub const VK_CLUSTER_ACCELERATION_STRUCTURE_CLUSTER_ALLOW_DISABLE_OPACITY_MICROMAPS_NV: VkClusterAccelerationStructureClusterFlagBitsNV = 1 << 0;
13326pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_CULL_DISABLE_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 0;
13327pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_NO_DUPLICATE_ANYHIT_INVOCATION_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 1;
13328pub const VK_CLUSTER_ACCELERATION_STRUCTURE_GEOMETRY_OPAQUE_BIT_NV: VkClusterAccelerationStructureGeometryFlagBitsNV = 1 << 2;
13329pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_16BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 1;
13330pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_32BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 2;
13331pub const VK_CLUSTER_ACCELERATION_STRUCTURE_INDEX_FORMAT_8BIT_NV: VkClusterAccelerationStructureIndexFormatFlagBitsNV = 1 << 0;
13332pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_COMPUTE_SIZES_NV: VkClusterAccelerationStructureOpModeNV = 2;
13333pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_EXPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = 1;
13334pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_MODE_IMPLICIT_DESTINATIONS_NV: VkClusterAccelerationStructureOpModeNV = 0;
13335pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureOpTypeNV = 1;
13336pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = 2;
13337pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_BUILD_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureOpTypeNV = 3;
13338pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_GET_CLUSTER_TEMPLATE_INDICES_NV: VkClusterAccelerationStructureOpTypeNV = 5;
13339pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_INSTANTIATE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureOpTypeNV = 4;
13340pub const VK_CLUSTER_ACCELERATION_STRUCTURE_OP_TYPE_MOVE_OBJECTS_NV: VkClusterAccelerationStructureOpTypeNV = 0;
13341pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_CLUSTERS_BOTTOM_LEVEL_NV: VkClusterAccelerationStructureTypeNV = 0;
13342pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_NV: VkClusterAccelerationStructureTypeNV = 1;
13343pub const VK_CLUSTER_ACCELERATION_STRUCTURE_TYPE_TRIANGLE_CLUSTER_TEMPLATE_NV: VkClusterAccelerationStructureTypeNV = 2;
13344pub const VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV: VkCoarseSampleOrderTypeNV = 1;
13345pub const VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV: VkCoarseSampleOrderTypeNV = 0;
13346pub const VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV: VkCoarseSampleOrderTypeNV = 2;
13347pub const VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV: VkCoarseSampleOrderTypeNV = 3;
13348pub const VK_COLORSPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR;
13349pub const VK_COLOR_COMPONENT_A_BIT: VkColorComponentFlagBits = 1 << 3;
13350pub const VK_COLOR_COMPONENT_B_BIT: VkColorComponentFlagBits = 1 << 2;
13351pub const VK_COLOR_COMPONENT_G_BIT: VkColorComponentFlagBits = 1 << 1;
13352pub const VK_COLOR_COMPONENT_R_BIT: VkColorComponentFlagBits = 1 << 0;
13353pub const VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT: VkColorSpaceKHR = 1000104011;
13354pub const VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT: VkColorSpaceKHR = 1000104012;
13355pub const VK_COLOR_SPACE_BT2020_LINEAR_EXT: VkColorSpaceKHR = 1000104007;
13356pub const VK_COLOR_SPACE_BT709_LINEAR_EXT: VkColorSpaceKHR = 1000104005;
13357pub const VK_COLOR_SPACE_BT709_NONLINEAR_EXT: VkColorSpaceKHR = 1000104006;
13358pub const VK_COLOR_SPACE_DCI_P3_LINEAR_EXT: VkColorSpaceKHR = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT;
13359pub const VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT: VkColorSpaceKHR = 1000104004;
13360pub const VK_COLOR_SPACE_DISPLAY_NATIVE_AMD: VkColorSpaceKHR = 1000213000;
13361pub const VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT: VkColorSpaceKHR = 1000104003;
13362pub const VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT: VkColorSpaceKHR = 1000104001;
13363pub const VK_COLOR_SPACE_DOLBYVISION_EXT: VkColorSpaceKHR = 1000104009;
13364pub const VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT: VkColorSpaceKHR = 1000104002;
13365pub const VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT: VkColorSpaceKHR = 1000104014;
13366pub const VK_COLOR_SPACE_HDR10_HLG_EXT: VkColorSpaceKHR = 1000104010;
13367pub const VK_COLOR_SPACE_HDR10_ST2084_EXT: VkColorSpaceKHR = 1000104008;
13368pub const VK_COLOR_SPACE_PASS_THROUGH_EXT: VkColorSpaceKHR = 1000104013;
13369pub const VK_COLOR_SPACE_SRGB_NONLINEAR_KHR: VkColorSpaceKHR = 0;
13370pub const VK_COMMAND_BUFFER_LEVEL_PRIMARY: VkCommandBufferLevel = 0;
13371pub const VK_COMMAND_BUFFER_LEVEL_SECONDARY: VkCommandBufferLevel = 1;
13372pub const VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT: VkCommandBufferResetFlagBits = 1 << 0;
13373pub const VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT: VkCommandBufferUsageFlagBits = 1 << 0;
13374pub const VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT: VkCommandBufferUsageFlagBits = 1 << 1;
13375pub const VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT: VkCommandBufferUsageFlagBits = 1 << 2;
13376pub const VK_COMMAND_POOL_CREATE_PROTECTED_BIT: VkCommandPoolCreateFlagBits = 1 << 2;
13377pub const VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT: VkCommandPoolCreateFlagBits = 1 << 1;
13378pub const VK_COMMAND_POOL_CREATE_TRANSIENT_BIT: VkCommandPoolCreateFlagBits = 1 << 0;
13379pub const VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT: VkCommandPoolResetFlagBits = 1 << 0;
13380pub const VK_COMPARE_OP_ALWAYS: VkCompareOp = 7;
13381pub const VK_COMPARE_OP_EQUAL: VkCompareOp = 2;
13382pub const VK_COMPARE_OP_GREATER: VkCompareOp = 4;
13383pub const VK_COMPARE_OP_GREATER_OR_EQUAL: VkCompareOp = 6;
13384pub const VK_COMPARE_OP_LESS: VkCompareOp = 1;
13385pub const VK_COMPARE_OP_LESS_OR_EQUAL: VkCompareOp = 3;
13386pub const VK_COMPARE_OP_NEVER: VkCompareOp = 0;
13387pub const VK_COMPARE_OP_NOT_EQUAL: VkCompareOp = 5;
13388pub const VK_COMPONENT_SWIZZLE_A: VkComponentSwizzle = 6;
13389pub const VK_COMPONENT_SWIZZLE_B: VkComponentSwizzle = 5;
13390pub const VK_COMPONENT_SWIZZLE_G: VkComponentSwizzle = 4;
13391pub const VK_COMPONENT_SWIZZLE_IDENTITY: VkComponentSwizzle = 0;
13392pub const VK_COMPONENT_SWIZZLE_ONE: VkComponentSwizzle = 2;
13393pub const VK_COMPONENT_SWIZZLE_R: VkComponentSwizzle = 3;
13394pub const VK_COMPONENT_SWIZZLE_ZERO: VkComponentSwizzle = 1;
13395pub const VK_COMPONENT_TYPE_BFLOAT16_KHR: VkComponentTypeKHR = 1000141000;
13396pub const VK_COMPONENT_TYPE_FLOAT16_KHR: VkComponentTypeKHR = 0;
13397pub const VK_COMPONENT_TYPE_FLOAT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT16_KHR;
13398pub const VK_COMPONENT_TYPE_FLOAT32_KHR: VkComponentTypeKHR = 1;
13399pub const VK_COMPONENT_TYPE_FLOAT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT32_KHR;
13400pub const VK_COMPONENT_TYPE_FLOAT64_KHR: VkComponentTypeKHR = 2;
13401pub const VK_COMPONENT_TYPE_FLOAT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT64_KHR;
13402pub const VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT: VkComponentTypeKHR = 1000491002;
13403pub const VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT: VkComponentTypeKHR = 1000491003;
13404pub const VK_COMPONENT_TYPE_FLOAT_E4M3_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E4M3_EXT;
13405pub const VK_COMPONENT_TYPE_FLOAT_E5M2_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_FLOAT8_E5M2_EXT;
13406pub const VK_COMPONENT_TYPE_SINT16_KHR: VkComponentTypeKHR = 4;
13407pub const VK_COMPONENT_TYPE_SINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT16_KHR;
13408pub const VK_COMPONENT_TYPE_SINT32_KHR: VkComponentTypeKHR = 5;
13409pub const VK_COMPONENT_TYPE_SINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT32_KHR;
13410pub const VK_COMPONENT_TYPE_SINT64_KHR: VkComponentTypeKHR = 6;
13411pub const VK_COMPONENT_TYPE_SINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT64_KHR;
13412pub const VK_COMPONENT_TYPE_SINT8_KHR: VkComponentTypeKHR = 3;
13413pub const VK_COMPONENT_TYPE_SINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_SINT8_KHR;
13414pub const VK_COMPONENT_TYPE_SINT8_PACKED_NV: VkComponentTypeKHR = 1000491000;
13415pub const VK_COMPONENT_TYPE_UINT16_KHR: VkComponentTypeKHR = 8;
13416pub const VK_COMPONENT_TYPE_UINT16_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT16_KHR;
13417pub const VK_COMPONENT_TYPE_UINT32_KHR: VkComponentTypeKHR = 9;
13418pub const VK_COMPONENT_TYPE_UINT32_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT32_KHR;
13419pub const VK_COMPONENT_TYPE_UINT64_KHR: VkComponentTypeKHR = 10;
13420pub const VK_COMPONENT_TYPE_UINT64_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT64_KHR;
13421pub const VK_COMPONENT_TYPE_UINT8_KHR: VkComponentTypeKHR = 7;
13422pub const VK_COMPONENT_TYPE_UINT8_NV: VkComponentTypeKHR = VK_COMPONENT_TYPE_UINT8_KHR;
13423pub const VK_COMPONENT_TYPE_UINT8_PACKED_NV: VkComponentTypeKHR = 1000491001;
13424pub const VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 3;
13425pub const VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 0;
13426pub const VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 2;
13427pub const VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR: VkCompositeAlphaFlagBitsKHR = 1 << 1;
13428pub const VK_COMPUTE_OCCUPANCY_PRIORITY_HIGH_NV: f32 = 0.75;
13429pub const VK_COMPUTE_OCCUPANCY_PRIORITY_LOW_NV: f32 = 0.25;
13430pub const VK_COMPUTE_OCCUPANCY_PRIORITY_NORMAL_NV: f32 = 0.50;
13431pub const VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT: VkConditionalRenderingFlagBitsEXT = 1 << 0;
13432pub const VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT: VkConservativeRasterizationModeEXT = 0;
13433pub const VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT: VkConservativeRasterizationModeEXT = 1;
13434pub const VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT: VkConservativeRasterizationModeEXT = 2;
13435pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_COLUMN_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = 1;
13436pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_INFERENCING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = 2;
13437pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_ROW_MAJOR_NV: VkCooperativeVectorMatrixLayoutNV = 0;
13438pub const VK_COOPERATIVE_VECTOR_MATRIX_LAYOUT_TRAINING_OPTIMAL_NV: VkCooperativeVectorMatrixLayoutNV = 3;
13439pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR: VkCopyAccelerationStructureModeKHR = 0;
13440pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR;
13441pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR: VkCopyAccelerationStructureModeKHR = 1;
13442pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV: VkCopyAccelerationStructureModeKHR = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR;
13443pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = 3;
13444pub const VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR: VkCopyAccelerationStructureModeKHR = 2;
13445pub const VK_COPY_MICROMAP_MODE_CLONE_EXT: VkCopyMicromapModeEXT = 0;
13446pub const VK_COPY_MICROMAP_MODE_COMPACT_EXT: VkCopyMicromapModeEXT = 3;
13447pub const VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT: VkCopyMicromapModeEXT = 2;
13448pub const VK_COPY_MICROMAP_MODE_SERIALIZE_EXT: VkCopyMicromapModeEXT = 1;
13449pub const VK_COVERAGE_MODULATION_MODE_ALPHA_NV: VkCoverageModulationModeNV = 2;
13450pub const VK_COVERAGE_MODULATION_MODE_NONE_NV: VkCoverageModulationModeNV = 0;
13451pub const VK_COVERAGE_MODULATION_MODE_RGBA_NV: VkCoverageModulationModeNV = 3;
13452pub const VK_COVERAGE_MODULATION_MODE_RGB_NV: VkCoverageModulationModeNV = 1;
13453pub const VK_COVERAGE_REDUCTION_MODE_MERGE_NV: VkCoverageReductionModeNV = 0;
13454pub const VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV: VkCoverageReductionModeNV = 1;
13455pub const VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM: VkCubicFilterWeightsQCOM = 2;
13456pub const VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM: VkCubicFilterWeightsQCOM = 0;
13457pub const VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM: VkCubicFilterWeightsQCOM = 3;
13458pub const VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM: VkCubicFilterWeightsQCOM = 1;
13459pub const VK_CULL_MODE_BACK_BIT: VkCullModeFlagBits = 1 << 1;
13460pub const VK_CULL_MODE_FRONT_AND_BACK: VkCullModeFlagBits = 0x00000003;
13461pub const VK_CULL_MODE_FRONT_BIT: VkCullModeFlagBits = 1 << 0;
13462pub const VK_CULL_MODE_NONE: VkCullModeFlagBits = 0;
13463pub const VK_DATA_GRAPH_MODEL_CACHE_TYPE_GENERIC_BINARY_QCOM: VkDataGraphModelCacheTypeQCOM = 0;
13464pub const VK_DATA_GRAPH_MODEL_TOOLCHAIN_VERSION_LENGTH_QCOM: u32 = 3;
13465pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_CREATION_LOG_ARM: VkDataGraphPipelinePropertyARM = 0;
13466pub const VK_DATA_GRAPH_PIPELINE_PROPERTY_IDENTIFIER_ARM: VkDataGraphPipelinePropertyARM = 1;
13467pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TRANSIENT_ARM: VkDataGraphPipelineSessionBindPointARM = 0;
13468pub const VK_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_TYPE_MEMORY_ARM: VkDataGraphPipelineSessionBindPointTypeARM = 0;
13469pub const VK_DATA_GRAPH_PIPELINE_SESSION_CREATE_PROTECTED_BIT_ARM: VkDataGraphPipelineSessionCreateFlagBitsARM = 1 << 0;
13470pub const VK_DEBUG_REPORT_DEBUG_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 4;
13471pub const VK_DEBUG_REPORT_ERROR_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 3;
13472pub const VK_DEBUG_REPORT_INFORMATION_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 0;
13473pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT: VkDebugReportObjectTypeEXT = 1000150000;
13474pub const VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT: VkDebugReportObjectTypeEXT = 1000165000;
13475pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT: VkDebugReportObjectTypeEXT = 9;
13476pub const VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT: VkDebugReportObjectTypeEXT = 13;
13477pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT: VkDebugReportObjectTypeEXT = 6;
13478pub const VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT: VkDebugReportObjectTypeEXT = 25;
13479pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT: VkDebugReportObjectTypeEXT = 1000029001;
13480pub const VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT: VkDebugReportObjectTypeEXT = 1000029000;
13481pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT: VkDebugReportObjectTypeEXT = 28;
13482pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT;
13483pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT: VkDebugReportObjectTypeEXT = 22;
13484pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT: VkDebugReportObjectTypeEXT = 23;
13485pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 20;
13486pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT: VkDebugReportObjectTypeEXT = 1000085000;
13487pub const VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT;
13488pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT: VkDebugReportObjectTypeEXT = 3;
13489pub const VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT: VkDebugReportObjectTypeEXT = 8;
13490pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT: VkDebugReportObjectTypeEXT = 29;
13491pub const VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT: VkDebugReportObjectTypeEXT = 30;
13492pub const VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT: VkDebugReportObjectTypeEXT = 11;
13493pub const VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT: VkDebugReportObjectTypeEXT = 7;
13494pub const VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT: VkDebugReportObjectTypeEXT = 24;
13495pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT: VkDebugReportObjectTypeEXT = 10;
13496pub const VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT: VkDebugReportObjectTypeEXT = 14;
13497pub const VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT: VkDebugReportObjectTypeEXT = 1;
13498pub const VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT: VkDebugReportObjectTypeEXT = 2;
13499pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT: VkDebugReportObjectTypeEXT = 16;
13500pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT: VkDebugReportObjectTypeEXT = 19;
13501pub const VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT: VkDebugReportObjectTypeEXT = 17;
13502pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT: VkDebugReportObjectTypeEXT = 12;
13503pub const VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT: VkDebugReportObjectTypeEXT = 4;
13504pub const VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT: VkDebugReportObjectTypeEXT = 18;
13505pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT: VkDebugReportObjectTypeEXT = 21;
13506pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT: VkDebugReportObjectTypeEXT = 1000156000;
13507pub const VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT;
13508pub const VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT: VkDebugReportObjectTypeEXT = 5;
13509pub const VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT: VkDebugReportObjectTypeEXT = 15;
13510pub const VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT: VkDebugReportObjectTypeEXT = 26;
13511pub const VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT: VkDebugReportObjectTypeEXT = 27;
13512pub const VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT: VkDebugReportObjectTypeEXT = 0;
13513pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkDebugReportObjectTypeEXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT;
13514pub const VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT: VkDebugReportObjectTypeEXT = 33;
13515pub const VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 2;
13516pub const VK_DEBUG_REPORT_WARNING_BIT_EXT: VkDebugReportFlagBitsEXT = 1 << 1;
13517pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 12;
13518pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 4;
13519pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 0;
13520pub const VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: VkDebugUtilsMessageSeverityFlagBitsEXT = 1 << 8;
13521pub const VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 3;
13522pub const VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 0;
13523pub const VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 2;
13524pub const VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: VkDebugUtilsMessageTypeFlagBitsEXT = 1 << 1;
13525pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ONE_KHR: VkDefaultVertexAttributeValueKHR = 1;
13526pub const VK_DEFAULT_VERTEX_ATTRIBUTE_VALUE_ZERO_ZERO_ZERO_ZERO_KHR: VkDefaultVertexAttributeValueKHR = 0;
13527pub const VK_DEPENDENCY_ASYMMETRIC_EVENT_BIT_KHR: VkDependencyFlagBits = 1 << 6;
13528pub const VK_DEPENDENCY_BY_REGION_BIT: VkDependencyFlagBits = 1 << 0;
13529pub const VK_DEPENDENCY_DEVICE_GROUP_BIT: VkDependencyFlagBits = 1 << 2;
13530pub const VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR: VkDependencyFlagBits = VK_DEPENDENCY_DEVICE_GROUP_BIT;
13531pub const VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT: VkDependencyFlagBits = 1 << 3;
13532pub const VK_DEPENDENCY_QUEUE_FAMILY_OWNERSHIP_TRANSFER_USE_ALL_STAGES_BIT_KHR: VkDependencyFlagBits = 1 << 5;
13533pub const VK_DEPENDENCY_VIEW_LOCAL_BIT: VkDependencyFlagBits = 1 << 1;
13534pub const VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR: VkDependencyFlagBits = VK_DEPENDENCY_VIEW_LOCAL_BIT;
13535pub const VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT: VkDepthBiasRepresentationEXT = 2;
13536pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT: VkDepthBiasRepresentationEXT = 1;
13537pub const VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT: VkDepthBiasRepresentationEXT = 0;
13538pub const VK_DEPTH_CLAMP_MODE_USER_DEFINED_RANGE_EXT: VkDepthClampModeEXT = 1;
13539pub const VK_DEPTH_CLAMP_MODE_VIEWPORT_RANGE_EXT: VkDepthClampModeEXT = 0;
13540pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT: VkDescriptorBindingFlagBits = 1 << 2;
13541pub const VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT;
13542pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT: VkDescriptorBindingFlagBits = 1 << 0;
13543pub const VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT;
13544pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT: VkDescriptorBindingFlagBits = 1 << 1;
13545pub const VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT;
13546pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT: VkDescriptorBindingFlagBits = 1 << 3;
13547pub const VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT: VkDescriptorBindingFlagBits = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT;
13548pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_CONSTANT_OFFSET_EXT: VkDescriptorMappingSourceEXT = 0;
13549pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_ARRAY_EXT: VkDescriptorMappingSourceEXT = 3;
13550pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_INDIRECT_INDEX_EXT: VkDescriptorMappingSourceEXT = 2;
13551pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_PUSH_INDEX_EXT: VkDescriptorMappingSourceEXT = 1;
13552pub const VK_DESCRIPTOR_MAPPING_SOURCE_HEAP_WITH_SHADER_RECORD_INDEX_EXT: VkDescriptorMappingSourceEXT = 8;
13553pub const VK_DESCRIPTOR_MAPPING_SOURCE_INDIRECT_ADDRESS_EXT: VkDescriptorMappingSourceEXT = 7;
13554pub const VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT: VkDescriptorMappingSourceEXT = 6;
13555pub const VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_DATA_EXT: VkDescriptorMappingSourceEXT = 5;
13556pub const VK_DESCRIPTOR_MAPPING_SOURCE_RESOURCE_HEAP_DATA_EXT: VkDescriptorMappingSourceEXT = 4;
13557pub const VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_ADDRESS_EXT: VkDescriptorMappingSourceEXT = 10;
13558pub const VK_DESCRIPTOR_MAPPING_SOURCE_SHADER_RECORD_DATA_EXT: VkDescriptorMappingSourceEXT = 9;
13559pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV: VkDescriptorPoolCreateFlagBits = 1 << 4;
13560pub const VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV: VkDescriptorPoolCreateFlagBits = 1 << 3;
13561pub const VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT: VkDescriptorPoolCreateFlagBits = 1 << 0;
13562pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT: VkDescriptorPoolCreateFlagBits = 1 << 2;
13563pub const VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE: VkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT;
13564pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT: VkDescriptorPoolCreateFlagBits = 1 << 1;
13565pub const VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT: VkDescriptorPoolCreateFlagBits = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT;
13566pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 4;
13567pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 5;
13568pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = 1 << 2;
13569pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT;
13570pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV: VkDescriptorSetLayoutCreateFlagBits = 1 << 7;
13571pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PER_STAGE_BIT_NV: VkDescriptorSetLayoutCreateFlagBits = 1 << 6;
13572pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT: VkDescriptorSetLayoutCreateFlagBits = 1 << 0;
13573pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT;
13574pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT: VkDescriptorSetLayoutCreateFlagBits = 1 << 1;
13575pub const VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT: VkDescriptorSetLayoutCreateFlagBits = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT;
13576pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR: VkDescriptorType = 1000150000;
13577pub const VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV: VkDescriptorType = 1000165000;
13578pub const VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM: VkDescriptorType = 1000440001;
13579pub const VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER: VkDescriptorType = 1;
13580pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK: VkDescriptorType = 1000138000;
13581pub const VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT: VkDescriptorType = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK;
13582pub const VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT: VkDescriptorType = 10;
13583pub const VK_DESCRIPTOR_TYPE_MUTABLE_EXT: VkDescriptorType = 1000351000;
13584pub const VK_DESCRIPTOR_TYPE_MUTABLE_VALVE: VkDescriptorType = VK_DESCRIPTOR_TYPE_MUTABLE_EXT;
13585pub const VK_DESCRIPTOR_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkDescriptorType = 1000570000;
13586pub const VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE: VkDescriptorType = 2;
13587pub const VK_DESCRIPTOR_TYPE_SAMPLER: VkDescriptorType = 0;
13588pub const VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM: VkDescriptorType = 1000440000;
13589pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER: VkDescriptorType = 7;
13590pub const VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC: VkDescriptorType = 9;
13591pub const VK_DESCRIPTOR_TYPE_STORAGE_IMAGE: VkDescriptorType = 3;
13592pub const VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER: VkDescriptorType = 5;
13593pub const VK_DESCRIPTOR_TYPE_TENSOR_ARM: VkDescriptorType = 1000460000;
13594pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER: VkDescriptorType = 6;
13595pub const VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC: VkDescriptorType = 8;
13596pub const VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER: VkDescriptorType = 4;
13597pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: VkDescriptorUpdateTemplateType = 0;
13598pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET;
13599pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS: VkDescriptorUpdateTemplateType = 1;
13600pub const VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR: VkDescriptorUpdateTemplateType = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS;
13601pub const VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT: VkDeviceAddressBindingFlagBitsEXT = 1 << 0;
13602pub const VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT: VkDeviceAddressBindingTypeEXT = 0;
13603pub const VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT: VkDeviceAddressBindingTypeEXT = 1;
13604pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 2;
13605pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 1;
13606pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 0;
13607pub const VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV: VkDeviceDiagnosticsConfigFlagBitsNV = 1 << 3;
13608pub const VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT: VkDeviceEventTypeEXT = 0;
13609pub const VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 3;
13610pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT: VkDeviceFaultAddressTypeEXT = 6;
13611pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 5;
13612pub const VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT: VkDeviceFaultAddressTypeEXT = 4;
13613pub const VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT: VkDeviceFaultAddressTypeEXT = 0;
13614pub const VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 1;
13615pub const VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT: VkDeviceFaultAddressTypeEXT = 2;
13616pub const VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT: VkDeviceFaultVendorBinaryHeaderVersionEXT = 1;
13617pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 0;
13618pub const VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 3;
13619pub const VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 1;
13620pub const VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR: VkDeviceGroupPresentModeFlagBitsKHR = 1 << 2;
13621pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT: VkDeviceMemoryReportEventTypeEXT = 0;
13622pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT: VkDeviceMemoryReportEventTypeEXT = 4;
13623pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT: VkDeviceMemoryReportEventTypeEXT = 1;
13624pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = 2;
13625pub const VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT: VkDeviceMemoryReportEventTypeEXT = 3;
13626pub const VK_DEVICE_QUEUE_CREATE_INTERNALLY_SYNCHRONIZED_BIT_KHR: VkDeviceQueueCreateFlagBits = 1 << 2;
13627pub const VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT: VkDeviceQueueCreateFlagBits = 1 << 0;
13628pub const VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = 0;
13629pub const VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG: VkDirectDriverLoadingModeLUNARG = 1;
13630pub const VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT: VkDiscardRectangleModeEXT = 1;
13631pub const VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT: VkDiscardRectangleModeEXT = 0;
13632pub const VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT: VkDisplayEventTypeEXT = 0;
13633pub const VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 1;
13634pub const VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 0;
13635pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 2;
13636pub const VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR: VkDisplayPlaneAlphaFlagBitsKHR = 1 << 3;
13637pub const VK_DISPLAY_POWER_STATE_OFF_EXT: VkDisplayPowerStateEXT = 0;
13638pub const VK_DISPLAY_POWER_STATE_ON_EXT: VkDisplayPowerStateEXT = 2;
13639pub const VK_DISPLAY_POWER_STATE_SUSPEND_EXT: VkDisplayPowerStateEXT = 1;
13640pub const VK_DISPLAY_SURFACE_STEREO_TYPE_HDMI_3D_NV: VkDisplaySurfaceStereoTypeNV = 2;
13641pub const VK_DISPLAY_SURFACE_STEREO_TYPE_INBAND_DISPLAYPORT_NV: VkDisplaySurfaceStereoTypeNV = 3;
13642pub const VK_DISPLAY_SURFACE_STEREO_TYPE_NONE_NV: VkDisplaySurfaceStereoTypeNV = 0;
13643pub const VK_DISPLAY_SURFACE_STEREO_TYPE_ONBOARD_DIN_NV: VkDisplaySurfaceStereoTypeNV = 1;
13644pub const VK_DRIVER_ID_AMD_OPEN_SOURCE: VkDriverId = 2;
13645pub const VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR: VkDriverId = VK_DRIVER_ID_AMD_OPEN_SOURCE;
13646pub const VK_DRIVER_ID_AMD_PROPRIETARY: VkDriverId = 1;
13647pub const VK_DRIVER_ID_AMD_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_AMD_PROPRIETARY;
13648pub const VK_DRIVER_ID_ARM_PROPRIETARY: VkDriverId = 9;
13649pub const VK_DRIVER_ID_ARM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_ARM_PROPRIETARY;
13650pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY: VkDriverId = 12;
13651pub const VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_BROADCOM_PROPRIETARY;
13652pub const VK_DRIVER_ID_COREAVI_PROPRIETARY: VkDriverId = 15;
13653pub const VK_DRIVER_ID_GGP_PROPRIETARY: VkDriverId = 11;
13654pub const VK_DRIVER_ID_GGP_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_GGP_PROPRIETARY;
13655pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER: VkDriverId = 10;
13656pub const VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR: VkDriverId = VK_DRIVER_ID_GOOGLE_SWIFTSHADER;
13657pub const VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA: VkDriverId = 25;
13658pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY: VkDriverId = 7;
13659pub const VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_IMAGINATION_PROPRIETARY;
13660pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA: VkDriverId = 6;
13661pub const VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR: VkDriverId = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA;
13662pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS: VkDriverId = 5;
13663pub const VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR: VkDriverId = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS;
13664pub const VK_DRIVER_ID_JUICE_PROPRIETARY: VkDriverId = 16;
13665pub const VK_DRIVER_ID_MESA_DOZEN: VkDriverId = 23;
13666pub const VK_DRIVER_ID_MESA_HONEYKRISP: VkDriverId = 26;
13667pub const VK_DRIVER_ID_MESA_KOSMICKRISP: VkDriverId = 28;
13668pub const VK_DRIVER_ID_MESA_LLVMPIPE: VkDriverId = 13;
13669pub const VK_DRIVER_ID_MESA_NVK: VkDriverId = 24;
13670pub const VK_DRIVER_ID_MESA_PANVK: VkDriverId = 20;
13671pub const VK_DRIVER_ID_MESA_RADV: VkDriverId = 3;
13672pub const VK_DRIVER_ID_MESA_RADV_KHR: VkDriverId = VK_DRIVER_ID_MESA_RADV;
13673pub const VK_DRIVER_ID_MESA_TURNIP: VkDriverId = 18;
13674pub const VK_DRIVER_ID_MESA_V3DV: VkDriverId = 19;
13675pub const VK_DRIVER_ID_MESA_VENUS: VkDriverId = 22;
13676pub const VK_DRIVER_ID_MOLTENVK: VkDriverId = 14;
13677pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY: VkDriverId = 4;
13678pub const VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_NVIDIA_PROPRIETARY;
13679pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY: VkDriverId = 8;
13680pub const VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR: VkDriverId = VK_DRIVER_ID_QUALCOMM_PROPRIETARY;
13681pub const VK_DRIVER_ID_SAMSUNG_PROPRIETARY: VkDriverId = 21;
13682pub const VK_DRIVER_ID_VERISILICON_PROPRIETARY: VkDriverId = 17;
13683pub const VK_DRIVER_ID_VULKAN_SC_EMULATION_ON_VULKAN: VkDriverId = 27;
13684pub const VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT: VkDynamicState = 1000455007;
13685pub const VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT: VkDynamicState = 1000455008;
13686pub const VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT: VkDynamicState = 1000524000;
13687pub const VK_DYNAMIC_STATE_BLEND_CONSTANTS: VkDynamicState = 4;
13688pub const VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT: VkDynamicState = 1000455018;
13689pub const VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT: VkDynamicState = 1000455010;
13690pub const VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT: VkDynamicState = 1000455011;
13691pub const VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT: VkDynamicState = 1000381000;
13692pub const VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT: VkDynamicState = 1000455012;
13693pub const VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT: VkDynamicState = 1000455014;
13694pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV: VkDynamicState = 1000455027;
13695pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV: VkDynamicState = 1000455028;
13696pub const VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV: VkDynamicState = 1000455029;
13697pub const VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV: VkDynamicState = 1000455032;
13698pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV: VkDynamicState = 1000455025;
13699pub const VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV: VkDynamicState = 1000455026;
13700pub const VK_DYNAMIC_STATE_CULL_MODE: VkDynamicState = 1000267000;
13701pub const VK_DYNAMIC_STATE_CULL_MODE_EXT: VkDynamicState = VK_DYNAMIC_STATE_CULL_MODE;
13702pub const VK_DYNAMIC_STATE_DEPTH_BIAS: VkDynamicState = 3;
13703pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE: VkDynamicState = 1000377002;
13704pub const VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE;
13705pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS: VkDynamicState = 5;
13706pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE: VkDynamicState = 1000267009;
13707pub const VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE;
13708pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT: VkDynamicState = 1000455003;
13709pub const VK_DYNAMIC_STATE_DEPTH_CLAMP_RANGE_EXT: VkDynamicState = 1000582000;
13710pub const VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT: VkDynamicState = 1000455016;
13711pub const VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT: VkDynamicState = 1000455022;
13712pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP: VkDynamicState = 1000267008;
13713pub const VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP;
13714pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE: VkDynamicState = 1000267006;
13715pub const VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE;
13716pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE: VkDynamicState = 1000267007;
13717pub const VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE;
13718pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT: VkDynamicState = 1000099001;
13719pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT: VkDynamicState = 1000099000;
13720pub const VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT: VkDynamicState = 1000099002;
13721pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV: VkDynamicState = 1000205000;
13722pub const VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV: VkDynamicState = 1000205001;
13723pub const VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT: VkDynamicState = 1000455015;
13724pub const VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR: VkDynamicState = 1000226000;
13725pub const VK_DYNAMIC_STATE_FRONT_FACE: VkDynamicState = 1000267001;
13726pub const VK_DYNAMIC_STATE_FRONT_FACE_EXT: VkDynamicState = VK_DYNAMIC_STATE_FRONT_FACE;
13727pub const VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT: VkDynamicState = 1000455020;
13728pub const VK_DYNAMIC_STATE_LINE_STIPPLE: VkDynamicState = 1000259000;
13729pub const VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT: VkDynamicState = 1000455021;
13730pub const VK_DYNAMIC_STATE_LINE_STIPPLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
13731pub const VK_DYNAMIC_STATE_LINE_STIPPLE_KHR: VkDynamicState = VK_DYNAMIC_STATE_LINE_STIPPLE;
13732pub const VK_DYNAMIC_STATE_LINE_WIDTH: VkDynamicState = 2;
13733pub const VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT: VkDynamicState = 1000455009;
13734pub const VK_DYNAMIC_STATE_LOGIC_OP_EXT: VkDynamicState = 1000377003;
13735pub const VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT: VkDynamicState = 1000377000;
13736pub const VK_DYNAMIC_STATE_POLYGON_MODE_EXT: VkDynamicState = 1000455004;
13737pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE: VkDynamicState = 1000377004;
13738pub const VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE;
13739pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY: VkDynamicState = 1000267002;
13740pub const VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT: VkDynamicState = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY;
13741pub const VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT: VkDynamicState = 1000455019;
13742pub const VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT: VkDynamicState = 1000455005;
13743pub const VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT: VkDynamicState = 1000455013;
13744pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE: VkDynamicState = 1000377001;
13745pub const VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE;
13746pub const VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR: VkDynamicState = 1000347000;
13747pub const VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV: VkDynamicState = 1000455031;
13748pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT: VkDynamicState = 1000455017;
13749pub const VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT: VkDynamicState = 1000143000;
13750pub const VK_DYNAMIC_STATE_SAMPLE_MASK_EXT: VkDynamicState = 1000455006;
13751pub const VK_DYNAMIC_STATE_SCISSOR: VkDynamicState = 1;
13752pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT: VkDynamicState = 1000267004;
13753pub const VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT;
13754pub const VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV: VkDynamicState = 1000455030;
13755pub const VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK: VkDynamicState = 6;
13756pub const VK_DYNAMIC_STATE_STENCIL_OP: VkDynamicState = 1000267011;
13757pub const VK_DYNAMIC_STATE_STENCIL_OP_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_OP;
13758pub const VK_DYNAMIC_STATE_STENCIL_REFERENCE: VkDynamicState = 8;
13759pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE: VkDynamicState = 1000267010;
13760pub const VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT: VkDynamicState = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE;
13761pub const VK_DYNAMIC_STATE_STENCIL_WRITE_MASK: VkDynamicState = 7;
13762pub const VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT: VkDynamicState = 1000455002;
13763pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE: VkDynamicState = 1000267005;
13764pub const VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT: VkDynamicState = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE;
13765pub const VK_DYNAMIC_STATE_VERTEX_INPUT_EXT: VkDynamicState = 1000352000;
13766pub const VK_DYNAMIC_STATE_VIEWPORT: VkDynamicState = 0;
13767pub const VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV: VkDynamicState = 1000164006;
13768pub const VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV: VkDynamicState = 1000164004;
13769pub const VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV: VkDynamicState = 1000455024;
13770pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT: VkDynamicState = 1000267003;
13771pub const VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT: VkDynamicState = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT;
13772pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV: VkDynamicState = 1000455023;
13773pub const VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV: VkDynamicState = 1000087000;
13774pub const VK_ERROR_COMPRESSION_EXHAUSTED_EXT: VkResult = -1000338000;
13775pub const VK_ERROR_DEVICE_LOST: VkResult = -4;
13776pub const VK_ERROR_EXTENSION_NOT_PRESENT: VkResult = -7;
13777pub const VK_ERROR_FEATURE_NOT_PRESENT: VkResult = -8;
13778pub const VK_ERROR_FORMAT_NOT_SUPPORTED: VkResult = -11;
13779pub const VK_ERROR_FRAGMENTATION: VkResult = -1000161000;
13780pub const VK_ERROR_FRAGMENTATION_EXT: VkResult = VK_ERROR_FRAGMENTATION;
13781pub const VK_ERROR_FRAGMENTED_POOL: VkResult = -12;
13782pub const VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR: VkResult = -1000023000;
13783pub const VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: VkResult = -1000003001;
13784pub const VK_ERROR_INCOMPATIBLE_DRIVER: VkResult = -9;
13785pub const VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = VK_INCOMPATIBLE_SHADER_BINARY_EXT;
13786pub const VK_ERROR_INITIALIZATION_FAILED: VkResult = -3;
13787pub const VK_ERROR_INVALID_DEVICE_ADDRESS_EXT: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
13788pub const VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: VkResult = -1000158000;
13789pub const VK_ERROR_INVALID_EXTERNAL_HANDLE: VkResult = -1000072003;
13790pub const VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR: VkResult = VK_ERROR_INVALID_EXTERNAL_HANDLE;
13791pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: VkResult = -1000257000;
13792pub const VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR: VkResult = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS;
13793pub const VK_ERROR_INVALID_SHADER_NV: VkResult = -1000012000;
13794pub const VK_ERROR_INVALID_VIDEO_STD_PARAMETERS_KHR: VkResult = -1000299000;
13795pub const VK_ERROR_LAYER_NOT_PRESENT: VkResult = -6;
13796pub const VK_ERROR_MEMORY_MAP_FAILED: VkResult = -5;
13797pub const VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: VkResult = -1000000001;
13798pub const VK_ERROR_NOT_ENOUGH_SPACE_KHR: VkResult = -1000483000;
13799pub const VK_ERROR_NOT_PERMITTED: VkResult = -1000174001;
13800pub const VK_ERROR_NOT_PERMITTED_EXT: VkResult = VK_ERROR_NOT_PERMITTED;
13801pub const VK_ERROR_NOT_PERMITTED_KHR: VkResult = VK_ERROR_NOT_PERMITTED;
13802pub const VK_ERROR_OUT_OF_DATE_KHR: VkResult = -1000001004;
13803pub const VK_ERROR_OUT_OF_DEVICE_MEMORY: VkResult = -2;
13804pub const VK_ERROR_OUT_OF_HOST_MEMORY: VkResult = -1;
13805pub const VK_ERROR_OUT_OF_POOL_MEMORY: VkResult = -1000069000;
13806pub const VK_ERROR_OUT_OF_POOL_MEMORY_KHR: VkResult = VK_ERROR_OUT_OF_POOL_MEMORY;
13807pub const VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
13808pub const VK_ERROR_PRESENT_TIMING_QUEUE_FULL_EXT: VkResult = -1000208000;
13809pub const VK_ERROR_SURFACE_LOST_KHR: VkResult = -1000000000;
13810pub const VK_ERROR_TOO_MANY_OBJECTS: VkResult = -10;
13811pub const VK_ERROR_UNKNOWN: VkResult = -13;
13812pub const VK_ERROR_VALIDATION_FAILED: VkResult = -1000011001;
13813pub const VK_ERROR_VALIDATION_FAILED_EXT: VkResult = VK_ERROR_VALIDATION_FAILED;
13814pub const VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR: VkResult = -1000023001;
13815pub const VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR: VkResult = -1000023004;
13816pub const VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR: VkResult = -1000023003;
13817pub const VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR: VkResult = -1000023002;
13818pub const VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR: VkResult = -1000023005;
13819pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT: VkEventCreateFlagBits = 1 << 0;
13820pub const VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR: VkEventCreateFlagBits = VK_EVENT_CREATE_DEVICE_ONLY_BIT;
13821pub const VK_EVENT_RESET: VkResult = 4;
13822pub const VK_EVENT_SET: VkResult = 3;
13823pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT: VkExternalFenceFeatureFlagBits = 1 << 0;
13824pub const VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT;
13825pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT: VkExternalFenceFeatureFlagBits = 1 << 1;
13826pub const VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalFenceFeatureFlagBits = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT;
13827pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 0;
13828pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT;
13829pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 1;
13830pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
13831pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 2;
13832pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
13833pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalFenceHandleTypeFlagBits = 1 << 3;
13834pub const VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalFenceHandleTypeFlagBits = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT;
13835pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT: VkExternalMemoryFeatureFlagBits = 1 << 0;
13836pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT;
13837pub const VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 0;
13838pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT: VkExternalMemoryFeatureFlagBits = 1 << 1;
13839pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
13840pub const VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 1;
13841pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT: VkExternalMemoryFeatureFlagBits = 1 << 2;
13842pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR: VkExternalMemoryFeatureFlagBits = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT;
13843pub const VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV: VkExternalMemoryFeatureFlagBitsNV = 1 << 2;
13844pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 2;
13845pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 3;
13846pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 3;
13847pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT;
13848pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 4;
13849pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT;
13850pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 5;
13851pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT;
13852pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 6;
13853pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT;
13854pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 9;
13855pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 7;
13856pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT: VkExternalMemoryHandleTypeFlagBits = 1 << 8;
13857pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 0;
13858pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
13859pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 1;
13860pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT;
13861pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 0;
13862pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalMemoryHandleTypeFlagBits = 1 << 2;
13863pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalMemoryHandleTypeFlagBits = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
13864pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV: VkExternalMemoryHandleTypeFlagBitsNV = 1 << 1;
13865pub const VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV: VkExternalMemoryHandleTypeFlagBits = 1 << 12;
13866pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBits = 1 << 0;
13867pub const VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBits = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT;
13868pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT: VkExternalSemaphoreFeatureFlagBits = 1 << 1;
13869pub const VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR: VkExternalSemaphoreFeatureFlagBits = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
13870pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
13871pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 3;
13872pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT;
13873pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 0;
13874pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
13875pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 1;
13876pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT;
13877pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 2;
13878pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT;
13879pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT: VkExternalSemaphoreHandleTypeFlagBits = 1 << 4;
13880pub const VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR: VkExternalSemaphoreHandleTypeFlagBits = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT;
13881pub const VK_EXT_4444_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_4444_formats";
13882pub const VK_EXT_4444_FORMATS_SPEC_VERSION: u32 = 1;
13883pub const VK_EXT_ACQUIRE_DRM_DISPLAY_EXTENSION_NAME: &CStr = c"VK_EXT_acquire_drm_display";
13884pub const VK_EXT_ACQUIRE_DRM_DISPLAY_SPEC_VERSION: u32 = 1;
13885pub const VK_EXT_ASTC_DECODE_MODE_EXTENSION_NAME: &CStr = c"VK_EXT_astc_decode_mode";
13886pub const VK_EXT_ASTC_DECODE_MODE_SPEC_VERSION: u32 = 1;
13887pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_attachment_feedback_loop_dynamic_state";
13888pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_SPEC_VERSION: u32 = 1;
13889pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME: &CStr = c"VK_EXT_attachment_feedback_loop_layout";
13890pub const VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_SPEC_VERSION: u32 = 2;
13891pub const VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME: &CStr = c"VK_EXT_blend_operation_advanced";
13892pub const VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION: u32 = 2;
13893pub const VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME: &CStr = c"VK_EXT_border_color_swizzle";
13894pub const VK_EXT_BORDER_COLOR_SWIZZLE_SPEC_VERSION: u32 = 1;
13895pub const VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME: &CStr = c"VK_EXT_buffer_device_address";
13896pub const VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION: u32 = 2;
13897pub const VK_EXT_CALIBRATED_TIMESTAMPS_EXTENSION_NAME: &CStr = c"VK_EXT_calibrated_timestamps";
13898pub const VK_EXT_CALIBRATED_TIMESTAMPS_SPEC_VERSION: u32 = 2;
13899pub const VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME: &CStr = c"VK_EXT_color_write_enable";
13900pub const VK_EXT_COLOR_WRITE_ENABLE_SPEC_VERSION: u32 = 1;
13901pub const VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME: &CStr = c"VK_EXT_conditional_rendering";
13902pub const VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION: u32 = 2;
13903pub const VK_EXT_CONSERVATIVE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_EXT_conservative_rasterization";
13904pub const VK_EXT_CONSERVATIVE_RASTERIZATION_SPEC_VERSION: u32 = 1;
13905pub const VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME: &CStr = c"VK_EXT_custom_border_color";
13906pub const VK_EXT_CUSTOM_BORDER_COLOR_SPEC_VERSION: u32 = 12;
13907pub const VK_EXT_CUSTOM_RESOLVE_EXTENSION_NAME: &CStr = c"VK_EXT_custom_resolve";
13908pub const VK_EXT_CUSTOM_RESOLVE_SPEC_VERSION: u32 = 1;
13909pub const VK_EXT_DEBUG_MARKER_EXTENSION_NAME: &CStr = c"VK_EXT_debug_marker";
13910pub const VK_EXT_DEBUG_MARKER_SPEC_VERSION: u32 = 4;
13911pub const VK_EXT_DEBUG_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_debug_report";
13912pub const VK_EXT_DEBUG_REPORT_SPEC_VERSION: u32 = 10;
13913pub const VK_EXT_DEBUG_UTILS_EXTENSION_NAME: &CStr = c"VK_EXT_debug_utils";
13914pub const VK_EXT_DEBUG_UTILS_SPEC_VERSION: u32 = 2;
13915pub const VK_EXT_DEPTH_BIAS_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_bias_control";
13916pub const VK_EXT_DEPTH_BIAS_CONTROL_SPEC_VERSION: u32 = 1;
13917pub const VK_EXT_DEPTH_CLAMP_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clamp_control";
13918pub const VK_EXT_DEPTH_CLAMP_CONTROL_SPEC_VERSION: u32 = 1;
13919pub const VK_EXT_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clamp_zero_one";
13920pub const VK_EXT_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION: u32 = 1;
13921pub const VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clip_control";
13922pub const VK_EXT_DEPTH_CLIP_CONTROL_SPEC_VERSION: u32 = 1;
13923pub const VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME: &CStr = c"VK_EXT_depth_clip_enable";
13924pub const VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION: u32 = 1;
13925pub const VK_EXT_DEPTH_RANGE_UNRESTRICTED_EXTENSION_NAME: &CStr = c"VK_EXT_depth_range_unrestricted";
13926pub const VK_EXT_DEPTH_RANGE_UNRESTRICTED_SPEC_VERSION: u32 = 1;
13927pub const VK_EXT_DESCRIPTOR_BUFFER_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_buffer";
13928pub const VK_EXT_DESCRIPTOR_BUFFER_SPEC_VERSION: u32 = 1;
13929pub const VK_EXT_DESCRIPTOR_HEAP_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_heap";
13930pub const VK_EXT_DESCRIPTOR_HEAP_SPEC_VERSION: u32 = 1;
13931pub const VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME: &CStr = c"VK_EXT_descriptor_indexing";
13932pub const VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION: u32 = 2;
13933pub const VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_device_address_binding_report";
13934pub const VK_EXT_DEVICE_ADDRESS_BINDING_REPORT_SPEC_VERSION: u32 = 1;
13935pub const VK_EXT_DEVICE_FAULT_EXTENSION_NAME: &CStr = c"VK_EXT_device_fault";
13936pub const VK_EXT_DEVICE_FAULT_SPEC_VERSION: u32 = 2;
13937pub const VK_EXT_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: &CStr = c"VK_EXT_device_generated_commands";
13938pub const VK_EXT_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: u32 = 1;
13939pub const VK_EXT_DEVICE_MEMORY_REPORT_EXTENSION_NAME: &CStr = c"VK_EXT_device_memory_report";
13940pub const VK_EXT_DEVICE_MEMORY_REPORT_SPEC_VERSION: u32 = 2;
13941pub const VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME: &CStr = c"VK_EXT_direct_mode_display";
13942pub const VK_EXT_DIRECT_MODE_DISPLAY_SPEC_VERSION: u32 = 1;
13943pub const VK_EXT_DISCARD_RECTANGLES_EXTENSION_NAME: &CStr = c"VK_EXT_discard_rectangles";
13944pub const VK_EXT_DISCARD_RECTANGLES_SPEC_VERSION: u32 = 2;
13945pub const VK_EXT_DISPLAY_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_display_control";
13946pub const VK_EXT_DISPLAY_CONTROL_SPEC_VERSION: u32 = 1;
13947pub const VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME: &CStr = c"VK_EXT_display_surface_counter";
13948pub const VK_EXT_DISPLAY_SURFACE_COUNTER_SPEC_VERSION: u32 = 1;
13949pub const VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_EXTENSION_NAME: &CStr = c"VK_EXT_dynamic_rendering_unused_attachments";
13950pub const VK_EXT_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_SPEC_VERSION: u32 = 1;
13951pub const VK_EXT_EXTENDED_DYNAMIC_STATE_2_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state2";
13952pub const VK_EXT_EXTENDED_DYNAMIC_STATE_2_SPEC_VERSION: u32 = 1;
13953pub const VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state3";
13954pub const VK_EXT_EXTENDED_DYNAMIC_STATE_3_SPEC_VERSION: u32 = 2;
13955pub const VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_extended_dynamic_state";
13956pub const VK_EXT_EXTENDED_DYNAMIC_STATE_SPEC_VERSION: u32 = 1;
13957pub const VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_acquire_unmodified";
13958pub const VK_EXT_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_SPEC_VERSION: u32 = 1;
13959pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_dma_buf";
13960pub const VK_EXT_EXTERNAL_MEMORY_DMA_BUF_SPEC_VERSION: u32 = 1;
13961pub const VK_EXT_EXTERNAL_MEMORY_HOST_EXTENSION_NAME: &CStr = c"VK_EXT_external_memory_host";
13962pub const VK_EXT_EXTERNAL_MEMORY_HOST_SPEC_VERSION: u32 = 1;
13963pub const VK_EXT_FILTER_CUBIC_EXTENSION_NAME: &CStr = c"VK_EXT_filter_cubic";
13964pub const VK_EXT_FILTER_CUBIC_SPEC_VERSION: u32 = 3;
13965pub const VK_EXT_FRAGMENT_DENSITY_MAP_2_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map2";
13966pub const VK_EXT_FRAGMENT_DENSITY_MAP_2_SPEC_VERSION: u32 = 1;
13967pub const VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map";
13968pub const VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_density_map_offset";
13969pub const VK_EXT_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION: u32 = 1;
13970pub const VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION: u32 = 3;
13971pub const VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME: &CStr = c"VK_EXT_fragment_shader_interlock";
13972pub const VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION: u32 = 1;
13973pub const VK_EXT_FRAME_BOUNDARY_EXTENSION_NAME: &CStr = c"VK_EXT_frame_boundary";
13974pub const VK_EXT_FRAME_BOUNDARY_SPEC_VERSION: u32 = 1;
13975pub const VK_EXT_GLOBAL_PRIORITY_EXTENSION_NAME: &CStr = c"VK_EXT_global_priority";
13976pub const VK_EXT_GLOBAL_PRIORITY_QUERY_EXTENSION_NAME: &CStr = c"VK_EXT_global_priority_query";
13977pub const VK_EXT_GLOBAL_PRIORITY_QUERY_SPEC_VERSION: u32 = 1;
13978pub const VK_EXT_GLOBAL_PRIORITY_SPEC_VERSION: u32 = 2;
13979pub const VK_EXT_GRAPHICS_PIPELINE_LIBRARY_EXTENSION_NAME: &CStr = c"VK_EXT_graphics_pipeline_library";
13980pub const VK_EXT_GRAPHICS_PIPELINE_LIBRARY_SPEC_VERSION: u32 = 1;
13981pub const VK_EXT_HDR_METADATA_EXTENSION_NAME: &CStr = c"VK_EXT_hdr_metadata";
13982pub const VK_EXT_HDR_METADATA_SPEC_VERSION: u32 = 3;
13983pub const VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME: &CStr = c"VK_EXT_headless_surface";
13984pub const VK_EXT_HEADLESS_SURFACE_SPEC_VERSION: u32 = 1;
13985pub const VK_EXT_HOST_IMAGE_COPY_EXTENSION_NAME: &CStr = c"VK_EXT_host_image_copy";
13986pub const VK_EXT_HOST_IMAGE_COPY_SPEC_VERSION: u32 = 1;
13987pub const VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME: &CStr = c"VK_EXT_host_query_reset";
13988pub const VK_EXT_HOST_QUERY_RESET_SPEC_VERSION: u32 = 1;
13989pub const VK_EXT_IMAGE_2D_VIEW_OF_3D_EXTENSION_NAME: &CStr = c"VK_EXT_image_2d_view_of_3d";
13990pub const VK_EXT_IMAGE_2D_VIEW_OF_3D_SPEC_VERSION: u32 = 1;
13991pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_image_compression_control";
13992pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SPEC_VERSION: u32 = 1;
13993pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_EXT_image_compression_control_swapchain";
13994pub const VK_EXT_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_SPEC_VERSION: u32 = 1;
13995pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_EXTENSION_NAME: &CStr = c"VK_EXT_image_drm_format_modifier";
13996pub const VK_EXT_IMAGE_DRM_FORMAT_MODIFIER_SPEC_VERSION: u32 = 2;
13997pub const VK_EXT_IMAGE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_image_robustness";
13998pub const VK_EXT_IMAGE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
13999pub const VK_EXT_IMAGE_SLICED_VIEW_OF_3D_EXTENSION_NAME: &CStr = c"VK_EXT_image_sliced_view_of_3d";
14000pub const VK_EXT_IMAGE_SLICED_VIEW_OF_3D_SPEC_VERSION: u32 = 1;
14001pub const VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME: &CStr = c"VK_EXT_image_view_min_lod";
14002pub const VK_EXT_IMAGE_VIEW_MIN_LOD_SPEC_VERSION: u32 = 1;
14003pub const VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME: &CStr = c"VK_EXT_index_type_uint8";
14004pub const VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION: u32 = 1;
14005pub const VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME: &CStr = c"VK_EXT_inline_uniform_block";
14006pub const VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION: u32 = 1;
14007pub const VK_EXT_LAYER_SETTINGS_EXTENSION_NAME: &CStr = c"VK_EXT_layer_settings";
14008pub const VK_EXT_LAYER_SETTINGS_SPEC_VERSION: u32 = 2;
14009pub const VK_EXT_LEGACY_DITHERING_EXTENSION_NAME: &CStr = c"VK_EXT_legacy_dithering";
14010pub const VK_EXT_LEGACY_DITHERING_SPEC_VERSION: u32 = 2;
14011pub const VK_EXT_LEGACY_VERTEX_ATTRIBUTES_EXTENSION_NAME: &CStr = c"VK_EXT_legacy_vertex_attributes";
14012pub const VK_EXT_LEGACY_VERTEX_ATTRIBUTES_SPEC_VERSION: u32 = 1;
14013pub const VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_EXT_line_rasterization";
14014pub const VK_EXT_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
14015pub const VK_EXT_LOAD_STORE_OP_NONE_EXTENSION_NAME: &CStr = c"VK_EXT_load_store_op_none";
14016pub const VK_EXT_LOAD_STORE_OP_NONE_SPEC_VERSION: u32 = 1;
14017pub const VK_EXT_MAP_MEMORY_PLACED_EXTENSION_NAME: &CStr = c"VK_EXT_map_memory_placed";
14018pub const VK_EXT_MAP_MEMORY_PLACED_SPEC_VERSION: u32 = 1;
14019pub const VK_EXT_MEMORY_BUDGET_EXTENSION_NAME: &CStr = c"VK_EXT_memory_budget";
14020pub const VK_EXT_MEMORY_BUDGET_SPEC_VERSION: u32 = 1;
14021pub const VK_EXT_MEMORY_DECOMPRESSION_EXTENSION_NAME: &CStr = c"VK_EXT_memory_decompression";
14022pub const VK_EXT_MEMORY_DECOMPRESSION_SPEC_VERSION: u32 = 1;
14023pub const VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME: &CStr = c"VK_EXT_memory_priority";
14024pub const VK_EXT_MEMORY_PRIORITY_SPEC_VERSION: u32 = 1;
14025pub const VK_EXT_MESH_SHADER_EXTENSION_NAME: &CStr = c"VK_EXT_mesh_shader";
14026pub const VK_EXT_MESH_SHADER_SPEC_VERSION: u32 = 1;
14027pub const VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_EXTENSION_NAME: &CStr = c"VK_EXT_multisampled_render_to_single_sampled";
14028pub const VK_EXT_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_SPEC_VERSION: u32 = 1;
14029pub const VK_EXT_MULTI_DRAW_EXTENSION_NAME: &CStr = c"VK_EXT_multi_draw";
14030pub const VK_EXT_MULTI_DRAW_SPEC_VERSION: u32 = 1;
14031pub const VK_EXT_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME: &CStr = c"VK_EXT_mutable_descriptor_type";
14032pub const VK_EXT_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION: u32 = 1;
14033pub const VK_EXT_NESTED_COMMAND_BUFFER_EXTENSION_NAME: &CStr = c"VK_EXT_nested_command_buffer";
14034pub const VK_EXT_NESTED_COMMAND_BUFFER_SPEC_VERSION: u32 = 1;
14035pub const VK_EXT_NON_SEAMLESS_CUBE_MAP_EXTENSION_NAME: &CStr = c"VK_EXT_non_seamless_cube_map";
14036pub const VK_EXT_NON_SEAMLESS_CUBE_MAP_SPEC_VERSION: u32 = 1;
14037pub const VK_EXT_OPACITY_MICROMAP_EXTENSION_NAME: &CStr = c"VK_EXT_opacity_micromap";
14038pub const VK_EXT_OPACITY_MICROMAP_SPEC_VERSION: u32 = 2;
14039pub const VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_EXT_pageable_device_local_memory";
14040pub const VK_EXT_PAGEABLE_DEVICE_LOCAL_MEMORY_SPEC_VERSION: u32 = 1;
14041pub const VK_EXT_PCI_BUS_INFO_EXTENSION_NAME: &CStr = c"VK_EXT_pci_bus_info";
14042pub const VK_EXT_PCI_BUS_INFO_SPEC_VERSION: u32 = 2;
14043pub const VK_EXT_PHYSICAL_DEVICE_DRM_EXTENSION_NAME: &CStr = c"VK_EXT_physical_device_drm";
14044pub const VK_EXT_PHYSICAL_DEVICE_DRM_SPEC_VERSION: u32 = 1;
14045pub const VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_creation_cache_control";
14046pub const VK_EXT_PIPELINE_CREATION_CACHE_CONTROL_SPEC_VERSION: u32 = 3;
14047pub const VK_EXT_PIPELINE_CREATION_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_creation_feedback";
14048pub const VK_EXT_PIPELINE_CREATION_FEEDBACK_SPEC_VERSION: u32 = 1;
14049pub const VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_library_group_handles";
14050pub const VK_EXT_PIPELINE_LIBRARY_GROUP_HANDLES_SPEC_VERSION: u32 = 1;
14051pub const VK_EXT_PIPELINE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_properties";
14052pub const VK_EXT_PIPELINE_PROPERTIES_SPEC_VERSION: u32 = 1;
14053pub const VK_EXT_PIPELINE_PROTECTED_ACCESS_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_protected_access";
14054pub const VK_EXT_PIPELINE_PROTECTED_ACCESS_SPEC_VERSION: u32 = 1;
14055pub const VK_EXT_PIPELINE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_pipeline_robustness";
14056pub const VK_EXT_PIPELINE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
14057pub const VK_EXT_POST_DEPTH_COVERAGE_EXTENSION_NAME: &CStr = c"VK_EXT_post_depth_coverage";
14058pub const VK_EXT_POST_DEPTH_COVERAGE_SPEC_VERSION: u32 = 1;
14059pub const VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME: &CStr = c"VK_EXT_present_mode_fifo_latest_ready";
14060pub const VK_EXT_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION: u32 = 1;
14061pub const VK_EXT_PRESENT_TIMING_EXTENSION_NAME: &CStr = c"VK_EXT_present_timing";
14062pub const VK_EXT_PRESENT_TIMING_SPEC_VERSION: u32 = 3;
14063pub const VK_EXT_PRIMITIVES_GENERATED_QUERY_EXTENSION_NAME: &CStr = c"VK_EXT_primitives_generated_query";
14064pub const VK_EXT_PRIMITIVES_GENERATED_QUERY_SPEC_VERSION: u32 = 1;
14065pub const VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_EXTENSION_NAME: &CStr = c"VK_EXT_primitive_topology_list_restart";
14066pub const VK_EXT_PRIMITIVE_TOPOLOGY_LIST_RESTART_SPEC_VERSION: u32 = 1;
14067pub const VK_EXT_PRIVATE_DATA_EXTENSION_NAME: &CStr = c"VK_EXT_private_data";
14068pub const VK_EXT_PRIVATE_DATA_SPEC_VERSION: u32 = 1;
14069pub const VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME: &CStr = c"VK_EXT_provoking_vertex";
14070pub const VK_EXT_PROVOKING_VERTEX_SPEC_VERSION: u32 = 1;
14071pub const VK_EXT_QUEUE_FAMILY_FOREIGN_EXTENSION_NAME: &CStr = c"VK_EXT_queue_family_foreign";
14072pub const VK_EXT_QUEUE_FAMILY_FOREIGN_SPEC_VERSION: u32 = 1;
14073pub const VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_EXTENSION_NAME: &CStr = c"VK_EXT_rasterization_order_attachment_access";
14074pub const VK_EXT_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_SPEC_VERSION: u32 = 1;
14075pub const VK_EXT_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME: &CStr = c"VK_EXT_ray_tracing_invocation_reorder";
14076pub const VK_EXT_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION: u32 = 1;
14077pub const VK_EXT_RGBA10X6_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_rgba10x6_formats";
14078pub const VK_EXT_RGBA10X6_FORMATS_SPEC_VERSION: u32 = 1;
14079pub const VK_EXT_ROBUSTNESS_2_EXTENSION_NAME: &CStr = c"VK_EXT_robustness2";
14080pub const VK_EXT_ROBUSTNESS_2_SPEC_VERSION: u32 = 1;
14081pub const VK_EXT_SAMPLER_FILTER_MINMAX_EXTENSION_NAME: &CStr = c"VK_EXT_sampler_filter_minmax";
14082pub const VK_EXT_SAMPLER_FILTER_MINMAX_SPEC_VERSION: u32 = 2;
14083pub const VK_EXT_SAMPLE_LOCATIONS_EXTENSION_NAME: &CStr = c"VK_EXT_sample_locations";
14084pub const VK_EXT_SAMPLE_LOCATIONS_SPEC_VERSION: u32 = 1;
14085pub const VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME: &CStr = c"VK_EXT_scalar_block_layout";
14086pub const VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION: u32 = 1;
14087pub const VK_EXT_SEPARATE_STENCIL_USAGE_EXTENSION_NAME: &CStr = c"VK_EXT_separate_stencil_usage";
14088pub const VK_EXT_SEPARATE_STENCIL_USAGE_SPEC_VERSION: u32 = 1;
14089pub const VK_EXT_SHADER_64BIT_INDEXING_EXTENSION_NAME: &CStr = c"VK_EXT_shader_64bit_indexing";
14090pub const VK_EXT_SHADER_64BIT_INDEXING_SPEC_VERSION: u32 = 1;
14091pub const VK_EXT_SHADER_ATOMIC_FLOAT_2_EXTENSION_NAME: &CStr = c"VK_EXT_shader_atomic_float2";
14092pub const VK_EXT_SHADER_ATOMIC_FLOAT_2_SPEC_VERSION: u32 = 1;
14093pub const VK_EXT_SHADER_ATOMIC_FLOAT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_atomic_float";
14094pub const VK_EXT_SHADER_ATOMIC_FLOAT_SPEC_VERSION: u32 = 1;
14095pub const VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME: &CStr = c"VK_EXT_shader_demote_to_helper_invocation";
14096pub const VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION: u32 = 1;
14097pub const VK_EXT_SHADER_FLOAT8_EXTENSION_NAME: &CStr = c"VK_EXT_shader_float8";
14098pub const VK_EXT_SHADER_FLOAT8_SPEC_VERSION: u32 = 1;
14099pub const VK_EXT_SHADER_IMAGE_ATOMIC_INT64_EXTENSION_NAME: &CStr = c"VK_EXT_shader_image_atomic_int64";
14100pub const VK_EXT_SHADER_IMAGE_ATOMIC_INT64_SPEC_VERSION: u32 = 1;
14101pub const VK_EXT_SHADER_LONG_VECTOR_EXTENSION_NAME: &CStr = c"VK_EXT_shader_long_vector";
14102pub const VK_EXT_SHADER_LONG_VECTOR_SPEC_VERSION: u32 = 1;
14103pub const VK_EXT_SHADER_MODULE_IDENTIFIER_EXTENSION_NAME: &CStr = c"VK_EXT_shader_module_identifier";
14104pub const VK_EXT_SHADER_MODULE_IDENTIFIER_SPEC_VERSION: u32 = 1;
14105pub const VK_EXT_SHADER_OBJECT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_object";
14106pub const VK_EXT_SHADER_OBJECT_SPEC_VERSION: u32 = 1;
14107pub const VK_EXT_SHADER_REPLICATED_COMPOSITES_EXTENSION_NAME: &CStr = c"VK_EXT_shader_replicated_composites";
14108pub const VK_EXT_SHADER_REPLICATED_COMPOSITES_SPEC_VERSION: u32 = 1;
14109pub const VK_EXT_SHADER_STENCIL_EXPORT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_stencil_export";
14110pub const VK_EXT_SHADER_STENCIL_EXPORT_SPEC_VERSION: u32 = 1;
14111pub const VK_EXT_SHADER_SUBGROUP_BALLOT_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_ballot";
14112pub const VK_EXT_SHADER_SUBGROUP_BALLOT_SPEC_VERSION: u32 = 1;
14113pub const VK_EXT_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_partitioned";
14114pub const VK_EXT_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION: u32 = 1;
14115pub const VK_EXT_SHADER_SUBGROUP_VOTE_EXTENSION_NAME: &CStr = c"VK_EXT_shader_subgroup_vote";
14116pub const VK_EXT_SHADER_SUBGROUP_VOTE_SPEC_VERSION: u32 = 1;
14117pub const VK_EXT_SHADER_TILE_IMAGE_EXTENSION_NAME: &CStr = c"VK_EXT_shader_tile_image";
14118pub const VK_EXT_SHADER_TILE_IMAGE_SPEC_VERSION: u32 = 1;
14119pub const VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_EXTENSION_NAME: &CStr = c"VK_EXT_shader_uniform_buffer_unsized_array";
14120pub const VK_EXT_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_SPEC_VERSION: u32 = 1;
14121pub const VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_EXTENSION_NAME: &CStr = c"VK_EXT_shader_viewport_index_layer";
14122pub const VK_EXT_SHADER_VIEWPORT_INDEX_LAYER_SPEC_VERSION: u32 = 1;
14123pub const VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME: &CStr = c"VK_EXT_subgroup_size_control";
14124pub const VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION: u32 = 2;
14125pub const VK_EXT_SUBPASS_MERGE_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_subpass_merge_feedback";
14126pub const VK_EXT_SUBPASS_MERGE_FEEDBACK_SPEC_VERSION: u32 = 2;
14127pub const VK_EXT_SURFACE_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_EXT_surface_maintenance1";
14128pub const VK_EXT_SURFACE_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
14129pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_EXTENSION_NAME: &CStr = c"VK_EXT_swapchain_colorspace";
14130pub const VK_EXT_SWAPCHAIN_COLOR_SPACE_SPEC_VERSION: u32 = 5;
14131pub const VK_EXT_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_EXT_swapchain_maintenance1";
14132pub const VK_EXT_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
14133pub const VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME: &CStr = c"VK_EXT_texel_buffer_alignment";
14134pub const VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION: u32 = 1;
14135pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_EXTENSION_NAME: &CStr = c"VK_EXT_texture_compression_astc_3d";
14136pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_3D_SPEC_VERSION: u32 = 1;
14137pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_EXTENSION_NAME: &CStr = c"VK_EXT_texture_compression_astc_hdr";
14138pub const VK_EXT_TEXTURE_COMPRESSION_ASTC_HDR_SPEC_VERSION: u32 = 1;
14139pub const VK_EXT_TOOLING_INFO_EXTENSION_NAME: &CStr = c"VK_EXT_tooling_info";
14140pub const VK_EXT_TOOLING_INFO_SPEC_VERSION: u32 = 1;
14141pub const VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME: &CStr = c"VK_EXT_transform_feedback";
14142pub const VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION: u32 = 1;
14143pub const VK_EXT_VALIDATION_CACHE_EXTENSION_NAME: &CStr = c"VK_EXT_validation_cache";
14144pub const VK_EXT_VALIDATION_CACHE_SPEC_VERSION: u32 = 1;
14145pub const VK_EXT_VALIDATION_FEATURES_EXTENSION_NAME: &CStr = c"VK_EXT_validation_features";
14146pub const VK_EXT_VALIDATION_FEATURES_SPEC_VERSION: u32 = 6;
14147pub const VK_EXT_VALIDATION_FLAGS_EXTENSION_NAME: &CStr = c"VK_EXT_validation_flags";
14148pub const VK_EXT_VALIDATION_FLAGS_SPEC_VERSION: u32 = 3;
14149pub const VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_attribute_divisor";
14150pub const VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION: u32 = 3;
14151pub const VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_attribute_robustness";
14152pub const VK_EXT_VERTEX_ATTRIBUTE_ROBUSTNESS_SPEC_VERSION: u32 = 1;
14153pub const VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_EXTENSION_NAME: &CStr = c"VK_EXT_vertex_input_dynamic_state";
14154pub const VK_EXT_VERTEX_INPUT_DYNAMIC_STATE_SPEC_VERSION: u32 = 2;
14155pub const VK_EXT_YCBCR_2PLANE_444_FORMATS_EXTENSION_NAME: &CStr = c"VK_EXT_ycbcr_2plane_444_formats";
14156pub const VK_EXT_YCBCR_2PLANE_444_FORMATS_SPEC_VERSION: u32 = 1;
14157pub const VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME: &CStr = c"VK_EXT_ycbcr_image_arrays";
14158pub const VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION: u32 = 1;
14159pub const VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_EXTENSION_NAME: &CStr = c"VK_EXT_zero_initialize_device_memory";
14160pub const VK_EXT_ZERO_INITIALIZE_DEVICE_MEMORY_SPEC_VERSION: u32 = 1;
14161pub const VK_FALSE: u32 = 0;
14162pub const VK_FENCE_CREATE_SIGNALED_BIT: VkFenceCreateFlagBits = 1 << 0;
14163pub const VK_FENCE_IMPORT_TEMPORARY_BIT: VkFenceImportFlagBits = 1 << 0;
14164pub const VK_FENCE_IMPORT_TEMPORARY_BIT_KHR: VkFenceImportFlagBits = VK_FENCE_IMPORT_TEMPORARY_BIT;
14165pub const VK_FILTER_CUBIC_EXT: VkFilter = 1000015000;
14166pub const VK_FILTER_CUBIC_IMG: VkFilter = VK_FILTER_CUBIC_EXT;
14167pub const VK_FILTER_LINEAR: VkFilter = 1;
14168pub const VK_FILTER_NEAREST: VkFilter = 0;
14169pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16: VkFormat = 1000470000;
14170pub const VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_A1B5G5R5_UNORM_PACK16;
14171pub const VK_FORMAT_A1R5G5B5_UNORM_PACK16: VkFormat = 8;
14172pub const VK_FORMAT_A2B10G10R10_SINT_PACK32: VkFormat = 69;
14173pub const VK_FORMAT_A2B10G10R10_SNORM_PACK32: VkFormat = 65;
14174pub const VK_FORMAT_A2B10G10R10_SSCALED_PACK32: VkFormat = 67;
14175pub const VK_FORMAT_A2B10G10R10_UINT_PACK32: VkFormat = 68;
14176pub const VK_FORMAT_A2B10G10R10_UNORM_PACK32: VkFormat = 64;
14177pub const VK_FORMAT_A2B10G10R10_USCALED_PACK32: VkFormat = 66;
14178pub const VK_FORMAT_A2R10G10B10_SINT_PACK32: VkFormat = 63;
14179pub const VK_FORMAT_A2R10G10B10_SNORM_PACK32: VkFormat = 59;
14180pub const VK_FORMAT_A2R10G10B10_SSCALED_PACK32: VkFormat = 61;
14181pub const VK_FORMAT_A2R10G10B10_UINT_PACK32: VkFormat = 62;
14182pub const VK_FORMAT_A2R10G10B10_UNORM_PACK32: VkFormat = 58;
14183pub const VK_FORMAT_A2R10G10B10_USCALED_PACK32: VkFormat = 60;
14184pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16: VkFormat = 1000340001;
14185pub const VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4B4G4R4_UNORM_PACK16;
14186pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16: VkFormat = 1000340000;
14187pub const VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT: VkFormat = VK_FORMAT_A4R4G4B4_UNORM_PACK16;
14188pub const VK_FORMAT_A8B8G8R8_SINT_PACK32: VkFormat = 56;
14189pub const VK_FORMAT_A8B8G8R8_SNORM_PACK32: VkFormat = 52;
14190pub const VK_FORMAT_A8B8G8R8_SRGB_PACK32: VkFormat = 57;
14191pub const VK_FORMAT_A8B8G8R8_SSCALED_PACK32: VkFormat = 54;
14192pub const VK_FORMAT_A8B8G8R8_UINT_PACK32: VkFormat = 55;
14193pub const VK_FORMAT_A8B8G8R8_UNORM_PACK32: VkFormat = 51;
14194pub const VK_FORMAT_A8B8G8R8_USCALED_PACK32: VkFormat = 53;
14195pub const VK_FORMAT_A8_UNORM: VkFormat = 1000470001;
14196pub const VK_FORMAT_A8_UNORM_KHR: VkFormat = VK_FORMAT_A8_UNORM;
14197pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK: VkFormat = 1000066011;
14198pub const VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK;
14199pub const VK_FORMAT_ASTC_10x10_SRGB_BLOCK: VkFormat = 180;
14200pub const VK_FORMAT_ASTC_10x10_UNORM_BLOCK: VkFormat = 179;
14201pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK: VkFormat = 1000066008;
14202pub const VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK;
14203pub const VK_FORMAT_ASTC_10x5_SRGB_BLOCK: VkFormat = 174;
14204pub const VK_FORMAT_ASTC_10x5_UNORM_BLOCK: VkFormat = 173;
14205pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK: VkFormat = 1000066009;
14206pub const VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK;
14207pub const VK_FORMAT_ASTC_10x6_SRGB_BLOCK: VkFormat = 176;
14208pub const VK_FORMAT_ASTC_10x6_UNORM_BLOCK: VkFormat = 175;
14209pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK: VkFormat = 1000066010;
14210pub const VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK;
14211pub const VK_FORMAT_ASTC_10x8_SRGB_BLOCK: VkFormat = 178;
14212pub const VK_FORMAT_ASTC_10x8_UNORM_BLOCK: VkFormat = 177;
14213pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK: VkFormat = 1000066012;
14214pub const VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK;
14215pub const VK_FORMAT_ASTC_12x10_SRGB_BLOCK: VkFormat = 182;
14216pub const VK_FORMAT_ASTC_12x10_UNORM_BLOCK: VkFormat = 181;
14217pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK: VkFormat = 1000066013;
14218pub const VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK;
14219pub const VK_FORMAT_ASTC_12x12_SRGB_BLOCK: VkFormat = 184;
14220pub const VK_FORMAT_ASTC_12x12_UNORM_BLOCK: VkFormat = 183;
14221pub const VK_FORMAT_ASTC_3x3x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288002;
14222pub const VK_FORMAT_ASTC_3x3x3_SRGB_BLOCK_EXT: VkFormat = 1000288001;
14223pub const VK_FORMAT_ASTC_3x3x3_UNORM_BLOCK_EXT: VkFormat = 1000288000;
14224pub const VK_FORMAT_ASTC_4x3x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288005;
14225pub const VK_FORMAT_ASTC_4x3x3_SRGB_BLOCK_EXT: VkFormat = 1000288004;
14226pub const VK_FORMAT_ASTC_4x3x3_UNORM_BLOCK_EXT: VkFormat = 1000288003;
14227pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK: VkFormat = 1000066000;
14228pub const VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK;
14229pub const VK_FORMAT_ASTC_4x4_SRGB_BLOCK: VkFormat = 158;
14230pub const VK_FORMAT_ASTC_4x4_UNORM_BLOCK: VkFormat = 157;
14231pub const VK_FORMAT_ASTC_4x4x3_SFLOAT_BLOCK_EXT: VkFormat = 1000288008;
14232pub const VK_FORMAT_ASTC_4x4x3_SRGB_BLOCK_EXT: VkFormat = 1000288007;
14233pub const VK_FORMAT_ASTC_4x4x3_UNORM_BLOCK_EXT: VkFormat = 1000288006;
14234pub const VK_FORMAT_ASTC_4x4x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288011;
14235pub const VK_FORMAT_ASTC_4x4x4_SRGB_BLOCK_EXT: VkFormat = 1000288010;
14236pub const VK_FORMAT_ASTC_4x4x4_UNORM_BLOCK_EXT: VkFormat = 1000288009;
14237pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK: VkFormat = 1000066001;
14238pub const VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK;
14239pub const VK_FORMAT_ASTC_5x4_SRGB_BLOCK: VkFormat = 160;
14240pub const VK_FORMAT_ASTC_5x4_UNORM_BLOCK: VkFormat = 159;
14241pub const VK_FORMAT_ASTC_5x4x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288014;
14242pub const VK_FORMAT_ASTC_5x4x4_SRGB_BLOCK_EXT: VkFormat = 1000288013;
14243pub const VK_FORMAT_ASTC_5x4x4_UNORM_BLOCK_EXT: VkFormat = 1000288012;
14244pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK: VkFormat = 1000066002;
14245pub const VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK;
14246pub const VK_FORMAT_ASTC_5x5_SRGB_BLOCK: VkFormat = 162;
14247pub const VK_FORMAT_ASTC_5x5_UNORM_BLOCK: VkFormat = 161;
14248pub const VK_FORMAT_ASTC_5x5x4_SFLOAT_BLOCK_EXT: VkFormat = 1000288017;
14249pub const VK_FORMAT_ASTC_5x5x4_SRGB_BLOCK_EXT: VkFormat = 1000288016;
14250pub const VK_FORMAT_ASTC_5x5x4_UNORM_BLOCK_EXT: VkFormat = 1000288015;
14251pub const VK_FORMAT_ASTC_5x5x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288020;
14252pub const VK_FORMAT_ASTC_5x5x5_SRGB_BLOCK_EXT: VkFormat = 1000288019;
14253pub const VK_FORMAT_ASTC_5x5x5_UNORM_BLOCK_EXT: VkFormat = 1000288018;
14254pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK: VkFormat = 1000066003;
14255pub const VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK;
14256pub const VK_FORMAT_ASTC_6x5_SRGB_BLOCK: VkFormat = 164;
14257pub const VK_FORMAT_ASTC_6x5_UNORM_BLOCK: VkFormat = 163;
14258pub const VK_FORMAT_ASTC_6x5x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288023;
14259pub const VK_FORMAT_ASTC_6x5x5_SRGB_BLOCK_EXT: VkFormat = 1000288022;
14260pub const VK_FORMAT_ASTC_6x5x5_UNORM_BLOCK_EXT: VkFormat = 1000288021;
14261pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK: VkFormat = 1000066004;
14262pub const VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK;
14263pub const VK_FORMAT_ASTC_6x6_SRGB_BLOCK: VkFormat = 166;
14264pub const VK_FORMAT_ASTC_6x6_UNORM_BLOCK: VkFormat = 165;
14265pub const VK_FORMAT_ASTC_6x6x5_SFLOAT_BLOCK_EXT: VkFormat = 1000288026;
14266pub const VK_FORMAT_ASTC_6x6x5_SRGB_BLOCK_EXT: VkFormat = 1000288025;
14267pub const VK_FORMAT_ASTC_6x6x5_UNORM_BLOCK_EXT: VkFormat = 1000288024;
14268pub const VK_FORMAT_ASTC_6x6x6_SFLOAT_BLOCK_EXT: VkFormat = 1000288029;
14269pub const VK_FORMAT_ASTC_6x6x6_SRGB_BLOCK_EXT: VkFormat = 1000288028;
14270pub const VK_FORMAT_ASTC_6x6x6_UNORM_BLOCK_EXT: VkFormat = 1000288027;
14271pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK: VkFormat = 1000066005;
14272pub const VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK;
14273pub const VK_FORMAT_ASTC_8x5_SRGB_BLOCK: VkFormat = 168;
14274pub const VK_FORMAT_ASTC_8x5_UNORM_BLOCK: VkFormat = 167;
14275pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK: VkFormat = 1000066006;
14276pub const VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK;
14277pub const VK_FORMAT_ASTC_8x6_SRGB_BLOCK: VkFormat = 170;
14278pub const VK_FORMAT_ASTC_8x6_UNORM_BLOCK: VkFormat = 169;
14279pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK: VkFormat = 1000066007;
14280pub const VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT: VkFormat = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK;
14281pub const VK_FORMAT_ASTC_8x8_SRGB_BLOCK: VkFormat = 172;
14282pub const VK_FORMAT_ASTC_8x8_UNORM_BLOCK: VkFormat = 171;
14283pub const VK_FORMAT_B10G11R11_UFLOAT_PACK32: VkFormat = 122;
14284pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16: VkFormat = 1000156011;
14285pub const VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16;
14286pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16: VkFormat = 1000156021;
14287pub const VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16;
14288pub const VK_FORMAT_B16G16R16G16_422_UNORM: VkFormat = 1000156028;
14289pub const VK_FORMAT_B16G16R16G16_422_UNORM_KHR: VkFormat = VK_FORMAT_B16G16R16G16_422_UNORM;
14290pub const VK_FORMAT_B4G4R4A4_UNORM_PACK16: VkFormat = 3;
14291pub const VK_FORMAT_B5G5R5A1_UNORM_PACK16: VkFormat = 7;
14292pub const VK_FORMAT_B5G6R5_UNORM_PACK16: VkFormat = 5;
14293pub const VK_FORMAT_B8G8R8A8_SINT: VkFormat = 49;
14294pub const VK_FORMAT_B8G8R8A8_SNORM: VkFormat = 45;
14295pub const VK_FORMAT_B8G8R8A8_SRGB: VkFormat = 50;
14296pub const VK_FORMAT_B8G8R8A8_SSCALED: VkFormat = 47;
14297pub const VK_FORMAT_B8G8R8A8_UINT: VkFormat = 48;
14298pub const VK_FORMAT_B8G8R8A8_UNORM: VkFormat = 44;
14299pub const VK_FORMAT_B8G8R8A8_USCALED: VkFormat = 46;
14300pub const VK_FORMAT_B8G8R8G8_422_UNORM: VkFormat = 1000156001;
14301pub const VK_FORMAT_B8G8R8G8_422_UNORM_KHR: VkFormat = VK_FORMAT_B8G8R8G8_422_UNORM;
14302pub const VK_FORMAT_B8G8R8_SINT: VkFormat = 35;
14303pub const VK_FORMAT_B8G8R8_SNORM: VkFormat = 31;
14304pub const VK_FORMAT_B8G8R8_SRGB: VkFormat = 36;
14305pub const VK_FORMAT_B8G8R8_SSCALED: VkFormat = 33;
14306pub const VK_FORMAT_B8G8R8_UINT: VkFormat = 34;
14307pub const VK_FORMAT_B8G8R8_UNORM: VkFormat = 30;
14308pub const VK_FORMAT_B8G8R8_USCALED: VkFormat = 32;
14309pub const VK_FORMAT_BC1_RGBA_SRGB_BLOCK: VkFormat = 134;
14310pub const VK_FORMAT_BC1_RGBA_UNORM_BLOCK: VkFormat = 133;
14311pub const VK_FORMAT_BC1_RGB_SRGB_BLOCK: VkFormat = 132;
14312pub const VK_FORMAT_BC1_RGB_UNORM_BLOCK: VkFormat = 131;
14313pub const VK_FORMAT_BC2_SRGB_BLOCK: VkFormat = 136;
14314pub const VK_FORMAT_BC2_UNORM_BLOCK: VkFormat = 135;
14315pub const VK_FORMAT_BC3_SRGB_BLOCK: VkFormat = 138;
14316pub const VK_FORMAT_BC3_UNORM_BLOCK: VkFormat = 137;
14317pub const VK_FORMAT_BC4_SNORM_BLOCK: VkFormat = 140;
14318pub const VK_FORMAT_BC4_UNORM_BLOCK: VkFormat = 139;
14319pub const VK_FORMAT_BC5_SNORM_BLOCK: VkFormat = 142;
14320pub const VK_FORMAT_BC5_UNORM_BLOCK: VkFormat = 141;
14321pub const VK_FORMAT_BC6H_SFLOAT_BLOCK: VkFormat = 144;
14322pub const VK_FORMAT_BC6H_UFLOAT_BLOCK: VkFormat = 143;
14323pub const VK_FORMAT_BC7_SRGB_BLOCK: VkFormat = 146;
14324pub const VK_FORMAT_BC7_UNORM_BLOCK: VkFormat = 145;
14325pub const VK_FORMAT_D16_UNORM: VkFormat = 124;
14326pub const VK_FORMAT_D16_UNORM_S8_UINT: VkFormat = 128;
14327pub const VK_FORMAT_D24_UNORM_S8_UINT: VkFormat = 129;
14328pub const VK_FORMAT_D32_SFLOAT: VkFormat = 126;
14329pub const VK_FORMAT_D32_SFLOAT_S8_UINT: VkFormat = 130;
14330pub const VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: VkFormat = 123;
14331pub const VK_FORMAT_EAC_R11G11_SNORM_BLOCK: VkFormat = 156;
14332pub const VK_FORMAT_EAC_R11G11_UNORM_BLOCK: VkFormat = 155;
14333pub const VK_FORMAT_EAC_R11_SNORM_BLOCK: VkFormat = 154;
14334pub const VK_FORMAT_EAC_R11_UNORM_BLOCK: VkFormat = 153;
14335pub const VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: VkFormat = 150;
14336pub const VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK: VkFormat = 149;
14337pub const VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: VkFormat = 152;
14338pub const VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: VkFormat = 151;
14339pub const VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK: VkFormat = 148;
14340pub const VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK: VkFormat = 147;
14341pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_RADIUS_BUFFER_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 51;
14342pub const VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 29;
14343pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT: VkFormatFeatureFlagBits2 = 1 << 11;
14344pub const VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_BLIT_DST_BIT;
14345pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT: VkFormatFeatureFlagBits2 = 1 << 10;
14346pub const VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_BLIT_SRC_BIT;
14347pub const VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 36;
14348pub const VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 37;
14349pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlagBits2 = 1 << 7;
14350pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT;
14351pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlagBits2 = 1 << 8;
14352pub const VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT;
14353pub const VK_FORMAT_FEATURE_2_COPY_IMAGE_INDIRECT_DST_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 59;
14354pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits2 = 1 << 23;
14355pub const VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT;
14356pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 52;
14357pub const VK_FORMAT_FEATURE_2_DEPTH_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 53;
14358pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlagBits2 = 1 << 9;
14359pub const VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT;
14360pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT: VkFormatFeatureFlagBits2 = 1 << 22;
14361pub const VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_DISJOINT_BIT;
14362pub const VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlagBits2 = 1 << 24;
14363pub const VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 30;
14364pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT: VkFormatFeatureFlagBits2 = 1 << 46;
14365pub const VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT;
14366pub const VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 38;
14367pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits2 = 1 << 17;
14368pub const VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT;
14369pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 42;
14370pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 40;
14371pub const VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV: VkFormatFeatureFlagBits2 = 1 << 41;
14372pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT: VkFormatFeatureFlagBits2 = 1 << 0;
14373pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT;
14374pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT: VkFormatFeatureFlagBits2 = 1 << 33;
14375pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT;
14376pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT: VkFormatFeatureFlagBits2 = 1 << 13;
14377pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT;
14378pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlagBits2 = 1 << 12;
14379pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
14380pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlagBits2 = 1 << 16;
14381pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
14382pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlagBits2 = 1 << 20;
14383pub 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;
14384pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlagBits2 = 1 << 21;
14385pub 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;
14386pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlagBits2 = 1 << 18;
14387pub 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;
14388pub const VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlagBits2 = 1 << 19;
14389pub 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;
14390pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_COMPUTE_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 54;
14391pub const VK_FORMAT_FEATURE_2_STENCIL_COPY_ON_TRANSFER_QUEUE_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 55;
14392pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlagBits2 = 1 << 2;
14393pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT;
14394pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT: VkFormatFeatureFlagBits2 = 1 << 1;
14395pub const VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT;
14396pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT: VkFormatFeatureFlagBits2 = 1 << 31;
14397pub const VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT;
14398pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlagBits2 = 1 << 5;
14399pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
14400pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 4;
14401pub const VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT;
14402pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT: VkFormatFeatureFlagBits2 = 1 << 32;
14403pub const VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT;
14404pub const VK_FORMAT_FEATURE_2_TENSOR_DATA_GRAPH_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 48;
14405pub const VK_FORMAT_FEATURE_2_TENSOR_IMAGE_ALIASING_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 43;
14406pub const VK_FORMAT_FEATURE_2_TENSOR_SHADER_BIT_ARM: VkFormatFeatureFlagBits2 = 1 << 39;
14407pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT: VkFormatFeatureFlagBits2 = 1 << 15;
14408pub const VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT;
14409pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT: VkFormatFeatureFlagBits2 = 1 << 14;
14410pub const VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT;
14411pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 3;
14412pub const VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT;
14413pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT: VkFormatFeatureFlagBits2 = 1 << 6;
14414pub const VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits2 = VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT;
14415pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 26;
14416pub const VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 25;
14417pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 28;
14418pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 50;
14419pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 27;
14420pub const VK_FORMAT_FEATURE_2_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkFormatFeatureFlagBits2 = 1 << 49;
14421pub const VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 34;
14422pub const VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM: VkFormatFeatureFlagBits2 = 1 << 35;
14423pub const VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR: VkFormatFeatureFlagBits = 1 << 29;
14424pub const VK_FORMAT_FEATURE_BLIT_DST_BIT: VkFormatFeatureFlagBits = 1 << 11;
14425pub const VK_FORMAT_FEATURE_BLIT_SRC_BIT: VkFormatFeatureFlagBits = 1 << 10;
14426pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 1 << 7;
14427pub const VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT: VkFormatFeatureFlagBits = 1 << 8;
14428pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 1 << 23;
14429pub const VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
14430pub const VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT: VkFormatFeatureFlagBits = 1 << 9;
14431pub const VK_FORMAT_FEATURE_DISJOINT_BIT: VkFormatFeatureFlagBits = 1 << 22;
14432pub const VK_FORMAT_FEATURE_DISJOINT_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_DISJOINT_BIT;
14433pub const VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkFormatFeatureFlagBits = 1 << 24;
14434pub const VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 30;
14435pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT: VkFormatFeatureFlagBits = 1 << 17;
14436pub const VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT;
14437pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT: VkFormatFeatureFlagBits = 1 << 0;
14438pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT: VkFormatFeatureFlagBits = 1 << 13;
14439pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT;
14440pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT: VkFormatFeatureFlagBits = 1 << 12;
14441pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT: VkFormatFeatureFlagBits = 1 << 16;
14442pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
14443pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT: VkFormatFeatureFlagBits = 1 << 20;
14444pub 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;
14445pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT: VkFormatFeatureFlagBits = 1 << 21;
14446pub 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;
14447pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT: VkFormatFeatureFlagBits = 1 << 18;
14448pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
14449pub const VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT: VkFormatFeatureFlagBits = 1 << 19;
14450pub 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;
14451pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT: VkFormatFeatureFlagBits = 1 << 2;
14452pub const VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT: VkFormatFeatureFlagBits = 1 << 1;
14453pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT: VkFormatFeatureFlagBits = 1 << 5;
14454pub const VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 4;
14455pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT: VkFormatFeatureFlagBits = 1 << 15;
14456pub const VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
14457pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT: VkFormatFeatureFlagBits = 1 << 14;
14458pub const VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR: VkFormatFeatureFlagBits = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
14459pub const VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 3;
14460pub const VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT: VkFormatFeatureFlagBits = 1 << 6;
14461pub const VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR: VkFormatFeatureFlagBits = 1 << 26;
14462pub const VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 25;
14463pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_DPB_BIT_KHR: VkFormatFeatureFlagBits = 1 << 28;
14464pub const VK_FORMAT_FEATURE_VIDEO_ENCODE_INPUT_BIT_KHR: VkFormatFeatureFlagBits = 1 << 27;
14465pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16: VkFormat = 1000156010;
14466pub const VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16;
14467pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156013;
14468pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16;
14469pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156015;
14470pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16;
14471pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16: VkFormat = 1000330001;
14472pub const VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16;
14473pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156012;
14474pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16;
14475pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156014;
14476pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16;
14477pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156016;
14478pub const VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16;
14479pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16: VkFormat = 1000156020;
14480pub const VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16;
14481pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: VkFormat = 1000156023;
14482pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16;
14483pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: VkFormat = 1000156025;
14484pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16;
14485pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16: VkFormat = 1000330002;
14486pub const VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT: VkFormat = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16;
14487pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: VkFormat = 1000156022;
14488pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16;
14489pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: VkFormat = 1000156024;
14490pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16;
14491pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: VkFormat = 1000156026;
14492pub const VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR: VkFormat = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16;
14493pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_420_UNORM_3PACK16_ARM: VkFormat = 1000609012;
14494pub const VK_FORMAT_G14X2_B14X2R14X2_2PLANE_422_UNORM_3PACK16_ARM: VkFormat = 1000609013;
14495pub const VK_FORMAT_G16B16G16R16_422_UNORM: VkFormat = 1000156027;
14496pub const VK_FORMAT_G16B16G16R16_422_UNORM_KHR: VkFormat = VK_FORMAT_G16B16G16R16_422_UNORM;
14497pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: VkFormat = 1000156030;
14498pub const VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM;
14499pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: VkFormat = 1000156032;
14500pub const VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM;
14501pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM: VkFormat = 1000330003;
14502pub const VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM;
14503pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: VkFormat = 1000156029;
14504pub const VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM;
14505pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: VkFormat = 1000156031;
14506pub const VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM;
14507pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: VkFormat = 1000156033;
14508pub const VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM;
14509pub const VK_FORMAT_G8B8G8R8_422_UNORM: VkFormat = 1000156000;
14510pub const VK_FORMAT_G8B8G8R8_422_UNORM_KHR: VkFormat = VK_FORMAT_G8B8G8R8_422_UNORM;
14511pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: VkFormat = 1000156003;
14512pub const VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
14513pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: VkFormat = 1000156005;
14514pub const VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM;
14515pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM: VkFormat = 1000330000;
14516pub const VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT: VkFormat = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM;
14517pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: VkFormat = 1000156002;
14518pub const VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
14519pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: VkFormat = 1000156004;
14520pub const VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM;
14521pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: VkFormat = 1000156006;
14522pub const VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR: VkFormat = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM;
14523pub const VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054004;
14524pub const VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054000;
14525pub const VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054005;
14526pub const VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054001;
14527pub const VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG: VkFormat = 1000054006;
14528pub const VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG: VkFormat = 1000054002;
14529pub const VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG: VkFormat = 1000054007;
14530pub const VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG: VkFormat = 1000054003;
14531pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UINT_4PACK16_ARM: VkFormat = 1000609002;
14532pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: VkFormat = 1000156009;
14533pub const VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16;
14534pub const VK_FORMAT_R10X6G10X6_UINT_2PACK16_ARM: VkFormat = 1000609001;
14535pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16: VkFormat = 1000156008;
14536pub const VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
14537pub const VK_FORMAT_R10X6_UINT_PACK16_ARM: VkFormat = 1000609000;
14538pub const VK_FORMAT_R10X6_UNORM_PACK16: VkFormat = 1000156007;
14539pub const VK_FORMAT_R10X6_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R10X6_UNORM_PACK16;
14540pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UINT_4PACK16_ARM: VkFormat = 1000609005;
14541pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: VkFormat = 1000156019;
14542pub const VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16;
14543pub const VK_FORMAT_R12X4G12X4_UINT_2PACK16_ARM: VkFormat = 1000609004;
14544pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16: VkFormat = 1000156018;
14545pub const VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR: VkFormat = VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
14546pub const VK_FORMAT_R12X4_UINT_PACK16_ARM: VkFormat = 1000609003;
14547pub const VK_FORMAT_R12X4_UNORM_PACK16: VkFormat = 1000156017;
14548pub const VK_FORMAT_R12X4_UNORM_PACK16_KHR: VkFormat = VK_FORMAT_R12X4_UNORM_PACK16;
14549pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UINT_4PACK16_ARM: VkFormat = 1000609008;
14550pub const VK_FORMAT_R14X2G14X2B14X2A14X2_UNORM_4PACK16_ARM: VkFormat = 1000609011;
14551pub const VK_FORMAT_R14X2G14X2_UINT_2PACK16_ARM: VkFormat = 1000609007;
14552pub const VK_FORMAT_R14X2G14X2_UNORM_2PACK16_ARM: VkFormat = 1000609010;
14553pub const VK_FORMAT_R14X2_UINT_PACK16_ARM: VkFormat = 1000609006;
14554pub const VK_FORMAT_R14X2_UNORM_PACK16_ARM: VkFormat = 1000609009;
14555pub const VK_FORMAT_R16G16B16A16_SFLOAT: VkFormat = 97;
14556pub const VK_FORMAT_R16G16B16A16_SINT: VkFormat = 96;
14557pub const VK_FORMAT_R16G16B16A16_SNORM: VkFormat = 92;
14558pub const VK_FORMAT_R16G16B16A16_SSCALED: VkFormat = 94;
14559pub const VK_FORMAT_R16G16B16A16_UINT: VkFormat = 95;
14560pub const VK_FORMAT_R16G16B16A16_UNORM: VkFormat = 91;
14561pub const VK_FORMAT_R16G16B16A16_USCALED: VkFormat = 93;
14562pub const VK_FORMAT_R16G16B16_SFLOAT: VkFormat = 90;
14563pub const VK_FORMAT_R16G16B16_SINT: VkFormat = 89;
14564pub const VK_FORMAT_R16G16B16_SNORM: VkFormat = 85;
14565pub const VK_FORMAT_R16G16B16_SSCALED: VkFormat = 87;
14566pub const VK_FORMAT_R16G16B16_UINT: VkFormat = 88;
14567pub const VK_FORMAT_R16G16B16_UNORM: VkFormat = 84;
14568pub const VK_FORMAT_R16G16B16_USCALED: VkFormat = 86;
14569pub const VK_FORMAT_R16G16_S10_5_NV: VkFormat = VK_FORMAT_R16G16_SFIXED5_NV;
14570pub const VK_FORMAT_R16G16_SFIXED5_NV: VkFormat = 1000464000;
14571pub const VK_FORMAT_R16G16_SFLOAT: VkFormat = 83;
14572pub const VK_FORMAT_R16G16_SINT: VkFormat = 82;
14573pub const VK_FORMAT_R16G16_SNORM: VkFormat = 78;
14574pub const VK_FORMAT_R16G16_SSCALED: VkFormat = 80;
14575pub const VK_FORMAT_R16G16_UINT: VkFormat = 81;
14576pub const VK_FORMAT_R16G16_UNORM: VkFormat = 77;
14577pub const VK_FORMAT_R16G16_USCALED: VkFormat = 79;
14578pub const VK_FORMAT_R16_SFLOAT: VkFormat = 76;
14579pub const VK_FORMAT_R16_SINT: VkFormat = 75;
14580pub const VK_FORMAT_R16_SNORM: VkFormat = 71;
14581pub const VK_FORMAT_R16_SSCALED: VkFormat = 73;
14582pub const VK_FORMAT_R16_UINT: VkFormat = 74;
14583pub const VK_FORMAT_R16_UNORM: VkFormat = 70;
14584pub const VK_FORMAT_R16_USCALED: VkFormat = 72;
14585pub const VK_FORMAT_R32G32B32A32_SFLOAT: VkFormat = 109;
14586pub const VK_FORMAT_R32G32B32A32_SINT: VkFormat = 108;
14587pub const VK_FORMAT_R32G32B32A32_UINT: VkFormat = 107;
14588pub const VK_FORMAT_R32G32B32_SFLOAT: VkFormat = 106;
14589pub const VK_FORMAT_R32G32B32_SINT: VkFormat = 105;
14590pub const VK_FORMAT_R32G32B32_UINT: VkFormat = 104;
14591pub const VK_FORMAT_R32G32_SFLOAT: VkFormat = 103;
14592pub const VK_FORMAT_R32G32_SINT: VkFormat = 102;
14593pub const VK_FORMAT_R32G32_UINT: VkFormat = 101;
14594pub const VK_FORMAT_R32_SFLOAT: VkFormat = 100;
14595pub const VK_FORMAT_R32_SINT: VkFormat = 99;
14596pub const VK_FORMAT_R32_UINT: VkFormat = 98;
14597pub const VK_FORMAT_R4G4B4A4_UNORM_PACK16: VkFormat = 2;
14598pub const VK_FORMAT_R4G4_UNORM_PACK8: VkFormat = 1;
14599pub const VK_FORMAT_R5G5B5A1_UNORM_PACK16: VkFormat = 6;
14600pub const VK_FORMAT_R5G6B5_UNORM_PACK16: VkFormat = 4;
14601pub const VK_FORMAT_R64G64B64A64_SFLOAT: VkFormat = 121;
14602pub const VK_FORMAT_R64G64B64A64_SINT: VkFormat = 120;
14603pub const VK_FORMAT_R64G64B64A64_UINT: VkFormat = 119;
14604pub const VK_FORMAT_R64G64B64_SFLOAT: VkFormat = 118;
14605pub const VK_FORMAT_R64G64B64_SINT: VkFormat = 117;
14606pub const VK_FORMAT_R64G64B64_UINT: VkFormat = 116;
14607pub const VK_FORMAT_R64G64_SFLOAT: VkFormat = 115;
14608pub const VK_FORMAT_R64G64_SINT: VkFormat = 114;
14609pub const VK_FORMAT_R64G64_UINT: VkFormat = 113;
14610pub const VK_FORMAT_R64_SFLOAT: VkFormat = 112;
14611pub const VK_FORMAT_R64_SINT: VkFormat = 111;
14612pub const VK_FORMAT_R64_UINT: VkFormat = 110;
14613pub const VK_FORMAT_R8G8B8A8_SINT: VkFormat = 42;
14614pub const VK_FORMAT_R8G8B8A8_SNORM: VkFormat = 38;
14615pub const VK_FORMAT_R8G8B8A8_SRGB: VkFormat = 43;
14616pub const VK_FORMAT_R8G8B8A8_SSCALED: VkFormat = 40;
14617pub const VK_FORMAT_R8G8B8A8_UINT: VkFormat = 41;
14618pub const VK_FORMAT_R8G8B8A8_UNORM: VkFormat = 37;
14619pub const VK_FORMAT_R8G8B8A8_USCALED: VkFormat = 39;
14620pub const VK_FORMAT_R8G8B8_SINT: VkFormat = 28;
14621pub const VK_FORMAT_R8G8B8_SNORM: VkFormat = 24;
14622pub const VK_FORMAT_R8G8B8_SRGB: VkFormat = 29;
14623pub const VK_FORMAT_R8G8B8_SSCALED: VkFormat = 26;
14624pub const VK_FORMAT_R8G8B8_UINT: VkFormat = 27;
14625pub const VK_FORMAT_R8G8B8_UNORM: VkFormat = 23;
14626pub const VK_FORMAT_R8G8B8_USCALED: VkFormat = 25;
14627pub const VK_FORMAT_R8G8_SINT: VkFormat = 21;
14628pub const VK_FORMAT_R8G8_SNORM: VkFormat = 17;
14629pub const VK_FORMAT_R8G8_SRGB: VkFormat = 22;
14630pub const VK_FORMAT_R8G8_SSCALED: VkFormat = 19;
14631pub const VK_FORMAT_R8G8_UINT: VkFormat = 20;
14632pub const VK_FORMAT_R8G8_UNORM: VkFormat = 16;
14633pub const VK_FORMAT_R8G8_USCALED: VkFormat = 18;
14634pub const VK_FORMAT_R8_BOOL_ARM: VkFormat = 1000460000;
14635pub const VK_FORMAT_R8_SINT: VkFormat = 14;
14636pub const VK_FORMAT_R8_SNORM: VkFormat = 10;
14637pub const VK_FORMAT_R8_SRGB: VkFormat = 15;
14638pub const VK_FORMAT_R8_SSCALED: VkFormat = 12;
14639pub const VK_FORMAT_R8_UINT: VkFormat = 13;
14640pub const VK_FORMAT_R8_UNORM: VkFormat = 9;
14641pub const VK_FORMAT_R8_USCALED: VkFormat = 11;
14642pub const VK_FORMAT_S8_UINT: VkFormat = 127;
14643pub const VK_FORMAT_UNDEFINED: VkFormat = 0;
14644pub const VK_FORMAT_X8_D24_UNORM_PACK32: VkFormat = 125;
14645pub const VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 14;
14646pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV: VkFragmentShadingRateNV = 1;
14647pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV: VkFragmentShadingRateNV = 4;
14648pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV: VkFragmentShadingRateNV = 5;
14649pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV: VkFragmentShadingRateNV = 6;
14650pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV: VkFragmentShadingRateNV = 9;
14651pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV: VkFragmentShadingRateNV = 10;
14652pub const VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV: VkFragmentShadingRateNV = 0;
14653pub const VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 11;
14654pub const VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 12;
14655pub const VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV: VkFragmentShadingRateNV = 13;
14656pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR: VkFragmentShadingRateCombinerOpKHR = 0;
14657pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR: VkFragmentShadingRateCombinerOpKHR = 3;
14658pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR: VkFragmentShadingRateCombinerOpKHR = 2;
14659pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR: VkFragmentShadingRateCombinerOpKHR = 4;
14660pub const VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR: VkFragmentShadingRateCombinerOpKHR = 1;
14661pub const VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV: VkFragmentShadingRateNV = 15;
14662pub const VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV: VkFragmentShadingRateTypeNV = 1;
14663pub const VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV: VkFragmentShadingRateTypeNV = 0;
14664pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT: VkFramebufferCreateFlagBits = 1 << 0;
14665pub const VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR: VkFramebufferCreateFlagBits = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT;
14666pub const VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT: VkFrameBoundaryFlagBitsEXT = 1 << 0;
14667pub const VK_FRONT_FACE_CLOCKWISE: VkFrontFace = 1;
14668pub const VK_FRONT_FACE_COUNTER_CLOCKWISE: VkFrontFace = 0;
14669pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT: VkGeometryInstanceFlagBitsKHR = 1 << 5;
14670pub const VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_BIT_EXT;
14671pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 3;
14672pub const VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR;
14673pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT: VkGeometryInstanceFlagBitsKHR = 1 << 4;
14674pub const VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_BIT_EXT;
14675pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 2;
14676pub const VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR;
14677pub const VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR;
14678pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 0;
14679pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR: VkGeometryInstanceFlagBitsKHR = 1 << 1;
14680pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR;
14681pub const VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV: VkGeometryInstanceFlagBitsKHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR;
14682pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR: VkGeometryFlagBitsKHR = 1 << 1;
14683pub const VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV: VkGeometryFlagBitsKHR = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR;
14684pub const VK_GEOMETRY_OPAQUE_BIT_KHR: VkGeometryFlagBitsKHR = 1 << 0;
14685pub const VK_GEOMETRY_OPAQUE_BIT_NV: VkGeometryFlagBitsKHR = VK_GEOMETRY_OPAQUE_BIT_KHR;
14686pub const VK_GEOMETRY_TYPE_AABBS_KHR: VkGeometryTypeKHR = 1;
14687pub const VK_GEOMETRY_TYPE_AABBS_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_AABBS_KHR;
14688pub const VK_GEOMETRY_TYPE_INSTANCES_KHR: VkGeometryTypeKHR = 2;
14689pub const VK_GEOMETRY_TYPE_LINEAR_SWEPT_SPHERES_NV: VkGeometryTypeKHR = 1000429005;
14690pub const VK_GEOMETRY_TYPE_SPHERES_NV: VkGeometryTypeKHR = 1000429004;
14691pub const VK_GEOMETRY_TYPE_TRIANGLES_KHR: VkGeometryTypeKHR = 0;
14692pub const VK_GEOMETRY_TYPE_TRIANGLES_NV: VkGeometryTypeKHR = VK_GEOMETRY_TYPE_TRIANGLES_KHR;
14693pub const VK_GOOGLE_DECORATE_STRING_EXTENSION_NAME: &CStr = c"VK_GOOGLE_decorate_string";
14694pub const VK_GOOGLE_DECORATE_STRING_SPEC_VERSION: u32 = 1;
14695pub const VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME: &CStr = c"VK_GOOGLE_display_timing";
14696pub const VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION: u32 = 1;
14697pub const VK_GOOGLE_HLSL_FUNCTIONALITY1_EXTENSION_NAME: &CStr = VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME;
14698pub const VK_GOOGLE_HLSL_FUNCTIONALITY1_SPEC_VERSION: u32 = VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION;
14699pub const VK_GOOGLE_HLSL_FUNCTIONALITY_1_EXTENSION_NAME: &CStr = c"VK_GOOGLE_hlsl_functionality1";
14700pub const VK_GOOGLE_HLSL_FUNCTIONALITY_1_SPEC_VERSION: u32 = 1;
14701pub const VK_GOOGLE_SURFACELESS_QUERY_EXTENSION_NAME: &CStr = c"VK_GOOGLE_surfaceless_query";
14702pub const VK_GOOGLE_SURFACELESS_QUERY_SPEC_VERSION: u32 = 2;
14703pub const VK_GOOGLE_USER_TYPE_EXTENSION_NAME: &CStr = c"VK_GOOGLE_user_type";
14704pub const VK_GOOGLE_USER_TYPE_SPEC_VERSION: u32 = 1;
14705pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 3;
14706pub const VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 2;
14707pub const VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 1;
14708pub const VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT: VkGraphicsPipelineLibraryFlagBitsEXT = 1 << 0;
14709pub const VK_HEADER_VERSION: u32 = 342;
14710pub const VK_HEADER_VERSION_COMPLETE: u32 = VK_MAKE_API_VERSION(0, 1, 4, VK_HEADER_VERSION);
14711pub const VK_HOST_IMAGE_COPY_MEMCPY: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
14712pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT: VkHostImageCopyFlagBits = 1 << 0;
14713pub const VK_HOST_IMAGE_COPY_MEMCPY_BIT_EXT: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
14714pub const VK_HOST_IMAGE_COPY_MEMCPY_EXT: VkHostImageCopyFlagBits = VK_HOST_IMAGE_COPY_MEMCPY_BIT;
14715pub const VK_HUAWEI_CLUSTER_CULLING_SHADER_EXTENSION_NAME: &CStr = c"VK_HUAWEI_cluster_culling_shader";
14716pub const VK_HUAWEI_CLUSTER_CULLING_SHADER_SPEC_VERSION: u32 = 3;
14717pub const VK_HUAWEI_HDR_VIVID_EXTENSION_NAME: &CStr = c"VK_HUAWEI_hdr_vivid";
14718pub const VK_HUAWEI_HDR_VIVID_SPEC_VERSION: u32 = 1;
14719pub const VK_HUAWEI_INVOCATION_MASK_EXTENSION_NAME: &CStr = c"VK_HUAWEI_invocation_mask";
14720pub const VK_HUAWEI_INVOCATION_MASK_SPEC_VERSION: u32 = 1;
14721pub const VK_HUAWEI_SUBPASS_SHADING_EXTENSION_NAME: &CStr = c"VK_HUAWEI_subpass_shading";
14722pub const VK_HUAWEI_SUBPASS_SHADING_SPEC_VERSION: u32 = 3;
14723pub const VK_IMAGE_ASPECT_COLOR_BIT: VkImageAspectFlagBits = 1 << 0;
14724pub const VK_IMAGE_ASPECT_DEPTH_BIT: VkImageAspectFlagBits = 1 << 1;
14725pub const VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT: VkImageAspectFlagBits = 1 << 7;
14726pub const VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT: VkImageAspectFlagBits = 1 << 8;
14727pub const VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT: VkImageAspectFlagBits = 1 << 9;
14728pub const VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT: VkImageAspectFlagBits = 1 << 10;
14729pub const VK_IMAGE_ASPECT_METADATA_BIT: VkImageAspectFlagBits = 1 << 3;
14730pub const VK_IMAGE_ASPECT_NONE: VkImageAspectFlagBits = 0;
14731pub const VK_IMAGE_ASPECT_NONE_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_NONE;
14732pub const VK_IMAGE_ASPECT_PLANE_0_BIT: VkImageAspectFlagBits = 1 << 4;
14733pub const VK_IMAGE_ASPECT_PLANE_0_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_0_BIT;
14734pub const VK_IMAGE_ASPECT_PLANE_1_BIT: VkImageAspectFlagBits = 1 << 5;
14735pub const VK_IMAGE_ASPECT_PLANE_1_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_1_BIT;
14736pub const VK_IMAGE_ASPECT_PLANE_2_BIT: VkImageAspectFlagBits = 1 << 6;
14737pub const VK_IMAGE_ASPECT_PLANE_2_BIT_KHR: VkImageAspectFlagBits = VK_IMAGE_ASPECT_PLANE_2_BIT;
14738pub const VK_IMAGE_ASPECT_STENCIL_BIT: VkImageAspectFlagBits = 1 << 2;
14739pub const VK_IMAGE_COMPRESSION_DEFAULT_EXT: VkImageCompressionFlagBitsEXT = 0;
14740pub const VK_IMAGE_COMPRESSION_DISABLED_EXT: VkImageCompressionFlagBitsEXT = 1 << 2;
14741pub const VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 9;
14742pub const VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 10;
14743pub const VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 11;
14744pub const VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 12;
14745pub const VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 13;
14746pub const VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 14;
14747pub const VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 15;
14748pub const VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 16;
14749pub const VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 17;
14750pub const VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 18;
14751pub const VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 0;
14752pub const VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 19;
14753pub const VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 20;
14754pub const VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 21;
14755pub const VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 22;
14756pub const VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 23;
14757pub const VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 1;
14758pub const VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 2;
14759pub const VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 3;
14760pub const VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 4;
14761pub const VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 5;
14762pub const VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 6;
14763pub const VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 7;
14764pub const VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT: VkImageCompressionFixedRateFlagBitsEXT = 1 << 8;
14765pub const VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT: VkImageCompressionFlagBitsEXT = 1 << 0;
14766pub const VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT: VkImageCompressionFlagBitsEXT = 1 << 1;
14767pub const VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT: VkImageCompressionFixedRateFlagBitsEXT = 0;
14768pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 5;
14769pub const VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT;
14770pub const VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT: VkImageCreateFlagBits = 1 << 17;
14771pub const VK_IMAGE_CREATE_ALIAS_BIT: VkImageCreateFlagBits = 1 << 10;
14772pub const VK_IMAGE_CREATE_ALIAS_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_ALIAS_BIT;
14773pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 7;
14774pub const VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT;
14775pub const VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV: VkImageCreateFlagBits = 1 << 13;
14776pub const VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT: VkImageCreateFlagBits = 1 << 4;
14777pub const VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageCreateFlagBits = VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT;
14778pub const VK_IMAGE_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_EXT: VkImageCreateFlagBits = 1 << 16;
14779pub const VK_IMAGE_CREATE_DISJOINT_BIT: VkImageCreateFlagBits = 1 << 9;
14780pub const VK_IMAGE_CREATE_DISJOINT_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_DISJOINT_BIT;
14781pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT: VkImageCreateFlagBits = 1 << 8;
14782pub const VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT;
14783pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT: VkImageCreateFlagBits = 1 << 15;
14784pub const VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM: VkImageCreateFlagBits = VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_EXT;
14785pub const VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT: VkImageCreateFlagBits = 1 << 18;
14786pub const VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT: VkImageCreateFlagBits = 1 << 3;
14787pub const VK_IMAGE_CREATE_PROTECTED_BIT: VkImageCreateFlagBits = 1 << 11;
14788pub const VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT: VkImageCreateFlagBits = 1 << 12;
14789pub const VK_IMAGE_CREATE_SPARSE_ALIASED_BIT: VkImageCreateFlagBits = 1 << 2;
14790pub const VK_IMAGE_CREATE_SPARSE_BINDING_BIT: VkImageCreateFlagBits = 1 << 0;
14791pub const VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT: VkImageCreateFlagBits = 1 << 1;
14792pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT: VkImageCreateFlagBits = 1 << 6;
14793pub const VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkImageCreateFlagBits = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT;
14794pub const VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT: VkImageCreateFlagBits = 1 << 14;
14795pub const VK_IMAGE_CREATE_VIDEO_PROFILE_INDEPENDENT_BIT_KHR: VkImageCreateFlagBits = 1 << 20;
14796pub const VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT: VkImageLayout = 1000339000;
14797pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL: VkImageLayout = 1000314001;
14798pub const VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL;
14799pub const VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: VkImageLayout = 2;
14800pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241000;
14801pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL;
14802pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000117001;
14803pub const VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
14804pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL: VkImageLayout = 1000241001;
14805pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL;
14806pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000117000;
14807pub const VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
14808pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 3;
14809pub const VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 4;
14810pub const VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT: VkImageLayout = 1000218000;
14811pub const VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = 1000164003;
14812pub const VK_IMAGE_LAYOUT_GENERAL: VkImageLayout = 1;
14813pub const VK_IMAGE_LAYOUT_PREINITIALIZED: VkImageLayout = 8;
14814pub const VK_IMAGE_LAYOUT_PRESENT_SRC_KHR: VkImageLayout = 1000001002;
14815pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL: VkImageLayout = 1000314000;
14816pub const VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL;
14817pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ: VkImageLayout = 1000232000;
14818pub const VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ_KHR: VkImageLayout = VK_IMAGE_LAYOUT_RENDERING_LOCAL_READ;
14819pub const VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: VkImageLayout = 5;
14820pub const VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV: VkImageLayout = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR;
14821pub const VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR: VkImageLayout = 1000111000;
14822pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL: VkImageLayout = 1000241002;
14823pub const VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL;
14824pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL: VkImageLayout = 1000241003;
14825pub const VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR: VkImageLayout = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL;
14826pub const VK_IMAGE_LAYOUT_TENSOR_ALIASING_ARM: VkImageLayout = 1000460000;
14827pub const VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: VkImageLayout = 7;
14828pub const VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: VkImageLayout = 6;
14829pub const VK_IMAGE_LAYOUT_UNDEFINED: VkImageLayout = 0;
14830pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR: VkImageLayout = 1000024002;
14831pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR: VkImageLayout = 1000024000;
14832pub const VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR: VkImageLayout = 1000024001;
14833pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DPB_KHR: VkImageLayout = 1000299002;
14834pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_DST_KHR: VkImageLayout = 1000299000;
14835pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_QUANTIZATION_MAP_KHR: VkImageLayout = 1000553000;
14836pub const VK_IMAGE_LAYOUT_VIDEO_ENCODE_SRC_KHR: VkImageLayout = 1000299001;
14837pub const VK_IMAGE_LAYOUT_ZERO_INITIALIZED_EXT: VkImageLayout = 1000620000;
14838pub const VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT: VkImageTiling = 1000158000;
14839pub const VK_IMAGE_TILING_LINEAR: VkImageTiling = 1;
14840pub const VK_IMAGE_TILING_OPTIMAL: VkImageTiling = 0;
14841pub const VK_IMAGE_TYPE_1D: VkImageType = 0;
14842pub const VK_IMAGE_TYPE_2D: VkImageType = 1;
14843pub const VK_IMAGE_TYPE_3D: VkImageType = 2;
14844pub const VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkImageUsageFlagBits = 1 << 19;
14845pub const VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 4;
14846pub const VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 5;
14847pub const VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT: VkImageUsageFlagBits = 1 << 9;
14848pub const VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkImageUsageFlagBits = 1 << 8;
14849pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT: VkImageUsageFlagBits = 1 << 22;
14850pub const VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT: VkImageUsageFlagBits = VK_IMAGE_USAGE_HOST_TRANSFER_BIT;
14851pub const VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 7;
14852pub const VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI: VkImageUsageFlagBits = 1 << 18;
14853pub const VK_IMAGE_USAGE_SAMPLED_BIT: VkImageUsageFlagBits = 1 << 2;
14854pub const VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM: VkImageUsageFlagBits = 1 << 21;
14855pub const VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM: VkImageUsageFlagBits = 1 << 20;
14856pub const VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV: VkImageUsageFlagBits = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
14857pub const VK_IMAGE_USAGE_STORAGE_BIT: VkImageUsageFlagBits = 1 << 3;
14858pub const VK_IMAGE_USAGE_TENSOR_ALIASING_BIT_ARM: VkImageUsageFlagBits = 1 << 23;
14859pub const VK_IMAGE_USAGE_TILE_MEMORY_BIT_QCOM: VkImageUsageFlagBits = 1 << 27;
14860pub const VK_IMAGE_USAGE_TRANSFER_DST_BIT: VkImageUsageFlagBits = 1 << 1;
14861pub const VK_IMAGE_USAGE_TRANSFER_SRC_BIT: VkImageUsageFlagBits = 1 << 0;
14862pub const VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT: VkImageUsageFlagBits = 1 << 6;
14863pub const VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR: VkImageUsageFlagBits = 1 << 12;
14864pub const VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR: VkImageUsageFlagBits = 1 << 10;
14865pub const VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR: VkImageUsageFlagBits = 1 << 11;
14866pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DPB_BIT_KHR: VkImageUsageFlagBits = 1 << 15;
14867pub const VK_IMAGE_USAGE_VIDEO_ENCODE_DST_BIT_KHR: VkImageUsageFlagBits = 1 << 13;
14868pub const VK_IMAGE_USAGE_VIDEO_ENCODE_EMPHASIS_MAP_BIT_KHR: VkImageUsageFlagBits = 1 << 26;
14869pub const VK_IMAGE_USAGE_VIDEO_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkImageUsageFlagBits = 1 << 25;
14870pub const VK_IMAGE_USAGE_VIDEO_ENCODE_SRC_BIT_KHR: VkImageUsageFlagBits = 1 << 14;
14871pub const VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkImageViewCreateFlagBits = 1 << 2;
14872pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT: VkImageViewCreateFlagBits = 1 << 1;
14873pub const VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT: VkImageViewCreateFlagBits = 1 << 0;
14874pub const VK_IMAGE_VIEW_TYPE_1D: VkImageViewType = 0;
14875pub const VK_IMAGE_VIEW_TYPE_1D_ARRAY: VkImageViewType = 4;
14876pub const VK_IMAGE_VIEW_TYPE_2D: VkImageViewType = 1;
14877pub const VK_IMAGE_VIEW_TYPE_2D_ARRAY: VkImageViewType = 5;
14878pub const VK_IMAGE_VIEW_TYPE_3D: VkImageViewType = 2;
14879pub const VK_IMAGE_VIEW_TYPE_CUBE: VkImageViewType = 3;
14880pub const VK_IMAGE_VIEW_TYPE_CUBE_ARRAY: VkImageViewType = 6;
14881pub const VK_IMG_FILTER_CUBIC_EXTENSION_NAME: &CStr = c"VK_IMG_filter_cubic";
14882pub const VK_IMG_FILTER_CUBIC_SPEC_VERSION: u32 = 1;
14883pub const VK_IMG_FORMAT_PVRTC_EXTENSION_NAME: &CStr = c"VK_IMG_format_pvrtc";
14884pub const VK_IMG_FORMAT_PVRTC_SPEC_VERSION: u32 = 1;
14885pub const VK_IMG_RELAXED_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_IMG_relaxed_line_rasterization";
14886pub const VK_IMG_RELAXED_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
14887pub const VK_INCOMPATIBLE_SHADER_BINARY_EXT: VkResult = 1000482000;
14888pub const VK_INCOMPLETE: VkResult = 5;
14889pub const VK_INDEX_TYPE_NONE_KHR: VkIndexType = 1000165000;
14890pub const VK_INDEX_TYPE_NONE_NV: VkIndexType = VK_INDEX_TYPE_NONE_KHR;
14891pub const VK_INDEX_TYPE_UINT16: VkIndexType = 0;
14892pub const VK_INDEX_TYPE_UINT32: VkIndexType = 1;
14893pub const VK_INDEX_TYPE_UINT8: VkIndexType = 1000265000;
14894pub const VK_INDEX_TYPE_UINT8_EXT: VkIndexType = VK_INDEX_TYPE_UINT8;
14895pub const VK_INDEX_TYPE_UINT8_KHR: VkIndexType = VK_INDEX_TYPE_UINT8;
14896pub const VK_INDIRECT_COMMANDS_INPUT_MODE_DXGI_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagBitsEXT = 1 << 1;
14897pub const VK_INDIRECT_COMMANDS_INPUT_MODE_VULKAN_INDEX_BUFFER_EXT: VkIndirectCommandsInputModeFlagBitsEXT = 1 << 0;
14898pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_EXT: VkIndirectCommandsLayoutUsageFlagBitsEXT = 1 << 0;
14899pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 0;
14900pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 1;
14901pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_EXT: VkIndirectCommandsLayoutUsageFlagBitsEXT = 1 << 1;
14902pub const VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV: VkIndirectCommandsLayoutUsageFlagBitsNV = 1 << 2;
14903pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_EXT: VkIndirectCommandsTokenTypeEXT = 9;
14904pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV: VkIndirectCommandsTokenTypeNV = 1000428004;
14905pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 8;
14906pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_EXT: VkIndirectCommandsTokenTypeEXT = 6;
14907pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 7;
14908pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_EXT: VkIndirectCommandsTokenTypeEXT = 5;
14909pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV: VkIndirectCommandsTokenTypeNV = 5;
14910pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_EXT: VkIndirectCommandsTokenTypeEXT = 1000328001;
14911pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_COUNT_NV_EXT: VkIndirectCommandsTokenTypeEXT = 1000202003;
14912pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_EXT: VkIndirectCommandsTokenTypeEXT = 1000328000;
14913pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV: VkIndirectCommandsTokenTypeNV = 1000328000;
14914pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV_EXT: VkIndirectCommandsTokenTypeEXT = 1000202002;
14915pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV: VkIndirectCommandsTokenTypeNV = 6;
14916pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV: VkIndirectCommandsTokenTypeNV = 7;
14917pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_EXECUTION_SET_EXT: VkIndirectCommandsTokenTypeEXT = 0;
14918pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = 3;
14919pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = 2;
14920pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV: VkIndirectCommandsTokenTypeNV = 1000428003;
14921pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_EXT: VkIndirectCommandsTokenTypeEXT = 1;
14922pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV: VkIndirectCommandsTokenTypeNV = 4;
14923pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_EXT: VkIndirectCommandsTokenTypeEXT = 1000135000;
14924pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_NV: VkIndirectCommandsTokenTypeNV = 1000135000;
14925pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_DATA_SEQUENCE_INDEX_EXT: VkIndirectCommandsTokenTypeEXT = 1000135001;
14926pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SEQUENCE_INDEX_EXT: VkIndirectCommandsTokenTypeEXT = 2;
14927pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV: VkIndirectCommandsTokenTypeNV = 0;
14928pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV: VkIndirectCommandsTokenTypeNV = 1;
14929pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_TRACE_RAYS2_EXT: VkIndirectCommandsTokenTypeEXT = 1000386004;
14930pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_EXT: VkIndirectCommandsTokenTypeEXT = 4;
14931pub const VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV: VkIndirectCommandsTokenTypeNV = 3;
14932pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_PIPELINES_EXT: VkIndirectExecutionSetInfoTypeEXT = 0;
14933pub const VK_INDIRECT_EXECUTION_SET_INFO_TYPE_SHADER_OBJECTS_EXT: VkIndirectExecutionSetInfoTypeEXT = 1;
14934pub const VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV: VkIndirectStateFlagBitsNV = 1 << 0;
14935pub const VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR: VkInstanceCreateFlagBits = 1 << 0;
14936pub const VK_INTEL_PERFORMANCE_QUERY_EXTENSION_NAME: &CStr = c"VK_INTEL_performance_query";
14937pub const VK_INTEL_PERFORMANCE_QUERY_SPEC_VERSION: u32 = 2;
14938pub const VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME: &CStr = c"VK_INTEL_shader_integer_functions2";
14939pub const VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION: u32 = 1;
14940pub const VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE: VkInternalAllocationType = 0;
14941pub const VK_KHR_16BIT_STORAGE_EXTENSION_NAME: &CStr = c"VK_KHR_16bit_storage";
14942pub const VK_KHR_16BIT_STORAGE_SPEC_VERSION: u32 = 1;
14943pub const VK_KHR_8BIT_STORAGE_EXTENSION_NAME: &CStr = c"VK_KHR_8bit_storage";
14944pub const VK_KHR_8BIT_STORAGE_SPEC_VERSION: u32 = 1;
14945pub const VK_KHR_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_KHR_acceleration_structure";
14946pub const VK_KHR_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 13;
14947pub const VK_KHR_BIND_MEMORY_2_EXTENSION_NAME: &CStr = c"VK_KHR_bind_memory2";
14948pub const VK_KHR_BIND_MEMORY_2_SPEC_VERSION: u32 = 1;
14949pub const VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME: &CStr = c"VK_KHR_buffer_device_address";
14950pub const VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION: u32 = 1;
14951pub const VK_KHR_CALIBRATED_TIMESTAMPS_EXTENSION_NAME: &CStr = c"VK_KHR_calibrated_timestamps";
14952pub const VK_KHR_CALIBRATED_TIMESTAMPS_SPEC_VERSION: u32 = 1;
14953pub const VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME: &CStr = c"VK_KHR_compute_shader_derivatives";
14954pub const VK_KHR_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION: u32 = 1;
14955pub const VK_KHR_COOPERATIVE_MATRIX_EXTENSION_NAME: &CStr = c"VK_KHR_cooperative_matrix";
14956pub const VK_KHR_COOPERATIVE_MATRIX_SPEC_VERSION: u32 = 2;
14957pub const VK_KHR_COPY_COMMANDS_2_EXTENSION_NAME: &CStr = c"VK_KHR_copy_commands2";
14958pub const VK_KHR_COPY_COMMANDS_2_SPEC_VERSION: u32 = 1;
14959pub const VK_KHR_COPY_MEMORY_INDIRECT_EXTENSION_NAME: &CStr = c"VK_KHR_copy_memory_indirect";
14960pub const VK_KHR_COPY_MEMORY_INDIRECT_SPEC_VERSION: u32 = 1;
14961pub const VK_KHR_CREATE_RENDERPASS_2_EXTENSION_NAME: &CStr = c"VK_KHR_create_renderpass2";
14962pub const VK_KHR_CREATE_RENDERPASS_2_SPEC_VERSION: u32 = 1;
14963pub const VK_KHR_DEDICATED_ALLOCATION_EXTENSION_NAME: &CStr = c"VK_KHR_dedicated_allocation";
14964pub const VK_KHR_DEDICATED_ALLOCATION_SPEC_VERSION: u32 = 3;
14965pub const VK_KHR_DEFERRED_HOST_OPERATIONS_EXTENSION_NAME: &CStr = c"VK_KHR_deferred_host_operations";
14966pub const VK_KHR_DEFERRED_HOST_OPERATIONS_SPEC_VERSION: u32 = 4;
14967pub const VK_KHR_DEPTH_CLAMP_ZERO_ONE_EXTENSION_NAME: &CStr = c"VK_KHR_depth_clamp_zero_one";
14968pub const VK_KHR_DEPTH_CLAMP_ZERO_ONE_SPEC_VERSION: u32 = 1;
14969pub const VK_KHR_DEPTH_STENCIL_RESOLVE_EXTENSION_NAME: &CStr = c"VK_KHR_depth_stencil_resolve";
14970pub const VK_KHR_DEPTH_STENCIL_RESOLVE_SPEC_VERSION: u32 = 1;
14971pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_EXTENSION_NAME: &CStr = c"VK_KHR_descriptor_update_template";
14972pub const VK_KHR_DESCRIPTOR_UPDATE_TEMPLATE_SPEC_VERSION: u32 = 1;
14973pub const VK_KHR_DEVICE_GROUP_CREATION_EXTENSION_NAME: &CStr = c"VK_KHR_device_group_creation";
14974pub const VK_KHR_DEVICE_GROUP_CREATION_SPEC_VERSION: u32 = 1;
14975pub const VK_KHR_DEVICE_GROUP_EXTENSION_NAME: &CStr = c"VK_KHR_device_group";
14976pub const VK_KHR_DEVICE_GROUP_SPEC_VERSION: u32 = 4;
14977pub const VK_KHR_DISPLAY_EXTENSION_NAME: &CStr = c"VK_KHR_display";
14978pub const VK_KHR_DISPLAY_SPEC_VERSION: u32 = 23;
14979pub const VK_KHR_DISPLAY_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_KHR_display_swapchain";
14980pub const VK_KHR_DISPLAY_SWAPCHAIN_SPEC_VERSION: u32 = 10;
14981pub const VK_KHR_DRAW_INDIRECT_COUNT_EXTENSION_NAME: &CStr = c"VK_KHR_draw_indirect_count";
14982pub const VK_KHR_DRAW_INDIRECT_COUNT_SPEC_VERSION: u32 = 1;
14983pub const VK_KHR_DRIVER_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_KHR_driver_properties";
14984pub const VK_KHR_DRIVER_PROPERTIES_SPEC_VERSION: u32 = 1;
14985pub const VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME: &CStr = c"VK_KHR_dynamic_rendering";
14986pub const VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_EXTENSION_NAME: &CStr = c"VK_KHR_dynamic_rendering_local_read";
14987pub const VK_KHR_DYNAMIC_RENDERING_LOCAL_READ_SPEC_VERSION: u32 = 1;
14988pub const VK_KHR_DYNAMIC_RENDERING_SPEC_VERSION: u32 = 1;
14989pub const VK_KHR_EXTERNAL_FENCE_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence_capabilities";
14990pub const VK_KHR_EXTERNAL_FENCE_CAPABILITIES_SPEC_VERSION: u32 = 1;
14991pub const VK_KHR_EXTERNAL_FENCE_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence";
14992pub const VK_KHR_EXTERNAL_FENCE_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_fence_fd";
14993pub const VK_KHR_EXTERNAL_FENCE_FD_SPEC_VERSION: u32 = 1;
14994pub const VK_KHR_EXTERNAL_FENCE_SPEC_VERSION: u32 = 1;
14995pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory_capabilities";
14996pub const VK_KHR_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: u32 = 1;
14997pub const VK_KHR_EXTERNAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory";
14998pub const VK_KHR_EXTERNAL_MEMORY_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_memory_fd";
14999pub const VK_KHR_EXTERNAL_MEMORY_FD_SPEC_VERSION: u32 = 1;
15000pub const VK_KHR_EXTERNAL_MEMORY_SPEC_VERSION: u32 = 1;
15001pub const VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore_capabilities";
15002pub const VK_KHR_EXTERNAL_SEMAPHORE_CAPABILITIES_SPEC_VERSION: u32 = 1;
15003pub const VK_KHR_EXTERNAL_SEMAPHORE_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore";
15004pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_EXTENSION_NAME: &CStr = c"VK_KHR_external_semaphore_fd";
15005pub const VK_KHR_EXTERNAL_SEMAPHORE_FD_SPEC_VERSION: u32 = 1;
15006pub const VK_KHR_EXTERNAL_SEMAPHORE_SPEC_VERSION: u32 = 1;
15007pub const VK_KHR_FORMAT_FEATURE_FLAGS_2_EXTENSION_NAME: &CStr = c"VK_KHR_format_feature_flags2";
15008pub const VK_KHR_FORMAT_FEATURE_FLAGS_2_SPEC_VERSION: u32 = 2;
15009pub const VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME: &CStr = c"VK_KHR_fragment_shader_barycentric";
15010pub const VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION: u32 = 1;
15011pub const VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME: &CStr = c"VK_KHR_fragment_shading_rate";
15012pub const VK_KHR_FRAGMENT_SHADING_RATE_SPEC_VERSION: u32 = 2;
15013pub const VK_KHR_GET_DISPLAY_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_display_properties2";
15014pub const VK_KHR_GET_DISPLAY_PROPERTIES_2_SPEC_VERSION: u32 = 1;
15015pub const VK_KHR_GET_MEMORY_REQUIREMENTS_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_memory_requirements2";
15016pub const VK_KHR_GET_MEMORY_REQUIREMENTS_2_SPEC_VERSION: u32 = 1;
15017pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_physical_device_properties2";
15018pub const VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_SPEC_VERSION: u32 = 2;
15019pub const VK_KHR_GET_SURFACE_CAPABILITIES_2_EXTENSION_NAME: &CStr = c"VK_KHR_get_surface_capabilities2";
15020pub const VK_KHR_GET_SURFACE_CAPABILITIES_2_SPEC_VERSION: u32 = 1;
15021pub const VK_KHR_GLOBAL_PRIORITY_EXTENSION_NAME: &CStr = c"VK_KHR_global_priority";
15022pub const VK_KHR_GLOBAL_PRIORITY_SPEC_VERSION: u32 = 1;
15023pub const VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME: &CStr = c"VK_KHR_imageless_framebuffer";
15024pub const VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION: u32 = 1;
15025pub const VK_KHR_IMAGE_FORMAT_LIST_EXTENSION_NAME: &CStr = c"VK_KHR_image_format_list";
15026pub const VK_KHR_IMAGE_FORMAT_LIST_SPEC_VERSION: u32 = 1;
15027pub const VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME: &CStr = c"VK_KHR_incremental_present";
15028pub const VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION: u32 = 2;
15029pub const VK_KHR_INDEX_TYPE_UINT8_EXTENSION_NAME: &CStr = c"VK_KHR_index_type_uint8";
15030pub const VK_KHR_INDEX_TYPE_UINT8_SPEC_VERSION: u32 = 1;
15031pub const VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_EXTENSION_NAME: &CStr = c"VK_KHR_internally_synchronized_queues";
15032pub const VK_KHR_INTERNALLY_SYNCHRONIZED_QUEUES_SPEC_VERSION: u32 = 1;
15033pub const VK_KHR_LINE_RASTERIZATION_EXTENSION_NAME: &CStr = c"VK_KHR_line_rasterization";
15034pub const VK_KHR_LINE_RASTERIZATION_SPEC_VERSION: u32 = 1;
15035pub const VK_KHR_LOAD_STORE_OP_NONE_EXTENSION_NAME: &CStr = c"VK_KHR_load_store_op_none";
15036pub const VK_KHR_LOAD_STORE_OP_NONE_SPEC_VERSION: u32 = 1;
15037pub const VK_KHR_MAINTENANCE1_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_1_EXTENSION_NAME;
15038pub const VK_KHR_MAINTENANCE1_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_1_SPEC_VERSION;
15039pub const VK_KHR_MAINTENANCE2_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_2_EXTENSION_NAME;
15040pub const VK_KHR_MAINTENANCE2_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_2_SPEC_VERSION;
15041pub const VK_KHR_MAINTENANCE3_EXTENSION_NAME: &CStr = VK_KHR_MAINTENANCE_3_EXTENSION_NAME;
15042pub const VK_KHR_MAINTENANCE3_SPEC_VERSION: u32 = VK_KHR_MAINTENANCE_3_SPEC_VERSION;
15043pub const VK_KHR_MAINTENANCE_10_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance10";
15044pub const VK_KHR_MAINTENANCE_10_SPEC_VERSION: u32 = 1;
15045pub const VK_KHR_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance1";
15046pub const VK_KHR_MAINTENANCE_1_SPEC_VERSION: u32 = 2;
15047pub const VK_KHR_MAINTENANCE_2_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance2";
15048pub const VK_KHR_MAINTENANCE_2_SPEC_VERSION: u32 = 1;
15049pub const VK_KHR_MAINTENANCE_3_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance3";
15050pub const VK_KHR_MAINTENANCE_3_SPEC_VERSION: u32 = 1;
15051pub const VK_KHR_MAINTENANCE_4_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance4";
15052pub const VK_KHR_MAINTENANCE_4_SPEC_VERSION: u32 = 2;
15053pub const VK_KHR_MAINTENANCE_5_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance5";
15054pub const VK_KHR_MAINTENANCE_5_SPEC_VERSION: u32 = 1;
15055pub const VK_KHR_MAINTENANCE_6_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance6";
15056pub const VK_KHR_MAINTENANCE_6_SPEC_VERSION: u32 = 1;
15057pub const VK_KHR_MAINTENANCE_7_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance7";
15058pub const VK_KHR_MAINTENANCE_7_SPEC_VERSION: u32 = 1;
15059pub const VK_KHR_MAINTENANCE_8_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance8";
15060pub const VK_KHR_MAINTENANCE_8_SPEC_VERSION: u32 = 1;
15061pub const VK_KHR_MAINTENANCE_9_EXTENSION_NAME: &CStr = c"VK_KHR_maintenance9";
15062pub const VK_KHR_MAINTENANCE_9_SPEC_VERSION: u32 = 1;
15063pub const VK_KHR_MAP_MEMORY_2_EXTENSION_NAME: &CStr = c"VK_KHR_map_memory2";
15064pub const VK_KHR_MAP_MEMORY_2_SPEC_VERSION: u32 = 1;
15065pub const VK_KHR_MULTIVIEW_EXTENSION_NAME: &CStr = c"VK_KHR_multiview";
15066pub const VK_KHR_MULTIVIEW_SPEC_VERSION: u32 = 1;
15067pub const VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME: &CStr = c"VK_KHR_performance_query";
15068pub const VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION: u32 = 1;
15069pub const VK_KHR_PIPELINE_BINARY_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_binary";
15070pub const VK_KHR_PIPELINE_BINARY_SPEC_VERSION: u32 = 1;
15071pub const VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_executable_properties";
15072pub const VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION: u32 = 1;
15073pub const VK_KHR_PIPELINE_LIBRARY_EXTENSION_NAME: &CStr = c"VK_KHR_pipeline_library";
15074pub const VK_KHR_PIPELINE_LIBRARY_SPEC_VERSION: u32 = 1;
15075pub const VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME: &CStr = c"VK_KHR_portability_enumeration";
15076pub const VK_KHR_PORTABILITY_ENUMERATION_SPEC_VERSION: u32 = 1;
15077pub const VK_KHR_PRESENT_ID_2_EXTENSION_NAME: &CStr = c"VK_KHR_present_id2";
15078pub const VK_KHR_PRESENT_ID_2_SPEC_VERSION: u32 = 1;
15079pub const VK_KHR_PRESENT_ID_EXTENSION_NAME: &CStr = c"VK_KHR_present_id";
15080pub const VK_KHR_PRESENT_ID_SPEC_VERSION: u32 = 1;
15081pub const VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_EXTENSION_NAME: &CStr = c"VK_KHR_present_mode_fifo_latest_ready";
15082pub const VK_KHR_PRESENT_MODE_FIFO_LATEST_READY_SPEC_VERSION: u32 = 1;
15083pub const VK_KHR_PRESENT_WAIT_2_EXTENSION_NAME: &CStr = c"VK_KHR_present_wait2";
15084pub const VK_KHR_PRESENT_WAIT_2_SPEC_VERSION: u32 = 1;
15085pub const VK_KHR_PRESENT_WAIT_EXTENSION_NAME: &CStr = c"VK_KHR_present_wait";
15086pub const VK_KHR_PRESENT_WAIT_SPEC_VERSION: u32 = 1;
15087pub const VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME: &CStr = c"VK_KHR_push_descriptor";
15088pub const VK_KHR_PUSH_DESCRIPTOR_SPEC_VERSION: u32 = 2;
15089pub const VK_KHR_RAY_QUERY_EXTENSION_NAME: &CStr = c"VK_KHR_ray_query";
15090pub const VK_KHR_RAY_QUERY_SPEC_VERSION: u32 = 1;
15091pub const VK_KHR_RAY_TRACING_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_maintenance1";
15092pub const VK_KHR_RAY_TRACING_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15093pub const VK_KHR_RAY_TRACING_PIPELINE_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_pipeline";
15094pub const VK_KHR_RAY_TRACING_PIPELINE_SPEC_VERSION: u32 = 1;
15095pub const VK_KHR_RAY_TRACING_POSITION_FETCH_EXTENSION_NAME: &CStr = c"VK_KHR_ray_tracing_position_fetch";
15096pub const VK_KHR_RAY_TRACING_POSITION_FETCH_SPEC_VERSION: u32 = 1;
15097pub const VK_KHR_RELAXED_BLOCK_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_relaxed_block_layout";
15098pub const VK_KHR_RELAXED_BLOCK_LAYOUT_SPEC_VERSION: u32 = 1;
15099pub const VK_KHR_ROBUSTNESS_2_EXTENSION_NAME: &CStr = c"VK_KHR_robustness2";
15100pub const VK_KHR_ROBUSTNESS_2_SPEC_VERSION: u32 = 1;
15101pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_EXTENSION_NAME: &CStr = c"VK_KHR_sampler_mirror_clamp_to_edge";
15102pub const VK_KHR_SAMPLER_MIRROR_CLAMP_TO_EDGE_SPEC_VERSION: u32 = 3;
15103pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME: &CStr = c"VK_KHR_sampler_ycbcr_conversion";
15104pub const VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION: u32 = 14;
15105pub const VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME: &CStr = c"VK_KHR_separate_depth_stencil_layouts";
15106pub const VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION: u32 = 1;
15107pub const VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME: &CStr = c"VK_KHR_shader_atomic_int64";
15108pub const VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION: u32 = 1;
15109pub const VK_KHR_SHADER_BFLOAT16_EXTENSION_NAME: &CStr = c"VK_KHR_shader_bfloat16";
15110pub const VK_KHR_SHADER_BFLOAT16_SPEC_VERSION: u32 = 1;
15111pub const VK_KHR_SHADER_CLOCK_EXTENSION_NAME: &CStr = c"VK_KHR_shader_clock";
15112pub const VK_KHR_SHADER_CLOCK_SPEC_VERSION: u32 = 1;
15113pub const VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_draw_parameters";
15114pub const VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION: u32 = 1;
15115pub const VK_KHR_SHADER_EXPECT_ASSUME_EXTENSION_NAME: &CStr = c"VK_KHR_shader_expect_assume";
15116pub const VK_KHR_SHADER_EXPECT_ASSUME_SPEC_VERSION: u32 = 1;
15117pub const VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float16_int8";
15118pub const VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION: u32 = 1;
15119pub const VK_KHR_SHADER_FLOAT_CONTROLS_2_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float_controls2";
15120pub const VK_KHR_SHADER_FLOAT_CONTROLS_2_SPEC_VERSION: u32 = 1;
15121pub const VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_float_controls";
15122pub const VK_KHR_SHADER_FLOAT_CONTROLS_SPEC_VERSION: u32 = 4;
15123pub const VK_KHR_SHADER_FMA_EXTENSION_NAME: &CStr = c"VK_KHR_shader_fma";
15124pub const VK_KHR_SHADER_FMA_SPEC_VERSION: u32 = 1;
15125pub const VK_KHR_SHADER_INTEGER_DOT_PRODUCT_EXTENSION_NAME: &CStr = c"VK_KHR_shader_integer_dot_product";
15126pub const VK_KHR_SHADER_INTEGER_DOT_PRODUCT_SPEC_VERSION: u32 = 1;
15127pub const VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_EXTENSION_NAME: &CStr = c"VK_KHR_shader_maximal_reconvergence";
15128pub const VK_KHR_SHADER_MAXIMAL_RECONVERGENCE_SPEC_VERSION: u32 = 1;
15129pub const VK_KHR_SHADER_NON_SEMANTIC_INFO_EXTENSION_NAME: &CStr = c"VK_KHR_shader_non_semantic_info";
15130pub const VK_KHR_SHADER_NON_SEMANTIC_INFO_SPEC_VERSION: u32 = 1;
15131pub const VK_KHR_SHADER_QUAD_CONTROL_EXTENSION_NAME: &CStr = c"VK_KHR_shader_quad_control";
15132pub const VK_KHR_SHADER_QUAD_CONTROL_SPEC_VERSION: u32 = 1;
15133pub const VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_EXTENSION_NAME: &CStr = c"VK_KHR_shader_relaxed_extended_instruction";
15134pub const VK_KHR_SHADER_RELAXED_EXTENDED_INSTRUCTION_SPEC_VERSION: u32 = 1;
15135pub const VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_extended_types";
15136pub const VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION: u32 = 1;
15137pub const VK_KHR_SHADER_SUBGROUP_ROTATE_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_rotate";
15138pub const VK_KHR_SHADER_SUBGROUP_ROTATE_SPEC_VERSION: u32 = 2;
15139pub const VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_EXTENSION_NAME: &CStr = c"VK_KHR_shader_subgroup_uniform_control_flow";
15140pub const VK_KHR_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_SPEC_VERSION: u32 = 1;
15141pub const VK_KHR_SHADER_TERMINATE_INVOCATION_EXTENSION_NAME: &CStr = c"VK_KHR_shader_terminate_invocation";
15142pub const VK_KHR_SHADER_TERMINATE_INVOCATION_SPEC_VERSION: u32 = 1;
15143pub const VK_KHR_SHADER_UNTYPED_POINTERS_EXTENSION_NAME: &CStr = c"VK_KHR_shader_untyped_pointers";
15144pub const VK_KHR_SHADER_UNTYPED_POINTERS_SPEC_VERSION: u32 = 1;
15145pub const VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME: &CStr = c"VK_KHR_shared_presentable_image";
15146pub const VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION: u32 = 1;
15147pub const VK_KHR_SPIRV_1_4_EXTENSION_NAME: &CStr = c"VK_KHR_spirv_1_4";
15148pub const VK_KHR_SPIRV_1_4_SPEC_VERSION: u32 = 1;
15149pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_EXTENSION_NAME: &CStr = c"VK_KHR_storage_buffer_storage_class";
15150pub const VK_KHR_STORAGE_BUFFER_STORAGE_CLASS_SPEC_VERSION: u32 = 1;
15151pub const VK_KHR_SURFACE_EXTENSION_NAME: &CStr = c"VK_KHR_surface";
15152pub const VK_KHR_SURFACE_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_surface_maintenance1";
15153pub const VK_KHR_SURFACE_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15154pub const VK_KHR_SURFACE_PROTECTED_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_KHR_surface_protected_capabilities";
15155pub const VK_KHR_SURFACE_PROTECTED_CAPABILITIES_SPEC_VERSION: u32 = 1;
15156pub const VK_KHR_SURFACE_SPEC_VERSION: u32 = 25;
15157pub const VK_KHR_SWAPCHAIN_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain";
15158pub const VK_KHR_SWAPCHAIN_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain_maintenance1";
15159pub const VK_KHR_SWAPCHAIN_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15160pub const VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_EXTENSION_NAME: &CStr = c"VK_KHR_swapchain_mutable_format";
15161pub const VK_KHR_SWAPCHAIN_MUTABLE_FORMAT_SPEC_VERSION: u32 = 1;
15162pub const VK_KHR_SWAPCHAIN_SPEC_VERSION: u32 = 70;
15163pub const VK_KHR_SYNCHRONIZATION_2_EXTENSION_NAME: &CStr = c"VK_KHR_synchronization2";
15164pub const VK_KHR_SYNCHRONIZATION_2_SPEC_VERSION: u32 = 1;
15165pub const VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME: &CStr = c"VK_KHR_timeline_semaphore";
15166pub const VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION: u32 = 2;
15167pub const VK_KHR_UNIFIED_IMAGE_LAYOUTS_EXTENSION_NAME: &CStr = c"VK_KHR_unified_image_layouts";
15168pub const VK_KHR_UNIFIED_IMAGE_LAYOUTS_SPEC_VERSION: u32 = 1;
15169pub const VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_uniform_buffer_standard_layout";
15170pub const VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION: u32 = 1;
15171pub const VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME: &CStr = c"VK_KHR_variable_pointers";
15172pub const VK_KHR_VARIABLE_POINTERS_SPEC_VERSION: u32 = 1;
15173pub const VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME: &CStr = c"VK_KHR_vertex_attribute_divisor";
15174pub const VK_KHR_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION: u32 = 1;
15175pub const VK_KHR_VIDEO_DECODE_AV1_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_av1";
15176pub const VK_KHR_VIDEO_DECODE_AV1_SPEC_VERSION: u32 = 1;
15177pub const VK_KHR_VIDEO_DECODE_H264_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_h264";
15178pub const VK_KHR_VIDEO_DECODE_H264_SPEC_VERSION: u32 = 9;
15179pub const VK_KHR_VIDEO_DECODE_H265_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_h265";
15180pub const VK_KHR_VIDEO_DECODE_H265_SPEC_VERSION: u32 = 8;
15181pub const VK_KHR_VIDEO_DECODE_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_queue";
15182pub const VK_KHR_VIDEO_DECODE_QUEUE_SPEC_VERSION: u32 = 8;
15183pub const VK_KHR_VIDEO_DECODE_VP9_EXTENSION_NAME: &CStr = c"VK_KHR_video_decode_vp9";
15184pub const VK_KHR_VIDEO_DECODE_VP9_SPEC_VERSION: u32 = 1;
15185pub const VK_KHR_VIDEO_ENCODE_AV1_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_av1";
15186pub const VK_KHR_VIDEO_ENCODE_AV1_SPEC_VERSION: u32 = 1;
15187pub const VK_KHR_VIDEO_ENCODE_H264_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_h264";
15188pub const VK_KHR_VIDEO_ENCODE_H264_SPEC_VERSION: u32 = 14;
15189pub const VK_KHR_VIDEO_ENCODE_H265_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_h265";
15190pub const VK_KHR_VIDEO_ENCODE_H265_SPEC_VERSION: u32 = 14;
15191pub const VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_intra_refresh";
15192pub const VK_KHR_VIDEO_ENCODE_INTRA_REFRESH_SPEC_VERSION: u32 = 1;
15193pub const VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_quantization_map";
15194pub const VK_KHR_VIDEO_ENCODE_QUANTIZATION_MAP_SPEC_VERSION: u32 = 2;
15195pub const VK_KHR_VIDEO_ENCODE_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_encode_queue";
15196pub const VK_KHR_VIDEO_ENCODE_QUEUE_SPEC_VERSION: u32 = 12;
15197pub const VK_KHR_VIDEO_MAINTENANCE_1_EXTENSION_NAME: &CStr = c"VK_KHR_video_maintenance1";
15198pub const VK_KHR_VIDEO_MAINTENANCE_1_SPEC_VERSION: u32 = 1;
15199pub const VK_KHR_VIDEO_MAINTENANCE_2_EXTENSION_NAME: &CStr = c"VK_KHR_video_maintenance2";
15200pub const VK_KHR_VIDEO_MAINTENANCE_2_SPEC_VERSION: u32 = 1;
15201pub const VK_KHR_VIDEO_QUEUE_EXTENSION_NAME: &CStr = c"VK_KHR_video_queue";
15202pub const VK_KHR_VIDEO_QUEUE_SPEC_VERSION: u32 = 8;
15203pub const VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME: &CStr = c"VK_KHR_vulkan_memory_model";
15204pub const VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION: u32 = 3;
15205pub const VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_EXTENSION_NAME: &CStr = c"VK_KHR_workgroup_memory_explicit_layout";
15206pub const VK_KHR_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_SPEC_VERSION: u32 = 1;
15207pub const VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_EXTENSION_NAME: &CStr = c"VK_KHR_zero_initialize_workgroup_memory";
15208pub const VK_KHR_ZERO_INITIALIZE_WORKGROUP_MEMORY_SPEC_VERSION: u32 = 1;
15209pub const VK_LATENCY_MARKER_INPUT_SAMPLE_NV: VkLatencyMarkerNV = 6;
15210pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV: VkLatencyMarkerNV = 11;
15211pub const VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV: VkLatencyMarkerNV = 10;
15212pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = 9;
15213pub const VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = 8;
15214pub const VK_LATENCY_MARKER_PRESENT_END_NV: VkLatencyMarkerNV = 5;
15215pub const VK_LATENCY_MARKER_PRESENT_START_NV: VkLatencyMarkerNV = 4;
15216pub const VK_LATENCY_MARKER_RENDERSUBMIT_END_NV: VkLatencyMarkerNV = 3;
15217pub const VK_LATENCY_MARKER_RENDERSUBMIT_START_NV: VkLatencyMarkerNV = 2;
15218pub const VK_LATENCY_MARKER_SIMULATION_END_NV: VkLatencyMarkerNV = 1;
15219pub const VK_LATENCY_MARKER_SIMULATION_START_NV: VkLatencyMarkerNV = 0;
15220pub const VK_LATENCY_MARKER_TRIGGER_FLASH_NV: VkLatencyMarkerNV = 7;
15221pub const VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT: VkLayeredDriverUnderlyingApiMSFT = 1;
15222pub const VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT: VkLayeredDriverUnderlyingApiMSFT = 0;
15223pub const VK_LAYER_SETTING_TYPE_BOOL32_EXT: VkLayerSettingTypeEXT = 0;
15224pub const VK_LAYER_SETTING_TYPE_FLOAT32_EXT: VkLayerSettingTypeEXT = 5;
15225pub const VK_LAYER_SETTING_TYPE_FLOAT64_EXT: VkLayerSettingTypeEXT = 6;
15226pub const VK_LAYER_SETTING_TYPE_INT32_EXT: VkLayerSettingTypeEXT = 1;
15227pub const VK_LAYER_SETTING_TYPE_INT64_EXT: VkLayerSettingTypeEXT = 2;
15228pub const VK_LAYER_SETTING_TYPE_STRING_EXT: VkLayerSettingTypeEXT = 7;
15229pub const VK_LAYER_SETTING_TYPE_UINT32_EXT: VkLayerSettingTypeEXT = 3;
15230pub const VK_LAYER_SETTING_TYPE_UINT64_EXT: VkLayerSettingTypeEXT = 4;
15231pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM: VkLineRasterizationMode = 2;
15232pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
15233pub const VK_LINE_RASTERIZATION_MODE_BRESENHAM_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_BRESENHAM;
15234pub const VK_LINE_RASTERIZATION_MODE_DEFAULT: VkLineRasterizationMode = 0;
15235pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
15236pub const VK_LINE_RASTERIZATION_MODE_DEFAULT_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_DEFAULT;
15237pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR: VkLineRasterizationMode = 1;
15238pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
15239pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR;
15240pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH: VkLineRasterizationMode = 3;
15241pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;
15242pub const VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_KHR: VkLineRasterizationMode = VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH;
15243pub const VK_LOD_CLAMP_NONE: f32 = 1000.0;
15244pub const VK_LOGIC_OP_AND: VkLogicOp = 1;
15245pub const VK_LOGIC_OP_AND_INVERTED: VkLogicOp = 4;
15246pub const VK_LOGIC_OP_AND_REVERSE: VkLogicOp = 2;
15247pub const VK_LOGIC_OP_CLEAR: VkLogicOp = 0;
15248pub const VK_LOGIC_OP_COPY: VkLogicOp = 3;
15249pub const VK_LOGIC_OP_COPY_INVERTED: VkLogicOp = 12;
15250pub const VK_LOGIC_OP_EQUIVALENT: VkLogicOp = 9;
15251pub const VK_LOGIC_OP_INVERT: VkLogicOp = 10;
15252pub const VK_LOGIC_OP_NAND: VkLogicOp = 14;
15253pub const VK_LOGIC_OP_NOR: VkLogicOp = 8;
15254pub const VK_LOGIC_OP_NO_OP: VkLogicOp = 5;
15255pub const VK_LOGIC_OP_OR: VkLogicOp = 7;
15256pub const VK_LOGIC_OP_OR_INVERTED: VkLogicOp = 13;
15257pub const VK_LOGIC_OP_OR_REVERSE: VkLogicOp = 11;
15258pub const VK_LOGIC_OP_SET: VkLogicOp = 15;
15259pub const VK_LOGIC_OP_XOR: VkLogicOp = 6;
15260pub const VK_LUID_SIZE: u32 = 8;
15261pub const VK_LUID_SIZE_KHR: u32 = VK_LUID_SIZE;
15262pub const VK_LUNARG_DIRECT_DRIVER_LOADING_EXTENSION_NAME: &CStr = c"VK_LUNARG_direct_driver_loading";
15263pub const VK_LUNARG_DIRECT_DRIVER_LOADING_SPEC_VERSION: u32 = 1;
15264pub const VK_MAX_DESCRIPTION_SIZE: u32 = 256;
15265pub const VK_MAX_DEVICE_GROUP_SIZE: u32 = 32;
15266pub const VK_MAX_DEVICE_GROUP_SIZE_KHR: u32 = VK_MAX_DEVICE_GROUP_SIZE;
15267pub const VK_MAX_DRIVER_INFO_SIZE: u32 = 256;
15268pub const VK_MAX_DRIVER_INFO_SIZE_KHR: u32 = VK_MAX_DRIVER_INFO_SIZE;
15269pub const VK_MAX_DRIVER_NAME_SIZE: u32 = 256;
15270pub const VK_MAX_DRIVER_NAME_SIZE_KHR: u32 = VK_MAX_DRIVER_NAME_SIZE;
15271pub const VK_MAX_EXTENSION_NAME_SIZE: u32 = 256;
15272pub const VK_MAX_GLOBAL_PRIORITY_SIZE: u32 = 16;
15273pub const VK_MAX_GLOBAL_PRIORITY_SIZE_EXT: u32 = VK_MAX_GLOBAL_PRIORITY_SIZE;
15274pub const VK_MAX_GLOBAL_PRIORITY_SIZE_KHR: u32 = VK_MAX_GLOBAL_PRIORITY_SIZE;
15275pub const VK_MAX_MEMORY_HEAPS: u32 = 16;
15276pub const VK_MAX_MEMORY_TYPES: u32 = 32;
15277pub const VK_MAX_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_SET_NAME_SIZE_ARM: u32 = 128;
15278pub const VK_MAX_PHYSICAL_DEVICE_NAME_SIZE: u32 = 256;
15279pub const VK_MAX_PIPELINE_BINARY_KEY_SIZE_KHR: u32 = 32;
15280pub const VK_MAX_SHADER_MODULE_IDENTIFIER_SIZE_EXT: u32 = 32;
15281pub const VK_MAX_VIDEO_AV1_REFERENCES_PER_FRAME_KHR: u32 = 7;
15282pub const VK_MAX_VIDEO_VP9_REFERENCES_PER_FRAME_KHR: u32 = 3;
15283pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT: VkMemoryAllocateFlagBits = 1 << 1;
15284pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT;
15285pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT: VkMemoryAllocateFlagBits = 1 << 2;
15286pub const VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT;
15287pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT: VkMemoryAllocateFlagBits = 1 << 0;
15288pub const VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR: VkMemoryAllocateFlagBits = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT;
15289pub const VK_MEMORY_ALLOCATE_ZERO_INITIALIZE_BIT_EXT: VkMemoryAllocateFlagBits = 1 << 3;
15290pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT: VkMemoryDecompressionMethodFlagBitsEXT = 1 << 0;
15291pub const VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV: VkMemoryDecompressionMethodFlagBitsEXT = VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_EXT;
15292pub const VK_MEMORY_HEAP_DEVICE_LOCAL_BIT: VkMemoryHeapFlagBits = 1 << 0;
15293pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT: VkMemoryHeapFlagBits = 1 << 1;
15294pub const VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR: VkMemoryHeapFlagBits = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT;
15295pub const VK_MEMORY_HEAP_TILE_MEMORY_BIT_QCOM: VkMemoryHeapFlagBits = 1 << 3;
15296pub const VK_MEMORY_MAP_PLACED_BIT_EXT: VkMemoryMapFlagBits = 1 << 0;
15297pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = 1;
15298pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD: VkMemoryOverallocationBehaviorAMD = 0;
15299pub const VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD: VkMemoryOverallocationBehaviorAMD = 2;
15300pub const VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD: VkMemoryPropertyFlagBits = 1 << 6;
15301pub const VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT: VkMemoryPropertyFlagBits = 1 << 0;
15302pub const VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD: VkMemoryPropertyFlagBits = 1 << 7;
15303pub const VK_MEMORY_PROPERTY_HOST_CACHED_BIT: VkMemoryPropertyFlagBits = 1 << 3;
15304pub const VK_MEMORY_PROPERTY_HOST_COHERENT_BIT: VkMemoryPropertyFlagBits = 1 << 2;
15305pub const VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT: VkMemoryPropertyFlagBits = 1 << 1;
15306pub const VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT: VkMemoryPropertyFlagBits = 1 << 4;
15307pub const VK_MEMORY_PROPERTY_PROTECTED_BIT: VkMemoryPropertyFlagBits = 1 << 5;
15308pub const VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV: VkMemoryPropertyFlagBits = 1 << 8;
15309pub const VK_MEMORY_UNMAP_RESERVE_BIT_EXT: VkMemoryUnmapFlagBits = 1 << 0;
15310pub const VK_MESA_IMAGE_ALIGNMENT_CONTROL_EXTENSION_NAME: &CStr = c"VK_MESA_image_alignment_control";
15311pub const VK_MESA_IMAGE_ALIGNMENT_CONTROL_SPEC_VERSION: u32 = 1;
15312pub const VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT: VkMicromapCreateFlagBitsEXT = 1 << 0;
15313pub const VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT: VkMicromapTypeEXT = 0;
15314pub const VK_MSFT_LAYERED_DRIVER_EXTENSION_NAME: &CStr = c"VK_MSFT_layered_driver";
15315pub const VK_MSFT_LAYERED_DRIVER_SPEC_VERSION: u32 = 1;
15316pub const VK_NOT_READY: VkResult = 1;
15317pub const VK_NVX_BINARY_IMPORT_EXTENSION_NAME: &CStr = c"VK_NVX_binary_import";
15318pub const VK_NVX_BINARY_IMPORT_SPEC_VERSION: u32 = 2;
15319pub const VK_NVX_IMAGE_VIEW_HANDLE_EXTENSION_NAME: &CStr = c"VK_NVX_image_view_handle";
15320pub const VK_NVX_IMAGE_VIEW_HANDLE_SPEC_VERSION: u32 = 4;
15321pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_EXTENSION_NAME: &CStr = c"VK_NVX_multiview_per_view_attributes";
15322pub const VK_NVX_MULTIVIEW_PER_VIEW_ATTRIBUTES_SPEC_VERSION: u32 = 1;
15323pub const VK_NV_CLIP_SPACE_W_SCALING_EXTENSION_NAME: &CStr = c"VK_NV_clip_space_w_scaling";
15324pub const VK_NV_CLIP_SPACE_W_SCALING_SPEC_VERSION: u32 = 1;
15325pub const VK_NV_CLUSTER_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_NV_cluster_acceleration_structure";
15326pub const VK_NV_CLUSTER_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 4;
15327pub const VK_NV_COMMAND_BUFFER_INHERITANCE_EXTENSION_NAME: &CStr = c"VK_NV_command_buffer_inheritance";
15328pub const VK_NV_COMMAND_BUFFER_INHERITANCE_SPEC_VERSION: u32 = 1;
15329pub const VK_NV_COMPUTE_OCCUPANCY_PRIORITY_EXTENSION_NAME: &CStr = c"VK_NV_compute_occupancy_priority";
15330pub const VK_NV_COMPUTE_OCCUPANCY_PRIORITY_SPEC_VERSION: u32 = 1;
15331pub const VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME: &CStr = c"VK_NV_compute_shader_derivatives";
15332pub const VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION: u32 = 1;
15333pub const VK_NV_COOPERATIVE_MATRIX_2_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_matrix2";
15334pub const VK_NV_COOPERATIVE_MATRIX_2_SPEC_VERSION: u32 = 1;
15335pub const VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_matrix";
15336pub const VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION: u32 = 1;
15337pub const VK_NV_COOPERATIVE_VECTOR_EXTENSION_NAME: &CStr = c"VK_NV_cooperative_vector";
15338pub const VK_NV_COOPERATIVE_VECTOR_SPEC_VERSION: u32 = 4;
15339pub const VK_NV_COPY_MEMORY_INDIRECT_EXTENSION_NAME: &CStr = c"VK_NV_copy_memory_indirect";
15340pub const VK_NV_COPY_MEMORY_INDIRECT_SPEC_VERSION: u32 = 1;
15341pub const VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME: &CStr = c"VK_NV_corner_sampled_image";
15342pub const VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION: u32 = 2;
15343pub const VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME: &CStr = c"VK_NV_coverage_reduction_mode";
15344pub const VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION: u32 = 1;
15345pub const VK_NV_DEDICATED_ALLOCATION_EXTENSION_NAME: &CStr = c"VK_NV_dedicated_allocation";
15346pub const VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME: &CStr = c"VK_NV_dedicated_allocation_image_aliasing";
15347pub const VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION: u32 = 1;
15348pub const VK_NV_DEDICATED_ALLOCATION_SPEC_VERSION: u32 = 1;
15349pub const VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_EXTENSION_NAME: &CStr = c"VK_NV_descriptor_pool_overallocation";
15350pub const VK_NV_DESCRIPTOR_POOL_OVERALLOCATION_SPEC_VERSION: u32 = 1;
15351pub const VK_NV_DEVICE_DIAGNOSTICS_CONFIG_EXTENSION_NAME: &CStr = c"VK_NV_device_diagnostics_config";
15352pub const VK_NV_DEVICE_DIAGNOSTICS_CONFIG_SPEC_VERSION: u32 = 2;
15353pub const VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_EXTENSION_NAME: &CStr = c"VK_NV_device_diagnostic_checkpoints";
15354pub const VK_NV_DEVICE_DIAGNOSTIC_CHECKPOINTS_SPEC_VERSION: u32 = 2;
15355pub const VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_EXTENSION_NAME: &CStr = c"VK_NV_device_generated_commands_compute";
15356pub const VK_NV_DEVICE_GENERATED_COMMANDS_COMPUTE_SPEC_VERSION: u32 = 2;
15357pub const VK_NV_DEVICE_GENERATED_COMMANDS_EXTENSION_NAME: &CStr = c"VK_NV_device_generated_commands";
15358pub const VK_NV_DEVICE_GENERATED_COMMANDS_SPEC_VERSION: u32 = 3;
15359pub const VK_NV_DISPLAY_STEREO_EXTENSION_NAME: &CStr = c"VK_NV_display_stereo";
15360pub const VK_NV_DISPLAY_STEREO_SPEC_VERSION: u32 = 1;
15361pub const VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_EXTENSION_NAME: &CStr = c"VK_NV_extended_sparse_address_space";
15362pub const VK_NV_EXTENDED_SPARSE_ADDRESS_SPACE_SPEC_VERSION: u32 = 1;
15363pub const VK_NV_EXTERNAL_COMPUTE_QUEUE_EXTENSION_NAME: &CStr = c"VK_NV_external_compute_queue";
15364pub const VK_NV_EXTERNAL_COMPUTE_QUEUE_SPEC_VERSION: u32 = 1;
15365pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME: &CStr = c"VK_NV_external_memory_capabilities";
15366pub const VK_NV_EXTERNAL_MEMORY_CAPABILITIES_SPEC_VERSION: u32 = 1;
15367pub const VK_NV_EXTERNAL_MEMORY_EXTENSION_NAME: &CStr = c"VK_NV_external_memory";
15368pub const VK_NV_EXTERNAL_MEMORY_RDMA_EXTENSION_NAME: &CStr = c"VK_NV_external_memory_rdma";
15369pub const VK_NV_EXTERNAL_MEMORY_RDMA_SPEC_VERSION: u32 = 1;
15370pub const VK_NV_EXTERNAL_MEMORY_SPEC_VERSION: u32 = 1;
15371pub const VK_NV_FILL_RECTANGLE_EXTENSION_NAME: &CStr = c"VK_NV_fill_rectangle";
15372pub const VK_NV_FILL_RECTANGLE_SPEC_VERSION: u32 = 1;
15373pub const VK_NV_FRAGMENT_COVERAGE_TO_COLOR_EXTENSION_NAME: &CStr = c"VK_NV_fragment_coverage_to_color";
15374pub const VK_NV_FRAGMENT_COVERAGE_TO_COLOR_SPEC_VERSION: u32 = 1;
15375pub const VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME: &CStr = c"VK_NV_fragment_shader_barycentric";
15376pub const VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION: u32 = 1;
15377pub const VK_NV_FRAGMENT_SHADING_RATE_ENUMS_EXTENSION_NAME: &CStr = c"VK_NV_fragment_shading_rate_enums";
15378pub const VK_NV_FRAGMENT_SHADING_RATE_ENUMS_SPEC_VERSION: u32 = 1;
15379pub const VK_NV_FRAMEBUFFER_MIXED_SAMPLES_EXTENSION_NAME: &CStr = c"VK_NV_framebuffer_mixed_samples";
15380pub const VK_NV_FRAMEBUFFER_MIXED_SAMPLES_SPEC_VERSION: u32 = 1;
15381pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_EXTENSION_NAME: &CStr = c"VK_NV_geometry_shader_passthrough";
15382pub const VK_NV_GEOMETRY_SHADER_PASSTHROUGH_SPEC_VERSION: u32 = 1;
15383pub const VK_NV_GLSL_SHADER_EXTENSION_NAME: &CStr = c"VK_NV_glsl_shader";
15384pub const VK_NV_GLSL_SHADER_SPEC_VERSION: u32 = 1;
15385pub const VK_NV_INHERITED_VIEWPORT_SCISSOR_EXTENSION_NAME: &CStr = c"VK_NV_inherited_viewport_scissor";
15386pub const VK_NV_INHERITED_VIEWPORT_SCISSOR_SPEC_VERSION: u32 = 1;
15387pub const VK_NV_LINEAR_COLOR_ATTACHMENT_EXTENSION_NAME: &CStr = c"VK_NV_linear_color_attachment";
15388pub const VK_NV_LINEAR_COLOR_ATTACHMENT_SPEC_VERSION: u32 = 1;
15389pub const VK_NV_LOW_LATENCY_2_EXTENSION_NAME: &CStr = c"VK_NV_low_latency2";
15390pub const VK_NV_LOW_LATENCY_2_SPEC_VERSION: u32 = 2;
15391pub const VK_NV_LOW_LATENCY_EXTENSION_NAME: &CStr = c"VK_NV_low_latency";
15392pub const VK_NV_LOW_LATENCY_SPEC_VERSION: u32 = 1;
15393pub const VK_NV_MEMORY_DECOMPRESSION_EXTENSION_NAME: &CStr = c"VK_NV_memory_decompression";
15394pub const VK_NV_MEMORY_DECOMPRESSION_SPEC_VERSION: u32 = 1;
15395pub const VK_NV_MESH_SHADER_EXTENSION_NAME: &CStr = c"VK_NV_mesh_shader";
15396pub const VK_NV_MESH_SHADER_SPEC_VERSION: u32 = 1;
15397pub const VK_NV_OPTICAL_FLOW_EXTENSION_NAME: &CStr = c"VK_NV_optical_flow";
15398pub const VK_NV_OPTICAL_FLOW_SPEC_VERSION: u32 = 1;
15399pub const VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_EXTENSION_NAME: &CStr = c"VK_NV_partitioned_acceleration_structure";
15400pub const VK_NV_PARTITIONED_ACCELERATION_STRUCTURE_SPEC_VERSION: u32 = 1;
15401pub const VK_NV_PER_STAGE_DESCRIPTOR_SET_EXTENSION_NAME: &CStr = c"VK_NV_per_stage_descriptor_set";
15402pub const VK_NV_PER_STAGE_DESCRIPTOR_SET_SPEC_VERSION: u32 = 1;
15403pub const VK_NV_PRESENT_BARRIER_EXTENSION_NAME: &CStr = c"VK_NV_present_barrier";
15404pub const VK_NV_PRESENT_BARRIER_SPEC_VERSION: u32 = 1;
15405pub const VK_NV_PUSH_CONSTANT_BANK_EXTENSION_NAME: &CStr = c"VK_NV_push_constant_bank";
15406pub const VK_NV_PUSH_CONSTANT_BANK_SPEC_VERSION: u32 = 1;
15407pub const VK_NV_RAW_ACCESS_CHAINS_EXTENSION_NAME: &CStr = c"VK_NV_raw_access_chains";
15408pub const VK_NV_RAW_ACCESS_CHAINS_SPEC_VERSION: u32 = 1;
15409pub const VK_NV_RAY_TRACING_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing";
15410pub const VK_NV_RAY_TRACING_INVOCATION_REORDER_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_invocation_reorder";
15411pub const VK_NV_RAY_TRACING_INVOCATION_REORDER_SPEC_VERSION: u32 = 1;
15412pub const VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_linear_swept_spheres";
15413pub const VK_NV_RAY_TRACING_LINEAR_SWEPT_SPHERES_SPEC_VERSION: u32 = 1;
15414pub const VK_NV_RAY_TRACING_MOTION_BLUR_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_motion_blur";
15415pub const VK_NV_RAY_TRACING_MOTION_BLUR_SPEC_VERSION: u32 = 1;
15416pub const VK_NV_RAY_TRACING_SPEC_VERSION: u32 = 3;
15417pub const VK_NV_RAY_TRACING_VALIDATION_EXTENSION_NAME: &CStr = c"VK_NV_ray_tracing_validation";
15418pub const VK_NV_RAY_TRACING_VALIDATION_SPEC_VERSION: u32 = 1;
15419pub const VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME: &CStr = c"VK_NV_representative_fragment_test";
15420pub const VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION: u32 = 2;
15421pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_EXTENSION_NAME: &CStr = c"VK_NV_sample_mask_override_coverage";
15422pub const VK_NV_SAMPLE_MASK_OVERRIDE_COVERAGE_SPEC_VERSION: u32 = 1;
15423pub const VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME: &CStr = c"VK_NV_scissor_exclusive";
15424pub const VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION: u32 = 2;
15425pub const VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_EXTENSION_NAME: &CStr = c"VK_NV_shader_atomic_float16_vector";
15426pub const VK_NV_SHADER_ATOMIC_FLOAT16_VECTOR_SPEC_VERSION: u32 = 1;
15427pub const VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME: &CStr = c"VK_NV_shader_image_footprint";
15428pub const VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION: u32 = 2;
15429pub const VK_NV_SHADER_SM_BUILTINS_EXTENSION_NAME: &CStr = c"VK_NV_shader_sm_builtins";
15430pub const VK_NV_SHADER_SM_BUILTINS_SPEC_VERSION: u32 = 1;
15431pub const VK_NV_SHADER_SUBGROUP_PARTITIONED_EXTENSION_NAME: &CStr = c"VK_NV_shader_subgroup_partitioned";
15432pub const VK_NV_SHADER_SUBGROUP_PARTITIONED_SPEC_VERSION: u32 = 1;
15433pub const VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME: &CStr = c"VK_NV_shading_rate_image";
15434pub const VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION: u32 = 3;
15435pub const VK_NV_VIEWPORT_ARRAY2_EXTENSION_NAME: &CStr = VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME;
15436pub const VK_NV_VIEWPORT_ARRAY2_SPEC_VERSION: u32 = VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION;
15437pub const VK_NV_VIEWPORT_ARRAY_2_EXTENSION_NAME: &CStr = c"VK_NV_viewport_array2";
15438pub const VK_NV_VIEWPORT_ARRAY_2_SPEC_VERSION: u32 = 1;
15439pub const VK_NV_VIEWPORT_SWIZZLE_EXTENSION_NAME: &CStr = c"VK_NV_viewport_swizzle";
15440pub const VK_NV_VIEWPORT_SWIZZLE_SPEC_VERSION: u32 = 1;
15441pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR: VkObjectType = 1000150000;
15442pub const VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV: VkObjectType = 1000165000;
15443pub const VK_OBJECT_TYPE_BUFFER: VkObjectType = 9;
15444pub const VK_OBJECT_TYPE_BUFFER_VIEW: VkObjectType = 13;
15445pub const VK_OBJECT_TYPE_COMMAND_BUFFER: VkObjectType = 6;
15446pub const VK_OBJECT_TYPE_COMMAND_POOL: VkObjectType = 25;
15447pub const VK_OBJECT_TYPE_CU_FUNCTION_NVX: VkObjectType = 1000029001;
15448pub const VK_OBJECT_TYPE_CU_MODULE_NVX: VkObjectType = 1000029000;
15449pub const VK_OBJECT_TYPE_DATA_GRAPH_PIPELINE_SESSION_ARM: VkObjectType = 1000507000;
15450pub const VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT: VkObjectType = 1000011000;
15451pub const VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT: VkObjectType = 1000128000;
15452pub const VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR: VkObjectType = 1000268000;
15453pub const VK_OBJECT_TYPE_DESCRIPTOR_POOL: VkObjectType = 22;
15454pub const VK_OBJECT_TYPE_DESCRIPTOR_SET: VkObjectType = 23;
15455pub const VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT: VkObjectType = 20;
15456pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE: VkObjectType = 1000085000;
15457pub const VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR: VkObjectType = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE;
15458pub const VK_OBJECT_TYPE_DEVICE: VkObjectType = 3;
15459pub const VK_OBJECT_TYPE_DEVICE_MEMORY: VkObjectType = 8;
15460pub const VK_OBJECT_TYPE_DISPLAY_KHR: VkObjectType = 1000002000;
15461pub const VK_OBJECT_TYPE_DISPLAY_MODE_KHR: VkObjectType = 1000002001;
15462pub const VK_OBJECT_TYPE_EVENT: VkObjectType = 11;
15463pub const VK_OBJECT_TYPE_EXTERNAL_COMPUTE_QUEUE_NV: VkObjectType = 1000556000;
15464pub const VK_OBJECT_TYPE_FENCE: VkObjectType = 7;
15465pub const VK_OBJECT_TYPE_FRAMEBUFFER: VkObjectType = 24;
15466pub const VK_OBJECT_TYPE_IMAGE: VkObjectType = 10;
15467pub const VK_OBJECT_TYPE_IMAGE_VIEW: VkObjectType = 14;
15468pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_EXT: VkObjectType = 1000572000;
15469pub const VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV: VkObjectType = 1000277000;
15470pub const VK_OBJECT_TYPE_INDIRECT_EXECUTION_SET_EXT: VkObjectType = 1000572001;
15471pub const VK_OBJECT_TYPE_INSTANCE: VkObjectType = 1;
15472pub const VK_OBJECT_TYPE_MICROMAP_EXT: VkObjectType = 1000396000;
15473pub const VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV: VkObjectType = 1000464000;
15474pub const VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL: VkObjectType = 1000210000;
15475pub const VK_OBJECT_TYPE_PHYSICAL_DEVICE: VkObjectType = 2;
15476pub const VK_OBJECT_TYPE_PIPELINE: VkObjectType = 19;
15477pub const VK_OBJECT_TYPE_PIPELINE_BINARY_KHR: VkObjectType = 1000483000;
15478pub const VK_OBJECT_TYPE_PIPELINE_CACHE: VkObjectType = 16;
15479pub const VK_OBJECT_TYPE_PIPELINE_LAYOUT: VkObjectType = 17;
15480pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT: VkObjectType = 1000295000;
15481pub const VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT: VkObjectType = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT;
15482pub const VK_OBJECT_TYPE_QUERY_POOL: VkObjectType = 12;
15483pub const VK_OBJECT_TYPE_QUEUE: VkObjectType = 4;
15484pub const VK_OBJECT_TYPE_RENDER_PASS: VkObjectType = 18;
15485pub const VK_OBJECT_TYPE_SAMPLER: VkObjectType = 21;
15486pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION: VkObjectType = 1000156000;
15487pub const VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR: VkObjectType = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION;
15488pub const VK_OBJECT_TYPE_SEMAPHORE: VkObjectType = 5;
15489pub const VK_OBJECT_TYPE_SHADER_EXT: VkObjectType = 1000482000;
15490pub const VK_OBJECT_TYPE_SHADER_MODULE: VkObjectType = 15;
15491pub const VK_OBJECT_TYPE_SURFACE_KHR: VkObjectType = 1000000000;
15492pub const VK_OBJECT_TYPE_SWAPCHAIN_KHR: VkObjectType = 1000001000;
15493pub const VK_OBJECT_TYPE_TENSOR_ARM: VkObjectType = 1000460000;
15494pub const VK_OBJECT_TYPE_TENSOR_VIEW_ARM: VkObjectType = 1000460001;
15495pub const VK_OBJECT_TYPE_UNKNOWN: VkObjectType = 0;
15496pub const VK_OBJECT_TYPE_VALIDATION_CACHE_EXT: VkObjectType = 1000160000;
15497pub const VK_OBJECT_TYPE_VIDEO_SESSION_KHR: VkObjectType = 1000023000;
15498pub const VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR: VkObjectType = 1000023001;
15499pub const VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT: VkOpacityMicromapFormatEXT = 1;
15500pub const VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT: VkOpacityMicromapFormatEXT = 2;
15501pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_CLUSTER_GEOMETRY_DISABLE_OPACITY_MICROMAP_NV: VkOpacityMicromapSpecialIndexEXT = -5;
15502pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = -2;
15503pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = -1;
15504pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT: VkOpacityMicromapSpecialIndexEXT = -4;
15505pub const VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT: VkOpacityMicromapSpecialIndexEXT = -3;
15506pub const VK_OPERATION_DEFERRED_KHR: VkResult = 1000268002;
15507pub const VK_OPERATION_NOT_DEFERRED_KHR: VkResult = 1000268003;
15508pub const VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV: VkOpticalFlowExecuteFlagBitsNV = 1 << 0;
15509pub const VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 0;
15510pub const VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 1;
15511pub const VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 2;
15512pub const VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV: VkOpticalFlowGridSizeFlagBitsNV = 1 << 3;
15513pub const VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV: VkOpticalFlowGridSizeFlagBitsNV = 0;
15514pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV: VkOpticalFlowPerformanceLevelNV = 3;
15515pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV: VkOpticalFlowPerformanceLevelNV = 2;
15516pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV: VkOpticalFlowPerformanceLevelNV = 1;
15517pub const VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV: VkOpticalFlowPerformanceLevelNV = 0;
15518pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV: VkOpticalFlowSessionBindingPointNV = 7;
15519pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = 5;
15520pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV: VkOpticalFlowSessionBindingPointNV = 6;
15521pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV: VkOpticalFlowSessionBindingPointNV = 4;
15522pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV: VkOpticalFlowSessionBindingPointNV = 8;
15523pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV: VkOpticalFlowSessionBindingPointNV = 3;
15524pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV: VkOpticalFlowSessionBindingPointNV = 1;
15525pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV: VkOpticalFlowSessionBindingPointNV = 2;
15526pub const VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV: VkOpticalFlowSessionBindingPointNV = 0;
15527pub const VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 3;
15528pub const VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 4;
15529pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 1;
15530pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 2;
15531pub const VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV: VkOpticalFlowSessionCreateFlagBitsNV = 1 << 0;
15532pub const VK_OPTICAL_FLOW_USAGE_COST_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 3;
15533pub const VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 4;
15534pub const VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 2;
15535pub const VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 0;
15536pub const VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV: VkOpticalFlowUsageFlagBitsNV = 1 << 1;
15537pub const VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV: VkOpticalFlowUsageFlagBitsNV = 0;
15538pub const VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV: VkOutOfBandQueueTypeNV = 1;
15539pub const VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV: VkOutOfBandQueueTypeNV = 0;
15540pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_ENABLE_EXPLICIT_BOUNDING_BOX_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 4;
15541pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_NO_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 3;
15542pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_FORCE_OPAQUE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 2;
15543pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FACING_CULL_DISABLE_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 0;
15544pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCE_FLAG_TRIANGLE_FLIP_FACING_BIT_NV: VkPartitionedAccelerationStructureInstanceFlagBitsNV = 1 << 1;
15545pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_UPDATE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = 1;
15546pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_INSTANCE_NV: VkPartitionedAccelerationStructureOpTypeNV = 0;
15547pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_OP_TYPE_WRITE_PARTITION_TRANSLATION_NV: VkPartitionedAccelerationStructureOpTypeNV = 2;
15548pub const VK_PARTITIONED_ACCELERATION_STRUCTURE_PARTITION_INDEX_GLOBAL_NV: u32 = !0;
15549pub const VK_PAST_PRESENTATION_TIMING_ALLOW_OUT_OF_ORDER_RESULTS_BIT_EXT: VkPastPresentationTimingFlagBitsEXT = 1 << 1;
15550pub const VK_PAST_PRESENTATION_TIMING_ALLOW_PARTIAL_RESULTS_BIT_EXT: VkPastPresentationTimingFlagBitsEXT = 1 << 0;
15551pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT: VkPeerMemoryFeatureFlagBits = 1 << 1;
15552pub const VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT;
15553pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT: VkPeerMemoryFeatureFlagBits = 1 << 0;
15554pub const VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT;
15555pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT: VkPeerMemoryFeatureFlagBits = 1 << 3;
15556pub const VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;
15557pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT: VkPeerMemoryFeatureFlagBits = 1 << 2;
15558pub const VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR: VkPeerMemoryFeatureFlagBits = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT;
15559pub const VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL: VkPerformanceConfigurationTypeINTEL = 0;
15560pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = 1 << 1;
15561pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR;
15562pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = 1 << 0;
15563pub const VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR: VkPerformanceCounterDescriptionFlagBitsKHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR;
15564pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = 0;
15565pub const VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = 2;
15566pub const VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = 1;
15567pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR: VkPerformanceCounterStorageKHR = 4;
15568pub const VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR: VkPerformanceCounterStorageKHR = 5;
15569pub const VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR: VkPerformanceCounterStorageKHR = 0;
15570pub const VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR: VkPerformanceCounterStorageKHR = 1;
15571pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR: VkPerformanceCounterStorageKHR = 2;
15572pub const VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR: VkPerformanceCounterStorageKHR = 3;
15573pub const VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR: VkPerformanceCounterUnitKHR = 8;
15574pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR: VkPerformanceCounterUnitKHR = 3;
15575pub const VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR: VkPerformanceCounterUnitKHR = 4;
15576pub const VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR: VkPerformanceCounterUnitKHR = 10;
15577pub const VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR: VkPerformanceCounterUnitKHR = 0;
15578pub const VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR: VkPerformanceCounterUnitKHR = 9;
15579pub const VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR: VkPerformanceCounterUnitKHR = 5;
15580pub const VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR: VkPerformanceCounterUnitKHR = 2;
15581pub const VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR: VkPerformanceCounterUnitKHR = 1;
15582pub const VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR: VkPerformanceCounterUnitKHR = 7;
15583pub const VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR: VkPerformanceCounterUnitKHR = 6;
15584pub const VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL: VkPerformanceOverrideTypeINTEL = 1;
15585pub const VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL: VkPerformanceOverrideTypeINTEL = 0;
15586pub const VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL: VkPerformanceParameterTypeINTEL = 0;
15587pub const VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL: VkPerformanceParameterTypeINTEL = 1;
15588pub const VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL: VkPerformanceValueTypeINTEL = 3;
15589pub const VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL: VkPerformanceValueTypeINTEL = 2;
15590pub const VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL: VkPerformanceValueTypeINTEL = 4;
15591pub const VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL: VkPerformanceValueTypeINTEL = 0;
15592pub const VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL: VkPerformanceValueTypeINTEL = 1;
15593pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_BUILTIN_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = 1000629001;
15594pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_NEURAL_MODEL_QCOM: VkPhysicalDeviceDataGraphOperationTypeARM = 1000629000;
15595pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_OPERATION_TYPE_SPIRV_EXTENDED_INSTRUCTION_SET_ARM: VkPhysicalDeviceDataGraphOperationTypeARM = 0;
15596pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_COMPUTE_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 1000629001;
15597pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_DEFAULT_ARM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 0;
15598pub const VK_PHYSICAL_DEVICE_DATA_GRAPH_PROCESSING_ENGINE_TYPE_NEURAL_QCOM: VkPhysicalDeviceDataGraphProcessingEngineTypeARM = 1000629000;
15599pub const VK_PHYSICAL_DEVICE_LAYERED_API_D3D12_KHR: VkPhysicalDeviceLayeredApiKHR = 1;
15600pub const VK_PHYSICAL_DEVICE_LAYERED_API_METAL_KHR: VkPhysicalDeviceLayeredApiKHR = 2;
15601pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGLES_KHR: VkPhysicalDeviceLayeredApiKHR = 4;
15602pub const VK_PHYSICAL_DEVICE_LAYERED_API_OPENGL_KHR: VkPhysicalDeviceLayeredApiKHR = 3;
15603pub const VK_PHYSICAL_DEVICE_LAYERED_API_VULKAN_KHR: VkPhysicalDeviceLayeredApiKHR = 0;
15604pub const VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM: VkPhysicalDeviceSchedulingControlsFlagBitsARM = 1 << 0;
15605pub const VK_PHYSICAL_DEVICE_TYPE_CPU: VkPhysicalDeviceType = 4;
15606pub const VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU: VkPhysicalDeviceType = 2;
15607pub const VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU: VkPhysicalDeviceType = 1;
15608pub const VK_PHYSICAL_DEVICE_TYPE_OTHER: VkPhysicalDeviceType = 0;
15609pub const VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU: VkPhysicalDeviceType = 3;
15610pub const VK_PIPELINE_BINARY_MISSING_KHR: VkResult = 1000483000;
15611pub const VK_PIPELINE_BIND_POINT_COMPUTE: VkPipelineBindPoint = 1;
15612pub const VK_PIPELINE_BIND_POINT_DATA_GRAPH_ARM: VkPipelineBindPoint = 1000507000;
15613pub const VK_PIPELINE_BIND_POINT_GRAPHICS: VkPipelineBindPoint = 0;
15614pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR: VkPipelineBindPoint = 1000165000;
15615pub const VK_PIPELINE_BIND_POINT_RAY_TRACING_NV: VkPipelineBindPoint = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR;
15616pub const VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI: VkPipelineBindPoint = 1000369003;
15617pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT: VkPipelineCacheCreateFlagBits = 1 << 0;
15618pub const VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT: VkPipelineCacheCreateFlagBits = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT;
15619pub const VK_PIPELINE_CACHE_CREATE_INTERNALLY_SYNCHRONIZED_MERGE_BIT_KHR: VkPipelineCacheCreateFlagBits = 1 << 3;
15620pub const VK_PIPELINE_CACHE_HEADER_VERSION_DATA_GRAPH_QCOM: VkPipelineCacheHeaderVersion = 1000629000;
15621pub const VK_PIPELINE_CACHE_HEADER_VERSION_ONE: VkPipelineCacheHeaderVersion = 1;
15622pub 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;
15623pub const VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT: VkPipelineColorBlendStateCreateFlagBits = 1 << 0;
15624pub const VK_PIPELINE_COMPILE_REQUIRED: VkResult = 1000297000;
15625pub const VK_PIPELINE_COMPILE_REQUIRED_EXT: VkResult = VK_PIPELINE_COMPILE_REQUIRED;
15626pub const VK_PIPELINE_CREATE_2_64_BIT_INDEXING_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 43;
15627pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlagBits2 = 1 << 1;
15628pub const VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT;
15629pub const VK_PIPELINE_CREATE_2_CAPTURE_DATA_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 31;
15630pub const VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 7;
15631pub const VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 6;
15632pub const VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 25;
15633pub const VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 5;
15634pub const VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 26;
15635pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT: VkPipelineCreateFlagBits2 = 1 << 2;
15636pub const VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DERIVATIVE_BIT;
15637pub const VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 29;
15638pub const VK_PIPELINE_CREATE_2_DESCRIPTOR_HEAP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 36;
15639pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlagBits2 = 1 << 0;
15640pub const VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT;
15641pub const VK_PIPELINE_CREATE_2_DISALLOW_OPACITY_MICROMAP_BIT_ARM: VkPipelineCreateFlagBits2 = 1 << 37;
15642pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT: VkPipelineCreateFlagBits2 = 1 << 4;
15643pub const VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT;
15644pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlagBits2 = 1 << 9;
15645pub const VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT;
15646pub const VK_PIPELINE_CREATE_2_ENABLE_LEGACY_DITHERING_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 34;
15647pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlagBits2 = 1 << 8;
15648pub const VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
15649pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 38;
15650pub const VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 18;
15651pub const VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 11;
15652pub const VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 10;
15653pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlagBits2 = 1 << 27;
15654pub const VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT;
15655pub const VK_PIPELINE_CREATE_2_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkPipelineCreateFlagBits2 = 1 << 40;
15656pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlagBits2 = 1 << 30;
15657pub const VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT;
15658pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 20;
15659pub const VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_SPHERES_AND_LINEAR_SWEPT_SPHERES_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 33;
15660pub const VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV: VkPipelineCreateFlagBits2 = 1 << 28;
15661pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 14;
15662pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 15;
15663pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 17;
15664pub const VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 16;
15665pub const VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 24;
15666pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 19;
15667pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 13;
15668pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_BUILT_IN_PRIMITIVES_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR;
15669pub const VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 12;
15670pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 22;
15671pub const VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits2 = 1 << 21;
15672pub const VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlagBits2 = 1 << 23;
15673pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlagBits2 = 1 << 3;
15674pub const VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlagBits2 = VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
15675pub const VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT: VkPipelineCreateFlagBits = 1 << 1;
15676pub const VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 7;
15677pub const VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 6;
15678pub const VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 25;
15679pub const VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV: VkPipelineCreateFlagBits = 1 << 5;
15680pub const VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 26;
15681pub const VK_PIPELINE_CREATE_DERIVATIVE_BIT: VkPipelineCreateFlagBits = 1 << 2;
15682pub const VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT: VkPipelineCreateFlagBits = 1 << 29;
15683pub const VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT: VkPipelineCreateFlagBits = 1 << 0;
15684pub const VK_PIPELINE_CREATE_DISPATCH_BASE: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
15685pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT: VkPipelineCreateFlagBits = 1 << 4;
15686pub const VK_PIPELINE_CREATE_DISPATCH_BASE_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
15687pub const VK_PIPELINE_CREATE_DISPATCH_BASE_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT;
15688pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT: VkPipelineCreateFlagBits = 1 << 9;
15689pub const VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT;
15690pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT: VkPipelineCreateFlagBits = 1 << 8;
15691pub const VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT;
15692pub const VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV: VkPipelineCreateFlagBits = 1 << 18;
15693pub const VK_PIPELINE_CREATE_LIBRARY_BIT_KHR: VkPipelineCreateFlagBits = 1 << 11;
15694pub const VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT: VkPipelineCreateFlagBits = 1 << 10;
15695pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT: VkPipelineCreateFlagBits = 1 << 27;
15696pub const VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT;
15697pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT: VkPipelineCreateFlagBits = 1 << 30;
15698pub const VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT;
15699pub const VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV: VkPipelineCreateFlagBits = 1 << 20;
15700pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 14;
15701pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 15;
15702pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 17;
15703pub const VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 16;
15704pub const VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT: VkPipelineCreateFlagBits = 1 << 24;
15705pub const VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR: VkPipelineCreateFlagBits = 1 << 19;
15706pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR: VkPipelineCreateFlagBits = 1 << 13;
15707pub const VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR: VkPipelineCreateFlagBits = 1 << 12;
15708pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits = 1 << 22;
15709pub const VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits = 1 << 21;
15710pub const VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT: VkPipelineCreateFlagBits = 1 << 23;
15711pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT: VkPipelineCreateFlagBits = 1 << 3;
15712pub const VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT;
15713pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 1;
15714pub const VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT;
15715pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 2;
15716pub const VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT;
15717pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT: VkPipelineCreationFeedbackFlagBits = 1 << 0;
15718pub const VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT: VkPipelineCreationFeedbackFlagBits = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT;
15719pub 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;
15720pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: VkPipelineDepthStencilStateCreateFlagBits = 1 << 0;
15721pub 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;
15722pub const VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: VkPipelineDepthStencilStateCreateFlagBits = 1 << 1;
15723pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR: VkPipelineExecutableStatisticFormatKHR = 0;
15724pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR: VkPipelineExecutableStatisticFormatKHR = 3;
15725pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR: VkPipelineExecutableStatisticFormatKHR = 1;
15726pub const VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR: VkPipelineExecutableStatisticFormatKHR = 2;
15727pub const VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT: VkPipelineLayoutCreateFlagBits = 1 << 1;
15728pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT;
15729pub const VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineCreateFlagBits = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
15730pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessBufferBehavior = 0;
15731pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT;
15732pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED: VkPipelineRobustnessBufferBehavior = 1;
15733pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED;
15734pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS: VkPipelineRobustnessBufferBehavior = 2;
15735pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2: VkPipelineRobustnessBufferBehavior = 3;
15736pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2;
15737pub const VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT: VkPipelineRobustnessBufferBehavior = VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS;
15738pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT: VkPipelineRobustnessImageBehavior = 0;
15739pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT;
15740pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED: VkPipelineRobustnessImageBehavior = 1;
15741pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED;
15742pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS: VkPipelineRobustnessImageBehavior = 2;
15743pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2: VkPipelineRobustnessImageBehavior = 3;
15744pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2;
15745pub const VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT: VkPipelineRobustnessImageBehavior = VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS;
15746pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT: VkPipelineShaderStageCreateFlagBits = 1 << 0;
15747pub const VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkPipelineShaderStageCreateFlagBits = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT;
15748pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT: VkPipelineShaderStageCreateFlagBits = 1 << 1;
15749pub const VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkPipelineShaderStageCreateFlagBits = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT;
15750pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 25;
15751pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
15752pub const VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 28;
15753pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT: VkPipelineStageFlagBits2 = 1 << 16;
15754pub const VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT;
15755pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits2 = 1 << 15;
15756pub const VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT;
15757pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT: VkPipelineStageFlagBits2 = 1 << 12;
15758pub const VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
15759pub const VK_PIPELINE_STAGE_2_BLIT_BIT: VkPipelineStageFlagBits2 = 1 << 34;
15760pub const VK_PIPELINE_STAGE_2_BLIT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_BLIT_BIT;
15761pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits2 = 1 << 13;
15762pub const VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT;
15763pub const VK_PIPELINE_STAGE_2_CLEAR_BIT: VkPipelineStageFlagBits2 = 1 << 35;
15764pub const VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_CLEAR_BIT;
15765pub const VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 41;
15766pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits2 = 1 << 10;
15767pub const VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT;
15768pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 17;
15769pub const VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_EXT;
15770pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 11;
15771pub const VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT;
15772pub const VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 18;
15773pub const VK_PIPELINE_STAGE_2_CONVERT_COOPERATIVE_VECTOR_MATRIX_BIT_NV: VkPipelineStageFlagBits2 = 1 << 44;
15774pub const VK_PIPELINE_STAGE_2_COPY_BIT: VkPipelineStageFlagBits2 = 1 << 32;
15775pub const VK_PIPELINE_STAGE_2_COPY_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_COPY_BIT;
15776pub const VK_PIPELINE_STAGE_2_COPY_INDIRECT_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 46;
15777pub const VK_PIPELINE_STAGE_2_DATA_GRAPH_BIT_ARM: VkPipelineStageFlagBits2 = 1 << 42;
15778pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits2 = 1 << 1;
15779pub const VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT;
15780pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2 = 1 << 8;
15781pub const VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT;
15782pub const VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 23;
15783pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 7;
15784pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT;
15785pub const VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 22;
15786pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 6;
15787pub const VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT;
15788pub const VK_PIPELINE_STAGE_2_HOST_BIT: VkPipelineStageFlagBits2 = 1 << 14;
15789pub const VK_PIPELINE_STAGE_2_HOST_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_HOST_BIT;
15790pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 36;
15791pub const VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT;
15792pub const VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 40;
15793pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits2 = 1 << 9;
15794pub const VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT;
15795pub const VK_PIPELINE_STAGE_2_MEMORY_DECOMPRESSION_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 45;
15796pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 20;
15797pub const VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT;
15798pub const VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 30;
15799pub const VK_PIPELINE_STAGE_2_NONE: VkPipelineStageFlagBits2 = 0;
15800pub const VK_PIPELINE_STAGE_2_NONE_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_NONE;
15801pub const VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV: VkPipelineStageFlagBits2 = 1 << 29;
15802pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT: VkPipelineStageFlagBits2 = 1 << 38;
15803pub const VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT;
15804pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 21;
15805pub const VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR;
15806pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT: VkPipelineStageFlagBits2 = 1 << 33;
15807pub const VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_RESOLVE_BIT;
15808pub const VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
15809pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI: VkPipelineStageFlagBits2 = 1 << 39;
15810pub const VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI;
15811pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 19;
15812pub const VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT;
15813pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 4;
15814pub const VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT;
15815pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 5;
15816pub const VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT;
15817pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits2 = 1 << 0;
15818pub const VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT;
15819pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
15820pub const VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT;
15821pub const VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlagBits2 = 1 << 24;
15822pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 37;
15823pub const VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT;
15824pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT: VkPipelineStageFlagBits2 = 1 << 2;
15825pub const VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT;
15826pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT: VkPipelineStageFlagBits2 = 1 << 3;
15827pub const VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR: VkPipelineStageFlagBits2 = VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT;
15828pub const VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 26;
15829pub const VK_PIPELINE_STAGE_2_VIDEO_ENCODE_BIT_KHR: VkPipelineStageFlagBits2 = 1 << 27;
15830pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR: VkPipelineStageFlagBits = 1 << 25;
15831pub const VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR;
15832pub const VK_PIPELINE_STAGE_ALL_COMMANDS_BIT: VkPipelineStageFlagBits = 1 << 16;
15833pub const VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT: VkPipelineStageFlagBits = 1 << 15;
15834pub const VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT: VkPipelineStageFlagBits = 1 << 13;
15835pub const VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT: VkPipelineStageFlagBits = 1 << 10;
15836pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT: VkPipelineStageFlagBits = 1 << 17;
15837pub const VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_EXT;
15838pub const VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT: VkPipelineStageFlagBits = 1 << 11;
15839pub const VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT: VkPipelineStageFlagBits = 1 << 18;
15840pub const VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT: VkPipelineStageFlagBits = 1 << 1;
15841pub const VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 1 << 8;
15842pub const VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT: VkPipelineStageFlagBits = 1 << 23;
15843pub const VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT: VkPipelineStageFlagBits = 1 << 7;
15844pub const VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR: VkPipelineStageFlagBits = 1 << 22;
15845pub const VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT: VkPipelineStageFlagBits = 1 << 6;
15846pub const VK_PIPELINE_STAGE_HOST_BIT: VkPipelineStageFlagBits = 1 << 14;
15847pub const VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT: VkPipelineStageFlagBits = 1 << 9;
15848pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT: VkPipelineStageFlagBits = 1 << 20;
15849pub const VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT;
15850pub const VK_PIPELINE_STAGE_NONE: VkPipelineStageFlagBits = 0;
15851pub const VK_PIPELINE_STAGE_NONE_KHR: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_NONE;
15852pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR: VkPipelineStageFlagBits = 1 << 21;
15853pub const VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR;
15854pub const VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR;
15855pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT: VkPipelineStageFlagBits = 1 << 19;
15856pub const VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV: VkPipelineStageFlagBits = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT;
15857pub const VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT: VkPipelineStageFlagBits = 1 << 4;
15858pub const VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT: VkPipelineStageFlagBits = 1 << 5;
15859pub const VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT: VkPipelineStageFlagBits = 1 << 0;
15860pub const VK_PIPELINE_STAGE_TRANSFER_BIT: VkPipelineStageFlagBits = 1 << 12;
15861pub const VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT: VkPipelineStageFlagBits = 1 << 24;
15862pub const VK_PIPELINE_STAGE_VERTEX_INPUT_BIT: VkPipelineStageFlagBits = 1 << 2;
15863pub const VK_PIPELINE_STAGE_VERTEX_SHADER_BIT: VkPipelineStageFlagBits = 1 << 3;
15864pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: VkPointClippingBehavior = 0;
15865pub const VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
15866pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: VkPointClippingBehavior = 1;
15867pub const VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR: VkPointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY;
15868pub const VK_POLYGON_MODE_FILL: VkPolygonMode = 0;
15869pub const VK_POLYGON_MODE_FILL_RECTANGLE_NV: VkPolygonMode = 1000153000;
15870pub const VK_POLYGON_MODE_LINE: VkPolygonMode = 1;
15871pub const VK_POLYGON_MODE_POINT: VkPolygonMode = 2;
15872pub const VK_PRESENT_GRAVITY_CENTERED_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_CENTERED_BIT_KHR;
15873pub const VK_PRESENT_GRAVITY_CENTERED_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 2;
15874pub const VK_PRESENT_GRAVITY_MAX_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_MAX_BIT_KHR;
15875pub const VK_PRESENT_GRAVITY_MAX_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 1;
15876pub const VK_PRESENT_GRAVITY_MIN_BIT_EXT: VkPresentGravityFlagBitsKHR = VK_PRESENT_GRAVITY_MIN_BIT_KHR;
15877pub const VK_PRESENT_GRAVITY_MIN_BIT_KHR: VkPresentGravityFlagBitsKHR = 1 << 0;
15878pub const VK_PRESENT_MODE_FIFO_KHR: VkPresentModeKHR = 2;
15879pub const VK_PRESENT_MODE_FIFO_LATEST_READY_EXT: VkPresentModeKHR = VK_PRESENT_MODE_FIFO_LATEST_READY_KHR;
15880pub const VK_PRESENT_MODE_FIFO_LATEST_READY_KHR: VkPresentModeKHR = 1000361000;
15881pub const VK_PRESENT_MODE_FIFO_RELAXED_KHR: VkPresentModeKHR = 3;
15882pub const VK_PRESENT_MODE_IMMEDIATE_KHR: VkPresentModeKHR = 0;
15883pub const VK_PRESENT_MODE_MAILBOX_KHR: VkPresentModeKHR = 1;
15884pub const VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR: VkPresentModeKHR = 1000111001;
15885pub const VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR: VkPresentModeKHR = 1000111000;
15886pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR;
15887pub const VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 1;
15888pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR;
15889pub const VK_PRESENT_SCALING_ONE_TO_ONE_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 0;
15890pub const VK_PRESENT_SCALING_STRETCH_BIT_EXT: VkPresentScalingFlagBitsKHR = VK_PRESENT_SCALING_STRETCH_BIT_KHR;
15891pub const VK_PRESENT_SCALING_STRETCH_BIT_KHR: VkPresentScalingFlagBitsKHR = 1 << 2;
15892pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_OUT_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 2;
15893pub const VK_PRESENT_STAGE_IMAGE_FIRST_PIXEL_VISIBLE_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 3;
15894pub const VK_PRESENT_STAGE_QUEUE_OPERATIONS_END_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 0;
15895pub const VK_PRESENT_STAGE_REQUEST_DEQUEUED_BIT_EXT: VkPresentStageFlagBitsEXT = 1 << 1;
15896pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_NEAREST_REFRESH_CYCLE_BIT_EXT: VkPresentTimingInfoFlagBitsEXT = 1 << 1;
15897pub const VK_PRESENT_TIMING_INFO_PRESENT_AT_RELATIVE_TIME_BIT_EXT: VkPresentTimingInfoFlagBitsEXT = 1 << 0;
15898pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST: VkPrimitiveTopology = 1;
15899pub const VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 6;
15900pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP: VkPrimitiveTopology = 2;
15901pub const VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 7;
15902pub const VK_PRIMITIVE_TOPOLOGY_PATCH_LIST: VkPrimitiveTopology = 10;
15903pub const VK_PRIMITIVE_TOPOLOGY_POINT_LIST: VkPrimitiveTopology = 0;
15904pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN: VkPrimitiveTopology = 5;
15905pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST: VkPrimitiveTopology = 3;
15906pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY: VkPrimitiveTopology = 8;
15907pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP: VkPrimitiveTopology = 4;
15908pub const VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY: VkPrimitiveTopology = 9;
15909pub const VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT: VkProvokingVertexModeEXT = 0;
15910pub const VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT: VkProvokingVertexModeEXT = 1;
15911pub const VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_EXTENSION_NAME: &CStr = c"VK_QCOM_cooperative_matrix_conversion";
15912pub const VK_QCOM_COOPERATIVE_MATRIX_CONVERSION_SPEC_VERSION: u32 = 1;
15913pub const VK_QCOM_DATA_GRAPH_MODEL_EXTENSION_NAME: &CStr = c"VK_QCOM_data_graph_model";
15914pub const VK_QCOM_DATA_GRAPH_MODEL_SPEC_VERSION: u32 = 1;
15915pub const VK_QCOM_FILTER_CUBIC_CLAMP_EXTENSION_NAME: &CStr = c"VK_QCOM_filter_cubic_clamp";
15916pub const VK_QCOM_FILTER_CUBIC_CLAMP_SPEC_VERSION: u32 = 1;
15917pub const VK_QCOM_FILTER_CUBIC_WEIGHTS_EXTENSION_NAME: &CStr = c"VK_QCOM_filter_cubic_weights";
15918pub const VK_QCOM_FILTER_CUBIC_WEIGHTS_SPEC_VERSION: u32 = 1;
15919pub const VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_EXTENSION_NAME: &CStr = c"VK_QCOM_fragment_density_map_offset";
15920pub const VK_QCOM_FRAGMENT_DENSITY_MAP_OFFSET_SPEC_VERSION: u32 = 3;
15921pub const VK_QCOM_IMAGE_PROCESSING_2_EXTENSION_NAME: &CStr = c"VK_QCOM_image_processing2";
15922pub const VK_QCOM_IMAGE_PROCESSING_2_SPEC_VERSION: u32 = 1;
15923pub const VK_QCOM_IMAGE_PROCESSING_EXTENSION_NAME: &CStr = c"VK_QCOM_image_processing";
15924pub const VK_QCOM_IMAGE_PROCESSING_SPEC_VERSION: u32 = 1;
15925pub const VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_EXTENSION_NAME: &CStr = c"VK_QCOM_multiview_per_view_render_areas";
15926pub const VK_QCOM_MULTIVIEW_PER_VIEW_RENDER_AREAS_SPEC_VERSION: u32 = 1;
15927pub const VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_EXTENSION_NAME: &CStr = c"VK_QCOM_multiview_per_view_viewports";
15928pub const VK_QCOM_MULTIVIEW_PER_VIEW_VIEWPORTS_SPEC_VERSION: u32 = 1;
15929pub const VK_QCOM_RENDER_PASS_SHADER_RESOLVE_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_shader_resolve";
15930pub const VK_QCOM_RENDER_PASS_SHADER_RESOLVE_SPEC_VERSION: u32 = 4;
15931pub const VK_QCOM_RENDER_PASS_STORE_OPS_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_store_ops";
15932pub const VK_QCOM_RENDER_PASS_STORE_OPS_SPEC_VERSION: u32 = 2;
15933pub const VK_QCOM_RENDER_PASS_TRANSFORM_EXTENSION_NAME: &CStr = c"VK_QCOM_render_pass_transform";
15934pub const VK_QCOM_RENDER_PASS_TRANSFORM_SPEC_VERSION: u32 = 5;
15935pub const VK_QCOM_ROTATED_COPY_COMMANDS_EXTENSION_NAME: &CStr = c"VK_QCOM_rotated_copy_commands";
15936pub const VK_QCOM_ROTATED_COPY_COMMANDS_SPEC_VERSION: u32 = 2;
15937pub const VK_QCOM_TILE_MEMORY_HEAP_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_memory_heap";
15938pub const VK_QCOM_TILE_MEMORY_HEAP_SPEC_VERSION: u32 = 1;
15939pub const VK_QCOM_TILE_PROPERTIES_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_properties";
15940pub const VK_QCOM_TILE_PROPERTIES_SPEC_VERSION: u32 = 1;
15941pub const VK_QCOM_TILE_SHADING_EXTENSION_NAME: &CStr = c"VK_QCOM_tile_shading";
15942pub const VK_QCOM_TILE_SHADING_SPEC_VERSION: u32 = 2;
15943pub const VK_QCOM_YCBCR_DEGAMMA_EXTENSION_NAME: &CStr = c"VK_QCOM_ycbcr_degamma";
15944pub const VK_QCOM_YCBCR_DEGAMMA_SPEC_VERSION: u32 = 1;
15945pub const VK_QUERY_CONTROL_PRECISE_BIT: VkQueryControlFlagBits = 1 << 0;
15946pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 5;
15947pub const VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 6;
15948pub const VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI: VkQueryPipelineStatisticFlagBits = 1 << 13;
15949pub const VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 10;
15950pub const VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 7;
15951pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 3;
15952pub const VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 4;
15953pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 1;
15954pub const VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 0;
15955pub const VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlagBits = 1 << 12;
15956pub const VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT: VkQueryPipelineStatisticFlagBits = 1 << 11;
15957pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT: VkQueryPipelineStatisticFlagBits = 1 << 8;
15958pub const VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 9;
15959pub const VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT: VkQueryPipelineStatisticFlagBits = 1 << 2;
15960pub const VK_QUERY_POOL_CREATE_RESET_BIT_KHR: VkQueryPoolCreateFlagBits = 1 << 0;
15961pub const VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL: VkQueryPoolSamplingModeINTEL = 0;
15962pub const VK_QUERY_RESULT_64_BIT: VkQueryResultFlagBits = 1 << 0;
15963pub const VK_QUERY_RESULT_PARTIAL_BIT: VkQueryResultFlagBits = 1 << 3;
15964pub const VK_QUERY_RESULT_STATUS_COMPLETE_KHR: VkQueryResultStatusKHR = 1;
15965pub const VK_QUERY_RESULT_STATUS_ERROR_KHR: VkQueryResultStatusKHR = -1;
15966pub const VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR: VkQueryResultStatusKHR = -1000299000;
15967pub const VK_QUERY_RESULT_STATUS_NOT_READY_KHR: VkQueryResultStatusKHR = 0;
15968pub const VK_QUERY_RESULT_WAIT_BIT: VkQueryResultFlagBits = 1 << 1;
15969pub const VK_QUERY_RESULT_WITH_AVAILABILITY_BIT: VkQueryResultFlagBits = 1 << 2;
15970pub const VK_QUERY_RESULT_WITH_STATUS_BIT_KHR: VkQueryResultFlagBits = 1 << 4;
15971pub const VK_QUERY_SCOPE_COMMAND_BUFFER_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR;
15972pub const VK_QUERY_SCOPE_COMMAND_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR;
15973pub const VK_QUERY_SCOPE_RENDER_PASS_KHR: VkPerformanceCounterScopeKHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR;
15974pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR: VkQueryType = 1000150000;
15975pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV: VkQueryType = 1000165000;
15976pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR: VkQueryType = 1000386000;
15977pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR: VkQueryType = 1000150001;
15978pub const VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR: VkQueryType = 1000386001;
15979pub const VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT: VkQueryType = 1000328000;
15980pub const VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT: VkQueryType = 1000396001;
15981pub const VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT: VkQueryType = 1000396000;
15982pub const VK_QUERY_TYPE_OCCLUSION: VkQueryType = 0;
15983pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL: VkQueryType = 1000210000;
15984pub const VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR: VkQueryType = 1000116000;
15985pub const VK_QUERY_TYPE_PIPELINE_STATISTICS: VkQueryType = 1;
15986pub const VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT: VkQueryType = 1000382000;
15987pub const VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR: VkQueryType = 1000023000;
15988pub const VK_QUERY_TYPE_TIMESTAMP: VkQueryType = 2;
15989pub const VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT: VkQueryType = 1000028004;
15990pub const VK_QUERY_TYPE_VIDEO_ENCODE_FEEDBACK_KHR: VkQueryType = 1000299000;
15991pub const VK_QUEUE_COMPUTE_BIT: VkQueueFlagBits = 1 << 1;
15992pub const VK_QUEUE_DATA_GRAPH_BIT_ARM: VkQueueFlagBits = 1 << 10;
15993pub const VK_QUEUE_FAMILY_EXTERNAL: u32 = !1;
15994pub const VK_QUEUE_FAMILY_EXTERNAL_KHR: u32 = VK_QUEUE_FAMILY_EXTERNAL;
15995pub const VK_QUEUE_FAMILY_FOREIGN_EXT: u32 = !2;
15996pub const VK_QUEUE_FAMILY_IGNORED: u32 = !0;
15997pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH: VkQueueGlobalPriority = 512;
15998pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
15999pub const VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_HIGH;
16000pub const VK_QUEUE_GLOBAL_PRIORITY_LOW: VkQueueGlobalPriority = 128;
16001pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
16002pub const VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_LOW;
16003pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM: VkQueueGlobalPriority = 256;
16004pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
16005pub const VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM;
16006pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME: VkQueueGlobalPriority = 1024;
16007pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;
16008pub const VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR: VkQueueGlobalPriority = VK_QUEUE_GLOBAL_PRIORITY_REALTIME;
16009pub const VK_QUEUE_GRAPHICS_BIT: VkQueueFlagBits = 1 << 0;
16010pub const VK_QUEUE_OPTICAL_FLOW_BIT_NV: VkQueueFlagBits = 1 << 8;
16011pub const VK_QUEUE_PROTECTED_BIT: VkQueueFlagBits = 1 << 4;
16012pub const VK_QUEUE_SPARSE_BINDING_BIT: VkQueueFlagBits = 1 << 3;
16013pub const VK_QUEUE_TRANSFER_BIT: VkQueueFlagBits = 1 << 2;
16014pub const VK_QUEUE_VIDEO_DECODE_BIT_KHR: VkQueueFlagBits = 1 << 5;
16015pub const VK_QUEUE_VIDEO_ENCODE_BIT_KHR: VkQueueFlagBits = 1 << 6;
16016pub const VK_RASTERIZATION_ORDER_RELAXED_AMD: VkRasterizationOrderAMD = 1;
16017pub const VK_RASTERIZATION_ORDER_STRICT_AMD: VkRasterizationOrderAMD = 0;
16018pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT: VkRayTracingInvocationReorderModeEXT = 0;
16019pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_EXT;
16020pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT: VkRayTracingInvocationReorderModeEXT = 1;
16021pub const VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV: VkRayTracingInvocationReorderModeEXT = VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_EXT;
16022pub const VK_RAY_TRACING_LSS_INDEXING_MODE_LIST_NV: VkRayTracingLssIndexingModeNV = 0;
16023pub const VK_RAY_TRACING_LSS_INDEXING_MODE_SUCCESSIVE_NV: VkRayTracingLssIndexingModeNV = 1;
16024pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_CHAINED_NV: VkRayTracingLssPrimitiveEndCapsModeNV = 1;
16025pub const VK_RAY_TRACING_LSS_PRIMITIVE_END_CAPS_MODE_NONE_NV: VkRayTracingLssPrimitiveEndCapsModeNV = 0;
16026pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR: VkRayTracingShaderGroupTypeKHR = 0;
16027pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR;
16028pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = 2;
16029pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR;
16030pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR: VkRayTracingShaderGroupTypeKHR = 1;
16031pub const VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV: VkRayTracingShaderGroupTypeKHR = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR;
16032pub const VK_REMAINING_3D_SLICES_EXT: u32 = !0;
16033pub const VK_REMAINING_ARRAY_LAYERS: u32 = !0;
16034pub const VK_REMAINING_MIP_LEVELS: u32 = !0;
16035pub const VK_RENDERING_ATTACHMENT_INPUT_ATTACHMENT_FEEDBACK_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 0;
16036pub const VK_RENDERING_ATTACHMENT_RESOLVE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 2;
16037pub const VK_RENDERING_ATTACHMENT_RESOLVE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkRenderingAttachmentFlagBitsKHR = 1 << 1;
16038pub const VK_RENDERING_CONTENTS_INLINE_BIT_EXT: VkRenderingFlagBits = VK_RENDERING_CONTENTS_INLINE_BIT_KHR;
16039pub const VK_RENDERING_CONTENTS_INLINE_BIT_KHR: VkRenderingFlagBits = 1 << 4;
16040pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT: VkRenderingFlagBits = 1 << 0;
16041pub const VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT;
16042pub const VK_RENDERING_CUSTOM_RESOLVE_BIT_EXT: VkRenderingFlagBits = 1 << 7;
16043pub const VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT: VkRenderingFlagBits = 1 << 3;
16044pub const VK_RENDERING_FRAGMENT_REGION_BIT_EXT: VkRenderingFlagBits = 1 << 6;
16045pub const VK_RENDERING_LOCAL_READ_CONCURRENT_ACCESS_CONTROL_BIT_KHR: VkRenderingFlagBits = 1 << 8;
16046pub const VK_RENDERING_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderingFlagBits = 1 << 5;
16047pub const VK_RENDERING_RESUMING_BIT: VkRenderingFlagBits = 1 << 2;
16048pub const VK_RENDERING_RESUMING_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_RESUMING_BIT;
16049pub const VK_RENDERING_SUSPENDING_BIT: VkRenderingFlagBits = 1 << 1;
16050pub const VK_RENDERING_SUSPENDING_BIT_KHR: VkRenderingFlagBits = VK_RENDERING_SUSPENDING_BIT;
16051pub const VK_RENDER_PASS_CREATE_PER_LAYER_FRAGMENT_DENSITY_BIT_VALVE: VkRenderPassCreateFlagBits = 1 << 2;
16052pub const VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM: VkRenderPassCreateFlagBits = 1 << 1;
16053pub const VK_RESOLVE_IMAGE_ENABLE_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagBitsKHR = 1 << 1;
16054pub const VK_RESOLVE_IMAGE_SKIP_TRANSFER_FUNCTION_BIT_KHR: VkResolveImageFlagBitsKHR = 1 << 0;
16055pub const VK_RESOLVE_MODE_AVERAGE_BIT: VkResolveModeFlagBits = 1 << 1;
16056pub const VK_RESOLVE_MODE_AVERAGE_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_AVERAGE_BIT;
16057pub const VK_RESOLVE_MODE_CUSTOM_BIT_EXT: VkResolveModeFlagBits = 1 << 5;
16058pub const VK_RESOLVE_MODE_MAX_BIT: VkResolveModeFlagBits = 1 << 3;
16059pub const VK_RESOLVE_MODE_MAX_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_MAX_BIT;
16060pub const VK_RESOLVE_MODE_MIN_BIT: VkResolveModeFlagBits = 1 << 2;
16061pub const VK_RESOLVE_MODE_MIN_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_MIN_BIT;
16062pub const VK_RESOLVE_MODE_NONE: VkResolveModeFlagBits = 0;
16063pub const VK_RESOLVE_MODE_NONE_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_NONE;
16064pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT: VkResolveModeFlagBits = 1 << 0;
16065pub const VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR: VkResolveModeFlagBits = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT;
16066pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER: VkSamplerAddressMode = 3;
16067pub const VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE: VkSamplerAddressMode = 2;
16068pub const VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT: VkSamplerAddressMode = 1;
16069pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE: VkSamplerAddressMode = 4;
16070pub const VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR: VkSamplerAddressMode = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE;
16071pub const VK_SAMPLER_ADDRESS_MODE_REPEAT: VkSamplerAddressMode = 0;
16072pub const VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT: VkSamplerCreateFlagBits = 1 << 3;
16073pub const VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM: VkSamplerCreateFlagBits = 1 << 4;
16074pub const VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT: VkSamplerCreateFlagBits = 1 << 2;
16075pub const VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT: VkSamplerCreateFlagBits = 1 << 0;
16076pub const VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT: VkSamplerCreateFlagBits = 1 << 1;
16077pub const VK_SAMPLER_MIPMAP_MODE_LINEAR: VkSamplerMipmapMode = 1;
16078pub const VK_SAMPLER_MIPMAP_MODE_NEAREST: VkSamplerMipmapMode = 0;
16079pub const VK_SAMPLER_REDUCTION_MODE_MAX: VkSamplerReductionMode = 2;
16080pub const VK_SAMPLER_REDUCTION_MODE_MAX_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MAX;
16081pub const VK_SAMPLER_REDUCTION_MODE_MIN: VkSamplerReductionMode = 1;
16082pub const VK_SAMPLER_REDUCTION_MODE_MIN_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_MIN;
16083pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE: VkSamplerReductionMode = 0;
16084pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT: VkSamplerReductionMode = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE;
16085pub const VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM: VkSamplerReductionMode = 1000521000;
16086pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: VkSamplerYcbcrModelConversion = 0;
16087pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY;
16088pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: VkSamplerYcbcrModelConversion = 4;
16089pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020;
16090pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: VkSamplerYcbcrModelConversion = 3;
16091pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601;
16092pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: VkSamplerYcbcrModelConversion = 2;
16093pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709;
16094pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: VkSamplerYcbcrModelConversion = 1;
16095pub const VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR: VkSamplerYcbcrModelConversion = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY;
16096pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL: VkSamplerYcbcrRange = 0;
16097pub const VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_FULL;
16098pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW: VkSamplerYcbcrRange = 1;
16099pub const VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR: VkSamplerYcbcrRange = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW;
16100pub const VK_SAMPLE_COUNT_16_BIT: VkSampleCountFlagBits = 1 << 4;
16101pub const VK_SAMPLE_COUNT_1_BIT: VkSampleCountFlagBits = 1 << 0;
16102pub const VK_SAMPLE_COUNT_2_BIT: VkSampleCountFlagBits = 1 << 1;
16103pub const VK_SAMPLE_COUNT_32_BIT: VkSampleCountFlagBits = 1 << 5;
16104pub const VK_SAMPLE_COUNT_4_BIT: VkSampleCountFlagBits = 1 << 2;
16105pub const VK_SAMPLE_COUNT_64_BIT: VkSampleCountFlagBits = 1 << 6;
16106pub const VK_SAMPLE_COUNT_8_BIT: VkSampleCountFlagBits = 1 << 3;
16107pub const VK_SCOPE_DEVICE_KHR: VkScopeKHR = 1;
16108pub const VK_SCOPE_DEVICE_NV: VkScopeKHR = VK_SCOPE_DEVICE_KHR;
16109pub const VK_SCOPE_QUEUE_FAMILY_KHR: VkScopeKHR = 5;
16110pub const VK_SCOPE_QUEUE_FAMILY_NV: VkScopeKHR = VK_SCOPE_QUEUE_FAMILY_KHR;
16111pub const VK_SCOPE_SUBGROUP_KHR: VkScopeKHR = 3;
16112pub const VK_SCOPE_SUBGROUP_NV: VkScopeKHR = VK_SCOPE_SUBGROUP_KHR;
16113pub const VK_SCOPE_WORKGROUP_KHR: VkScopeKHR = 2;
16114pub const VK_SCOPE_WORKGROUP_NV: VkScopeKHR = VK_SCOPE_WORKGROUP_KHR;
16115pub const VK_SEC_AMIGO_PROFILING_EXTENSION_NAME: &CStr = c"VK_SEC_amigo_profiling";
16116pub const VK_SEC_AMIGO_PROFILING_SPEC_VERSION: u32 = 1;
16117pub const VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_EXTENSION_NAME: &CStr = c"VK_SEC_pipeline_cache_incremental_mode";
16118pub const VK_SEC_PIPELINE_CACHE_INCREMENTAL_MODE_SPEC_VERSION: u32 = 1;
16119pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT: VkSemaphoreImportFlagBits = 1 << 0;
16120pub const VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR: VkSemaphoreImportFlagBits = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT;
16121pub const VK_SEMAPHORE_TYPE_BINARY: VkSemaphoreType = 0;
16122pub const VK_SEMAPHORE_TYPE_BINARY_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_BINARY;
16123pub const VK_SEMAPHORE_TYPE_TIMELINE: VkSemaphoreType = 1;
16124pub const VK_SEMAPHORE_TYPE_TIMELINE_KHR: VkSemaphoreType = VK_SEMAPHORE_TYPE_TIMELINE;
16125pub const VK_SEMAPHORE_WAIT_ANY_BIT: VkSemaphoreWaitFlagBits = 1 << 0;
16126pub const VK_SEMAPHORE_WAIT_ANY_BIT_KHR: VkSemaphoreWaitFlagBits = VK_SEMAPHORE_WAIT_ANY_BIT;
16127pub const VK_SHADER_CODE_TYPE_BINARY_EXT: VkShaderCodeTypeEXT = 0;
16128pub const VK_SHADER_CODE_TYPE_SPIRV_EXT: VkShaderCodeTypeEXT = 1;
16129pub const VK_SHADER_CREATE_64_BIT_INDEXING_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 15;
16130pub const VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 1;
16131pub const VK_SHADER_CREATE_DESCRIPTOR_HEAP_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 10;
16132pub const VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 4;
16133pub const VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 6;
16134pub const VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 5;
16135pub const VK_SHADER_CREATE_INDIRECT_BINDABLE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 7;
16136pub const VK_SHADER_CREATE_LINK_STAGE_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 0;
16137pub const VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 3;
16138pub const VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT: VkShaderCreateFlagBitsEXT = 1 << 2;
16139pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY: VkShaderFloatControlsIndependence = 0;
16140pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY;
16141pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL: VkShaderFloatControlsIndependence = 1;
16142pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL;
16143pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE: VkShaderFloatControlsIndependence = 2;
16144pub const VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR: VkShaderFloatControlsIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;
16145pub const VK_SHADER_GROUP_SHADER_ANY_HIT_KHR: VkShaderGroupShaderKHR = 2;
16146pub const VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR: VkShaderGroupShaderKHR = 1;
16147pub const VK_SHADER_GROUP_SHADER_GENERAL_KHR: VkShaderGroupShaderKHR = 0;
16148pub const VK_SHADER_GROUP_SHADER_INTERSECTION_KHR: VkShaderGroupShaderKHR = 3;
16149pub const VK_SHADER_INFO_TYPE_BINARY_AMD: VkShaderInfoTypeAMD = 1;
16150pub const VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD: VkShaderInfoTypeAMD = 2;
16151pub const VK_SHADER_INFO_TYPE_STATISTICS_AMD: VkShaderInfoTypeAMD = 0;
16152pub const VK_SHADER_STAGE_ALL: VkShaderStageFlagBits = 0x7FFFFFFF;
16153pub const VK_SHADER_STAGE_ALL_GRAPHICS: VkShaderStageFlagBits = 0x0000001F;
16154pub const VK_SHADER_STAGE_ANY_HIT_BIT_KHR: VkShaderStageFlagBits = 1 << 9;
16155pub const VK_SHADER_STAGE_ANY_HIT_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_ANY_HIT_BIT_KHR;
16156pub const VK_SHADER_STAGE_CALLABLE_BIT_KHR: VkShaderStageFlagBits = 1 << 13;
16157pub const VK_SHADER_STAGE_CALLABLE_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_CALLABLE_BIT_KHR;
16158pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR: VkShaderStageFlagBits = 1 << 10;
16159pub const VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR;
16160pub const VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI: VkShaderStageFlagBits = 1 << 19;
16161pub const VK_SHADER_STAGE_COMPUTE_BIT: VkShaderStageFlagBits = 1 << 5;
16162pub const VK_SHADER_STAGE_FRAGMENT_BIT: VkShaderStageFlagBits = 1 << 4;
16163pub const VK_SHADER_STAGE_GEOMETRY_BIT: VkShaderStageFlagBits = 1 << 3;
16164pub const VK_SHADER_STAGE_INTERSECTION_BIT_KHR: VkShaderStageFlagBits = 1 << 12;
16165pub const VK_SHADER_STAGE_INTERSECTION_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_INTERSECTION_BIT_KHR;
16166pub const VK_SHADER_STAGE_MESH_BIT_EXT: VkShaderStageFlagBits = 1 << 7;
16167pub const VK_SHADER_STAGE_MESH_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_MESH_BIT_EXT;
16168pub const VK_SHADER_STAGE_MISS_BIT_KHR: VkShaderStageFlagBits = 1 << 11;
16169pub const VK_SHADER_STAGE_MISS_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_MISS_BIT_KHR;
16170pub const VK_SHADER_STAGE_RAYGEN_BIT_KHR: VkShaderStageFlagBits = 1 << 8;
16171pub const VK_SHADER_STAGE_RAYGEN_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_RAYGEN_BIT_KHR;
16172pub const VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI: VkShaderStageFlagBits = 1 << 14;
16173pub const VK_SHADER_STAGE_TASK_BIT_EXT: VkShaderStageFlagBits = 1 << 6;
16174pub const VK_SHADER_STAGE_TASK_BIT_NV: VkShaderStageFlagBits = VK_SHADER_STAGE_TASK_BIT_EXT;
16175pub const VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT: VkShaderStageFlagBits = 1 << 1;
16176pub const VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT: VkShaderStageFlagBits = 1 << 2;
16177pub const VK_SHADER_STAGE_VERTEX_BIT: VkShaderStageFlagBits = 1 << 0;
16178pub const VK_SHADER_UNUSED_KHR: u32 = !0;
16179pub const VK_SHADER_UNUSED_NV: u32 = VK_SHADER_UNUSED_KHR;
16180pub const VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 1;
16181pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 7;
16182pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV: VkShadingRatePaletteEntryNV = 6;
16183pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 8;
16184pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV: VkShadingRatePaletteEntryNV = 10;
16185pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV: VkShadingRatePaletteEntryNV = 9;
16186pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV: VkShadingRatePaletteEntryNV = 11;
16187pub const VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 5;
16188pub const VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 4;
16189pub const VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 3;
16190pub const VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV: VkShadingRatePaletteEntryNV = 2;
16191pub const VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV: VkShadingRatePaletteEntryNV = 0;
16192pub const VK_SHARING_MODE_CONCURRENT: VkSharingMode = 1;
16193pub const VK_SHARING_MODE_EXCLUSIVE: VkSharingMode = 0;
16194pub const VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT: VkSparseImageFormatFlagBits = 1 << 1;
16195pub const VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT: VkSparseImageFormatFlagBits = 1 << 2;
16196pub const VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT: VkSparseImageFormatFlagBits = 1 << 0;
16197pub const VK_SPARSE_MEMORY_BIND_METADATA_BIT: VkSparseMemoryBindFlagBits = 1 << 0;
16198pub const VK_SPIRV_RESOURCE_TYPE_ACCELERATION_STRUCTURE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 8;
16199pub const VK_SPIRV_RESOURCE_TYPE_ALL_EXT: VkSpirvResourceTypeFlagBitsEXT = 0x7FFFFFFF;
16200pub const VK_SPIRV_RESOURCE_TYPE_COMBINED_SAMPLED_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 4;
16201pub const VK_SPIRV_RESOURCE_TYPE_READ_ONLY_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 2;
16202pub const VK_SPIRV_RESOURCE_TYPE_READ_ONLY_STORAGE_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 6;
16203pub const VK_SPIRV_RESOURCE_TYPE_READ_WRITE_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 3;
16204pub const VK_SPIRV_RESOURCE_TYPE_READ_WRITE_STORAGE_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 7;
16205pub const VK_SPIRV_RESOURCE_TYPE_SAMPLED_IMAGE_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 1;
16206pub const VK_SPIRV_RESOURCE_TYPE_SAMPLER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 0;
16207pub const VK_SPIRV_RESOURCE_TYPE_TENSOR_BIT_ARM: VkSpirvResourceTypeFlagBitsEXT = 1 << 9;
16208pub const VK_SPIRV_RESOURCE_TYPE_UNIFORM_BUFFER_BIT_EXT: VkSpirvResourceTypeFlagBitsEXT = 1 << 5;
16209pub const VK_STENCIL_FACE_BACK_BIT: VkStencilFaceFlagBits = 1 << 1;
16210pub const VK_STENCIL_FACE_FRONT_AND_BACK: VkStencilFaceFlagBits = 0x00000003;
16211pub const VK_STENCIL_FACE_FRONT_BIT: VkStencilFaceFlagBits = 1 << 0;
16212pub const VK_STENCIL_FRONT_AND_BACK: VkStencilFaceFlagBits = VK_STENCIL_FACE_FRONT_AND_BACK;
16213pub const VK_STENCIL_OP_DECREMENT_AND_CLAMP: VkStencilOp = 4;
16214pub const VK_STENCIL_OP_DECREMENT_AND_WRAP: VkStencilOp = 7;
16215pub const VK_STENCIL_OP_INCREMENT_AND_CLAMP: VkStencilOp = 3;
16216pub const VK_STENCIL_OP_INCREMENT_AND_WRAP: VkStencilOp = 6;
16217pub const VK_STENCIL_OP_INVERT: VkStencilOp = 5;
16218pub const VK_STENCIL_OP_KEEP: VkStencilOp = 0;
16219pub const VK_STENCIL_OP_REPLACE: VkStencilOp = 2;
16220pub const VK_STENCIL_OP_ZERO: VkStencilOp = 1;
16221pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: VkStructureType = 1000150000;
16222pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: VkStructureType = 1000150020;
16223pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316009;
16224pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: VkStructureType = 1000150017;
16225pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = 1000165001;
16226pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: VkStructureType = 1000150002;
16227pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: VkStructureType = 1000150003;
16228pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: VkStructureType = 1000150004;
16229pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: VkStructureType = 1000150006;
16230pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_LINEAR_SWEPT_SPHERES_DATA_NV: VkStructureType = 1000429009;
16231pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: VkStructureType = 1000327000;
16232pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_SPHERES_DATA_NV: VkStructureType = 1000429010;
16233pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: VkStructureType = 1000150005;
16234pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = 1000165012;
16235pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = 1000165008;
16236pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: VkStructureType = 1000327002;
16237pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT: VkStructureType = 1000396009;
16238pub const VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: VkStructureType = 1000150009;
16239pub const VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: VkStructureType = 1000060010;
16240pub const VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: VkStructureType = 1000116004;
16241pub const VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC: VkStructureType = 1000485001;
16242pub const VK_STRUCTURE_TYPE_ANTI_LAG_DATA_AMD: VkStructureType = 1000476001;
16243pub const VK_STRUCTURE_TYPE_ANTI_LAG_PRESENTATION_INFO_AMD: VkStructureType = 1000476002;
16244pub const VK_STRUCTURE_TYPE_APPLICATION_INFO: VkStructureType = 0;
16245pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: VkStructureType = 1000109000;
16246pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2;
16247pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: VkStructureType = 1000241002;
16248pub const VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT;
16249pub const VK_STRUCTURE_TYPE_ATTACHMENT_FEEDBACK_LOOP_INFO_EXT: VkStructureType = 1000527001;
16250pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: VkStructureType = 1000109001;
16251pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2;
16252pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: VkStructureType = 1000241001;
16253pub const VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT;
16254pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: VkStructureType = 1000044008;
16255pub const VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV: VkStructureType = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD;
16256pub const VK_STRUCTURE_TYPE_BEGIN_CUSTOM_RESOLVE_INFO_EXT: VkStructureType = 1000628001;
16257pub const VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: VkStructureType = 1000165006;
16258pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060013;
16259pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO;
16260pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: VkStructureType = 1000157000;
16261pub const VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO;
16262pub const VK_STRUCTURE_TYPE_BIND_DATA_GRAPH_PIPELINE_SESSION_MEMORY_INFO_ARM: VkStructureType = 1000507005;
16263pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_BUFFER_EMBEDDED_SAMPLERS_INFO_EXT: VkStructureType = 1000545008;
16264pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO: VkStructureType = 1000545003;
16265pub const VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_DESCRIPTOR_SETS_INFO;
16266pub const VK_STRUCTURE_TYPE_BIND_HEAP_INFO_EXT: VkStructureType = 1000135003;
16267pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: VkStructureType = 1000060014;
16268pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO;
16269pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: VkStructureType = 1000157001;
16270pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO;
16271pub const VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: VkStructureType = 1000060009;
16272pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: VkStructureType = 1000156002;
16273pub const VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO;
16274pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS: VkStructureType = 1000545002;
16275pub const VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS_KHR: VkStructureType = VK_STRUCTURE_TYPE_BIND_MEMORY_STATUS;
16276pub const VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: VkStructureType = 7;
16277pub const VK_STRUCTURE_TYPE_BIND_TENSOR_MEMORY_INFO_ARM: VkStructureType = 1000460002;
16278pub const VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: VkStructureType = 1000023004;
16279pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM: VkStructureType = 1000519002;
16280pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: VkStructureType = 1000337004;
16281pub const VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2;
16282pub const VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316005;
16283pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2: VkStructureType = 1000337006;
16284pub const VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_COPY_2;
16285pub const VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: VkStructureType = 12;
16286pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: VkStructureType = 1000244002;
16287pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: VkStructureType = 1000244001;
16288pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
16289pub const VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO;
16290pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: VkStructureType = 1000337009;
16291pub const VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2;
16292pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: VkStructureType = 44;
16293pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: VkStructureType = 1000314001;
16294pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2;
16295pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146000;
16296pub const VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2;
16297pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: VkStructureType = 1000257002;
16298pub const VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO;
16299pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO: VkStructureType = 1000470006;
16300pub const VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO;
16301pub const VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: VkStructureType = 13;
16302pub const VK_STRUCTURE_TYPE_BUILD_PARTITIONED_ACCELERATION_STRUCTURE_INFO_NV: VkStructureType = 1000570004;
16303pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR;
16304pub const VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_KHR: VkStructureType = 1000184000;
16305pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: VkStructureType = 1000314009;
16306pub const VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: VkStructureType = 1000206000;
16307pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_CLUSTERS_BOTTOM_LEVEL_INPUT_NV: VkStructureType = 1000569002;
16308pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_COMMANDS_INFO_NV: VkStructureType = 1000569006;
16309pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_INPUT_INFO_NV: VkStructureType = 1000569005;
16310pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_MOVE_OBJECTS_INPUT_NV: VkStructureType = 1000569004;
16311pub const VK_STRUCTURE_TYPE_CLUSTER_ACCELERATION_STRUCTURE_TRIANGLE_CLUSTER_INPUT_NV: VkStructureType = 1000569003;
16312pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: VkStructureType = 40;
16313pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 42;
16314pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: VkStructureType = 1000081000;
16315pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_DESCRIPTOR_HEAP_INFO_EXT: VkStructureType = 1000135010;
16316pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: VkStructureType = 41;
16317pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: VkStructureType = 1000044004;
16318pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO;
16319pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: VkStructureType = 1000282000;
16320pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: VkStructureType = 1000278001;
16321pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: VkStructureType = 1000314006;
16322pub const VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO;
16323pub const VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: VkStructureType = 39;
16324pub const VK_STRUCTURE_TYPE_COMPUTE_OCCUPANCY_PRIORITY_PARAMETERS_NV: VkStructureType = 1000645000;
16325pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: VkStructureType = 29;
16326pub const VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV: VkStructureType = 1000428001;
16327pub const VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: VkStructureType = 1000081002;
16328pub const VK_STRUCTURE_TYPE_CONVERT_COOPERATIVE_VECTOR_MATRIX_INFO_NV: VkStructureType = 1000491004;
16329pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_FLEXIBLE_DIMENSIONS_PROPERTIES_NV: VkStructureType = 1000593001;
16330pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = 1000506001;
16331pub const VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = 1000249001;
16332pub const VK_STRUCTURE_TYPE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = 1000491002;
16333pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = 1000150010;
16334pub const VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: VkStructureType = 1000150011;
16335pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: VkStructureType = 1000337000;
16336pub const VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2;
16337pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: VkStructureType = 1000337002;
16338pub const VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2;
16339pub const VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: VkStructureType = 1000333000;
16340pub const VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: VkStructureType = 36;
16341pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: VkStructureType = 1000337001;
16342pub const VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2;
16343pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: VkStructureType = 1000337003;
16344pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2;
16345pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO: VkStructureType = 1000270007;
16346pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO;
16347pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO: VkStructureType = 1000270004;
16348pub const VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO;
16349pub const VK_STRUCTURE_TYPE_COPY_MEMORY_INDIRECT_INFO_KHR: VkStructureType = 1000549002;
16350pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: VkStructureType = 1000150012;
16351pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INDIRECT_INFO_KHR: VkStructureType = 1000549003;
16352pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO: VkStructureType = 1000270005;
16353pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO;
16354pub const VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT: VkStructureType = 1000396004;
16355pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT: VkStructureType = 1000396002;
16356pub const VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT: VkStructureType = 1000396003;
16357pub const VK_STRUCTURE_TYPE_COPY_TENSOR_INFO_ARM: VkStructureType = 1000460011;
16358pub const VK_STRUCTURE_TYPE_CUSTOM_RESOLVE_CREATE_INFO_EXT: VkStructureType = 1000628002;
16359pub const VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: VkStructureType = 1000029001;
16360pub const VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: VkStructureType = 1000029002;
16361pub const VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: VkStructureType = 1000029000;
16362pub const VK_STRUCTURE_TYPE_CU_MODULE_TEXTURING_MODE_CREATE_INFO_NVX: VkStructureType = 1000029004;
16363pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_BUILTIN_MODEL_CREATE_INFO_QCOM: VkStructureType = 1000629001;
16364pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_COMPILER_CONTROL_CREATE_INFO_ARM: VkStructureType = 1000507010;
16365pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_ARM: VkStructureType = 1000507003;
16366pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CONSTANT_TENSOR_SEMI_STRUCTURED_SPARSITY_INFO_ARM: VkStructureType = 1000507015;
16367pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_CREATE_INFO_ARM: VkStructureType = 1000507000;
16368pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_DISPATCH_INFO_ARM: VkStructureType = 1000507014;
16369pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_IDENTIFIER_CREATE_INFO_ARM: VkStructureType = 1000507013;
16370pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_INFO_ARM: VkStructureType = 1000507009;
16371pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_PROPERTY_QUERY_RESULT_ARM: VkStructureType = 1000507008;
16372pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_RESOURCE_INFO_ARM: VkStructureType = 1000507002;
16373pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENTS_INFO_ARM: VkStructureType = 1000507011;
16374pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_BIND_POINT_REQUIREMENT_ARM: VkStructureType = 1000507012;
16375pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_CREATE_INFO_ARM: VkStructureType = 1000507001;
16376pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SESSION_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = 1000507004;
16377pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PIPELINE_SHADER_MODULE_CREATE_INFO_ARM: VkStructureType = 1000507007;
16378pub const VK_STRUCTURE_TYPE_DATA_GRAPH_PROCESSING_ENGINE_CREATE_INFO_ARM: VkStructureType = 1000507016;
16379pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: VkStructureType = 1000022002;
16380pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: VkStructureType = 1000022000;
16381pub const VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: VkStructureType = 1000022001;
16382pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: VkStructureType = 1000011000;
16383pub const VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT;
16384pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: VkStructureType = 1000128002;
16385pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: VkStructureType = 1000128003;
16386pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: VkStructureType = 1000128004;
16387pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: VkStructureType = 1000128000;
16388pub const VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: VkStructureType = 1000128001;
16389pub const VK_STRUCTURE_TYPE_DECOMPRESS_MEMORY_INFO_EXT: VkStructureType = 1000550002;
16390pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: VkStructureType = 1000026001;
16391pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: VkStructureType = 1000026000;
16392pub const VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000026002;
16393pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO: VkStructureType = 1000314003;
16394pub const VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEPENDENCY_INFO;
16395pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT: VkStructureType = 1000283001;
16396pub const VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT: VkStructureType = 1000283002;
16397pub const VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT: VkStructureType = 1000316003;
16398pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT: VkStructureType = 1000316011;
16399pub const VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT: VkStructureType = 1000316012;
16400pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT: VkStructureType = 1000316004;
16401pub const VK_STRUCTURE_TYPE_DESCRIPTOR_GET_TENSOR_INFO_ARM: VkStructureType = 1000460020;
16402pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: VkStructureType = 33;
16403pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: VkStructureType = 1000138003;
16404pub const VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO;
16405pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: VkStructureType = 34;
16406pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_AND_BINDING_MAPPING_EXT: VkStructureType = 1000135005;
16407pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: VkStructureType = 1000420001;
16408pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: VkStructureType = 1000161000;
16409pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO;
16410pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: VkStructureType = 32;
16411pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: VkStructureType = 1000420002;
16412pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: VkStructureType = 1000168001;
16413pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT;
16414pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: VkStructureType = 1000161003;
16415pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO;
16416pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: VkStructureType = 1000161004;
16417pub const VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT;
16418pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: VkStructureType = 1000085000;
16419pub const VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO;
16420pub const VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT: VkStructureType = 1000354001;
16421pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: VkStructureType = 1000413002;
16422pub const VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS;
16423pub const VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: VkStructureType = 3;
16424pub const VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: VkStructureType = 1000284001;
16425pub const VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: VkStructureType = 1000300001;
16426pub const VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: VkStructureType = 1000091001;
16427pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT: VkStructureType = 1000341001;
16428pub const VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT: VkStructureType = 1000341002;
16429pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: VkStructureType = 1000060006;
16430pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO;
16431pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: VkStructureType = 1000060004;
16432pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO;
16433pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: VkStructureType = 1000070001;
16434pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO;
16435pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: VkStructureType = 1000060007;
16436pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: VkStructureType = 1000060011;
16437pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: VkStructureType = 1000060003;
16438pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO;
16439pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: VkStructureType = 1000060005;
16440pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO;
16441pub const VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060012;
16442pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: VkStructureType = 1000413003;
16443pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS;
16444pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO: VkStructureType = 1000470004;
16445pub const VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO;
16446pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: VkStructureType = 1000257004;
16447pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO;
16448pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: VkStructureType = 1000189000;
16449pub const VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: VkStructureType = 1000284002;
16450pub const VK_STRUCTURE_TYPE_DEVICE_PIPELINE_BINARY_INTERNAL_CACHE_CONTROL_KHR: VkStructureType = 1000483008;
16451pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: VkStructureType = 1000295001;
16452pub const VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO;
16453pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: VkStructureType = 2;
16454pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO: VkStructureType = 1000174000;
16455pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
16456pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO;
16457pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: VkStructureType = 1000145003;
16458pub const VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM: VkStructureType = 1000417000;
16459pub const VK_STRUCTURE_TYPE_DEVICE_TENSOR_MEMORY_REQUIREMENTS_ARM: VkStructureType = 1000460010;
16460pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG: VkStructureType = 1000459000;
16461pub const VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG: VkStructureType = 1000459001;
16462pub const VK_STRUCTURE_TYPE_DISPATCH_TILE_INFO_QCOM: VkStructureType = 1000309005;
16463pub const VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: VkStructureType = 1000091002;
16464pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: VkStructureType = 1000002000;
16465pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: VkStructureType = 1000121002;
16466pub const VK_STRUCTURE_TYPE_DISPLAY_MODE_STEREO_PROPERTIES_NV: VkStructureType = 1000551001;
16467pub const VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: VkStructureType = 1000213000;
16468pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: VkStructureType = 1000121004;
16469pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: VkStructureType = 1000121003;
16470pub const VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: VkStructureType = 1000121001;
16471pub const VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: VkStructureType = 1000091000;
16472pub const VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: VkStructureType = 1000003000;
16473pub const VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: VkStructureType = 1000121000;
16474pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: VkStructureType = 1000002001;
16475pub const VK_STRUCTURE_TYPE_DISPLAY_SURFACE_STEREO_CREATE_INFO_NV: VkStructureType = 1000551000;
16476pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: VkStructureType = 1000158006;
16477pub const VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: VkStructureType = 1000158000;
16478pub const VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: VkStructureType = 10;
16479pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: VkStructureType = 1000113000;
16480pub const VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO;
16481pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: VkStructureType = 1000072002;
16482pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO;
16483pub const VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: VkStructureType = 1000056001;
16484pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: VkStructureType = 1000077000;
16485pub const VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO;
16486pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: VkStructureType = 1000071003;
16487pub const VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES;
16488pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_CREATE_INFO_NV: VkStructureType = 1000556001;
16489pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DATA_PARAMS_NV: VkStructureType = 1000556002;
16490pub const VK_STRUCTURE_TYPE_EXTERNAL_COMPUTE_QUEUE_DEVICE_CREATE_INFO_NV: VkStructureType = 1000556000;
16491pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: VkStructureType = 1000112001;
16492pub const VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES;
16493pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000071001;
16494pub const VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES;
16495pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT: VkStructureType = 1000453000;
16496pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: VkStructureType = 1000072000;
16497pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO;
16498pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: VkStructureType = 1000072001;
16499pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO;
16500pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: VkStructureType = 1000056000;
16501pub const VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_TENSOR_CREATE_INFO_ARM: VkStructureType = 1000460017;
16502pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: VkStructureType = 1000076001;
16503pub const VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES;
16504pub const VK_STRUCTURE_TYPE_EXTERNAL_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460016;
16505pub const VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: VkStructureType = 8;
16506pub const VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: VkStructureType = 1000115001;
16507pub const VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: VkStructureType = 1000170001;
16508pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: VkStructureType = 1000059002;
16509pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
16510pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: VkStructureType = 1000360000;
16511pub const VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR: VkStructureType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3;
16512pub const VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = 1000226000;
16513pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: VkStructureType = 1000108001;
16514pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO;
16515pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: VkStructureType = 1000108002;
16516pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO;
16517pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: VkStructureType = 37;
16518pub const VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: VkStructureType = 1000250002;
16519pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT: VkStructureType = 1000375001;
16520pub const VK_STRUCTURE_TYPE_FRAME_BOUNDARY_TENSORS_ARM: VkStructureType = 1000460023;
16521pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_EXT: VkStructureType = 1000572004;
16522pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: VkStructureType = 1000277005;
16523pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_EXT: VkStructureType = 1000572002;
16524pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: VkStructureType = 1000277006;
16525pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_PIPELINE_INFO_EXT: VkStructureType = 1000572013;
16526pub const VK_STRUCTURE_TYPE_GENERATED_COMMANDS_SHADER_INFO_EXT: VkStructureType = 1000572014;
16527pub const VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: VkStructureType = 1000165005;
16528pub const VK_STRUCTURE_TYPE_GEOMETRY_NV: VkStructureType = 1000165003;
16529pub const VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: VkStructureType = 1000165004;
16530pub const VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV: VkStructureType = 1000505003;
16531pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: VkStructureType = 28;
16532pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: VkStructureType = 1000320002;
16533pub const VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: VkStructureType = 1000277002;
16534pub const VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = 1000277001;
16535pub const VK_STRUCTURE_TYPE_HDR_METADATA_EXT: VkStructureType = 1000105000;
16536pub const VK_STRUCTURE_TYPE_HDR_VIVID_DYNAMIC_METADATA_HUAWEI: VkStructureType = 1000590001;
16537pub const VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: VkStructureType = 1000256000;
16538pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY: VkStructureType = 1000270009;
16539pub const VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY;
16540pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO: VkStructureType = 1000270006;
16541pub const VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO;
16542pub const VK_STRUCTURE_TYPE_IMAGE_ALIGNMENT_CONTROL_CREATE_INFO_MESA: VkStructureType = 1000575002;
16543pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2: VkStructureType = 1000337008;
16544pub const VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_BLIT_2;
16545pub const VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316006;
16546pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: VkStructureType = 1000338001;
16547pub const VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: VkStructureType = 1000338004;
16548pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2: VkStructureType = 1000337007;
16549pub const VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_COPY_2;
16550pub const VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: VkStructureType = 14;
16551pub const VK_STRUCTURE_TYPE_IMAGE_DESCRIPTOR_INFO_EXT: VkStructureType = 1000135001;
16552pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: VkStructureType = 1000158004;
16553pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: VkStructureType = 1000158003;
16554pub const VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: VkStructureType = 1000158005;
16555pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: VkStructureType = 1000147000;
16556pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO;
16557pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059003;
16558pub const VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
16559pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: VkStructureType = 45;
16560pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: VkStructureType = 1000314002;
16561pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2;
16562pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146001;
16563pub const VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2;
16564pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: VkStructureType = 1000156003;
16565pub const VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO;
16566pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: VkStructureType = 1000337010;
16567pub const VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2;
16568pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: VkStructureType = 1000146002;
16569pub const VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2;
16570pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: VkStructureType = 1000246000;
16571pub const VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO;
16572pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2: VkStructureType = 1000338003;
16573pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
16574pub const VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2;
16575pub const VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000060008;
16576pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY: VkStructureType = 1000270003;
16577pub const VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY;
16578pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: VkStructureType = 1000030001;
16579pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: VkStructureType = 1000067000;
16580pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316007;
16581pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: VkStructureType = 15;
16582pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: VkStructureType = 1000030000;
16583pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: VkStructureType = 1000391001;
16584pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM: VkStructureType = 1000440002;
16585pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT: VkStructureType = 1000418001;
16586pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: VkStructureType = 1000117002;
16587pub const VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO;
16588pub const VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: VkStructureType = 1000115000;
16589pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: VkStructureType = 1000074000;
16590pub const VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: VkStructureType = 1000178000;
16591pub const VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: VkStructureType = 1000079000;
16592pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_EXT: VkStructureType = 1000572006;
16593pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: VkStructureType = 1000277004;
16594pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_PUSH_DATA_TOKEN_NV: VkStructureType = 1000135012;
16595pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_EXT: VkStructureType = 1000572007;
16596pub const VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: VkStructureType = 1000277003;
16597pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_CREATE_INFO_EXT: VkStructureType = 1000572003;
16598pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_PIPELINE_INFO_EXT: VkStructureType = 1000572010;
16599pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_INFO_EXT: VkStructureType = 1000572011;
16600pub const VK_STRUCTURE_TYPE_INDIRECT_EXECUTION_SET_SHADER_LAYOUT_INFO_EXT: VkStructureType = 1000572012;
16601pub const VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: VkStructureType = 1000210001;
16602pub const VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: VkStructureType = 1;
16603pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV: VkStructureType = 1000505001;
16604pub const VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV: VkStructureType = 1000505000;
16605pub const VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV: VkStructureType = 1000505005;
16606pub const VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV: VkStructureType = 1000505008;
16607pub const VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV: VkStructureType = 1000505004;
16608pub const VK_STRUCTURE_TYPE_LAYER_SETTINGS_CREATE_INFO_EXT: VkStructureType = 1000496000;
16609pub const VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO: VkStructureType = 48;
16610pub const VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO: VkStructureType = 47;
16611pub const VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: VkStructureType = 6;
16612pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: VkStructureType = 1000060000;
16613pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO;
16614pub const VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: VkStructureType = 5;
16615pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER: VkStructureType = 46;
16616pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: VkStructureType = 1000314000;
16617pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2;
16618pub const VK_STRUCTURE_TYPE_MEMORY_BARRIER_ACCESS_FLAGS_3_KHR: VkStructureType = 1000574002;
16619pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: VkStructureType = 1000127001;
16620pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO;
16621pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_TENSOR_ARM: VkStructureType = 1000460014;
16622pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: VkStructureType = 1000127000;
16623pub const VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS;
16624pub const VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: VkStructureType = 1000074001;
16625pub const VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: VkStructureType = 1000074002;
16626pub const VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: VkStructureType = 1000371000;
16627pub const VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: VkStructureType = 1000178001;
16628pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO: VkStructureType = 1000271000;
16629pub const VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_MAP_INFO;
16630pub const VK_STRUCTURE_TYPE_MEMORY_MAP_PLACED_INFO_EXT: VkStructureType = 1000272002;
16631pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: VkStructureType = 1000257003;
16632pub const VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO;
16633pub const VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: VkStructureType = 1000238001;
16634pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146003;
16635pub const VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2;
16636pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY: VkStructureType = 1000270002;
16637pub const VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY;
16638pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO: VkStructureType = 1000271001;
16639pub const VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO;
16640pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT: VkStructureType = 1000396000;
16641pub const VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT: VkStructureType = 1000396008;
16642pub const VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT: VkStructureType = 1000396007;
16643pub const VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT: VkStructureType = 1000396001;
16644pub const VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: VkStructureType = 1000376002;
16645pub const VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: VkStructureType = 1000143004;
16646pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: VkStructureType = 1000044009;
16647pub const VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM: VkStructureType = 1000510001;
16648pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT: VkStructureType = 1000351002;
16649pub const VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: VkStructureType = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT;
16650pub const VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DATA_CREATE_INFO_EXT: VkStructureType = 1000135007;
16651pub const VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT: VkStructureType = 1000316010;
16652pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV: VkStructureType = 1000464005;
16653pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV: VkStructureType = 1000464002;
16654pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV: VkStructureType = 1000464003;
16655pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV: VkStructureType = 1000464004;
16656pub const VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV: VkStructureType = 1000464010;
16657pub const VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV: VkStructureType = 1000505006;
16658pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_FLAGS_NV: VkStructureType = 1000570005;
16659pub const VK_STRUCTURE_TYPE_PARTITIONED_ACCELERATION_STRUCTURE_INSTANCES_INPUT_NV: VkStructureType = 1000570003;
16660pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_EXT: VkStructureType = 1000208007;
16661pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_INFO_EXT: VkStructureType = 1000208005;
16662pub const VK_STRUCTURE_TYPE_PAST_PRESENTATION_TIMING_PROPERTIES_EXT: VkStructureType = 1000208006;
16663pub const VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: VkStructureType = 1000210005;
16664pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_ARM: VkStructureType = 1000605002;
16665pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_ARM: VkStructureType = 1000605003;
16666pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: VkStructureType = 1000116006;
16667pub const VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: VkStructureType = 1000116005;
16668pub const VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: VkStructureType = 1000210002;
16669pub const VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: VkStructureType = 1000210004;
16670pub const VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: VkStructureType = 1000116003;
16671pub const VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: VkStructureType = 1000210003;
16672pub const VK_STRUCTURE_TYPE_PER_TILE_BEGIN_INFO_QCOM: VkStructureType = 1000309003;
16673pub const VK_STRUCTURE_TYPE_PER_TILE_END_INFO_QCOM: VkStructureType = 1000309004;
16674pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: VkStructureType = 1000083000;
16675pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES;
16676pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: VkStructureType = 1000340000;
16677pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: VkStructureType = 1000177000;
16678pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES;
16679pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: VkStructureType = 1000150013;
16680pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: VkStructureType = 1000150014;
16681pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT: VkStructureType = 1000354000;
16682pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC: VkStructureType = 1000485000;
16683pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ANTI_LAG_FEATURES_AMD: VkStructureType = 1000476000;
16684pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: VkStructureType = 1000067001;
16685pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000524000;
16686pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT: VkStructureType = 1000339000;
16687pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: VkStructureType = 1000148000;
16688pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: VkStructureType = 1000148001;
16689pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: VkStructureType = 1000411000;
16690pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT;
16691pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: VkStructureType = 1000257000;
16692pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: VkStructureType = 1000244000;
16693pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES;
16694pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = 1000569000;
16695pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = 1000569001;
16696pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI: VkStructureType = 1000404000;
16697pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI: VkStructureType = 1000404001;
16698pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_VRS_FEATURES_HUAWEI: VkStructureType = 1000404002;
16699pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: VkStructureType = 1000229000;
16700pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: VkStructureType = 1000381000;
16701pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMMAND_BUFFER_INHERITANCE_FEATURES_NV: VkStructureType = 1000559000;
16702pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_OCCUPANCY_PRIORITY_FEATURES_NV: VkStructureType = 1000645001;
16703pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR: VkStructureType = 1000201000;
16704pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_KHR;
16705pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_PROPERTIES_KHR: VkStructureType = 1000511000;
16706pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: VkStructureType = 1000081001;
16707pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = 1000101000;
16708pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_FEATURES_NV: VkStructureType = 1000593000;
16709pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_2_PROPERTIES_NV: VkStructureType = 1000593002;
16710pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_CONVERSION_FEATURES_QCOM: VkStructureType = 1000172000;
16711pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR: VkStructureType = 1000506000;
16712pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: VkStructureType = 1000249000;
16713pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR: VkStructureType = 1000506002;
16714pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: VkStructureType = 1000249002;
16715pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_FEATURES_NV: VkStructureType = 1000491000;
16716pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_VECTOR_PROPERTIES_NV: VkStructureType = 1000491001;
16717pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_KHR: VkStructureType = 1000549000;
16718pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV: VkStructureType = 1000426000;
16719pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR: VkStructureType = 1000426001;
16720pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_KHR;
16721pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: VkStructureType = 1000050000;
16722pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: VkStructureType = 1000250000;
16723pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM: VkStructureType = 1000521000;
16724pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM: VkStructureType = 1000519001;
16725pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: VkStructureType = 1000287002;
16726pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: VkStructureType = 1000287001;
16727pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_RESOLVE_FEATURES_EXT: VkStructureType = 1000628000;
16728pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_FEATURES_ARM: VkStructureType = 1000507006;
16729pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DATA_GRAPH_MODEL_FEATURES_QCOM: VkStructureType = 1000629000;
16730pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: VkStructureType = 1000240000;
16731pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT: VkStructureType = 1000283000;
16732pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_CONTROL_FEATURES_EXT: VkStructureType = 1000582000;
16733pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR;
16734pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_KHR: VkStructureType = 1000421000;
16735pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: VkStructureType = 1000355000;
16736pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: VkStructureType = 1000102000;
16737pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: VkStructureType = 1000199000;
16738pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES;
16739pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = 1000316001;
16740pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT: VkStructureType = 1000316002;
16741pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT: VkStructureType = 1000316000;
16742pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_FEATURES_ARM: VkStructureType = 1000460018;
16743pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460019;
16744pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_FEATURES_EXT: VkStructureType = 1000135009;
16745pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_PROPERTIES_EXT: VkStructureType = 1000135008;
16746pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_HEAP_TENSOR_PROPERTIES_ARM: VkStructureType = 1000135014;
16747pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: VkStructureType = 1000161001;
16748pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
16749pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: VkStructureType = 1000161002;
16750pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES;
16751pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV: VkStructureType = 1000546000;
16752pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: VkStructureType = 1000420000;
16753pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV: VkStructureType = 1000428000;
16754pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_EXT: VkStructureType = 1000572000;
16755pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: VkStructureType = 1000277007;
16756pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_EXT: VkStructureType = 1000572001;
16757pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: VkStructureType = 1000277000;
16758pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: VkStructureType = 1000284000;
16759pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: VkStructureType = 1000300000;
16760pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: VkStructureType = 1000099000;
16761pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: VkStructureType = 1000196000;
16762pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES;
16763pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: VkStructureType = 1000353000;
16764pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: VkStructureType = 1000044003;
16765pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES;
16766pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES: VkStructureType = 1000232000;
16767pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_LOCAL_READ_FEATURES;
16768pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT: VkStructureType = 1000499000;
16769pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: VkStructureType = 1000205002;
16770pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: VkStructureType = 1000377000;
16771pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT: VkStructureType = 1000455000;
16772pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT: VkStructureType = 1000455001;
16773pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000267000;
16774pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV: VkStructureType = 1000492000;
16775pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV: VkStructureType = 1000492001;
16776pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: VkStructureType = 1000071002;
16777pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO;
16778pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_COMPUTE_QUEUE_PROPERTIES_NV: VkStructureType = 1000556003;
16779pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: VkStructureType = 1000112000;
16780pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO;
16781pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: VkStructureType = 1000071000;
16782pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO;
16783pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: VkStructureType = 1000178002;
16784pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: VkStructureType = 1000371001;
16785pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: VkStructureType = 1000076000;
16786pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO;
16787pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_TENSOR_INFO_ARM: VkStructureType = 1000460015;
16788pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT: VkStructureType = 1000341000;
16789pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: VkStructureType = 1000059000;
16790pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
16791pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
16792pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: VkStructureType = 1000197000;
16793pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES;
16794pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FORMAT_PACK_FEATURES_ARM: VkStructureType = 1000609000;
16795pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: VkStructureType = 1000332000;
16796pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: VkStructureType = 1000332001;
16797pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: VkStructureType = 1000218000;
16798pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_FEATURES_VALVE: VkStructureType = 1000611000;
16799pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_LAYERED_PROPERTIES_VALVE: VkStructureType = 1000611001;
16800pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT: VkStructureType = 1000425000;
16801pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_EXT;
16802pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT: VkStructureType = 1000425001;
16803pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_EXT;
16804pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: VkStructureType = 1000218001;
16805pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: VkStructureType = 1000203000;
16806pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR;
16807pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: VkStructureType = 1000322000;
16808pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: VkStructureType = 1000251000;
16809pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: VkStructureType = 1000326001;
16810pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: VkStructureType = 1000326000;
16811pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: VkStructureType = 1000226003;
16812pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: VkStructureType = 1000226004;
16813pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: VkStructureType = 1000226002;
16814pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT: VkStructureType = 1000375000;
16815pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES: VkStructureType = 1000388000;
16816pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
16817pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES;
16818pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: VkStructureType = 1000320000;
16819pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: VkStructureType = 1000320001;
16820pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: VkStructureType = 1000070000;
16821pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES;
16822pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HDR_VIVID_FEATURES_HUAWEI: VkStructureType = 1000590000;
16823pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES: VkStructureType = 1000270000;
16824pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES;
16825pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES: VkStructureType = 1000270001;
16826pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES;
16827pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: VkStructureType = 1000261000;
16828pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES;
16829pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: VkStructureType = 1000071004;
16830pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
16831pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: VkStructureType = 1000108000;
16832pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES;
16833pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: VkStructureType = 1000393000;
16834pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_FEATURES_MESA: VkStructureType = 1000575000;
16835pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ALIGNMENT_CONTROL_PROPERTIES_MESA: VkStructureType = 1000575001;
16836pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: VkStructureType = 1000338000;
16837pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: VkStructureType = 1000437000;
16838pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: VkStructureType = 1000158002;
16839pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059004;
16840pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2;
16841pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM: VkStructureType = 1000518000;
16842pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM: VkStructureType = 1000518001;
16843pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM: VkStructureType = 1000440000;
16844pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM: VkStructureType = 1000440001;
16845pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: VkStructureType = 1000335000;
16846pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES;
16847pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT: VkStructureType = 1000418000;
16848pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: VkStructureType = 1000170000;
16849pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: VkStructureType = 1000391000;
16850pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES: VkStructureType = 1000265000;
16851pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
16852pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES;
16853pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: VkStructureType = 1000278000;
16854pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: VkStructureType = 1000138000;
16855pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES;
16856pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: VkStructureType = 1000138001;
16857pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES;
16858pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INTERNALLY_SYNCHRONIZED_QUEUES_FEATURES_KHR: VkStructureType = 1000504000;
16859pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: VkStructureType = 1000370000;
16860pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_KHR: VkStructureType = 1000562003;
16861pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_PROPERTIES_LIST_KHR: VkStructureType = 1000562002;
16862pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_API_VULKAN_PROPERTIES_KHR: VkStructureType = 1000562004;
16863pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT: VkStructureType = 1000530000;
16864pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT: VkStructureType = 1000465000;
16865pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_FEATURES_EXT: VkStructureType = 1000495000;
16866pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_VERTEX_ATTRIBUTES_PROPERTIES_EXT: VkStructureType = 1000495001;
16867pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: VkStructureType = 1000430000;
16868pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES: VkStructureType = 1000259000;
16869pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
16870pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES;
16871pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES: VkStructureType = 1000259002;
16872pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
16873pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES;
16874pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_FEATURES_KHR: VkStructureType = 1000630000;
16875pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_10_PROPERTIES_KHR: VkStructureType = 1000630001;
16876pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: VkStructureType = 1000168000;
16877pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES;
16878pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: VkStructureType = 1000413000;
16879pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES;
16880pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: VkStructureType = 1000413001;
16881pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES;
16882pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES: VkStructureType = 1000470000;
16883pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES;
16884pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES: VkStructureType = 1000470001;
16885pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES;
16886pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES: VkStructureType = 1000545000;
16887pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_FEATURES;
16888pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES: VkStructureType = 1000545001;
16889pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_6_PROPERTIES;
16890pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_FEATURES_KHR: VkStructureType = 1000562000;
16891pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_7_PROPERTIES_KHR: VkStructureType = 1000562001;
16892pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_8_FEATURES_KHR: VkStructureType = 1000574000;
16893pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_FEATURES_KHR: VkStructureType = 1000584000;
16894pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_9_PROPERTIES_KHR: VkStructureType = 1000584001;
16895pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_FEATURES_EXT: VkStructureType = 1000272000;
16896pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAP_MEMORY_PLACED_PROPERTIES_EXT: VkStructureType = 1000272001;
16897pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: VkStructureType = 1000237000;
16898pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT: VkStructureType = 1000427000;
16899pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_EXT;
16900pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT: VkStructureType = 1000427001;
16901pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_EXT;
16902pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: VkStructureType = 1000238000;
16903pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: VkStructureType = 1000059006;
16904pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
16905pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT: VkStructureType = 1000328000;
16906pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: VkStructureType = 1000202000;
16907pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT: VkStructureType = 1000328001;
16908pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: VkStructureType = 1000202001;
16909pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: VkStructureType = 1000376000;
16910pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: VkStructureType = 1000053001;
16911pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES;
16912pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: VkStructureType = 1000097000;
16913pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM: VkStructureType = 1000510000;
16914pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM: VkStructureType = 1000488000;
16915pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: VkStructureType = 1000053002;
16916pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES;
16917pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: VkStructureType = 1000392000;
16918pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: VkStructureType = 1000392001;
16919pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT: VkStructureType = 1000351000;
16920pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT;
16921pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT: VkStructureType = 1000451000;
16922pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT: VkStructureType = 1000451001;
16923pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: VkStructureType = 1000422000;
16924pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT: VkStructureType = 1000396005;
16925pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT: VkStructureType = 1000396006;
16926pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV: VkStructureType = 1000464000;
16927pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV: VkStructureType = 1000464001;
16928pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: VkStructureType = 1000412000;
16929pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_FEATURES_NV: VkStructureType = 1000570000;
16930pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PARTITIONED_ACCELERATION_STRUCTURE_PROPERTIES_NV: VkStructureType = 1000570001;
16931pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: VkStructureType = 1000212000;
16932pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_FEATURES_ARM: VkStructureType = 1000605000;
16933pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_COUNTERS_BY_REGION_PROPERTIES_ARM: VkStructureType = 1000605001;
16934pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: VkStructureType = 1000116000;
16935pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: VkStructureType = 1000116001;
16936pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PER_STAGE_DESCRIPTOR_SET_FEATURES_NV: VkStructureType = 1000516000;
16937pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_FEATURES_KHR: VkStructureType = 1000483000;
16938pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_BINARY_PROPERTIES_KHR: VkStructureType = 1000483004;
16939pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CACHE_INCREMENTAL_MODE_FEATURES_SEC: VkStructureType = 1000637000;
16940pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: VkStructureType = 1000297000;
16941pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES;
16942pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: VkStructureType = 1000269000;
16943pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT: VkStructureType = 1000498000;
16944pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_OPACITY_MICROMAP_FEATURES_ARM: VkStructureType = 1000596000;
16945pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: VkStructureType = 1000372001;
16946pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES: VkStructureType = 1000466000;
16947pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES;
16948pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES: VkStructureType = 1000068001;
16949pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES;
16950pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES: VkStructureType = 1000068002;
16951pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES;
16952pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: VkStructureType = 1000117000;
16953pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES;
16954pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV: VkStructureType = 1000292000;
16955pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_2_FEATURES_KHR: VkStructureType = 1000479002;
16956pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: VkStructureType = 1000294001;
16957pub 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;
16958pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_MODE_FIFO_LATEST_READY_FEATURES_KHR: VkStructureType = 1000361000;
16959pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_TIMING_FEATURES_EXT: VkStructureType = 1000208000;
16960pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_2_FEATURES_KHR: VkStructureType = 1000480001;
16961pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: VkStructureType = 1000248000;
16962pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: VkStructureType = 1000382000;
16963pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: VkStructureType = 1000356000;
16964pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: VkStructureType = 1000295000;
16965pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES;
16966pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: VkStructureType = 1000059001;
16967pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
16968pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: VkStructureType = 1000145001;
16969pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: VkStructureType = 1000145002;
16970pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: VkStructureType = 1000254000;
16971pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: VkStructureType = 1000254002;
16972pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_FEATURES_NV: VkStructureType = 1000580001;
16973pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_CONSTANT_BANK_PROPERTIES_NV: VkStructureType = 1000580002;
16974pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES: VkStructureType = 1000080000;
16975pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES;
16976pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_INFO_ARM: VkStructureType = 1000507019;
16977pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT;
16978pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT: VkStructureType = 1000342000;
16979pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAW_ACCESS_CHAINS_FEATURES_NV: VkStructureType = 1000555000;
16980pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: VkStructureType = 1000348013;
16981pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_EXT: VkStructureType = 1000581000;
16982pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV: VkStructureType = 1000490000;
16983pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_EXT: VkStructureType = 1000581001;
16984pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV: VkStructureType = 1000490001;
16985pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_LINEAR_SWEPT_SPHERES_FEATURES_NV: VkStructureType = 1000429008;
16986pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000386000;
16987pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: VkStructureType = 1000327001;
16988pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: VkStructureType = 1000347000;
16989pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: VkStructureType = 1000347001;
16990pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR: VkStructureType = 1000481000;
16991pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: VkStructureType = 1000165009;
16992pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_VALIDATION_FEATURES_NV: VkStructureType = 1000568000;
16993pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RELAXED_LINE_RASTERIZATION_FEATURES_IMG: VkStructureType = 1000110000;
16994pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_FEATURES_ARM: VkStructureType = 1000424000;
16995pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RENDER_PASS_STRIPED_PROPERTIES_ARM: VkStructureType = 1000424001;
16996pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: VkStructureType = 1000166000;
16997pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: VkStructureType = 1000344000;
16998pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR;
16999pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_KHR: VkStructureType = 1000286000;
17000pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR;
17001pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_KHR: VkStructureType = 1000286001;
17002pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: VkStructureType = 1000130000;
17003pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES;
17004pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: VkStructureType = 1000156004;
17005pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
17006pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: VkStructureType = 1000143003;
17007pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: VkStructureType = 1000221000;
17008pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES;
17009pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM: VkStructureType = 1000417001;
17010pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM: VkStructureType = 1000417002;
17011pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: VkStructureType = 1000241000;
17012pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES;
17013pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_64_BIT_INDEXING_FEATURES_EXT: VkStructureType = 1000627000;
17014pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT16_VECTOR_FEATURES_NV: VkStructureType = 1000563000;
17015pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: VkStructureType = 1000273000;
17016pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: VkStructureType = 1000260000;
17017pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: VkStructureType = 1000180000;
17018pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES;
17019pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_BFLOAT16_FEATURES_KHR: VkStructureType = 1000141000;
17020pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: VkStructureType = 1000181000;
17021pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM: VkStructureType = 1000497000;
17022pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM: VkStructureType = 1000497001;
17023pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: VkStructureType = 1000227000;
17024pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: VkStructureType = 1000185000;
17025pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM: VkStructureType = 1000415000;
17026pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: VkStructureType = 1000276000;
17027pub 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;
17028pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: VkStructureType = 1000063000;
17029pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES;
17030pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: VkStructureType = 1000321000;
17031pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES: VkStructureType = 1000544000;
17032pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EXPECT_ASSUME_FEATURES;
17033pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: VkStructureType = 1000082000;
17034pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES;
17035pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT8_FEATURES_EXT: VkStructureType = 1000567000;
17036pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES: VkStructureType = 1000528000;
17037pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT_CONTROLS_2_FEATURES;
17038pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FMA_FEATURES_KHR: VkStructureType = 1000579000;
17039pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: VkStructureType = 1000234000;
17040pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: VkStructureType = 1000204000;
17041pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: VkStructureType = 1000280000;
17042pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES;
17043pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: VkStructureType = 1000280001;
17044pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES;
17045pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: VkStructureType = 1000209000;
17046pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_FEATURES_EXT: VkStructureType = 1000635000;
17047pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_LONG_VECTOR_PROPERTIES_EXT: VkStructureType = 1000635001;
17048pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MAXIMAL_RECONVERGENCE_FEATURES_KHR: VkStructureType = 1000434000;
17049pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: VkStructureType = 1000462000;
17050pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: VkStructureType = 1000462001;
17051pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT: VkStructureType = 1000482000;
17052pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT: VkStructureType = 1000482001;
17053pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_QUAD_CONTROL_FEATURES_KHR: VkStructureType = 1000235000;
17054pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_RELAXED_EXTENDED_INSTRUCTION_FEATURES_KHR: VkStructureType = 1000558000;
17055pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_REPLICATED_COMPOSITES_FEATURES_EXT: VkStructureType = 1000564000;
17056pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: VkStructureType = 1000154000;
17057pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: VkStructureType = 1000154001;
17058pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: VkStructureType = 1000175000;
17059pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES;
17060pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_PARTITIONED_FEATURES_EXT: VkStructureType = 1000662000;
17061pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES: VkStructureType = 1000416000;
17062pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_ROTATE_FEATURES;
17063pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: VkStructureType = 1000323000;
17064pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: VkStructureType = 1000215000;
17065pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES;
17066pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT: VkStructureType = 1000395000;
17067pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT: VkStructureType = 1000395001;
17068pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNIFORM_BUFFER_UNSIZED_ARRAY_FEATURES_EXT: VkStructureType = 1000642000;
17069pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_UNTYPED_POINTERS_FEATURES_KHR: VkStructureType = 1000387000;
17070pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: VkStructureType = 1000164001;
17071pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: VkStructureType = 1000164002;
17072pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: VkStructureType = 1000059008;
17073pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2;
17074pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: VkStructureType = 1000094000;
17075pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: VkStructureType = 1000225002;
17076pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES;
17077pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: VkStructureType = 1000225000;
17078pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES;
17079pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: VkStructureType = 1000458000;
17080pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: VkStructureType = 1000369001;
17081pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: VkStructureType = 1000369002;
17082pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: VkStructureType = 1000119000;
17083pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR;
17084pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000275000;
17085pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: VkStructureType = 1000314007;
17086pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES;
17087pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_FEATURES_ARM: VkStructureType = 1000460009;
17088pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TENSOR_PROPERTIES_ARM: VkStructureType = 1000460004;
17089pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: VkStructureType = 1000281000;
17090pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: VkStructureType = 1000281001;
17091pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES;
17092pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_3D_FEATURES_EXT: VkStructureType = 1000288000;
17093pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: VkStructureType = 1000066000;
17094pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES;
17095pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_FEATURES_QCOM: VkStructureType = 1000547000;
17096pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_MEMORY_HEAP_PROPERTIES_QCOM: VkStructureType = 1000547001;
17097pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM: VkStructureType = 1000484000;
17098pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_FEATURES_QCOM: VkStructureType = 1000309000;
17099pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_SHADING_PROPERTIES_QCOM: VkStructureType = 1000309001;
17100pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: VkStructureType = 1000207000;
17101pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES;
17102pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: VkStructureType = 1000207001;
17103pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES;
17104pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: VkStructureType = 1000245000;
17105pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES;
17106pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: VkStructureType = 1000028000;
17107pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: VkStructureType = 1000028001;
17108pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFIED_IMAGE_LAYOUTS_FEATURES_KHR: VkStructureType = 1000527000;
17109pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: VkStructureType = 1000253000;
17110pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES;
17111pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: VkStructureType = 1000120000;
17112pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
17113pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES;
17114pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR;
17115pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES: VkStructureType = 1000190002;
17116pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
17117pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES;
17118pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES: VkStructureType = 1000525000;
17119pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: VkStructureType = 1000190000;
17120pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES;
17121pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_ROBUSTNESS_FEATURES_EXT: VkStructureType = 1000608000;
17122pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: VkStructureType = 1000352000;
17123pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_DECODE_VP9_FEATURES_KHR: VkStructureType = 1000514000;
17124pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_AV1_FEATURES_KHR: VkStructureType = 1000513004;
17125pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_INTRA_REFRESH_FEATURES_KHR: VkStructureType = 1000552004;
17126pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = 1000299006;
17127pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_QUANTIZATION_MAP_FEATURES_KHR: VkStructureType = 1000553009;
17128pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_ENCODE_RGB_CONVERSION_FEATURES_VALVE: VkStructureType = 1000390000;
17129pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: VkStructureType = 1000023014;
17130pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_1_FEATURES_KHR: VkStructureType = 1000515000;
17131pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_MAINTENANCE_2_FEATURES_KHR: VkStructureType = 1000586000;
17132pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: VkStructureType = 49;
17133pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: VkStructureType = 50;
17134pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: VkStructureType = 51;
17135pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: VkStructureType = 52;
17136pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: VkStructureType = 53;
17137pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: VkStructureType = 54;
17138pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_FEATURES: VkStructureType = 55;
17139pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_4_PROPERTIES: VkStructureType = 56;
17140pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: VkStructureType = 1000211000;
17141pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES;
17142pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: VkStructureType = 1000336000;
17143pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: VkStructureType = 1000330000;
17144pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM: VkStructureType = 1000520000;
17145pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: VkStructureType = 1000252000;
17146pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_DEVICE_MEMORY_FEATURES_EXT: VkStructureType = 1000620000;
17147pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: VkStructureType = 1000325000;
17148pub const VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR: VkStructureType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES;
17149pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_CREATE_INFO_KHR: VkStructureType = 1000483001;
17150pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_DATA_INFO_KHR: VkStructureType = 1000483006;
17151pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_HANDLES_INFO_KHR: VkStructureType = 1000483009;
17152pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_INFO_KHR: VkStructureType = 1000483002;
17153pub const VK_STRUCTURE_TYPE_PIPELINE_BINARY_KEY_KHR: VkStructureType = 1000483003;
17154pub const VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: VkStructureType = 17;
17155pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: VkStructureType = 1000148002;
17156pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: VkStructureType = 26;
17157pub const VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: VkStructureType = 1000381001;
17158pub const VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: VkStructureType = 1000183000;
17159pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: VkStructureType = 1000152000;
17160pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: VkStructureType = 1000250001;
17161pub const VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: VkStructureType = 1000149000;
17162pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO: VkStructureType = 1000470005;
17163pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO;
17164pub const VK_STRUCTURE_TYPE_PIPELINE_CREATE_INFO_KHR: VkStructureType = 1000483007;
17165pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: VkStructureType = 1000192000;
17166pub const VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO;
17167pub const VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: VkStructureType = 25;
17168pub const VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: VkStructureType = 1000099001;
17169pub const VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: VkStructureType = 27;
17170pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: VkStructureType = 1000269003;
17171pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: VkStructureType = 1000269005;
17172pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: VkStructureType = 1000269002;
17173pub const VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: VkStructureType = 1000269004;
17174pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_DENSITY_MAP_LAYERED_CREATE_INFO_VALVE: VkStructureType = 1000611002;
17175pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: VkStructureType = 1000326002;
17176pub const VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: VkStructureType = 1000226001;
17177pub const VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV: VkStructureType = 1000428002;
17178pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR;
17179pub const VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: VkStructureType = 1000269001;
17180pub const VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: VkStructureType = 20;
17181pub const VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: VkStructureType = 30;
17182pub const VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: VkStructureType = 1000290000;
17183pub const VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: VkStructureType = 24;
17184pub const VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: VkStructureType = 1000372000;
17185pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: VkStructureType = 1000101001;
17186pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: VkStructureType = 1000102001;
17187pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO: VkStructureType = 1000259001;
17188pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
17189pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO;
17190pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: VkStructureType = 1000254001;
17191pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: VkStructureType = 23;
17192pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: VkStructureType = 1000018000;
17193pub const VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: VkStructureType = 1000028002;
17194pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: VkStructureType = 1000044002;
17195pub const VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
17196pub const VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: VkStructureType = 1000166001;
17197pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO: VkStructureType = 1000068000;
17198pub const VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO;
17199pub const VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: VkStructureType = 1000143002;
17200pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: VkStructureType = 18;
17201pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: VkStructureType = 1000462002;
17202pub const VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: VkStructureType = 1000225001;
17203pub 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;
17204pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: VkStructureType = 1000117003;
17205pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO;
17206pub const VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: VkStructureType = 21;
17207pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO: VkStructureType = 1000190001;
17208pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
17209pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO;
17210pub const VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: VkStructureType = 19;
17211pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: VkStructureType = 1000164005;
17212pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLAMP_CONTROL_CREATE_INFO_EXT: VkStructureType = 1000582001;
17213pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: VkStructureType = 1000355001;
17214pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: VkStructureType = 1000205000;
17215pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: VkStructureType = 1000164000;
17216pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: VkStructureType = 22;
17217pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: VkStructureType = 1000098000;
17218pub const VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: VkStructureType = 1000087000;
17219pub const VK_STRUCTURE_TYPE_PRESENT_ID_2_KHR: VkStructureType = 1000479001;
17220pub const VK_STRUCTURE_TYPE_PRESENT_ID_KHR: VkStructureType = 1000294000;
17221pub const VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: VkStructureType = 1000001001;
17222pub const VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: VkStructureType = 1000084000;
17223pub const VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: VkStructureType = 1000092000;
17224pub const VK_STRUCTURE_TYPE_PRESENT_TIMINGS_INFO_EXT: VkStructureType = 1000208003;
17225pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_INFO_EXT: VkStructureType = 1000208004;
17226pub const VK_STRUCTURE_TYPE_PRESENT_TIMING_SURFACE_CAPABILITIES_EXT: VkStructureType = 1000208008;
17227pub const VK_STRUCTURE_TYPE_PRESENT_WAIT_2_INFO_KHR: VkStructureType = 1000480002;
17228pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: VkStructureType = 1000295002;
17229pub const VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO;
17230pub const VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: VkStructureType = 1000145000;
17231pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO: VkStructureType = 1000545004;
17232pub const VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_CONSTANTS_INFO;
17233pub const VK_STRUCTURE_TYPE_PUSH_CONSTANT_BANK_INFO_NV: VkStructureType = 1000580000;
17234pub const VK_STRUCTURE_TYPE_PUSH_DATA_INFO_EXT: VkStructureType = 1000135004;
17235pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO: VkStructureType = 1000545005;
17236pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_INFO;
17237pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO: VkStructureType = 1000545006;
17238pub const VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_INFO;
17239pub const VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV: VkStructureType = 1000310000;
17240pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: VkStructureType = 11;
17241pub const VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL: VkStructureType = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL;
17242pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: VkStructureType = 1000116002;
17243pub const VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: VkStructureType = 1000210000;
17244pub const VK_STRUCTURE_TYPE_QUERY_POOL_VIDEO_ENCODE_FEEDBACK_CREATE_INFO_KHR: VkStructureType = 1000299005;
17245pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: VkStructureType = 1000314008;
17246pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: VkStructureType = 1000206001;
17247pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROCESSING_ENGINE_PROPERTIES_ARM: VkStructureType = 1000507017;
17248pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_DATA_GRAPH_PROPERTIES_ARM: VkStructureType = 1000507018;
17249pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES: VkStructureType = 1000388001;
17250pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
17251pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES;
17252pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_OWNERSHIP_TRANSFER_PROPERTIES_KHR: VkStructureType = 1000584002;
17253pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: VkStructureType = 1000059005;
17254pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
17255pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: VkStructureType = 1000023016;
17256pub const VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: VkStructureType = 1000023012;
17257pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CLUSTER_ACCELERATION_STRUCTURE_CREATE_INFO_NV: VkStructureType = 1000569007;
17258pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: VkStructureType = 1000150015;
17259pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: VkStructureType = 1000165000;
17260pub const VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: VkStructureType = 1000150018;
17261pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: VkStructureType = 1000150016;
17262pub const VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: VkStructureType = 1000165011;
17263pub const VK_STRUCTURE_TYPE_RELEASE_CAPTURED_PIPELINE_DATA_INFO_KHR: VkStructureType = 1000483005;
17264pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR;
17265pub const VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_KHR: VkStructureType = 1000275005;
17266pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO: VkStructureType = 1000470003;
17267pub const VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_AREA_INFO;
17268pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_FLAGS_INFO_KHR: VkStructureType = 1000630002;
17269pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: VkStructureType = 1000044001;
17270pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
17271pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO: VkStructureType = 1000232001;
17272pub const VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_LOCATION_INFO;
17273pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR;
17274pub const VK_STRUCTURE_TYPE_RENDERING_END_INFO_KHR: VkStructureType = 1000619003;
17275pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: VkStructureType = 1000044007;
17276pub const VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: VkStructureType = 1000044006;
17277pub const VK_STRUCTURE_TYPE_RENDERING_INFO: VkStructureType = 1000044000;
17278pub const VK_STRUCTURE_TYPE_RENDERING_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INFO;
17279pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO: VkStructureType = 1000232002;
17280pub const VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDERING_INPUT_ATTACHMENT_INDEX_INFO;
17281pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: VkStructureType = 1000108003;
17282pub const VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO;
17283pub const VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: VkStructureType = 43;
17284pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: VkStructureType = 38;
17285pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: VkStructureType = 1000109004;
17286pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2;
17287pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: VkStructureType = 1000458001;
17288pub const VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: VkStructureType = 1000458002;
17289pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: VkStructureType = 1000218002;
17290pub const VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_EXT: VkStructureType = 1000425002;
17291pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: VkStructureType = 1000117001;
17292pub const VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO;
17293pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: VkStructureType = 1000053000;
17294pub const VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO;
17295pub const VK_STRUCTURE_TYPE_RENDER_PASS_PERFORMANCE_COUNTERS_BY_REGION_BEGIN_INFO_ARM: VkStructureType = 1000605004;
17296pub const VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: VkStructureType = 1000143001;
17297pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_BEGIN_INFO_ARM: VkStructureType = 1000424002;
17298pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_INFO_ARM: VkStructureType = 1000424003;
17299pub const VK_STRUCTURE_TYPE_RENDER_PASS_STRIPE_SUBMIT_INFO_ARM: VkStructureType = 1000424004;
17300pub const VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: VkStructureType = 1000458003;
17301pub const VK_STRUCTURE_TYPE_RENDER_PASS_TILE_SHADING_CREATE_INFO_QCOM: VkStructureType = 1000309002;
17302pub const VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: VkStructureType = 1000282001;
17303pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: VkStructureType = 1000337005;
17304pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2;
17305pub const VK_STRUCTURE_TYPE_RESOLVE_IMAGE_MODE_INFO_KHR: VkStructureType = 1000630004;
17306pub const VK_STRUCTURE_TYPE_RESOURCE_DESCRIPTOR_INFO_EXT: VkStructureType = 1000135002;
17307pub const VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM: VkStructureType = 1000518002;
17308pub const VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: VkStructureType = 1000411001;
17309pub const VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT: VkStructureType = 1000316008;
17310pub const VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: VkStructureType = 31;
17311pub const VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM: VkStructureType = 1000519000;
17312pub const VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: VkStructureType = 1000287000;
17313pub const VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_INDEX_CREATE_INFO_EXT: VkStructureType = 1000135011;
17314pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: VkStructureType = 1000130001;
17315pub const VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO;
17316pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: VkStructureType = 1000156000;
17317pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO;
17318pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: VkStructureType = 1000156005;
17319pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES;
17320pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: VkStructureType = 1000156001;
17321pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO;
17322pub const VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM: VkStructureType = 1000520001;
17323pub const VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: VkStructureType = 1000143000;
17324pub const VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: VkStructureType = 9;
17325pub const VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: VkStructureType = 1000079001;
17326pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: VkStructureType = 1000207005;
17327pub const VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO;
17328pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000314005;
17329pub const VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO;
17330pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: VkStructureType = 1000207002;
17331pub const VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO;
17332pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: VkStructureType = 1000207004;
17333pub const VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO;
17334pub const VK_STRUCTURE_TYPE_SET_DESCRIPTOR_BUFFER_OFFSETS_INFO_EXT: VkStructureType = 1000545007;
17335pub const VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV: VkStructureType = 1000505002;
17336pub const VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT: VkStructureType = 1000482002;
17337pub const VK_STRUCTURE_TYPE_SHADER_DESCRIPTOR_SET_AND_BINDING_MAPPING_INFO_EXT: VkStructureType = 1000135006;
17338pub const VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: VkStructureType = 16;
17339pub const VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: VkStructureType = 1000462003;
17340pub const VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160001;
17341pub const VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO;
17342pub const VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: VkStructureType = 1000111000;
17343pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: VkStructureType = 1000059007;
17344pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
17345pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: VkStructureType = 1000146004;
17346pub const VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2;
17347pub const VK_STRUCTURE_TYPE_SUBMIT_INFO: VkStructureType = 4;
17348pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2: VkStructureType = 1000314004;
17349pub const VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2;
17350pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: VkStructureType = 1000109005;
17351pub const VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO;
17352pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: VkStructureType = 1000109003;
17353pub const VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2;
17354pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: VkStructureType = 1000109002;
17355pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2;
17356pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: VkStructureType = 1000199001;
17357pub const VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE;
17358pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO: VkStructureType = 1000109006;
17359pub const VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBPASS_END_INFO;
17360pub 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;
17361pub const VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: VkStructureType = 1000376001;
17362pub const VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: VkStructureType = 1000369000;
17363pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE: VkStructureType = 1000270008;
17364pub const VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE;
17365pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2: VkStructureType = 1000338002;
17366pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
17367pub const VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR: VkStructureType = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2;
17368pub const VK_STRUCTURE_TYPE_SUBSAMPLED_IMAGE_FORMAT_PROPERTIES_EXT: VkStructureType = 1000135013;
17369pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT;
17370pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: VkStructureType = 1000090000;
17371pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: VkStructureType = 1000119001;
17372pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV: VkStructureType = 1000292001;
17373pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_ID_2_KHR: VkStructureType = 1000479000;
17374pub const VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_WAIT_2_KHR: VkStructureType = 1000480000;
17375pub const VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: VkStructureType = 1000119002;
17376pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR;
17377pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_KHR: VkStructureType = 1000274002;
17378pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR;
17379pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_KHR: VkStructureType = 1000274000;
17380pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT: VkStructureType = VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR;
17381pub const VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_KHR: VkStructureType = 1000274001;
17382pub const VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: VkStructureType = 1000239000;
17383pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CALIBRATED_TIMESTAMP_INFO_EXT: VkStructureType = 1000208009;
17384pub const VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: VkStructureType = 1000091003;
17385pub const VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: VkStructureType = 1000001000;
17386pub const VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: VkStructureType = 1000213001;
17387pub const VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV: VkStructureType = 1000505007;
17388pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV: VkStructureType = 1000292002;
17389pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR;
17390pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_KHR: VkStructureType = 1000275001;
17391pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR;
17392pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_KHR: VkStructureType = 1000275002;
17393pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR;
17394pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_KHR: VkStructureType = 1000275003;
17395pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT: VkStructureType = VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR;
17396pub const VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_KHR: VkStructureType = 1000275004;
17397pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIME_DOMAIN_PROPERTIES_EXT: VkStructureType = 1000208002;
17398pub const VK_STRUCTURE_TYPE_SWAPCHAIN_TIMING_PROPERTIES_EXT: VkStructureType = 1000208001;
17399pub const VK_STRUCTURE_TYPE_TENSOR_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = 1000460021;
17400pub const VK_STRUCTURE_TYPE_TENSOR_COPY_ARM: VkStructureType = 1000460012;
17401pub const VK_STRUCTURE_TYPE_TENSOR_CREATE_INFO_ARM: VkStructureType = 1000460000;
17402pub const VK_STRUCTURE_TYPE_TENSOR_DEPENDENCY_INFO_ARM: VkStructureType = 1000460013;
17403pub const VK_STRUCTURE_TYPE_TENSOR_DESCRIPTION_ARM: VkStructureType = 1000460006;
17404pub const VK_STRUCTURE_TYPE_TENSOR_FORMAT_PROPERTIES_ARM: VkStructureType = 1000460005;
17405pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_BARRIER_ARM: VkStructureType = 1000460008;
17406pub const VK_STRUCTURE_TYPE_TENSOR_MEMORY_REQUIREMENTS_INFO_ARM: VkStructureType = 1000460007;
17407pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_ARM: VkStructureType = 1000460022;
17408pub const VK_STRUCTURE_TYPE_TENSOR_VIEW_CREATE_INFO_ARM: VkStructureType = 1000460001;
17409pub const VK_STRUCTURE_TYPE_TEXEL_BUFFER_DESCRIPTOR_INFO_EXT: VkStructureType = 1000135000;
17410pub const VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: VkStructureType = 1000041000;
17411pub const VK_STRUCTURE_TYPE_TILE_MEMORY_BIND_INFO_QCOM: VkStructureType = 1000547003;
17412pub const VK_STRUCTURE_TYPE_TILE_MEMORY_REQUIREMENTS_QCOM: VkStructureType = 1000547002;
17413pub const VK_STRUCTURE_TYPE_TILE_MEMORY_SIZE_INFO_QCOM: VkStructureType = 1000547004;
17414pub const VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM: VkStructureType = 1000484001;
17415pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: VkStructureType = 1000207003;
17416pub const VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR: VkStructureType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO;
17417pub const VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: VkStructureType = 1000160000;
17418pub const VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: VkStructureType = 1000247000;
17419pub const VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: VkStructureType = 1000061000;
17420pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: VkStructureType = 1000352002;
17421pub const VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: VkStructureType = 1000352001;
17422pub const VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: VkStructureType = 1000023008;
17423pub const VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: VkStructureType = 1000023001;
17424pub const VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: VkStructureType = 1000023010;
17425pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_CAPABILITIES_KHR: VkStructureType = 1000512000;
17426pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = 1000512005;
17427pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586003;
17428pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PICTURE_INFO_KHR: VkStructureType = 1000512001;
17429pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_PROFILE_INFO_KHR: VkStructureType = 1000512003;
17430pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000512004;
17431pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: VkStructureType = 1000024001;
17432pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR: VkStructureType = 1000040000;
17433pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = 1000040006;
17434pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586001;
17435pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR: VkStructureType = 1000040001;
17436pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR: VkStructureType = 1000040003;
17437pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000040005;
17438pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000040004;
17439pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR: VkStructureType = 1000187000;
17440pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = 1000187005;
17441pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_INLINE_SESSION_PARAMETERS_INFO_KHR: VkStructureType = 1000586002;
17442pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR: VkStructureType = 1000187004;
17443pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR: VkStructureType = 1000187003;
17444pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000187002;
17445pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000187001;
17446pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: VkStructureType = 1000024000;
17447pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: VkStructureType = 1000024002;
17448pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_CAPABILITIES_KHR: VkStructureType = 1000514001;
17449pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PICTURE_INFO_KHR: VkStructureType = 1000514002;
17450pub const VK_STRUCTURE_TYPE_VIDEO_DECODE_VP9_PROFILE_INFO_KHR: VkStructureType = 1000514003;
17451pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_CAPABILITIES_KHR: VkStructureType = 1000513000;
17452pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_DPB_SLOT_INFO_KHR: VkStructureType = 1000513003;
17453pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000513010;
17454pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PICTURE_INFO_KHR: VkStructureType = 1000513002;
17455pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_PROFILE_INFO_KHR: VkStructureType = 1000513005;
17456pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000513008;
17457pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553007;
17458pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_INFO_KHR: VkStructureType = 1000513006;
17459pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000513007;
17460pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_CREATE_INFO_KHR: VkStructureType = 1000513009;
17461pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_AV1_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000513001;
17462pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: VkStructureType = 1000299003;
17463pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_KHR: VkStructureType = 1000038000;
17464pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_KHR: VkStructureType = 1000038004;
17465pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000038006;
17466pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_KHR: VkStructureType = 1000038005;
17467pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PICTURE_INFO_KHR: VkStructureType = 1000038003;
17468pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_KHR: VkStructureType = 1000038007;
17469pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000038011;
17470pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553003;
17471pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_KHR: VkStructureType = 1000038008;
17472pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000038009;
17473pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_CREATE_INFO_KHR: VkStructureType = 1000038010;
17474pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000038002;
17475pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000038001;
17476pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000038013;
17477pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000038012;
17478pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_KHR: VkStructureType = 1000039000;
17479pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_KHR: VkStructureType = 1000039004;
17480pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_GOP_REMAINING_FRAME_INFO_KHR: VkStructureType = 1000039006;
17481pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_KHR: VkStructureType = 1000039005;
17482pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PICTURE_INFO_KHR: VkStructureType = 1000039003;
17483pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_KHR: VkStructureType = 1000039007;
17484pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000039012;
17485pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553004;
17486pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_KHR: VkStructureType = 1000039009;
17487pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000039010;
17488pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_CREATE_INFO_KHR: VkStructureType = 1000039011;
17489pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR: VkStructureType = 1000039002;
17490pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000039001;
17491pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000039014;
17492pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000039013;
17493pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: VkStructureType = 1000299000;
17494pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_CAPABILITIES_KHR: VkStructureType = 1000552000;
17495pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_INTRA_REFRESH_INFO_KHR: VkStructureType = 1000552002;
17496pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_PROFILE_RGB_CONVERSION_INFO_VALVE: VkStructureType = 1000390002;
17497pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_INFO_KHR: VkStructureType = 1000299008;
17498pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUALITY_LEVEL_PROPERTIES_KHR: VkStructureType = 1000299007;
17499pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_CAPABILITIES_KHR: VkStructureType = 1000553000;
17500pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_INFO_KHR: VkStructureType = 1000553002;
17501pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_QUANTIZATION_MAP_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000553005;
17502pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: VkStructureType = 1000299001;
17503pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: VkStructureType = 1000299002;
17504pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_RGB_CONVERSION_CAPABILITIES_VALVE: VkStructureType = 1000390001;
17505pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_INTRA_REFRESH_CREATE_INFO_KHR: VkStructureType = 1000552001;
17506pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_FEEDBACK_INFO_KHR: VkStructureType = 1000299010;
17507pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_PARAMETERS_GET_INFO_KHR: VkStructureType = 1000299009;
17508pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_SESSION_RGB_CONVERSION_CREATE_INFO_VALVE: VkStructureType = 1000390003;
17509pub const VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: VkStructureType = 1000299004;
17510pub const VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: VkStructureType = 1000023009;
17511pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_AV1_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553008;
17512pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_H265_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553006;
17513pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: VkStructureType = 1000023015;
17514pub const VK_STRUCTURE_TYPE_VIDEO_FORMAT_QUANTIZATION_MAP_PROPERTIES_KHR: VkStructureType = 1000553001;
17515pub const VK_STRUCTURE_TYPE_VIDEO_INLINE_QUERY_INFO_KHR: VkStructureType = 1000515001;
17516pub const VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: VkStructureType = 1000023002;
17517pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: VkStructureType = 1000023000;
17518pub const VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: VkStructureType = 1000023013;
17519pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_INTRA_REFRESH_INFO_KHR: VkStructureType = 1000552003;
17520pub const VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: VkStructureType = 1000023011;
17521pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: VkStructureType = 1000023005;
17522pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: VkStructureType = 1000023003;
17523pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: VkStructureType = 1000023006;
17524pub const VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: VkStructureType = 1000023007;
17525pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: VkStructureType = 35;
17526pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: VkStructureType = 1000150007;
17527pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: VkStructureType = 1000165007;
17528pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: VkStructureType = 1000138002;
17529pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT: VkStructureType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK;
17530pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_PARTITIONED_ACCELERATION_STRUCTURE_NV: VkStructureType = 1000570002;
17531pub const VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_TENSOR_ARM: VkStructureType = 1000460003;
17532pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_PIPELINE_EXT: VkStructureType = 1000572008;
17533pub const VK_STRUCTURE_TYPE_WRITE_INDIRECT_EXECUTION_SET_SHADER_EXT: VkStructureType = 1000572009;
17534pub const VK_SUBGROUP_FEATURE_ARITHMETIC_BIT: VkSubgroupFeatureFlagBits = 1 << 2;
17535pub const VK_SUBGROUP_FEATURE_BALLOT_BIT: VkSubgroupFeatureFlagBits = 1 << 3;
17536pub const VK_SUBGROUP_FEATURE_BASIC_BIT: VkSubgroupFeatureFlagBits = 1 << 0;
17537pub const VK_SUBGROUP_FEATURE_CLUSTERED_BIT: VkSubgroupFeatureFlagBits = 1 << 6;
17538pub const VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT: VkSubgroupFeatureFlagBits = 1 << 8;
17539pub const VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_PARTITIONED_BIT_EXT;
17540pub const VK_SUBGROUP_FEATURE_QUAD_BIT: VkSubgroupFeatureFlagBits = 1 << 7;
17541pub const VK_SUBGROUP_FEATURE_ROTATE_BIT: VkSubgroupFeatureFlagBits = 1 << 9;
17542pub const VK_SUBGROUP_FEATURE_ROTATE_BIT_KHR: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_ROTATE_BIT;
17543pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT: VkSubgroupFeatureFlagBits = 1 << 10;
17544pub const VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT_KHR: VkSubgroupFeatureFlagBits = VK_SUBGROUP_FEATURE_ROTATE_CLUSTERED_BIT;
17545pub const VK_SUBGROUP_FEATURE_SHUFFLE_BIT: VkSubgroupFeatureFlagBits = 1 << 4;
17546pub const VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT: VkSubgroupFeatureFlagBits = 1 << 5;
17547pub const VK_SUBGROUP_FEATURE_VOTE_BIT: VkSubgroupFeatureFlagBits = 1 << 1;
17548pub const VK_SUBMIT_PROTECTED_BIT: VkSubmitFlagBits = 1 << 0;
17549pub const VK_SUBMIT_PROTECTED_BIT_KHR: VkSubmitFlagBits = VK_SUBMIT_PROTECTED_BIT;
17550pub const VK_SUBOPTIMAL_KHR: VkResult = 1000001003;
17551pub const VK_SUBPASS_CONTENTS_INLINE: VkSubpassContents = 0;
17552pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT: VkSubpassContents = VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR;
17553pub const VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_KHR: VkSubpassContents = 1000451000;
17554pub const VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS: VkSubpassContents = 1;
17555pub const VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 3;
17556pub const VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 7;
17557pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 2;
17558pub const VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_EXT;
17559pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX: VkSubpassDescriptionFlagBits = 1 << 0;
17560pub const VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX: VkSubpassDescriptionFlagBits = 1 << 1;
17561pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT;
17562pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 4;
17563pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT;
17564pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 5;
17565pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT;
17566pub const VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT: VkSubpassDescriptionFlagBits = 1 << 6;
17567pub const VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM: VkSubpassDescriptionFlagBits = VK_SUBPASS_DESCRIPTION_CUSTOM_RESOLVE_BIT_EXT;
17568pub const VK_SUBPASS_DESCRIPTION_TILE_SHADING_APRON_BIT_QCOM: VkSubpassDescriptionFlagBits = 1 << 8;
17569pub const VK_SUBPASS_EXTERNAL: u32 = !0;
17570pub const VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT: VkSubpassMergeStatusEXT = 1;
17571pub const VK_SUBPASS_MERGE_STATUS_MERGED_EXT: VkSubpassMergeStatusEXT = 0;
17572pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT: VkSubpassMergeStatusEXT = 5;
17573pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT: VkSubpassMergeStatusEXT = 6;
17574pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT: VkSubpassMergeStatusEXT = 10;
17575pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT: VkSubpassMergeStatusEXT = 7;
17576pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT: VkSubpassMergeStatusEXT = 9;
17577pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT: VkSubpassMergeStatusEXT = 11;
17578pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT: VkSubpassMergeStatusEXT = 3;
17579pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT: VkSubpassMergeStatusEXT = 2;
17580pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT: VkSubpassMergeStatusEXT = 12;
17581pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT: VkSubpassMergeStatusEXT = 8;
17582pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT: VkSubpassMergeStatusEXT = 13;
17583pub const VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT: VkSubpassMergeStatusEXT = 4;
17584pub const VK_SUCCESS: VkResult = 0;
17585pub const VK_SURFACE_COUNTER_VBLANK_BIT_EXT: VkSurfaceCounterFlagBitsEXT = 1 << 0;
17586pub const VK_SURFACE_COUNTER_VBLANK_EXT: VkSurfaceCounterFlagBitsEXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT;
17587pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 4;
17588pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 6;
17589pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 7;
17590pub const VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 5;
17591pub const VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 0;
17592pub const VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 8;
17593pub const VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 2;
17594pub const VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 3;
17595pub const VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR: VkSurfaceTransformFlagBitsKHR = 1 << 1;
17596pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT: VkSwapchainCreateFlagBitsKHR = VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR;
17597pub const VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 3;
17598pub const VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 2;
17599pub const VK_SWAPCHAIN_CREATE_PRESENT_ID_2_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 6;
17600pub const VK_SWAPCHAIN_CREATE_PRESENT_TIMING_BIT_EXT: VkSwapchainCreateFlagBitsKHR = 1 << 9;
17601pub const VK_SWAPCHAIN_CREATE_PRESENT_WAIT_2_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 7;
17602pub const VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 1;
17603pub const VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR: VkSwapchainCreateFlagBitsKHR = 1 << 0;
17604pub const VK_SYSTEM_ALLOCATION_SCOPE_CACHE: VkSystemAllocationScope = 2;
17605pub const VK_SYSTEM_ALLOCATION_SCOPE_COMMAND: VkSystemAllocationScope = 0;
17606pub const VK_SYSTEM_ALLOCATION_SCOPE_DEVICE: VkSystemAllocationScope = 3;
17607pub const VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE: VkSystemAllocationScope = 4;
17608pub const VK_SYSTEM_ALLOCATION_SCOPE_OBJECT: VkSystemAllocationScope = 1;
17609pub const VK_TENSOR_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 2;
17610pub const VK_TENSOR_CREATE_DESCRIPTOR_HEAP_CAPTURE_REPLAY_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 3;
17611pub const VK_TENSOR_CREATE_MUTABLE_FORMAT_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 0;
17612pub const VK_TENSOR_CREATE_PROTECTED_BIT_ARM: VkTensorCreateFlagBitsARM = 1 << 1;
17613pub const VK_TENSOR_TILING_LINEAR_ARM: VkTensorTilingARM = 1;
17614pub const VK_TENSOR_TILING_OPTIMAL_ARM: VkTensorTilingARM = 0;
17615pub const VK_TENSOR_USAGE_DATA_GRAPH_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 5;
17616pub const VK_TENSOR_USAGE_IMAGE_ALIASING_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 4;
17617pub const VK_TENSOR_USAGE_SHADER_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 1;
17618pub const VK_TENSOR_USAGE_TRANSFER_DST_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 3;
17619pub const VK_TENSOR_USAGE_TRANSFER_SRC_BIT_ARM: VkTensorUsageFlagBitsARM = 1 << 2;
17620pub const VK_TENSOR_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_ARM: VkTensorViewCreateFlagBitsARM = 1 << 0;
17621pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT: VkTessellationDomainOrigin = 1;
17622pub const VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT;
17623pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT: VkTessellationDomainOrigin = 0;
17624pub const VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR: VkTessellationDomainOrigin = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT;
17625pub const VK_THREAD_DONE_KHR: VkResult = 1000268001;
17626pub const VK_THREAD_IDLE_KHR: VkResult = 1000268000;
17627pub const VK_TILE_SHADING_RENDER_PASS_ENABLE_BIT_QCOM: VkTileShadingRenderPassFlagBitsQCOM = 1 << 0;
17628pub const VK_TILE_SHADING_RENDER_PASS_PER_TILE_EXECUTION_BIT_QCOM: VkTileShadingRenderPassFlagBitsQCOM = 1 << 1;
17629pub const VK_TIMEOUT: VkResult = 2;
17630pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR;
17631pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_KHR: VkTimeDomainKHR = 1;
17632pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR;
17633pub const VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_KHR: VkTimeDomainKHR = 2;
17634pub const VK_TIME_DOMAIN_DEVICE_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_DEVICE_KHR;
17635pub const VK_TIME_DOMAIN_DEVICE_KHR: VkTimeDomainKHR = 0;
17636pub const VK_TIME_DOMAIN_PRESENT_STAGE_LOCAL_EXT: VkTimeDomainKHR = 1000208000;
17637pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT: VkTimeDomainKHR = VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR;
17638pub const VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_KHR: VkTimeDomainKHR = 3;
17639pub const VK_TIME_DOMAIN_SWAPCHAIN_LOCAL_EXT: VkTimeDomainKHR = 1000208001;
17640pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT: VkToolPurposeFlagBits = 1 << 3;
17641pub const VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT;
17642pub const VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT: VkToolPurposeFlagBits = 1 << 6;
17643pub const VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT: VkToolPurposeFlagBits = 1 << 5;
17644pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT: VkToolPurposeFlagBits = 1 << 4;
17645pub const VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT;
17646pub const VK_TOOL_PURPOSE_PROFILING_BIT: VkToolPurposeFlagBits = 1 << 1;
17647pub const VK_TOOL_PURPOSE_PROFILING_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_PROFILING_BIT;
17648pub const VK_TOOL_PURPOSE_TRACING_BIT: VkToolPurposeFlagBits = 1 << 2;
17649pub const VK_TOOL_PURPOSE_TRACING_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_TRACING_BIT;
17650pub const VK_TOOL_PURPOSE_VALIDATION_BIT: VkToolPurposeFlagBits = 1 << 0;
17651pub const VK_TOOL_PURPOSE_VALIDATION_BIT_EXT: VkToolPurposeFlagBits = VK_TOOL_PURPOSE_VALIDATION_BIT;
17652pub const VK_TRUE: u32 = 1;
17653pub const VK_USE_64_BIT_PTR_DEFINES: bool = true;
17654pub const VK_UUID_SIZE: u32 = 16;
17655pub const VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT: VkValidationCacheHeaderVersionEXT = 1;
17656pub const VK_VALIDATION_CHECK_ALL_EXT: VkValidationCheckEXT = 0;
17657pub const VK_VALIDATION_CHECK_SHADERS_EXT: VkValidationCheckEXT = 1;
17658pub const VK_VALIDATION_FEATURE_DISABLE_ALL_EXT: VkValidationFeatureDisableEXT = 0;
17659pub const VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT: VkValidationFeatureDisableEXT = 3;
17660pub const VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT: VkValidationFeatureDisableEXT = 5;
17661pub const VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT: VkValidationFeatureDisableEXT = 4;
17662pub const VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT: VkValidationFeatureDisableEXT = 1;
17663pub const VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT: VkValidationFeatureDisableEXT = 7;
17664pub const VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT: VkValidationFeatureDisableEXT = 2;
17665pub const VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT: VkValidationFeatureDisableEXT = 6;
17666pub const VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT: VkValidationFeatureEnableEXT = 2;
17667pub const VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT: VkValidationFeatureEnableEXT = 3;
17668pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT: VkValidationFeatureEnableEXT = 0;
17669pub const VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT: VkValidationFeatureEnableEXT = 1;
17670pub const VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT: VkValidationFeatureEnableEXT = 4;
17671pub const VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_EXTENSION_NAME: &CStr = c"VK_VALVE_descriptor_set_host_mapping";
17672pub const VK_VALVE_DESCRIPTOR_SET_HOST_MAPPING_SPEC_VERSION: u32 = 1;
17673pub const VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_EXTENSION_NAME: &CStr = c"VK_VALVE_fragment_density_map_layered";
17674pub const VK_VALVE_FRAGMENT_DENSITY_MAP_LAYERED_SPEC_VERSION: u32 = 1;
17675pub const VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_EXTENSION_NAME: &CStr = c"VK_VALVE_mutable_descriptor_type";
17676pub const VK_VALVE_MUTABLE_DESCRIPTOR_TYPE_SPEC_VERSION: u32 = 1;
17677pub const VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_EXTENSION_NAME: &CStr = c"VK_VALVE_video_encode_rgb_conversion";
17678pub const VK_VALVE_VIDEO_ENCODE_RGB_CONVERSION_SPEC_VERSION: u32 = 1;
17679pub const VK_VENDOR_ID_CODEPLAY: VkVendorId = 0x10004;
17680pub const VK_VENDOR_ID_KAZAN: VkVendorId = 0x10003;
17681pub const VK_VENDOR_ID_KHRONOS: VkVendorId = 0x10000;
17682pub const VK_VENDOR_ID_MESA: VkVendorId = 0x10005;
17683pub const VK_VENDOR_ID_MOBILEYE: VkVendorId = 0x10007;
17684pub const VK_VENDOR_ID_POCL: VkVendorId = 0x10006;
17685pub const VK_VENDOR_ID_VIV: VkVendorId = 0x10001;
17686pub const VK_VENDOR_ID_VSI: VkVendorId = 0x10002;
17687pub const VK_VERTEX_INPUT_RATE_INSTANCE: VkVertexInputRate = 1;
17688pub const VK_VERTEX_INPUT_RATE_VERTEX: VkVertexInputRate = 0;
17689pub const VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR: VkVideoCapabilityFlagBitsKHR = 1 << 0;
17690pub const VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR: VkVideoCapabilityFlagBitsKHR = 1 << 1;
17691pub const VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 1;
17692pub const VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 2;
17693pub const VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 3;
17694pub const VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 0;
17695pub const VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR: VkVideoChromaSubsamplingFlagBitsKHR = 1 << 0;
17696pub const VK_VIDEO_CODEC_OPERATION_DECODE_AV1_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 2;
17697pub const VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 0;
17698pub const VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 1;
17699pub const VK_VIDEO_CODEC_OPERATION_DECODE_VP9_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 3;
17700pub const VK_VIDEO_CODEC_OPERATION_ENCODE_AV1_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 18;
17701pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H264_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 16;
17702pub const VK_VIDEO_CODEC_OPERATION_ENCODE_H265_BIT_KHR: VkVideoCodecOperationFlagBitsKHR = 1 << 17;
17703pub const VK_VIDEO_CODEC_OPERATION_NONE_KHR: VkVideoCodecOperationFlagBitsKHR = 0;
17704pub const VK_VIDEO_CODING_CONTROL_ENCODE_QUALITY_LEVEL_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 2;
17705pub const VK_VIDEO_CODING_CONTROL_ENCODE_RATE_CONTROL_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 1;
17706pub const VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR: VkVideoCodingControlFlagBitsKHR = 1 << 0;
17707pub const VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 2;
17708pub const VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 4;
17709pub const VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR: VkVideoComponentBitDepthFlagBitsKHR = 1 << 0;
17710pub const VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR: VkVideoComponentBitDepthFlagBitsKHR = 0;
17711pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR: VkVideoDecodeCapabilityFlagBitsKHR = 1 << 0;
17712pub const VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR: VkVideoDecodeCapabilityFlagBitsKHR = 1 << 1;
17713pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 1 << 0;
17714pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 1 << 1;
17715pub const VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR: VkVideoDecodeH264PictureLayoutFlagBitsKHR = 0;
17716pub const VK_VIDEO_DECODE_USAGE_DEFAULT_KHR: VkVideoDecodeUsageFlagBitsKHR = 0;
17717pub const VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 1;
17718pub const VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 2;
17719pub const VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR: VkVideoDecodeUsageFlagBitsKHR = 1 << 0;
17720pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_COMPOUND_PREDICTION_INTRA_REFRESH_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 5;
17721pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_FRAME_SIZE_OVERRIDE_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 3;
17722pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_GENERATE_OBU_EXTENSION_HEADER_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 1;
17723pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_MOTION_VECTOR_SCALING_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 4;
17724pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PER_RATE_CONTROL_GROUP_MIN_MAX_Q_INDEX_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 0;
17725pub const VK_VIDEO_ENCODE_AV1_CAPABILITY_PRIMARY_REFERENCE_CDF_ONLY_BIT_KHR: VkVideoEncodeAV1CapabilityFlagBitsKHR = 1 << 2;
17726pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_BIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = 3;
17727pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_INTRA_ONLY_KHR: VkVideoEncodeAV1PredictionModeKHR = 0;
17728pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_SINGLE_REFERENCE_KHR: VkVideoEncodeAV1PredictionModeKHR = 1;
17729pub const VK_VIDEO_ENCODE_AV1_PREDICTION_MODE_UNIDIRECTIONAL_COMPOUND_KHR: VkVideoEncodeAV1PredictionModeKHR = 2;
17730pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_BIPREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = 2;
17731pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_INTRA_KHR: VkVideoEncodeAV1RateControlGroupKHR = 0;
17732pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_GROUP_PREDICTIVE_KHR: VkVideoEncodeAV1RateControlGroupKHR = 1;
17733pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 3;
17734pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 2;
17735pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 0;
17736pub const VK_VIDEO_ENCODE_AV1_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeAV1RateControlFlagBitsKHR = 1 << 1;
17737pub const VK_VIDEO_ENCODE_AV1_STD_DELTA_Q_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 3;
17738pub const VK_VIDEO_ENCODE_AV1_STD_PRIMARY_REF_FRAME_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 2;
17739pub const VK_VIDEO_ENCODE_AV1_STD_SKIP_MODE_PRESENT_UNSET_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 1;
17740pub const VK_VIDEO_ENCODE_AV1_STD_UNIFORM_TILE_SPACING_FLAG_SET_BIT_KHR: VkVideoEncodeAV1StdFlagBitsKHR = 1 << 0;
17741pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_128_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = 1 << 1;
17742pub const VK_VIDEO_ENCODE_AV1_SUPERBLOCK_SIZE_64_BIT_KHR: VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = 1 << 0;
17743pub const VK_VIDEO_ENCODE_CAPABILITY_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 3;
17744pub const VK_VIDEO_ENCODE_CAPABILITY_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_DETECTION_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 1;
17745pub const VK_VIDEO_ENCODE_CAPABILITY_PRECEDING_EXTERNALLY_ENCODED_BYTES_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 0;
17746pub const VK_VIDEO_ENCODE_CAPABILITY_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeCapabilityFlagBitsKHR = 1 << 2;
17747pub const VK_VIDEO_ENCODE_CONTENT_CAMERA_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 0;
17748pub const VK_VIDEO_ENCODE_CONTENT_DEFAULT_KHR: VkVideoEncodeContentFlagBitsKHR = 0;
17749pub const VK_VIDEO_ENCODE_CONTENT_DESKTOP_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 1;
17750pub const VK_VIDEO_ENCODE_CONTENT_RENDERED_BIT_KHR: VkVideoEncodeContentFlagBitsKHR = 1 << 2;
17751pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BUFFER_OFFSET_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 0;
17752pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_BYTES_WRITTEN_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 1;
17753pub const VK_VIDEO_ENCODE_FEEDBACK_BITSTREAM_HAS_OVERRIDES_BIT_KHR: VkVideoEncodeFeedbackFlagBitsKHR = 1 << 2;
17754pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 4;
17755pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 5;
17756pub const VK_VIDEO_ENCODE_H264_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 10;
17757pub const VK_VIDEO_ENCODE_H264_CAPABILITY_DIFFERENT_SLICE_TYPE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 3;
17758pub const VK_VIDEO_ENCODE_H264_CAPABILITY_GENERATE_PREFIX_NALU_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 8;
17759pub const VK_VIDEO_ENCODE_H264_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 0;
17760pub const VK_VIDEO_ENCODE_H264_CAPABILITY_MB_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 9;
17761pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 6;
17762pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PER_SLICE_CONSTANT_QP_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 7;
17763pub const VK_VIDEO_ENCODE_H264_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 1;
17764pub const VK_VIDEO_ENCODE_H264_CAPABILITY_ROW_UNALIGNED_SLICE_BIT_KHR: VkVideoEncodeH264CapabilityFlagBitsKHR = 1 << 2;
17765pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 0;
17766pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 3;
17767pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 2;
17768pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 1;
17769pub const VK_VIDEO_ENCODE_H264_RATE_CONTROL_TEMPORAL_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH264RateControlFlagBitsKHR = 1 << 4;
17770pub const VK_VIDEO_ENCODE_H264_STD_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 3;
17771pub const VK_VIDEO_ENCODE_H264_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 14;
17772pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_DISABLED_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 15;
17773pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_ENABLED_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 16;
17774pub const VK_VIDEO_ENCODE_H264_STD_DEBLOCKING_FILTER_PARTIAL_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 17;
17775pub const VK_VIDEO_ENCODE_H264_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 20;
17776pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_8X8_INFERENCE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 13;
17777pub const VK_VIDEO_ENCODE_H264_STD_DIRECT_SPATIAL_MV_PRED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 10;
17778pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 12;
17779pub const VK_VIDEO_ENCODE_H264_STD_ENTROPY_CODING_MODE_FLAG_UNSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 11;
17780pub const VK_VIDEO_ENCODE_H264_STD_PIC_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 5;
17781pub const VK_VIDEO_ENCODE_H264_STD_QPPRIME_Y_ZERO_TRANSFORM_BYPASS_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 1;
17782pub const VK_VIDEO_ENCODE_H264_STD_SCALING_MATRIX_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 2;
17783pub const VK_VIDEO_ENCODE_H264_STD_SECOND_CHROMA_QP_INDEX_OFFSET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 4;
17784pub const VK_VIDEO_ENCODE_H264_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 0;
17785pub const VK_VIDEO_ENCODE_H264_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 19;
17786pub const VK_VIDEO_ENCODE_H264_STD_TRANSFORM_8X8_MODE_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 9;
17787pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_EXPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 7;
17788pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_BIPRED_IDC_IMPLICIT_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 8;
17789pub const VK_VIDEO_ENCODE_H264_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH264StdFlagBitsKHR = 1 << 6;
17790pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L0_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 4;
17791pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_FRAME_IN_L1_LIST_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 5;
17792pub const VK_VIDEO_ENCODE_H265_CAPABILITY_B_PICTURE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 11;
17793pub const VK_VIDEO_ENCODE_H265_CAPABILITY_CU_QP_DIFF_WRAPAROUND_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 10;
17794pub const VK_VIDEO_ENCODE_H265_CAPABILITY_DIFFERENT_SLICE_SEGMENT_TYPE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 3;
17795pub const VK_VIDEO_ENCODE_H265_CAPABILITY_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 0;
17796pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_SLICE_SEGMENTS_PER_TILE_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 9;
17797pub const VK_VIDEO_ENCODE_H265_CAPABILITY_MULTIPLE_TILES_PER_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 8;
17798pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_PICTURE_TYPE_MIN_MAX_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 6;
17799pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PER_SLICE_SEGMENT_CONSTANT_QP_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 7;
17800pub const VK_VIDEO_ENCODE_H265_CAPABILITY_PREDICTION_WEIGHT_TABLE_GENERATED_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 1;
17801pub const VK_VIDEO_ENCODE_H265_CAPABILITY_ROW_UNALIGNED_SLICE_SEGMENT_BIT_KHR: VkVideoEncodeH265CapabilityFlagBitsKHR = 1 << 2;
17802pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_16_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 0;
17803pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_32_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 1;
17804pub const VK_VIDEO_ENCODE_H265_CTB_SIZE_64_BIT_KHR: VkVideoEncodeH265CtbSizeFlagBitsKHR = 1 << 2;
17805pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_ATTEMPT_HRD_COMPLIANCE_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 0;
17806pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 3;
17807pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REFERENCE_PATTERN_FLAT_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 2;
17808pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_REGULAR_GOP_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 1;
17809pub const VK_VIDEO_ENCODE_H265_RATE_CONTROL_TEMPORAL_SUB_LAYER_PATTERN_DYADIC_BIT_KHR: VkVideoEncodeH265RateControlFlagBitsKHR = 1 << 4;
17810pub const VK_VIDEO_ENCODE_H265_STD_CONSTRAINED_INTRA_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 14;
17811pub const VK_VIDEO_ENCODE_H265_STD_DEBLOCKING_FILTER_OVERRIDE_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 16;
17812pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENTS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 17;
17813pub const VK_VIDEO_ENCODE_H265_STD_DEPENDENT_SLICE_SEGMENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 18;
17814pub const VK_VIDEO_ENCODE_H265_STD_DIFFERENT_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 20;
17815pub const VK_VIDEO_ENCODE_H265_STD_ENTROPY_CODING_SYNC_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 15;
17816pub const VK_VIDEO_ENCODE_H265_STD_INIT_QP_MINUS26_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 5;
17817pub const VK_VIDEO_ENCODE_H265_STD_LOG2_PARALLEL_MERGE_LEVEL_MINUS2_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 8;
17818pub const VK_VIDEO_ENCODE_H265_STD_PCM_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 3;
17819pub const VK_VIDEO_ENCODE_H265_STD_PPS_SLICE_CHROMA_QP_OFFSETS_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 12;
17820pub const VK_VIDEO_ENCODE_H265_STD_SAMPLE_ADAPTIVE_OFFSET_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 1;
17821pub const VK_VIDEO_ENCODE_H265_STD_SCALING_LIST_DATA_PRESENT_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 2;
17822pub const VK_VIDEO_ENCODE_H265_STD_SEPARATE_COLOR_PLANE_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 0;
17823pub const VK_VIDEO_ENCODE_H265_STD_SIGN_DATA_HIDING_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 9;
17824pub const VK_VIDEO_ENCODE_H265_STD_SLICE_QP_DELTA_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 19;
17825pub const VK_VIDEO_ENCODE_H265_STD_SPS_TEMPORAL_MVP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 4;
17826pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 10;
17827pub const VK_VIDEO_ENCODE_H265_STD_TRANSFORM_SKIP_ENABLED_FLAG_UNSET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 11;
17828pub const VK_VIDEO_ENCODE_H265_STD_TRANSQUANT_BYPASS_ENABLED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 13;
17829pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_BIPRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 7;
17830pub const VK_VIDEO_ENCODE_H265_STD_WEIGHTED_PRED_FLAG_SET_BIT_KHR: VkVideoEncodeH265StdFlagBitsKHR = 1 << 6;
17831pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_16_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 2;
17832pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_32_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 3;
17833pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_4_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 0;
17834pub const VK_VIDEO_ENCODE_H265_TRANSFORM_BLOCK_SIZE_8_BIT_KHR: VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = 1 << 1;
17835pub const VK_VIDEO_ENCODE_INTRA_REFRESH_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 2;
17836pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 1;
17837pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_COLUMN_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 3;
17838pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_BLOCK_ROW_BASED_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 2;
17839pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_NONE_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 0;
17840pub const VK_VIDEO_ENCODE_INTRA_REFRESH_MODE_PER_PICTURE_PARTITION_BIT_KHR: VkVideoEncodeIntraRefreshModeFlagBitsKHR = 1 << 0;
17841pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_CBR_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 1;
17842pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DEFAULT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 0;
17843pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_DISABLED_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 0;
17844pub const VK_VIDEO_ENCODE_RATE_CONTROL_MODE_VBR_BIT_KHR: VkVideoEncodeRateControlModeFlagBitsKHR = 1 << 2;
17845pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_COSITED_EVEN_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = 1 << 0;
17846pub const VK_VIDEO_ENCODE_RGB_CHROMA_OFFSET_MIDPOINT_BIT_VALVE: VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = 1 << 1;
17847pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_RGB_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 0;
17848pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_2020_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 4;
17849pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_601_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 3;
17850pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_709_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 2;
17851pub const VK_VIDEO_ENCODE_RGB_MODEL_CONVERSION_YCBCR_IDENTITY_BIT_VALVE: VkVideoEncodeRgbModelConversionFlagBitsVALVE = 1 << 1;
17852pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_FULL_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = 1 << 0;
17853pub const VK_VIDEO_ENCODE_RGB_RANGE_COMPRESSION_NARROW_RANGE_BIT_VALVE: VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = 1 << 1;
17854pub const VK_VIDEO_ENCODE_TUNING_MODE_DEFAULT_KHR: VkVideoEncodeTuningModeKHR = 0;
17855pub const VK_VIDEO_ENCODE_TUNING_MODE_HIGH_QUALITY_KHR: VkVideoEncodeTuningModeKHR = 1;
17856pub const VK_VIDEO_ENCODE_TUNING_MODE_LOSSLESS_KHR: VkVideoEncodeTuningModeKHR = 4;
17857pub const VK_VIDEO_ENCODE_TUNING_MODE_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = 2;
17858pub const VK_VIDEO_ENCODE_TUNING_MODE_ULTRA_LOW_LATENCY_KHR: VkVideoEncodeTuningModeKHR = 3;
17859pub const VK_VIDEO_ENCODE_USAGE_CONFERENCING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 3;
17860pub const VK_VIDEO_ENCODE_USAGE_DEFAULT_KHR: VkVideoEncodeUsageFlagBitsKHR = 0;
17861pub const VK_VIDEO_ENCODE_USAGE_RECORDING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 2;
17862pub const VK_VIDEO_ENCODE_USAGE_STREAMING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 1;
17863pub const VK_VIDEO_ENCODE_USAGE_TRANSCODING_BIT_KHR: VkVideoEncodeUsageFlagBitsKHR = 1 << 0;
17864pub const VK_VIDEO_ENCODE_WITH_EMPHASIS_MAP_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 1;
17865pub const VK_VIDEO_ENCODE_WITH_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoEncodeFlagBitsKHR = 1 << 0;
17866pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_EMPHASIS_MAP_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 4;
17867pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_PARAMETER_OPTIMIZATIONS_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 1;
17868pub const VK_VIDEO_SESSION_CREATE_ALLOW_ENCODE_QUANTIZATION_DELTA_MAP_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 3;
17869pub const VK_VIDEO_SESSION_CREATE_INLINE_QUERIES_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 2;
17870pub const VK_VIDEO_SESSION_CREATE_INLINE_SESSION_PARAMETERS_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 5;
17871pub const VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR: VkVideoSessionCreateFlagBitsKHR = 1 << 0;
17872pub const VK_VIDEO_SESSION_PARAMETERS_CREATE_QUANTIZATION_MAP_COMPATIBLE_BIT_KHR: VkVideoSessionParametersCreateFlagBitsKHR = 1 << 0;
17873pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV: VkViewportCoordinateSwizzleNV = 7;
17874pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV: VkViewportCoordinateSwizzleNV = 1;
17875pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV: VkViewportCoordinateSwizzleNV = 3;
17876pub const VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV: VkViewportCoordinateSwizzleNV = 5;
17877pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV: VkViewportCoordinateSwizzleNV = 6;
17878pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV: VkViewportCoordinateSwizzleNV = 0;
17879pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV: VkViewportCoordinateSwizzleNV = 2;
17880pub const VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV: VkViewportCoordinateSwizzleNV = 4;
17881pub const VK_WHOLE_SIZE: u64 = !0;
17882
17883pub const fn VK_API_VERSION_MAJOR(version: u32) -> u32 {
17884    (version >> 22) & 0x7F
17885}
17886
17887pub const fn VK_API_VERSION_MINOR(version: u32) -> u32 {
17888    (version >> 12) & 0x3FF
17889}
17890
17891pub const fn VK_API_VERSION_PATCH(version: u32) -> u32 {
17892    version & 0xFFF
17893}
17894
17895pub const fn VK_API_VERSION_VARIANT(version: u32) -> u32 {
17896    version >> 29
17897}
17898
17899pub const fn VK_MAKE_API_VERSION(variant: u32, major: u32, minor: u32, patch: u32) -> u32 {
17900    (variant << 29) | (major << 22) | (minor << 12) | patch
17901}
17902
17903pub const fn VK_MAKE_VERSION(major: u32, minor: u32, patch: u32) -> u32 {
17904    (major << 22) | (minor << 12) | patch
17905}
17906
17907pub const fn VK_VERSION_MAJOR(version: u32) -> u32 {
17908    version >> 22
17909}
17910
17911pub const fn VK_VERSION_MINOR(version: u32) -> u32 {
17912    (version >> 12) & 0x3FF
17913}
17914
17915pub const fn VK_VERSION_PATCH(version: u32) -> u32 {
17916    version & 0xFFF
17917}
17918
17919unsafe extern "system" {
17920    /// Available if built with `prototypes`.
17921    #[cfg(any(doc, feature = "prototypes"))]
17922    pub fn vkAcquireDrmDisplayEXT(physicalDevice: VkPhysicalDevice, drmFd: i32, display: VkDisplayKHR) -> VkResult;
17923
17924    /// Available if built with `prototypes`.
17925    #[cfg(any(doc, feature = "prototypes"))]
17926    pub fn vkAcquireNextImage2KHR(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut u32) -> VkResult;
17927
17928    /// Available if built with `prototypes`.
17929    #[cfg(any(doc, feature = "prototypes"))]
17930    pub fn vkAcquireNextImageKHR(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult;
17931
17932    /// Available if built with `prototypes`.
17933    #[cfg(any(doc, feature = "prototypes"))]
17934    pub fn vkAcquirePerformanceConfigurationINTEL(device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult;
17935
17936    /// Available if built with `prototypes`.
17937    #[cfg(any(doc, feature = "prototypes"))]
17938    pub fn vkAcquireProfilingLockKHR(device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult;
17939
17940    /// Available if built with `exported-prototypes`.
17941    #[cfg(any(doc, feature = "exported-prototypes"))]
17942    pub fn vkAllocateCommandBuffers(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;
17943
17944    /// Available if built with `exported-prototypes`.
17945    #[cfg(any(doc, feature = "exported-prototypes"))]
17946    pub fn vkAllocateDescriptorSets(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;
17947
17948    /// Available if built with `exported-prototypes`.
17949    #[cfg(any(doc, feature = "exported-prototypes"))]
17950    pub fn vkAllocateMemory(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;
17951
17952    /// Available if built with `prototypes`.
17953    #[cfg(any(doc, feature = "prototypes"))]
17954    pub fn vkAntiLagUpdateAMD(device: VkDevice, pData: *const VkAntiLagDataAMD);
17955
17956    /// Available if built with `exported-prototypes`.
17957    #[cfg(any(doc, feature = "exported-prototypes"))]
17958    pub fn vkBeginCommandBuffer(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;
17959
17960    /// Available if built with `prototypes`.
17961    #[cfg(any(doc, feature = "prototypes"))]
17962    pub fn vkBindAccelerationStructureMemoryNV(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult;
17963
17964    /// Available if built with `exported-prototypes`.
17965    #[cfg(any(doc, feature = "exported-prototypes"))]
17966    pub fn vkBindBufferMemory(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
17967
17968    /// Available if built with `exported-prototypes`.
17969    #[cfg(any(doc, feature = "exported-prototypes"))]
17970    pub fn vkBindBufferMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
17971
17972    /// Available if built with `prototypes`.
17973    #[cfg(any(doc, feature = "prototypes"))]
17974    pub fn vkBindBufferMemory2KHR(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
17975
17976    /// Available if built with `prototypes`.
17977    #[cfg(any(doc, feature = "prototypes"))]
17978    pub fn vkBindDataGraphPipelineSessionMemoryARM(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult;
17979
17980    /// Available if built with `exported-prototypes`.
17981    #[cfg(any(doc, feature = "exported-prototypes"))]
17982    pub fn vkBindImageMemory(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
17983
17984    /// Available if built with `exported-prototypes`.
17985    #[cfg(any(doc, feature = "exported-prototypes"))]
17986    pub fn vkBindImageMemory2(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
17987
17988    /// Available if built with `prototypes`.
17989    #[cfg(any(doc, feature = "prototypes"))]
17990    pub fn vkBindImageMemory2KHR(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
17991
17992    /// Available if built with `prototypes`.
17993    #[cfg(any(doc, feature = "prototypes"))]
17994    pub fn vkBindOpticalFlowSessionImageNV(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult;
17995
17996    /// Available if built with `prototypes`.
17997    #[cfg(any(doc, feature = "prototypes"))]
17998    pub fn vkBindTensorMemoryARM(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult;
17999
18000    /// Available if built with `prototypes`.
18001    #[cfg(any(doc, feature = "prototypes"))]
18002    pub fn vkBindVideoSessionMemoryKHR(device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: u32, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult;
18003
18004    /// Available if built with `prototypes`.
18005    #[cfg(any(doc, feature = "prototypes"))]
18006    pub fn vkBuildAccelerationStructuresKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult;
18007
18008    /// Available if built with `prototypes`.
18009    #[cfg(any(doc, feature = "prototypes"))]
18010    pub fn vkBuildMicromapsEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult;
18011
18012    /// Available if built with `prototypes`.
18013    #[cfg(any(doc, feature = "prototypes"))]
18014    pub fn vkCmdBeginConditionalRenderingEXT(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT);
18015
18016    /// Available if built with `prototypes`.
18017    #[cfg(any(doc, feature = "prototypes"))]
18018    pub fn vkCmdBeginCustomResolveEXT(commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT);
18019
18020    /// Available if built with `prototypes`.
18021    #[cfg(any(doc, feature = "prototypes"))]
18022    pub fn vkCmdBeginDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
18023
18024    /// Available if built with `prototypes`.
18025    #[cfg(any(doc, feature = "prototypes"))]
18026    pub fn vkCmdBeginPerTileExecutionQCOM(commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM);
18027
18028    /// Available if built with `exported-prototypes`.
18029    #[cfg(any(doc, feature = "exported-prototypes"))]
18030    pub fn vkCmdBeginQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags);
18031
18032    /// Available if built with `prototypes`.
18033    #[cfg(any(doc, feature = "prototypes"))]
18034    pub fn vkCmdBeginQueryIndexedEXT(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags, index: u32);
18035
18036    /// Available if built with `exported-prototypes`.
18037    #[cfg(any(doc, feature = "exported-prototypes"))]
18038    pub fn vkCmdBeginRenderPass(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents);
18039
18040    /// Available if built with `exported-prototypes`.
18041    #[cfg(any(doc, feature = "exported-prototypes"))]
18042    pub fn vkCmdBeginRenderPass2(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
18043
18044    /// Available if built with `prototypes`.
18045    #[cfg(any(doc, feature = "prototypes"))]
18046    pub fn vkCmdBeginRenderPass2KHR(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
18047
18048    /// Available if built with `exported-prototypes`.
18049    #[cfg(any(doc, feature = "exported-prototypes"))]
18050    pub fn vkCmdBeginRendering(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
18051
18052    /// Available if built with `prototypes`.
18053    #[cfg(any(doc, feature = "prototypes"))]
18054    pub fn vkCmdBeginRenderingKHR(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
18055
18056    /// Available if built with `prototypes`.
18057    #[cfg(any(doc, feature = "prototypes"))]
18058    pub fn vkCmdBeginTransformFeedbackEXT(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
18059
18060    /// Available if built with `prototypes`.
18061    #[cfg(any(doc, feature = "prototypes"))]
18062    pub fn vkCmdBeginVideoCodingKHR(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR);
18063
18064    /// Available if built with `prototypes`.
18065    #[cfg(any(doc, feature = "prototypes"))]
18066    pub fn vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
18067
18068    /// Available if built with `prototypes`.
18069    #[cfg(any(doc, feature = "prototypes"))]
18070    pub fn vkCmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32);
18071
18072    /// Available if built with `prototypes`.
18073    #[cfg(any(doc, feature = "prototypes"))]
18074    pub fn vkCmdBindDescriptorBuffersEXT(commandBuffer: VkCommandBuffer, bufferCount: u32, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT);
18075
18076    /// Available if built with `exported-prototypes`.
18077    #[cfg(any(doc, feature = "exported-prototypes"))]
18078    pub fn vkCmdBindDescriptorSets(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet, dynamicOffsetCount: u32, pDynamicOffsets: *const u32);
18079
18080    /// Available if built with `exported-prototypes`.
18081    #[cfg(any(doc, feature = "exported-prototypes"))]
18082    pub fn vkCmdBindDescriptorSets2(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
18083
18084    /// Available if built with `prototypes`.
18085    #[cfg(any(doc, feature = "prototypes"))]
18086    pub fn vkCmdBindDescriptorSets2KHR(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
18087
18088    /// Available if built with `exported-prototypes`.
18089    #[cfg(any(doc, feature = "exported-prototypes"))]
18090    pub fn vkCmdBindIndexBuffer(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType);
18091
18092    /// Available if built with `exported-prototypes`.
18093    #[cfg(any(doc, feature = "exported-prototypes"))]
18094    pub fn vkCmdBindIndexBuffer2(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
18095
18096    /// Available if built with `prototypes`.
18097    #[cfg(any(doc, feature = "prototypes"))]
18098    pub fn vkCmdBindIndexBuffer2KHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
18099
18100    /// Available if built with `prototypes`.
18101    #[cfg(any(doc, feature = "prototypes"))]
18102    pub fn vkCmdBindInvocationMaskHUAWEI(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
18103
18104    /// Available if built with `exported-prototypes`.
18105    #[cfg(any(doc, feature = "exported-prototypes"))]
18106    pub fn vkCmdBindPipeline(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
18107
18108    /// Available if built with `prototypes`.
18109    #[cfg(any(doc, feature = "prototypes"))]
18110    pub fn vkCmdBindPipelineShaderGroupNV(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: u32);
18111
18112    /// Available if built with `prototypes`.
18113    #[cfg(any(doc, feature = "prototypes"))]
18114    pub fn vkCmdBindResourceHeapEXT(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
18115
18116    /// Available if built with `prototypes`.
18117    #[cfg(any(doc, feature = "prototypes"))]
18118    pub fn vkCmdBindSamplerHeapEXT(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
18119
18120    /// Available if built with `prototypes`.
18121    #[cfg(any(doc, feature = "prototypes"))]
18122    pub fn vkCmdBindShadersEXT(commandBuffer: VkCommandBuffer, stageCount: u32, pStages: *const VkShaderStageFlagBits, pShaders: *const VkShaderEXT);
18123
18124    /// Available if built with `prototypes`.
18125    #[cfg(any(doc, feature = "prototypes"))]
18126    pub fn vkCmdBindShadingRateImageNV(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
18127
18128    /// Available if built with `prototypes`.
18129    #[cfg(any(doc, feature = "prototypes"))]
18130    pub fn vkCmdBindTileMemoryQCOM(commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM);
18131
18132    /// Available if built with `prototypes`.
18133    #[cfg(any(doc, feature = "prototypes"))]
18134    pub fn vkCmdBindTransformFeedbackBuffersEXT(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize);
18135
18136    /// Available if built with `exported-prototypes`.
18137    #[cfg(any(doc, feature = "exported-prototypes"))]
18138    pub fn vkCmdBindVertexBuffers(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize);
18139
18140    /// Available if built with `exported-prototypes`.
18141    #[cfg(any(doc, feature = "exported-prototypes"))]
18142    pub fn vkCmdBindVertexBuffers2(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
18143
18144    /// Available if built with `prototypes`.
18145    #[cfg(any(doc, feature = "prototypes"))]
18146    pub fn vkCmdBindVertexBuffers2EXT(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize, pStrides: *const VkDeviceSize);
18147
18148    /// Available if built with `exported-prototypes`.
18149    #[cfg(any(doc, feature = "exported-prototypes"))]
18150    pub fn vkCmdBlitImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filter: VkFilter);
18151
18152    /// Available if built with `exported-prototypes`.
18153    #[cfg(any(doc, feature = "exported-prototypes"))]
18154    pub fn vkCmdBlitImage2(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
18155
18156    /// Available if built with `prototypes`.
18157    #[cfg(any(doc, feature = "prototypes"))]
18158    pub fn vkCmdBlitImage2KHR(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
18159
18160    /// Available if built with `prototypes`.
18161    #[cfg(any(doc, feature = "prototypes"))]
18162    pub fn vkCmdBuildAccelerationStructureNV(commandBuffer: VkCommandBuffer, pInfo: *const VkAccelerationStructureInfoNV, instanceData: VkBuffer, instanceOffset: VkDeviceSize, update: VkBool32, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, scratch: VkBuffer, scratchOffset: VkDeviceSize);
18163
18164    /// Available if built with `prototypes`.
18165    #[cfg(any(doc, feature = "prototypes"))]
18166    pub fn vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const u32, ppMaxPrimitiveCounts: *const *const u32);
18167
18168    /// Available if built with `prototypes`.
18169    #[cfg(any(doc, feature = "prototypes"))]
18170    pub fn vkCmdBuildAccelerationStructuresKHR(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR);
18171
18172    /// Available if built with `prototypes`.
18173    #[cfg(any(doc, feature = "prototypes"))]
18174    pub fn vkCmdBuildClusterAccelerationStructureIndirectNV(commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV);
18175
18176    /// Available if built with `prototypes`.
18177    #[cfg(any(doc, feature = "prototypes"))]
18178    pub fn vkCmdBuildMicromapsEXT(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT);
18179
18180    /// Available if built with `prototypes`.
18181    #[cfg(any(doc, feature = "prototypes"))]
18182    pub fn vkCmdBuildPartitionedAccelerationStructuresNV(commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV);
18183
18184    /// Available if built with `exported-prototypes`.
18185    #[cfg(any(doc, feature = "exported-prototypes"))]
18186    pub fn vkCmdClearAttachments(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect);
18187
18188    /// Available if built with `exported-prototypes`.
18189    #[cfg(any(doc, feature = "exported-prototypes"))]
18190    pub fn vkCmdClearColorImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
18191
18192    /// Available if built with `exported-prototypes`.
18193    #[cfg(any(doc, feature = "exported-prototypes"))]
18194    pub fn vkCmdClearDepthStencilImage(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
18195
18196    /// Available if built with `prototypes`.
18197    #[cfg(any(doc, feature = "prototypes"))]
18198    pub fn vkCmdControlVideoCodingKHR(commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR);
18199
18200    /// Available if built with `prototypes`.
18201    #[cfg(any(doc, feature = "prototypes"))]
18202    pub fn vkCmdConvertCooperativeVectorMatrixNV(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV);
18203
18204    /// Available if built with `prototypes`.
18205    #[cfg(any(doc, feature = "prototypes"))]
18206    pub fn vkCmdCopyAccelerationStructureKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR);
18207
18208    /// Available if built with `prototypes`.
18209    #[cfg(any(doc, feature = "prototypes"))]
18210    pub fn vkCmdCopyAccelerationStructureNV(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR);
18211
18212    /// Available if built with `prototypes`.
18213    #[cfg(any(doc, feature = "prototypes"))]
18214    pub fn vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR);
18215
18216    /// Available if built with `exported-prototypes`.
18217    #[cfg(any(doc, feature = "exported-prototypes"))]
18218    pub fn vkCmdCopyBuffer(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy);
18219
18220    /// Available if built with `exported-prototypes`.
18221    #[cfg(any(doc, feature = "exported-prototypes"))]
18222    pub fn vkCmdCopyBuffer2(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
18223
18224    /// Available if built with `prototypes`.
18225    #[cfg(any(doc, feature = "prototypes"))]
18226    pub fn vkCmdCopyBuffer2KHR(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
18227
18228    /// Available if built with `exported-prototypes`.
18229    #[cfg(any(doc, feature = "exported-prototypes"))]
18230    pub fn vkCmdCopyBufferToImage(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy);
18231
18232    /// Available if built with `exported-prototypes`.
18233    #[cfg(any(doc, feature = "exported-prototypes"))]
18234    pub fn vkCmdCopyBufferToImage2(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
18235
18236    /// Available if built with `prototypes`.
18237    #[cfg(any(doc, feature = "prototypes"))]
18238    pub fn vkCmdCopyBufferToImage2KHR(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
18239
18240    /// Available if built with `exported-prototypes`.
18241    #[cfg(any(doc, feature = "exported-prototypes"))]
18242    pub fn vkCmdCopyImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy);
18243
18244    /// Available if built with `exported-prototypes`.
18245    #[cfg(any(doc, feature = "exported-prototypes"))]
18246    pub fn vkCmdCopyImage2(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
18247
18248    /// Available if built with `prototypes`.
18249    #[cfg(any(doc, feature = "prototypes"))]
18250    pub fn vkCmdCopyImage2KHR(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
18251
18252    /// Available if built with `exported-prototypes`.
18253    #[cfg(any(doc, feature = "exported-prototypes"))]
18254    pub fn vkCmdCopyImageToBuffer(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy);
18255
18256    /// Available if built with `exported-prototypes`.
18257    #[cfg(any(doc, feature = "exported-prototypes"))]
18258    pub fn vkCmdCopyImageToBuffer2(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
18259
18260    /// Available if built with `prototypes`.
18261    #[cfg(any(doc, feature = "prototypes"))]
18262    pub fn vkCmdCopyImageToBuffer2KHR(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
18263
18264    /// Available if built with `prototypes`.
18265    #[cfg(any(doc, feature = "prototypes"))]
18266    pub fn vkCmdCopyMemoryIndirectKHR(commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR);
18267
18268    /// Available if built with `prototypes`.
18269    #[cfg(any(doc, feature = "prototypes"))]
18270    pub fn vkCmdCopyMemoryIndirectNV(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32);
18271
18272    /// Available if built with `prototypes`.
18273    #[cfg(any(doc, feature = "prototypes"))]
18274    pub fn vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR);
18275
18276    /// Available if built with `prototypes`.
18277    #[cfg(any(doc, feature = "prototypes"))]
18278    pub fn vkCmdCopyMemoryToImageIndirectKHR(commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR);
18279
18280    /// Available if built with `prototypes`.
18281    #[cfg(any(doc, feature = "prototypes"))]
18282    pub fn vkCmdCopyMemoryToImageIndirectNV(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers);
18283
18284    /// Available if built with `prototypes`.
18285    #[cfg(any(doc, feature = "prototypes"))]
18286    pub fn vkCmdCopyMemoryToMicromapEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT);
18287
18288    /// Available if built with `prototypes`.
18289    #[cfg(any(doc, feature = "prototypes"))]
18290    pub fn vkCmdCopyMicromapEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT);
18291
18292    /// Available if built with `prototypes`.
18293    #[cfg(any(doc, feature = "prototypes"))]
18294    pub fn vkCmdCopyMicromapToMemoryEXT(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT);
18295
18296    /// Available if built with `exported-prototypes`.
18297    #[cfg(any(doc, feature = "exported-prototypes"))]
18298    pub fn vkCmdCopyQueryPoolResults(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags);
18299
18300    /// Available if built with `prototypes`.
18301    #[cfg(any(doc, feature = "prototypes"))]
18302    pub fn vkCmdCopyTensorARM(commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM);
18303
18304    /// Available if built with `prototypes`.
18305    #[cfg(any(doc, feature = "prototypes"))]
18306    pub fn vkCmdCuLaunchKernelNVX(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX);
18307
18308    /// Available if built with `prototypes`.
18309    #[cfg(any(doc, feature = "prototypes"))]
18310    pub fn vkCmdDebugMarkerBeginEXT(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
18311
18312    /// Available if built with `prototypes`.
18313    #[cfg(any(doc, feature = "prototypes"))]
18314    pub fn vkCmdDebugMarkerEndEXT(commandBuffer: VkCommandBuffer);
18315
18316    /// Available if built with `prototypes`.
18317    #[cfg(any(doc, feature = "prototypes"))]
18318    pub fn vkCmdDebugMarkerInsertEXT(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
18319
18320    /// Available if built with `prototypes`.
18321    #[cfg(any(doc, feature = "prototypes"))]
18322    pub fn vkCmdDecodeVideoKHR(commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR);
18323
18324    /// Available if built with `prototypes`.
18325    #[cfg(any(doc, feature = "prototypes"))]
18326    pub fn vkCmdDecompressMemoryEXT(commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT);
18327
18328    /// Available if built with `prototypes`.
18329    #[cfg(any(doc, feature = "prototypes"))]
18330    pub fn vkCmdDecompressMemoryIndirectCountEXT(commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: u32, stride: u32);
18331
18332    /// Available if built with `prototypes`.
18333    #[cfg(any(doc, feature = "prototypes"))]
18334    pub fn vkCmdDecompressMemoryIndirectCountNV(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: u32);
18335
18336    /// Available if built with `prototypes`.
18337    #[cfg(any(doc, feature = "prototypes"))]
18338    pub fn vkCmdDecompressMemoryNV(commandBuffer: VkCommandBuffer, decompressRegionCount: u32, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV);
18339
18340    /// Available if built with `exported-prototypes`.
18341    #[cfg(any(doc, feature = "exported-prototypes"))]
18342    pub fn vkCmdDispatch(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18343
18344    /// Available if built with `exported-prototypes`.
18345    #[cfg(any(doc, feature = "exported-prototypes"))]
18346    pub fn vkCmdDispatchBase(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18347
18348    /// Available if built with `prototypes`.
18349    #[cfg(any(doc, feature = "prototypes"))]
18350    pub fn vkCmdDispatchBaseKHR(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18351
18352    /// Available if built with `prototypes`.
18353    #[cfg(any(doc, feature = "prototypes"))]
18354    pub fn vkCmdDispatchDataGraphARM(commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM);
18355
18356    /// Available if built with `exported-prototypes`.
18357    #[cfg(any(doc, feature = "exported-prototypes"))]
18358    pub fn vkCmdDispatchIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
18359
18360    /// Available if built with `prototypes`.
18361    #[cfg(any(doc, feature = "prototypes"))]
18362    pub fn vkCmdDispatchTileQCOM(commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM);
18363
18364    /// Available if built with `exported-prototypes`.
18365    #[cfg(any(doc, feature = "exported-prototypes"))]
18366    pub fn vkCmdDraw(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
18367
18368    /// Available if built with `prototypes`.
18369    #[cfg(any(doc, feature = "prototypes"))]
18370    pub fn vkCmdDrawClusterHUAWEI(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18371
18372    /// Available if built with `prototypes`.
18373    #[cfg(any(doc, feature = "prototypes"))]
18374    pub fn vkCmdDrawClusterIndirectHUAWEI(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
18375
18376    /// Available if built with `exported-prototypes`.
18377    #[cfg(any(doc, feature = "exported-prototypes"))]
18378    pub fn vkCmdDrawIndexed(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
18379
18380    /// Available if built with `exported-prototypes`.
18381    #[cfg(any(doc, feature = "exported-prototypes"))]
18382    pub fn vkCmdDrawIndexedIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18383
18384    /// Available if built with `exported-prototypes`.
18385    #[cfg(any(doc, feature = "exported-prototypes"))]
18386    pub fn vkCmdDrawIndexedIndirectCount(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18387
18388    /// Available if built with `prototypes`.
18389    #[cfg(any(doc, feature = "prototypes"))]
18390    pub fn vkCmdDrawIndexedIndirectCountAMD(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18391
18392    /// Available if built with `prototypes`.
18393    #[cfg(any(doc, feature = "prototypes"))]
18394    pub fn vkCmdDrawIndexedIndirectCountKHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18395
18396    /// Available if built with `exported-prototypes`.
18397    #[cfg(any(doc, feature = "exported-prototypes"))]
18398    pub fn vkCmdDrawIndirect(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18399
18400    /// Available if built with `prototypes`.
18401    #[cfg(any(doc, feature = "prototypes"))]
18402    pub fn vkCmdDrawIndirectByteCountEXT(commandBuffer: VkCommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: u32, vertexStride: u32);
18403
18404    /// Available if built with `exported-prototypes`.
18405    #[cfg(any(doc, feature = "exported-prototypes"))]
18406    pub fn vkCmdDrawIndirectCount(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18407
18408    /// Available if built with `prototypes`.
18409    #[cfg(any(doc, feature = "prototypes"))]
18410    pub fn vkCmdDrawIndirectCountAMD(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18411
18412    /// Available if built with `prototypes`.
18413    #[cfg(any(doc, feature = "prototypes"))]
18414    pub fn vkCmdDrawIndirectCountKHR(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18415
18416    /// Available if built with `prototypes`.
18417    #[cfg(any(doc, feature = "prototypes"))]
18418    pub fn vkCmdDrawMeshTasksEXT(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
18419
18420    /// Available if built with `prototypes`.
18421    #[cfg(any(doc, feature = "prototypes"))]
18422    pub fn vkCmdDrawMeshTasksIndirectCountEXT(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18423
18424    /// Available if built with `prototypes`.
18425    #[cfg(any(doc, feature = "prototypes"))]
18426    pub fn vkCmdDrawMeshTasksIndirectCountNV(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
18427
18428    /// Available if built with `prototypes`.
18429    #[cfg(any(doc, feature = "prototypes"))]
18430    pub fn vkCmdDrawMeshTasksIndirectEXT(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18431
18432    /// Available if built with `prototypes`.
18433    #[cfg(any(doc, feature = "prototypes"))]
18434    pub fn vkCmdDrawMeshTasksIndirectNV(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
18435
18436    /// Available if built with `prototypes`.
18437    #[cfg(any(doc, feature = "prototypes"))]
18438    pub fn vkCmdDrawMeshTasksNV(commandBuffer: VkCommandBuffer, taskCount: u32, firstTask: u32);
18439
18440    /// Available if built with `prototypes`.
18441    #[cfg(any(doc, feature = "prototypes"))]
18442    pub fn vkCmdDrawMultiEXT(commandBuffer: VkCommandBuffer, drawCount: u32, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);
18443
18444    /// Available if built with `prototypes`.
18445    #[cfg(any(doc, feature = "prototypes"))]
18446    pub fn vkCmdDrawMultiIndexedEXT(commandBuffer: VkCommandBuffer, drawCount: u32, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: *const i32);
18447
18448    /// Available if built with `prototypes`.
18449    #[cfg(any(doc, feature = "prototypes"))]
18450    pub fn vkCmdEncodeVideoKHR(commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR);
18451
18452    /// Available if built with `prototypes`.
18453    #[cfg(any(doc, feature = "prototypes"))]
18454    pub fn vkCmdEndConditionalRenderingEXT(commandBuffer: VkCommandBuffer);
18455
18456    /// Available if built with `prototypes`.
18457    #[cfg(any(doc, feature = "prototypes"))]
18458    pub fn vkCmdEndDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer);
18459
18460    /// Available if built with `prototypes`.
18461    #[cfg(any(doc, feature = "prototypes"))]
18462    pub fn vkCmdEndPerTileExecutionQCOM(commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM);
18463
18464    /// Available if built with `exported-prototypes`.
18465    #[cfg(any(doc, feature = "exported-prototypes"))]
18466    pub fn vkCmdEndQuery(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32);
18467
18468    /// Available if built with `prototypes`.
18469    #[cfg(any(doc, feature = "prototypes"))]
18470    pub fn vkCmdEndQueryIndexedEXT(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, index: u32);
18471
18472    /// Available if built with `exported-prototypes`.
18473    #[cfg(any(doc, feature = "exported-prototypes"))]
18474    pub fn vkCmdEndRenderPass(commandBuffer: VkCommandBuffer);
18475
18476    /// Available if built with `exported-prototypes`.
18477    #[cfg(any(doc, feature = "exported-prototypes"))]
18478    pub fn vkCmdEndRenderPass2(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
18479
18480    /// Available if built with `prototypes`.
18481    #[cfg(any(doc, feature = "prototypes"))]
18482    pub fn vkCmdEndRenderPass2KHR(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
18483
18484    /// Available if built with `exported-prototypes`.
18485    #[cfg(any(doc, feature = "exported-prototypes"))]
18486    pub fn vkCmdEndRendering(commandBuffer: VkCommandBuffer);
18487
18488    /// Available if built with `prototypes`.
18489    #[cfg(any(doc, feature = "prototypes"))]
18490    pub fn vkCmdEndRendering2EXT(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
18491
18492    /// Available if built with `prototypes`.
18493    #[cfg(any(doc, feature = "prototypes"))]
18494    pub fn vkCmdEndRendering2KHR(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
18495
18496    /// Available if built with `prototypes`.
18497    #[cfg(any(doc, feature = "prototypes"))]
18498    pub fn vkCmdEndRenderingKHR(commandBuffer: VkCommandBuffer);
18499
18500    /// Available if built with `prototypes`.
18501    #[cfg(any(doc, feature = "prototypes"))]
18502    pub fn vkCmdEndTransformFeedbackEXT(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
18503
18504    /// Available if built with `prototypes`.
18505    #[cfg(any(doc, feature = "prototypes"))]
18506    pub fn vkCmdEndVideoCodingKHR(commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR);
18507
18508    /// Available if built with `exported-prototypes`.
18509    #[cfg(any(doc, feature = "exported-prototypes"))]
18510    pub fn vkCmdExecuteCommands(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
18511
18512    /// Available if built with `prototypes`.
18513    #[cfg(any(doc, feature = "prototypes"))]
18514    pub fn vkCmdExecuteGeneratedCommandsEXT(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT);
18515
18516    /// Available if built with `prototypes`.
18517    #[cfg(any(doc, feature = "prototypes"))]
18518    pub fn vkCmdExecuteGeneratedCommandsNV(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
18519
18520    /// Available if built with `exported-prototypes`.
18521    #[cfg(any(doc, feature = "exported-prototypes"))]
18522    pub fn vkCmdFillBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: u32);
18523
18524    /// Available if built with `prototypes`.
18525    #[cfg(any(doc, feature = "prototypes"))]
18526    pub fn vkCmdInsertDebugUtilsLabelEXT(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
18527
18528    /// Available if built with `exported-prototypes`.
18529    #[cfg(any(doc, feature = "exported-prototypes"))]
18530    pub fn vkCmdNextSubpass(commandBuffer: VkCommandBuffer, contents: VkSubpassContents);
18531
18532    /// Available if built with `exported-prototypes`.
18533    #[cfg(any(doc, feature = "exported-prototypes"))]
18534    pub fn vkCmdNextSubpass2(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
18535
18536    /// Available if built with `prototypes`.
18537    #[cfg(any(doc, feature = "prototypes"))]
18538    pub fn vkCmdNextSubpass2KHR(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
18539
18540    /// Available if built with `prototypes`.
18541    #[cfg(any(doc, feature = "prototypes"))]
18542    pub fn vkCmdOpticalFlowExecuteNV(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV);
18543
18544    /// Available if built with `exported-prototypes`.
18545    #[cfg(any(doc, feature = "exported-prototypes"))]
18546    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);
18547
18548    /// Available if built with `exported-prototypes`.
18549    #[cfg(any(doc, feature = "exported-prototypes"))]
18550    pub fn vkCmdPipelineBarrier2(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
18551
18552    /// Available if built with `prototypes`.
18553    #[cfg(any(doc, feature = "prototypes"))]
18554    pub fn vkCmdPipelineBarrier2KHR(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
18555
18556    /// Available if built with `prototypes`.
18557    #[cfg(any(doc, feature = "prototypes"))]
18558    pub fn vkCmdPreprocessGeneratedCommandsEXT(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer);
18559
18560    /// Available if built with `prototypes`.
18561    #[cfg(any(doc, feature = "prototypes"))]
18562    pub fn vkCmdPreprocessGeneratedCommandsNV(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
18563
18564    /// Available if built with `exported-prototypes`.
18565    #[cfg(any(doc, feature = "exported-prototypes"))]
18566    pub fn vkCmdPushConstants(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const c_void);
18567
18568    /// Available if built with `exported-prototypes`.
18569    #[cfg(any(doc, feature = "exported-prototypes"))]
18570    pub fn vkCmdPushConstants2(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
18571
18572    /// Available if built with `prototypes`.
18573    #[cfg(any(doc, feature = "prototypes"))]
18574    pub fn vkCmdPushConstants2KHR(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
18575
18576    /// Available if built with `prototypes`.
18577    #[cfg(any(doc, feature = "prototypes"))]
18578    pub fn vkCmdPushDataEXT(commandBuffer: VkCommandBuffer, pPushDataInfo: *const VkPushDataInfoEXT);
18579
18580    /// Available if built with `exported-prototypes`.
18581    #[cfg(any(doc, feature = "exported-prototypes"))]
18582    pub fn vkCmdPushDescriptorSet(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
18583
18584    /// Available if built with `exported-prototypes`.
18585    #[cfg(any(doc, feature = "exported-prototypes"))]
18586    pub fn vkCmdPushDescriptorSet2(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
18587
18588    /// Available if built with `prototypes`.
18589    #[cfg(any(doc, feature = "prototypes"))]
18590    pub fn vkCmdPushDescriptorSet2KHR(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
18591
18592    /// Available if built with `prototypes`.
18593    #[cfg(any(doc, feature = "prototypes"))]
18594    pub fn vkCmdPushDescriptorSetKHR(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
18595
18596    /// Available if built with `exported-prototypes`.
18597    #[cfg(any(doc, feature = "exported-prototypes"))]
18598    pub fn vkCmdPushDescriptorSetWithTemplate(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
18599
18600    /// Available if built with `exported-prototypes`.
18601    #[cfg(any(doc, feature = "exported-prototypes"))]
18602    pub fn vkCmdPushDescriptorSetWithTemplate2(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
18603
18604    /// Available if built with `prototypes`.
18605    #[cfg(any(doc, feature = "prototypes"))]
18606    pub fn vkCmdPushDescriptorSetWithTemplate2KHR(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
18607
18608    /// Available if built with `prototypes`.
18609    #[cfg(any(doc, feature = "prototypes"))]
18610    pub fn vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
18611
18612    /// Available if built with `exported-prototypes`.
18613    #[cfg(any(doc, feature = "exported-prototypes"))]
18614    pub fn vkCmdResetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
18615
18616    /// Available if built with `exported-prototypes`.
18617    #[cfg(any(doc, feature = "exported-prototypes"))]
18618    pub fn vkCmdResetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
18619
18620    /// Available if built with `prototypes`.
18621    #[cfg(any(doc, feature = "prototypes"))]
18622    pub fn vkCmdResetEvent2KHR(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
18623
18624    /// Available if built with `exported-prototypes`.
18625    #[cfg(any(doc, feature = "exported-prototypes"))]
18626    pub fn vkCmdResetQueryPool(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
18627
18628    /// Available if built with `exported-prototypes`.
18629    #[cfg(any(doc, feature = "exported-prototypes"))]
18630    pub fn vkCmdResolveImage(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve);
18631
18632    /// Available if built with `exported-prototypes`.
18633    #[cfg(any(doc, feature = "exported-prototypes"))]
18634    pub fn vkCmdResolveImage2(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
18635
18636    /// Available if built with `prototypes`.
18637    #[cfg(any(doc, feature = "prototypes"))]
18638    pub fn vkCmdResolveImage2KHR(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
18639
18640    /// Available if built with `prototypes`.
18641    #[cfg(any(doc, feature = "prototypes"))]
18642    pub fn vkCmdSetAlphaToCoverageEnableEXT(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32);
18643
18644    /// Available if built with `prototypes`.
18645    #[cfg(any(doc, feature = "prototypes"))]
18646    pub fn vkCmdSetAlphaToOneEnableEXT(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32);
18647
18648    /// Available if built with `prototypes`.
18649    #[cfg(any(doc, feature = "prototypes"))]
18650    pub fn vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags);
18651
18652    /// Available if built with `exported-prototypes`.
18653    #[cfg(any(doc, feature = "exported-prototypes"))]
18654    pub fn vkCmdSetBlendConstants(commandBuffer: VkCommandBuffer, blendConstants: *const f32);
18655
18656    /// Available if built with `prototypes`.
18657    #[cfg(any(doc, feature = "prototypes"))]
18658    pub fn vkCmdSetCheckpointNV(commandBuffer: VkCommandBuffer, pCheckpointMarker: *const c_void);
18659
18660    /// Available if built with `prototypes`.
18661    #[cfg(any(doc, feature = "prototypes"))]
18662    pub fn vkCmdSetCoarseSampleOrderNV(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV);
18663
18664    /// Available if built with `prototypes`.
18665    #[cfg(any(doc, feature = "prototypes"))]
18666    pub fn vkCmdSetColorBlendAdvancedEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT);
18667
18668    /// Available if built with `prototypes`.
18669    #[cfg(any(doc, feature = "prototypes"))]
18670    pub fn vkCmdSetColorBlendEnableEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEnables: *const VkBool32);
18671
18672    /// Available if built with `prototypes`.
18673    #[cfg(any(doc, feature = "prototypes"))]
18674    pub fn vkCmdSetColorBlendEquationEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEquations: *const VkColorBlendEquationEXT);
18675
18676    /// Available if built with `prototypes`.
18677    #[cfg(any(doc, feature = "prototypes"))]
18678    pub fn vkCmdSetColorWriteEnableEXT(commandBuffer: VkCommandBuffer, attachmentCount: u32, pColorWriteEnables: *const VkBool32);
18679
18680    /// Available if built with `prototypes`.
18681    #[cfg(any(doc, feature = "prototypes"))]
18682    pub fn vkCmdSetColorWriteMaskEXT(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorWriteMasks: *const VkColorComponentFlags);
18683
18684    /// Available if built with `prototypes`.
18685    #[cfg(any(doc, feature = "prototypes"))]
18686    pub fn vkCmdSetComputeOccupancyPriorityNV(commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV);
18687
18688    /// Available if built with `prototypes`.
18689    #[cfg(any(doc, feature = "prototypes"))]
18690    pub fn vkCmdSetConservativeRasterizationModeEXT(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT);
18691
18692    /// Available if built with `prototypes`.
18693    #[cfg(any(doc, feature = "prototypes"))]
18694    pub fn vkCmdSetCoverageModulationModeNV(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV);
18695
18696    /// Available if built with `prototypes`.
18697    #[cfg(any(doc, feature = "prototypes"))]
18698    pub fn vkCmdSetCoverageModulationTableEnableNV(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32);
18699
18700    /// Available if built with `prototypes`.
18701    #[cfg(any(doc, feature = "prototypes"))]
18702    pub fn vkCmdSetCoverageModulationTableNV(commandBuffer: VkCommandBuffer, coverageModulationTableCount: u32, pCoverageModulationTable: *const f32);
18703
18704    /// Available if built with `prototypes`.
18705    #[cfg(any(doc, feature = "prototypes"))]
18706    pub fn vkCmdSetCoverageReductionModeNV(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV);
18707
18708    /// Available if built with `prototypes`.
18709    #[cfg(any(doc, feature = "prototypes"))]
18710    pub fn vkCmdSetCoverageToColorEnableNV(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32);
18711
18712    /// Available if built with `prototypes`.
18713    #[cfg(any(doc, feature = "prototypes"))]
18714    pub fn vkCmdSetCoverageToColorLocationNV(commandBuffer: VkCommandBuffer, coverageToColorLocation: u32);
18715
18716    /// Available if built with `exported-prototypes`.
18717    #[cfg(any(doc, feature = "exported-prototypes"))]
18718    pub fn vkCmdSetCullMode(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
18719
18720    /// Available if built with `prototypes`.
18721    #[cfg(any(doc, feature = "prototypes"))]
18722    pub fn vkCmdSetCullModeEXT(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
18723
18724    /// Available if built with `exported-prototypes`.
18725    #[cfg(any(doc, feature = "exported-prototypes"))]
18726    pub fn vkCmdSetDepthBias(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);
18727
18728    /// Available if built with `prototypes`.
18729    #[cfg(any(doc, feature = "prototypes"))]
18730    pub fn vkCmdSetDepthBias2EXT(commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT);
18731
18732    /// Available if built with `exported-prototypes`.
18733    #[cfg(any(doc, feature = "exported-prototypes"))]
18734    pub fn vkCmdSetDepthBiasEnable(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
18735
18736    /// Available if built with `prototypes`.
18737    #[cfg(any(doc, feature = "prototypes"))]
18738    pub fn vkCmdSetDepthBiasEnableEXT(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
18739
18740    /// Available if built with `exported-prototypes`.
18741    #[cfg(any(doc, feature = "exported-prototypes"))]
18742    pub fn vkCmdSetDepthBounds(commandBuffer: VkCommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);
18743
18744    /// Available if built with `exported-prototypes`.
18745    #[cfg(any(doc, feature = "exported-prototypes"))]
18746    pub fn vkCmdSetDepthBoundsTestEnable(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
18747
18748    /// Available if built with `prototypes`.
18749    #[cfg(any(doc, feature = "prototypes"))]
18750    pub fn vkCmdSetDepthBoundsTestEnableEXT(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
18751
18752    /// Available if built with `prototypes`.
18753    #[cfg(any(doc, feature = "prototypes"))]
18754    pub fn vkCmdSetDepthClampEnableEXT(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32);
18755
18756    /// Available if built with `prototypes`.
18757    #[cfg(any(doc, feature = "prototypes"))]
18758    pub fn vkCmdSetDepthClampRangeEXT(commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT);
18759
18760    /// Available if built with `prototypes`.
18761    #[cfg(any(doc, feature = "prototypes"))]
18762    pub fn vkCmdSetDepthClipEnableEXT(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32);
18763
18764    /// Available if built with `prototypes`.
18765    #[cfg(any(doc, feature = "prototypes"))]
18766    pub fn vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32);
18767
18768    /// Available if built with `exported-prototypes`.
18769    #[cfg(any(doc, feature = "exported-prototypes"))]
18770    pub fn vkCmdSetDepthCompareOp(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
18771
18772    /// Available if built with `prototypes`.
18773    #[cfg(any(doc, feature = "prototypes"))]
18774    pub fn vkCmdSetDepthCompareOpEXT(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
18775
18776    /// Available if built with `exported-prototypes`.
18777    #[cfg(any(doc, feature = "exported-prototypes"))]
18778    pub fn vkCmdSetDepthTestEnable(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
18779
18780    /// Available if built with `prototypes`.
18781    #[cfg(any(doc, feature = "prototypes"))]
18782    pub fn vkCmdSetDepthTestEnableEXT(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
18783
18784    /// Available if built with `exported-prototypes`.
18785    #[cfg(any(doc, feature = "exported-prototypes"))]
18786    pub fn vkCmdSetDepthWriteEnable(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
18787
18788    /// Available if built with `prototypes`.
18789    #[cfg(any(doc, feature = "prototypes"))]
18790    pub fn vkCmdSetDepthWriteEnableEXT(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
18791
18792    /// Available if built with `prototypes`.
18793    #[cfg(any(doc, feature = "prototypes"))]
18794    pub fn vkCmdSetDescriptorBufferOffsets2EXT(commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT);
18795
18796    /// Available if built with `prototypes`.
18797    #[cfg(any(doc, feature = "prototypes"))]
18798    pub fn vkCmdSetDescriptorBufferOffsetsEXT(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, setCount: u32, pBufferIndices: *const u32, pOffsets: *const VkDeviceSize);
18799
18800    /// Available if built with `exported-prototypes`.
18801    #[cfg(any(doc, feature = "exported-prototypes"))]
18802    pub fn vkCmdSetDeviceMask(commandBuffer: VkCommandBuffer, deviceMask: u32);
18803
18804    /// Available if built with `prototypes`.
18805    #[cfg(any(doc, feature = "prototypes"))]
18806    pub fn vkCmdSetDeviceMaskKHR(commandBuffer: VkCommandBuffer, deviceMask: u32);
18807
18808    /// Available if built with `prototypes`.
18809    #[cfg(any(doc, feature = "prototypes"))]
18810    pub fn vkCmdSetDiscardRectangleEXT(commandBuffer: VkCommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: *const VkRect2D);
18811
18812    /// Available if built with `prototypes`.
18813    #[cfg(any(doc, feature = "prototypes"))]
18814    pub fn vkCmdSetDiscardRectangleEnableEXT(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32);
18815
18816    /// Available if built with `prototypes`.
18817    #[cfg(any(doc, feature = "prototypes"))]
18818    pub fn vkCmdSetDiscardRectangleModeEXT(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT);
18819
18820    /// Available if built with `exported-prototypes`.
18821    #[cfg(any(doc, feature = "exported-prototypes"))]
18822    pub fn vkCmdSetEvent(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
18823
18824    /// Available if built with `exported-prototypes`.
18825    #[cfg(any(doc, feature = "exported-prototypes"))]
18826    pub fn vkCmdSetEvent2(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
18827
18828    /// Available if built with `prototypes`.
18829    #[cfg(any(doc, feature = "prototypes"))]
18830    pub fn vkCmdSetEvent2KHR(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
18831
18832    /// Available if built with `prototypes`.
18833    #[cfg(any(doc, feature = "prototypes"))]
18834    pub fn vkCmdSetExclusiveScissorEnableNV(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissorEnables: *const VkBool32);
18835
18836    /// Available if built with `prototypes`.
18837    #[cfg(any(doc, feature = "prototypes"))]
18838    pub fn vkCmdSetExclusiveScissorNV(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: *const VkRect2D);
18839
18840    /// Available if built with `prototypes`.
18841    #[cfg(any(doc, feature = "prototypes"))]
18842    pub fn vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: f32);
18843
18844    /// Available if built with `prototypes`.
18845    #[cfg(any(doc, feature = "prototypes"))]
18846    pub fn vkCmdSetFragmentShadingRateEnumNV(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
18847
18848    /// Available if built with `prototypes`.
18849    #[cfg(any(doc, feature = "prototypes"))]
18850    pub fn vkCmdSetFragmentShadingRateKHR(commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
18851
18852    /// Available if built with `exported-prototypes`.
18853    #[cfg(any(doc, feature = "exported-prototypes"))]
18854    pub fn vkCmdSetFrontFace(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
18855
18856    /// Available if built with `prototypes`.
18857    #[cfg(any(doc, feature = "prototypes"))]
18858    pub fn vkCmdSetFrontFaceEXT(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
18859
18860    /// Available if built with `prototypes`.
18861    #[cfg(any(doc, feature = "prototypes"))]
18862    pub fn vkCmdSetLineRasterizationModeEXT(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT);
18863
18864    /// Available if built with `exported-prototypes`.
18865    #[cfg(any(doc, feature = "exported-prototypes"))]
18866    pub fn vkCmdSetLineStipple(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
18867
18868    /// Available if built with `prototypes`.
18869    #[cfg(any(doc, feature = "prototypes"))]
18870    pub fn vkCmdSetLineStippleEXT(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
18871
18872    /// Available if built with `prototypes`.
18873    #[cfg(any(doc, feature = "prototypes"))]
18874    pub fn vkCmdSetLineStippleEnableEXT(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32);
18875
18876    /// Available if built with `prototypes`.
18877    #[cfg(any(doc, feature = "prototypes"))]
18878    pub fn vkCmdSetLineStippleKHR(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
18879
18880    /// Available if built with `exported-prototypes`.
18881    #[cfg(any(doc, feature = "exported-prototypes"))]
18882    pub fn vkCmdSetLineWidth(commandBuffer: VkCommandBuffer, lineWidth: f32);
18883
18884    /// Available if built with `prototypes`.
18885    #[cfg(any(doc, feature = "prototypes"))]
18886    pub fn vkCmdSetLogicOpEXT(commandBuffer: VkCommandBuffer, logicOp: VkLogicOp);
18887
18888    /// Available if built with `prototypes`.
18889    #[cfg(any(doc, feature = "prototypes"))]
18890    pub fn vkCmdSetLogicOpEnableEXT(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32);
18891
18892    /// Available if built with `prototypes`.
18893    #[cfg(any(doc, feature = "prototypes"))]
18894    pub fn vkCmdSetPatchControlPointsEXT(commandBuffer: VkCommandBuffer, patchControlPoints: u32);
18895
18896    /// Available if built with `prototypes`.
18897    #[cfg(any(doc, feature = "prototypes"))]
18898    pub fn vkCmdSetPerformanceMarkerINTEL(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult;
18899
18900    /// Available if built with `prototypes`.
18901    #[cfg(any(doc, feature = "prototypes"))]
18902    pub fn vkCmdSetPerformanceOverrideINTEL(commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult;
18903
18904    /// Available if built with `prototypes`.
18905    #[cfg(any(doc, feature = "prototypes"))]
18906    pub fn vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult;
18907
18908    /// Available if built with `prototypes`.
18909    #[cfg(any(doc, feature = "prototypes"))]
18910    pub fn vkCmdSetPolygonModeEXT(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode);
18911
18912    /// Available if built with `exported-prototypes`.
18913    #[cfg(any(doc, feature = "exported-prototypes"))]
18914    pub fn vkCmdSetPrimitiveRestartEnable(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
18915
18916    /// Available if built with `prototypes`.
18917    #[cfg(any(doc, feature = "prototypes"))]
18918    pub fn vkCmdSetPrimitiveRestartEnableEXT(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
18919
18920    /// Available if built with `exported-prototypes`.
18921    #[cfg(any(doc, feature = "exported-prototypes"))]
18922    pub fn vkCmdSetPrimitiveTopology(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
18923
18924    /// Available if built with `prototypes`.
18925    #[cfg(any(doc, feature = "prototypes"))]
18926    pub fn vkCmdSetPrimitiveTopologyEXT(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
18927
18928    /// Available if built with `prototypes`.
18929    #[cfg(any(doc, feature = "prototypes"))]
18930    pub fn vkCmdSetProvokingVertexModeEXT(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT);
18931
18932    /// Available if built with `prototypes`.
18933    #[cfg(any(doc, feature = "prototypes"))]
18934    pub fn vkCmdSetRasterizationSamplesEXT(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits);
18935
18936    /// Available if built with `prototypes`.
18937    #[cfg(any(doc, feature = "prototypes"))]
18938    pub fn vkCmdSetRasterizationStreamEXT(commandBuffer: VkCommandBuffer, rasterizationStream: u32);
18939
18940    /// Available if built with `exported-prototypes`.
18941    #[cfg(any(doc, feature = "exported-prototypes"))]
18942    pub fn vkCmdSetRasterizerDiscardEnable(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
18943
18944    /// Available if built with `prototypes`.
18945    #[cfg(any(doc, feature = "prototypes"))]
18946    pub fn vkCmdSetRasterizerDiscardEnableEXT(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
18947
18948    /// Available if built with `prototypes`.
18949    #[cfg(any(doc, feature = "prototypes"))]
18950    pub fn vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer: VkCommandBuffer, pipelineStackSize: u32);
18951
18952    /// Available if built with `exported-prototypes`.
18953    #[cfg(any(doc, feature = "exported-prototypes"))]
18954    pub fn vkCmdSetRenderingAttachmentLocations(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
18955
18956    /// Available if built with `prototypes`.
18957    #[cfg(any(doc, feature = "prototypes"))]
18958    pub fn vkCmdSetRenderingAttachmentLocationsKHR(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
18959
18960    /// Available if built with `exported-prototypes`.
18961    #[cfg(any(doc, feature = "exported-prototypes"))]
18962    pub fn vkCmdSetRenderingInputAttachmentIndices(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
18963
18964    /// Available if built with `prototypes`.
18965    #[cfg(any(doc, feature = "prototypes"))]
18966    pub fn vkCmdSetRenderingInputAttachmentIndicesKHR(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
18967
18968    /// Available if built with `prototypes`.
18969    #[cfg(any(doc, feature = "prototypes"))]
18970    pub fn vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32);
18971
18972    /// Available if built with `prototypes`.
18973    #[cfg(any(doc, feature = "prototypes"))]
18974    pub fn vkCmdSetSampleLocationsEXT(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT);
18975
18976    /// Available if built with `prototypes`.
18977    #[cfg(any(doc, feature = "prototypes"))]
18978    pub fn vkCmdSetSampleLocationsEnableEXT(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32);
18979
18980    /// Available if built with `prototypes`.
18981    #[cfg(any(doc, feature = "prototypes"))]
18982    pub fn vkCmdSetSampleMaskEXT(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: *const VkSampleMask);
18983
18984    /// Available if built with `exported-prototypes`.
18985    #[cfg(any(doc, feature = "exported-prototypes"))]
18986    pub fn vkCmdSetScissor(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D);
18987
18988    /// Available if built with `exported-prototypes`.
18989    #[cfg(any(doc, feature = "exported-prototypes"))]
18990    pub fn vkCmdSetScissorWithCount(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
18991
18992    /// Available if built with `prototypes`.
18993    #[cfg(any(doc, feature = "prototypes"))]
18994    pub fn vkCmdSetScissorWithCountEXT(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
18995
18996    /// Available if built with `prototypes`.
18997    #[cfg(any(doc, feature = "prototypes"))]
18998    pub fn vkCmdSetShadingRateImageEnableNV(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32);
18999
19000    /// Available if built with `exported-prototypes`.
19001    #[cfg(any(doc, feature = "exported-prototypes"))]
19002    pub fn vkCmdSetStencilCompareMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32);
19003
19004    /// Available if built with `exported-prototypes`.
19005    #[cfg(any(doc, feature = "exported-prototypes"))]
19006    pub fn vkCmdSetStencilOp(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
19007
19008    /// Available if built with `prototypes`.
19009    #[cfg(any(doc, feature = "prototypes"))]
19010    pub fn vkCmdSetStencilOpEXT(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
19011
19012    /// Available if built with `exported-prototypes`.
19013    #[cfg(any(doc, feature = "exported-prototypes"))]
19014    pub fn vkCmdSetStencilReference(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32);
19015
19016    /// Available if built with `exported-prototypes`.
19017    #[cfg(any(doc, feature = "exported-prototypes"))]
19018    pub fn vkCmdSetStencilTestEnable(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
19019
19020    /// Available if built with `prototypes`.
19021    #[cfg(any(doc, feature = "prototypes"))]
19022    pub fn vkCmdSetStencilTestEnableEXT(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
19023
19024    /// Available if built with `exported-prototypes`.
19025    #[cfg(any(doc, feature = "exported-prototypes"))]
19026    pub fn vkCmdSetStencilWriteMask(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32);
19027
19028    /// Available if built with `prototypes`.
19029    #[cfg(any(doc, feature = "prototypes"))]
19030    pub fn vkCmdSetTessellationDomainOriginEXT(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin);
19031
19032    /// Available if built with `prototypes`.
19033    #[cfg(any(doc, feature = "prototypes"))]
19034    pub fn vkCmdSetVertexInputEXT(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT);
19035
19036    /// Available if built with `exported-prototypes`.
19037    #[cfg(any(doc, feature = "exported-prototypes"))]
19038    pub fn vkCmdSetViewport(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport);
19039
19040    /// Available if built with `prototypes`.
19041    #[cfg(any(doc, feature = "prototypes"))]
19042    pub fn vkCmdSetViewportShadingRatePaletteNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: *const VkShadingRatePaletteNV);
19043
19044    /// Available if built with `prototypes`.
19045    #[cfg(any(doc, feature = "prototypes"))]
19046    pub fn vkCmdSetViewportSwizzleNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportSwizzles: *const VkViewportSwizzleNV);
19047
19048    /// Available if built with `prototypes`.
19049    #[cfg(any(doc, feature = "prototypes"))]
19050    pub fn vkCmdSetViewportWScalingEnableNV(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32);
19051
19052    /// Available if built with `prototypes`.
19053    #[cfg(any(doc, feature = "prototypes"))]
19054    pub fn vkCmdSetViewportWScalingNV(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: *const VkViewportWScalingNV);
19055
19056    /// Available if built with `exported-prototypes`.
19057    #[cfg(any(doc, feature = "exported-prototypes"))]
19058    pub fn vkCmdSetViewportWithCount(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
19059
19060    /// Available if built with `prototypes`.
19061    #[cfg(any(doc, feature = "prototypes"))]
19062    pub fn vkCmdSetViewportWithCountEXT(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
19063
19064    /// Available if built with `prototypes`.
19065    #[cfg(any(doc, feature = "prototypes"))]
19066    pub fn vkCmdSubpassShadingHUAWEI(commandBuffer: VkCommandBuffer);
19067
19068    /// Available if built with `prototypes`.
19069    #[cfg(any(doc, feature = "prototypes"))]
19070    pub fn vkCmdTraceRaysIndirect2KHR(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress);
19071
19072    /// Available if built with `prototypes`.
19073    #[cfg(any(doc, feature = "prototypes"))]
19074    pub fn vkCmdTraceRaysIndirectKHR(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress);
19075
19076    /// Available if built with `prototypes`.
19077    #[cfg(any(doc, feature = "prototypes"))]
19078    pub fn vkCmdTraceRaysKHR(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, width: u32, height: u32, depth: u32);
19079
19080    /// Available if built with `prototypes`.
19081    #[cfg(any(doc, feature = "prototypes"))]
19082    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);
19083
19084    /// Available if built with `exported-prototypes`.
19085    #[cfg(any(doc, feature = "exported-prototypes"))]
19086    pub fn vkCmdUpdateBuffer(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const c_void);
19087
19088    /// Available if built with `prototypes`.
19089    #[cfg(any(doc, feature = "prototypes"))]
19090    pub fn vkCmdUpdatePipelineIndirectBufferNV(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
19091
19092    /// Available if built with `exported-prototypes`.
19093    #[cfg(any(doc, feature = "exported-prototypes"))]
19094    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);
19095
19096    /// Available if built with `exported-prototypes`.
19097    #[cfg(any(doc, feature = "exported-prototypes"))]
19098    pub fn vkCmdWaitEvents2(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
19099
19100    /// Available if built with `prototypes`.
19101    #[cfg(any(doc, feature = "prototypes"))]
19102    pub fn vkCmdWaitEvents2KHR(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
19103
19104    /// Available if built with `prototypes`.
19105    #[cfg(any(doc, feature = "prototypes"))]
19106    pub fn vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
19107
19108    /// Available if built with `prototypes`.
19109    #[cfg(any(doc, feature = "prototypes"))]
19110    pub fn vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
19111
19112    /// Available if built with `prototypes`.
19113    #[cfg(any(doc, feature = "prototypes"))]
19114    pub fn vkCmdWriteBufferMarker2AMD(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
19115
19116    /// Available if built with `prototypes`.
19117    #[cfg(any(doc, feature = "prototypes"))]
19118    pub fn vkCmdWriteBufferMarkerAMD(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
19119
19120    /// Available if built with `prototypes`.
19121    #[cfg(any(doc, feature = "prototypes"))]
19122    pub fn vkCmdWriteMicromapsPropertiesEXT(commandBuffer: VkCommandBuffer, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
19123
19124    /// Available if built with `exported-prototypes`.
19125    #[cfg(any(doc, feature = "exported-prototypes"))]
19126    pub fn vkCmdWriteTimestamp(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: u32);
19127
19128    /// Available if built with `exported-prototypes`.
19129    #[cfg(any(doc, feature = "exported-prototypes"))]
19130    pub fn vkCmdWriteTimestamp2(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
19131
19132    /// Available if built with `prototypes`.
19133    #[cfg(any(doc, feature = "prototypes"))]
19134    pub fn vkCmdWriteTimestamp2KHR(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
19135
19136    /// Available if built with `prototypes`.
19137    #[cfg(any(doc, feature = "prototypes"))]
19138    pub fn vkCompileDeferredNV(device: VkDevice, pipeline: VkPipeline, shader: u32) -> VkResult;
19139
19140    /// Available if built with `prototypes`.
19141    #[cfg(any(doc, feature = "prototypes"))]
19142    pub fn vkConvertCooperativeVectorMatrixNV(device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult;
19143
19144    /// Available if built with `prototypes`.
19145    #[cfg(any(doc, feature = "prototypes"))]
19146    pub fn vkCopyAccelerationStructureKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult;
19147
19148    /// Available if built with `prototypes`.
19149    #[cfg(any(doc, feature = "prototypes"))]
19150    pub fn vkCopyAccelerationStructureToMemoryKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult;
19151
19152    /// Available if built with `exported-prototypes`.
19153    #[cfg(any(doc, feature = "exported-prototypes"))]
19154    pub fn vkCopyImageToImage(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
19155
19156    /// Available if built with `prototypes`.
19157    #[cfg(any(doc, feature = "prototypes"))]
19158    pub fn vkCopyImageToImageEXT(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
19159
19160    /// Available if built with `exported-prototypes`.
19161    #[cfg(any(doc, feature = "exported-prototypes"))]
19162    pub fn vkCopyImageToMemory(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
19163
19164    /// Available if built with `prototypes`.
19165    #[cfg(any(doc, feature = "prototypes"))]
19166    pub fn vkCopyImageToMemoryEXT(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
19167
19168    /// Available if built with `prototypes`.
19169    #[cfg(any(doc, feature = "prototypes"))]
19170    pub fn vkCopyMemoryToAccelerationStructureKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult;
19171
19172    /// Available if built with `exported-prototypes`.
19173    #[cfg(any(doc, feature = "exported-prototypes"))]
19174    pub fn vkCopyMemoryToImage(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
19175
19176    /// Available if built with `prototypes`.
19177    #[cfg(any(doc, feature = "prototypes"))]
19178    pub fn vkCopyMemoryToImageEXT(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
19179
19180    /// Available if built with `prototypes`.
19181    #[cfg(any(doc, feature = "prototypes"))]
19182    pub fn vkCopyMemoryToMicromapEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult;
19183
19184    /// Available if built with `prototypes`.
19185    #[cfg(any(doc, feature = "prototypes"))]
19186    pub fn vkCopyMicromapEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult;
19187
19188    /// Available if built with `prototypes`.
19189    #[cfg(any(doc, feature = "prototypes"))]
19190    pub fn vkCopyMicromapToMemoryEXT(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult;
19191
19192    /// Available if built with `prototypes`.
19193    #[cfg(any(doc, feature = "prototypes"))]
19194    pub fn vkCreateAccelerationStructureKHR(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult;
19195
19196    /// Available if built with `prototypes`.
19197    #[cfg(any(doc, feature = "prototypes"))]
19198    pub fn vkCreateAccelerationStructureNV(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult;
19199
19200    /// Available if built with `exported-prototypes`.
19201    #[cfg(any(doc, feature = "exported-prototypes"))]
19202    pub fn vkCreateBuffer(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;
19203
19204    /// Available if built with `exported-prototypes`.
19205    #[cfg(any(doc, feature = "exported-prototypes"))]
19206    pub fn vkCreateBufferView(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;
19207
19208    /// Available if built with `exported-prototypes`.
19209    #[cfg(any(doc, feature = "exported-prototypes"))]
19210    pub fn vkCreateCommandPool(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;
19211
19212    /// Available if built with `exported-prototypes`.
19213    #[cfg(any(doc, feature = "exported-prototypes"))]
19214    pub fn vkCreateComputePipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19215
19216    /// Available if built with `prototypes`.
19217    #[cfg(any(doc, feature = "prototypes"))]
19218    pub fn vkCreateCuFunctionNVX(device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult;
19219
19220    /// Available if built with `prototypes`.
19221    #[cfg(any(doc, feature = "prototypes"))]
19222    pub fn vkCreateCuModuleNVX(device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult;
19223
19224    /// Available if built with `prototypes`.
19225    #[cfg(any(doc, feature = "prototypes"))]
19226    pub fn vkCreateDataGraphPipelineSessionARM(device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult;
19227
19228    /// Available if built with `prototypes`.
19229    #[cfg(any(doc, feature = "prototypes"))]
19230    pub fn vkCreateDataGraphPipelinesARM(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkDataGraphPipelineCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19231
19232    /// Available if built with `prototypes`.
19233    #[cfg(any(doc, feature = "prototypes"))]
19234    pub fn vkCreateDebugReportCallbackEXT(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult;
19235
19236    /// Available if built with `prototypes`.
19237    #[cfg(any(doc, feature = "prototypes"))]
19238    pub fn vkCreateDebugUtilsMessengerEXT(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult;
19239
19240    /// Available if built with `prototypes`.
19241    #[cfg(any(doc, feature = "prototypes"))]
19242    pub fn vkCreateDeferredOperationKHR(device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult;
19243
19244    /// Available if built with `exported-prototypes`.
19245    #[cfg(any(doc, feature = "exported-prototypes"))]
19246    pub fn vkCreateDescriptorPool(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult;
19247
19248    /// Available if built with `exported-prototypes`.
19249    #[cfg(any(doc, feature = "exported-prototypes"))]
19250    pub fn vkCreateDescriptorSetLayout(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;
19251
19252    /// Available if built with `exported-prototypes`.
19253    #[cfg(any(doc, feature = "exported-prototypes"))]
19254    pub fn vkCreateDescriptorUpdateTemplate(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
19255
19256    /// Available if built with `prototypes`.
19257    #[cfg(any(doc, feature = "prototypes"))]
19258    pub fn vkCreateDescriptorUpdateTemplateKHR(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
19259
19260    /// Available if built with `exported-prototypes`.
19261    #[cfg(any(doc, feature = "exported-prototypes"))]
19262    pub fn vkCreateDevice(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;
19263
19264    /// Available if built with `prototypes`.
19265    #[cfg(any(doc, feature = "prototypes"))]
19266    pub fn vkCreateDisplayModeKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;
19267
19268    /// Available if built with `prototypes`.
19269    #[cfg(any(doc, feature = "prototypes"))]
19270    pub fn vkCreateDisplayPlaneSurfaceKHR(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
19271
19272    /// Available if built with `exported-prototypes`.
19273    #[cfg(any(doc, feature = "exported-prototypes"))]
19274    pub fn vkCreateEvent(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;
19275
19276    /// Available if built with `prototypes`.
19277    #[cfg(any(doc, feature = "prototypes"))]
19278    pub fn vkCreateExternalComputeQueueNV(device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult;
19279
19280    /// Available if built with `exported-prototypes`.
19281    #[cfg(any(doc, feature = "exported-prototypes"))]
19282    pub fn vkCreateFence(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
19283
19284    /// Available if built with `exported-prototypes`.
19285    #[cfg(any(doc, feature = "exported-prototypes"))]
19286    pub fn vkCreateFramebuffer(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;
19287
19288    /// Available if built with `exported-prototypes`.
19289    #[cfg(any(doc, feature = "exported-prototypes"))]
19290    pub fn vkCreateGraphicsPipelines(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19291
19292    /// Available if built with `prototypes`.
19293    #[cfg(any(doc, feature = "prototypes"))]
19294    pub fn vkCreateHeadlessSurfaceEXT(instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
19295
19296    /// Available if built with `exported-prototypes`.
19297    #[cfg(any(doc, feature = "exported-prototypes"))]
19298    pub fn vkCreateImage(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;
19299
19300    /// Available if built with `exported-prototypes`.
19301    #[cfg(any(doc, feature = "exported-prototypes"))]
19302    pub fn vkCreateImageView(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;
19303
19304    /// Available if built with `prototypes`.
19305    #[cfg(any(doc, feature = "prototypes"))]
19306    pub fn vkCreateIndirectCommandsLayoutEXT(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult;
19307
19308    /// Available if built with `prototypes`.
19309    #[cfg(any(doc, feature = "prototypes"))]
19310    pub fn vkCreateIndirectCommandsLayoutNV(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult;
19311
19312    /// Available if built with `prototypes`.
19313    #[cfg(any(doc, feature = "prototypes"))]
19314    pub fn vkCreateIndirectExecutionSetEXT(device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult;
19315
19316    /// Available if built with `exported-prototypes`.
19317    #[cfg(any(doc, feature = "exported-prototypes"))]
19318    pub fn vkCreateInstance(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;
19319
19320    /// Available if built with `prototypes`.
19321    #[cfg(any(doc, feature = "prototypes"))]
19322    pub fn vkCreateMicromapEXT(device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult;
19323
19324    /// Available if built with `prototypes`.
19325    #[cfg(any(doc, feature = "prototypes"))]
19326    pub fn vkCreateOpticalFlowSessionNV(device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult;
19327
19328    /// Available if built with `prototypes`.
19329    #[cfg(any(doc, feature = "prototypes"))]
19330    pub fn vkCreatePipelineBinariesKHR(device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult;
19331
19332    /// Available if built with `exported-prototypes`.
19333    #[cfg(any(doc, feature = "exported-prototypes"))]
19334    pub fn vkCreatePipelineCache(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;
19335
19336    /// Available if built with `exported-prototypes`.
19337    #[cfg(any(doc, feature = "exported-prototypes"))]
19338    pub fn vkCreatePipelineLayout(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;
19339
19340    /// Available if built with `exported-prototypes`.
19341    #[cfg(any(doc, feature = "exported-prototypes"))]
19342    pub fn vkCreatePrivateDataSlot(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
19343
19344    /// Available if built with `prototypes`.
19345    #[cfg(any(doc, feature = "prototypes"))]
19346    pub fn vkCreatePrivateDataSlotEXT(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
19347
19348    /// Available if built with `exported-prototypes`.
19349    #[cfg(any(doc, feature = "exported-prototypes"))]
19350    pub fn vkCreateQueryPool(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;
19351
19352    /// Available if built with `prototypes`.
19353    #[cfg(any(doc, feature = "prototypes"))]
19354    pub fn vkCreateRayTracingPipelinesKHR(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19355
19356    /// Available if built with `prototypes`.
19357    #[cfg(any(doc, feature = "prototypes"))]
19358    pub fn vkCreateRayTracingPipelinesNV(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
19359
19360    /// Available if built with `exported-prototypes`.
19361    #[cfg(any(doc, feature = "exported-prototypes"))]
19362    pub fn vkCreateRenderPass(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
19363
19364    /// Available if built with `exported-prototypes`.
19365    #[cfg(any(doc, feature = "exported-prototypes"))]
19366    pub fn vkCreateRenderPass2(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
19367
19368    /// Available if built with `prototypes`.
19369    #[cfg(any(doc, feature = "prototypes"))]
19370    pub fn vkCreateRenderPass2KHR(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
19371
19372    /// Available if built with `exported-prototypes`.
19373    #[cfg(any(doc, feature = "exported-prototypes"))]
19374    pub fn vkCreateSampler(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;
19375
19376    /// Available if built with `exported-prototypes`.
19377    #[cfg(any(doc, feature = "exported-prototypes"))]
19378    pub fn vkCreateSamplerYcbcrConversion(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
19379
19380    /// Available if built with `prototypes`.
19381    #[cfg(any(doc, feature = "prototypes"))]
19382    pub fn vkCreateSamplerYcbcrConversionKHR(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
19383
19384    /// Available if built with `exported-prototypes`.
19385    #[cfg(any(doc, feature = "exported-prototypes"))]
19386    pub fn vkCreateSemaphore(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;
19387
19388    /// Available if built with `exported-prototypes`.
19389    #[cfg(any(doc, feature = "exported-prototypes"))]
19390    pub fn vkCreateShaderModule(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult;
19391
19392    /// Available if built with `prototypes`.
19393    #[cfg(any(doc, feature = "prototypes"))]
19394    pub fn vkCreateShadersEXT(device: VkDevice, createInfoCount: u32, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult;
19395
19396    /// Available if built with `prototypes`.
19397    #[cfg(any(doc, feature = "prototypes"))]
19398    pub fn vkCreateSharedSwapchainsKHR(device: VkDevice, swapchainCount: u32, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult;
19399
19400    /// Available if built with `prototypes`.
19401    #[cfg(any(doc, feature = "prototypes"))]
19402    pub fn vkCreateSwapchainKHR(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;
19403
19404    /// Available if built with `prototypes`.
19405    #[cfg(any(doc, feature = "prototypes"))]
19406    pub fn vkCreateTensorARM(device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult;
19407
19408    /// Available if built with `prototypes`.
19409    #[cfg(any(doc, feature = "prototypes"))]
19410    pub fn vkCreateTensorViewARM(device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult;
19411
19412    /// Available if built with `prototypes`.
19413    #[cfg(any(doc, feature = "prototypes"))]
19414    pub fn vkCreateValidationCacheEXT(device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult;
19415
19416    /// Available if built with `prototypes`.
19417    #[cfg(any(doc, feature = "prototypes"))]
19418    pub fn vkCreateVideoSessionKHR(device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult;
19419
19420    /// Available if built with `prototypes`.
19421    #[cfg(any(doc, feature = "prototypes"))]
19422    pub fn vkCreateVideoSessionParametersKHR(device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult;
19423
19424    /// Available if built with `prototypes`.
19425    #[cfg(any(doc, feature = "prototypes"))]
19426    pub fn vkDebugMarkerSetObjectNameEXT(device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult;
19427
19428    /// Available if built with `prototypes`.
19429    #[cfg(any(doc, feature = "prototypes"))]
19430    pub fn vkDebugMarkerSetObjectTagEXT(device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult;
19431
19432    /// Available if built with `prototypes`.
19433    #[cfg(any(doc, feature = "prototypes"))]
19434    pub fn vkDebugReportMessageEXT(instance: VkInstance, flags: VkDebugReportFlagsEXT, objectType: VkDebugReportObjectTypeEXT, object: u64, location: usize, messageCode: i32, pLayerPrefix: *const c_char, pMessage: *const c_char);
19435
19436    /// Available if built with `prototypes`.
19437    #[cfg(any(doc, feature = "prototypes"))]
19438    pub fn vkDeferredOperationJoinKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
19439
19440    /// Available if built with `prototypes`.
19441    #[cfg(any(doc, feature = "prototypes"))]
19442    pub fn vkDestroyAccelerationStructureKHR(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks);
19443
19444    /// Available if built with `prototypes`.
19445    #[cfg(any(doc, feature = "prototypes"))]
19446    pub fn vkDestroyAccelerationStructureNV(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks);
19447
19448    /// Available if built with `exported-prototypes`.
19449    #[cfg(any(doc, feature = "exported-prototypes"))]
19450    pub fn vkDestroyBuffer(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks);
19451
19452    /// Available if built with `exported-prototypes`.
19453    #[cfg(any(doc, feature = "exported-prototypes"))]
19454    pub fn vkDestroyBufferView(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks);
19455
19456    /// Available if built with `exported-prototypes`.
19457    #[cfg(any(doc, feature = "exported-prototypes"))]
19458    pub fn vkDestroyCommandPool(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks);
19459
19460    /// Available if built with `prototypes`.
19461    #[cfg(any(doc, feature = "prototypes"))]
19462    pub fn vkDestroyCuFunctionNVX(device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks);
19463
19464    /// Available if built with `prototypes`.
19465    #[cfg(any(doc, feature = "prototypes"))]
19466    pub fn vkDestroyCuModuleNVX(device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks);
19467
19468    /// Available if built with `prototypes`.
19469    #[cfg(any(doc, feature = "prototypes"))]
19470    pub fn vkDestroyDataGraphPipelineSessionARM(device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks);
19471
19472    /// Available if built with `prototypes`.
19473    #[cfg(any(doc, feature = "prototypes"))]
19474    pub fn vkDestroyDebugReportCallbackEXT(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks);
19475
19476    /// Available if built with `prototypes`.
19477    #[cfg(any(doc, feature = "prototypes"))]
19478    pub fn vkDestroyDebugUtilsMessengerEXT(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks);
19479
19480    /// Available if built with `prototypes`.
19481    #[cfg(any(doc, feature = "prototypes"))]
19482    pub fn vkDestroyDeferredOperationKHR(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks);
19483
19484    /// Available if built with `exported-prototypes`.
19485    #[cfg(any(doc, feature = "exported-prototypes"))]
19486    pub fn vkDestroyDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks);
19487
19488    /// Available if built with `exported-prototypes`.
19489    #[cfg(any(doc, feature = "exported-prototypes"))]
19490    pub fn vkDestroyDescriptorSetLayout(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks);
19491
19492    /// Available if built with `exported-prototypes`.
19493    #[cfg(any(doc, feature = "exported-prototypes"))]
19494    pub fn vkDestroyDescriptorUpdateTemplate(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
19495
19496    /// Available if built with `prototypes`.
19497    #[cfg(any(doc, feature = "prototypes"))]
19498    pub fn vkDestroyDescriptorUpdateTemplateKHR(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
19499
19500    /// Available if built with `exported-prototypes`.
19501    #[cfg(any(doc, feature = "exported-prototypes"))]
19502    pub fn vkDestroyDevice(device: VkDevice, pAllocator: *const VkAllocationCallbacks);
19503
19504    /// Available if built with `exported-prototypes`.
19505    #[cfg(any(doc, feature = "exported-prototypes"))]
19506    pub fn vkDestroyEvent(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks);
19507
19508    /// Available if built with `prototypes`.
19509    #[cfg(any(doc, feature = "prototypes"))]
19510    pub fn vkDestroyExternalComputeQueueNV(device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks);
19511
19512    /// Available if built with `exported-prototypes`.
19513    #[cfg(any(doc, feature = "exported-prototypes"))]
19514    pub fn vkDestroyFence(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks);
19515
19516    /// Available if built with `exported-prototypes`.
19517    #[cfg(any(doc, feature = "exported-prototypes"))]
19518    pub fn vkDestroyFramebuffer(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks);
19519
19520    /// Available if built with `exported-prototypes`.
19521    #[cfg(any(doc, feature = "exported-prototypes"))]
19522    pub fn vkDestroyImage(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks);
19523
19524    /// Available if built with `exported-prototypes`.
19525    #[cfg(any(doc, feature = "exported-prototypes"))]
19526    pub fn vkDestroyImageView(device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks);
19527
19528    /// Available if built with `prototypes`.
19529    #[cfg(any(doc, feature = "prototypes"))]
19530    pub fn vkDestroyIndirectCommandsLayoutEXT(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks);
19531
19532    /// Available if built with `prototypes`.
19533    #[cfg(any(doc, feature = "prototypes"))]
19534    pub fn vkDestroyIndirectCommandsLayoutNV(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks);
19535
19536    /// Available if built with `prototypes`.
19537    #[cfg(any(doc, feature = "prototypes"))]
19538    pub fn vkDestroyIndirectExecutionSetEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks);
19539
19540    /// Available if built with `exported-prototypes`.
19541    #[cfg(any(doc, feature = "exported-prototypes"))]
19542    pub fn vkDestroyInstance(instance: VkInstance, pAllocator: *const VkAllocationCallbacks);
19543
19544    /// Available if built with `prototypes`.
19545    #[cfg(any(doc, feature = "prototypes"))]
19546    pub fn vkDestroyMicromapEXT(device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks);
19547
19548    /// Available if built with `prototypes`.
19549    #[cfg(any(doc, feature = "prototypes"))]
19550    pub fn vkDestroyOpticalFlowSessionNV(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks);
19551
19552    /// Available if built with `exported-prototypes`.
19553    #[cfg(any(doc, feature = "exported-prototypes"))]
19554    pub fn vkDestroyPipeline(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks);
19555
19556    /// Available if built with `prototypes`.
19557    #[cfg(any(doc, feature = "prototypes"))]
19558    pub fn vkDestroyPipelineBinaryKHR(device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks);
19559
19560    /// Available if built with `exported-prototypes`.
19561    #[cfg(any(doc, feature = "exported-prototypes"))]
19562    pub fn vkDestroyPipelineCache(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks);
19563
19564    /// Available if built with `exported-prototypes`.
19565    #[cfg(any(doc, feature = "exported-prototypes"))]
19566    pub fn vkDestroyPipelineLayout(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks);
19567
19568    /// Available if built with `exported-prototypes`.
19569    #[cfg(any(doc, feature = "exported-prototypes"))]
19570    pub fn vkDestroyPrivateDataSlot(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
19571
19572    /// Available if built with `prototypes`.
19573    #[cfg(any(doc, feature = "prototypes"))]
19574    pub fn vkDestroyPrivateDataSlotEXT(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
19575
19576    /// Available if built with `exported-prototypes`.
19577    #[cfg(any(doc, feature = "exported-prototypes"))]
19578    pub fn vkDestroyQueryPool(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks);
19579
19580    /// Available if built with `exported-prototypes`.
19581    #[cfg(any(doc, feature = "exported-prototypes"))]
19582    pub fn vkDestroyRenderPass(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks);
19583
19584    /// Available if built with `exported-prototypes`.
19585    #[cfg(any(doc, feature = "exported-prototypes"))]
19586    pub fn vkDestroySampler(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks);
19587
19588    /// Available if built with `exported-prototypes`.
19589    #[cfg(any(doc, feature = "exported-prototypes"))]
19590    pub fn vkDestroySamplerYcbcrConversion(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
19591
19592    /// Available if built with `prototypes`.
19593    #[cfg(any(doc, feature = "prototypes"))]
19594    pub fn vkDestroySamplerYcbcrConversionKHR(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
19595
19596    /// Available if built with `exported-prototypes`.
19597    #[cfg(any(doc, feature = "exported-prototypes"))]
19598    pub fn vkDestroySemaphore(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks);
19599
19600    /// Available if built with `prototypes`.
19601    #[cfg(any(doc, feature = "prototypes"))]
19602    pub fn vkDestroyShaderEXT(device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks);
19603
19604    /// Available if built with `exported-prototypes`.
19605    #[cfg(any(doc, feature = "exported-prototypes"))]
19606    pub fn vkDestroyShaderModule(device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks);
19607
19608    /// Available if built with `prototypes`.
19609    #[cfg(any(doc, feature = "prototypes"))]
19610    pub fn vkDestroySurfaceKHR(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks);
19611
19612    /// Available if built with `prototypes`.
19613    #[cfg(any(doc, feature = "prototypes"))]
19614    pub fn vkDestroySwapchainKHR(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks);
19615
19616    /// Available if built with `prototypes`.
19617    #[cfg(any(doc, feature = "prototypes"))]
19618    pub fn vkDestroyTensorARM(device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks);
19619
19620    /// Available if built with `prototypes`.
19621    #[cfg(any(doc, feature = "prototypes"))]
19622    pub fn vkDestroyTensorViewARM(device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks);
19623
19624    /// Available if built with `prototypes`.
19625    #[cfg(any(doc, feature = "prototypes"))]
19626    pub fn vkDestroyValidationCacheEXT(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks);
19627
19628    /// Available if built with `prototypes`.
19629    #[cfg(any(doc, feature = "prototypes"))]
19630    pub fn vkDestroyVideoSessionKHR(device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks);
19631
19632    /// Available if built with `prototypes`.
19633    #[cfg(any(doc, feature = "prototypes"))]
19634    pub fn vkDestroyVideoSessionParametersKHR(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks);
19635
19636    /// Available if built with `exported-prototypes`.
19637    #[cfg(any(doc, feature = "exported-prototypes"))]
19638    pub fn vkDeviceWaitIdle(device: VkDevice) -> VkResult;
19639
19640    /// Available if built with `prototypes`.
19641    #[cfg(any(doc, feature = "prototypes"))]
19642    pub fn vkDisplayPowerControlEXT(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult;
19643
19644    /// Available if built with `exported-prototypes`.
19645    #[cfg(any(doc, feature = "exported-prototypes"))]
19646    pub fn vkEndCommandBuffer(commandBuffer: VkCommandBuffer) -> VkResult;
19647
19648    /// Available if built with `exported-prototypes`.
19649    #[cfg(any(doc, feature = "exported-prototypes"))]
19650    pub fn vkEnumerateDeviceExtensionProperties(physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
19651
19652    /// Available if built with `exported-prototypes`.
19653    #[cfg(any(doc, feature = "exported-prototypes"))]
19654    pub fn vkEnumerateDeviceLayerProperties(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
19655
19656    /// Available if built with `exported-prototypes`.
19657    #[cfg(any(doc, feature = "exported-prototypes"))]
19658    pub fn vkEnumerateInstanceExtensionProperties(pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
19659
19660    /// Available if built with `exported-prototypes`.
19661    #[cfg(any(doc, feature = "exported-prototypes"))]
19662    pub fn vkEnumerateInstanceLayerProperties(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
19663
19664    /// Available if built with `exported-prototypes`.
19665    #[cfg(any(doc, feature = "exported-prototypes"))]
19666    pub fn vkEnumerateInstanceVersion(pApiVersion: *mut u32) -> VkResult;
19667
19668    /// Available if built with `exported-prototypes`.
19669    #[cfg(any(doc, feature = "exported-prototypes"))]
19670    pub fn vkEnumeratePhysicalDeviceGroups(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
19671
19672    /// Available if built with `prototypes`.
19673    #[cfg(any(doc, feature = "prototypes"))]
19674    pub fn vkEnumeratePhysicalDeviceGroupsKHR(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
19675
19676    /// Available if built with `prototypes`.
19677    #[cfg(any(doc, feature = "prototypes"))]
19678    pub fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult;
19679
19680    /// Available if built with `prototypes`.
19681    #[cfg(any(doc, feature = "prototypes"))]
19682    pub fn vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult;
19683
19684    /// Available if built with `exported-prototypes`.
19685    #[cfg(any(doc, feature = "exported-prototypes"))]
19686    pub fn vkEnumeratePhysicalDevices(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;
19687
19688    /// Available if built with `exported-prototypes`.
19689    #[cfg(any(doc, feature = "exported-prototypes"))]
19690    pub fn vkFlushMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
19691
19692    /// Available if built with `exported-prototypes`.
19693    #[cfg(any(doc, feature = "exported-prototypes"))]
19694    pub fn vkFreeCommandBuffers(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
19695
19696    /// Available if built with `exported-prototypes`.
19697    #[cfg(any(doc, feature = "exported-prototypes"))]
19698    pub fn vkFreeDescriptorSets(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult;
19699
19700    /// Available if built with `exported-prototypes`.
19701    #[cfg(any(doc, feature = "exported-prototypes"))]
19702    pub fn vkFreeMemory(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks);
19703
19704    /// Available if built with `prototypes`.
19705    #[cfg(any(doc, feature = "prototypes"))]
19706    pub fn vkGetAccelerationStructureBuildSizesKHR(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const u32, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
19707
19708    /// Available if built with `prototypes`.
19709    #[cfg(any(doc, feature = "prototypes"))]
19710    pub fn vkGetAccelerationStructureDeviceAddressKHR(device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress;
19711
19712    /// Available if built with `prototypes`.
19713    #[cfg(any(doc, feature = "prototypes"))]
19714    pub fn vkGetAccelerationStructureHandleNV(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: usize, pData: *mut c_void) -> VkResult;
19715
19716    /// Available if built with `prototypes`.
19717    #[cfg(any(doc, feature = "prototypes"))]
19718    pub fn vkGetAccelerationStructureMemoryRequirementsNV(device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR);
19719
19720    /// Available if built with `prototypes`.
19721    #[cfg(any(doc, feature = "prototypes"))]
19722    pub fn vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
19723
19724    /// Available if built with `exported-prototypes`.
19725    #[cfg(any(doc, feature = "exported-prototypes"))]
19726    pub fn vkGetBufferDeviceAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
19727
19728    /// Available if built with `prototypes`.
19729    #[cfg(any(doc, feature = "prototypes"))]
19730    pub fn vkGetBufferDeviceAddressEXT(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
19731
19732    /// Available if built with `prototypes`.
19733    #[cfg(any(doc, feature = "prototypes"))]
19734    pub fn vkGetBufferDeviceAddressKHR(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
19735
19736    /// Available if built with `exported-prototypes`.
19737    #[cfg(any(doc, feature = "exported-prototypes"))]
19738    pub fn vkGetBufferMemoryRequirements(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements);
19739
19740    /// Available if built with `exported-prototypes`.
19741    #[cfg(any(doc, feature = "exported-prototypes"))]
19742    pub fn vkGetBufferMemoryRequirements2(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19743
19744    /// Available if built with `prototypes`.
19745    #[cfg(any(doc, feature = "prototypes"))]
19746    pub fn vkGetBufferMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19747
19748    /// Available if built with `exported-prototypes`.
19749    #[cfg(any(doc, feature = "exported-prototypes"))]
19750    pub fn vkGetBufferOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
19751
19752    /// Available if built with `prototypes`.
19753    #[cfg(any(doc, feature = "prototypes"))]
19754    pub fn vkGetBufferOpaqueCaptureAddressKHR(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
19755
19756    /// Available if built with `prototypes`.
19757    #[cfg(any(doc, feature = "prototypes"))]
19758    pub fn vkGetBufferOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
19759
19760    /// Available if built with `prototypes`.
19761    #[cfg(any(doc, feature = "prototypes"))]
19762    pub fn vkGetCalibratedTimestampsEXT(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
19763
19764    /// Available if built with `prototypes`.
19765    #[cfg(any(doc, feature = "prototypes"))]
19766    pub fn vkGetCalibratedTimestampsKHR(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
19767
19768    /// Available if built with `prototypes`.
19769    #[cfg(any(doc, feature = "prototypes"))]
19770    pub fn vkGetClusterAccelerationStructureBuildSizesNV(device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
19771
19772    /// Available if built with `prototypes`.
19773    #[cfg(any(doc, feature = "prototypes"))]
19774    pub fn vkGetDataGraphPipelineAvailablePropertiesARM(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut u32, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult;
19775
19776    /// Available if built with `prototypes`.
19777    #[cfg(any(doc, feature = "prototypes"))]
19778    pub fn vkGetDataGraphPipelinePropertiesARM(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: u32, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult;
19779
19780    /// Available if built with `prototypes`.
19781    #[cfg(any(doc, feature = "prototypes"))]
19782    pub fn vkGetDataGraphPipelineSessionBindPointRequirementsARM(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut u32, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult;
19783
19784    /// Available if built with `prototypes`.
19785    #[cfg(any(doc, feature = "prototypes"))]
19786    pub fn vkGetDataGraphPipelineSessionMemoryRequirementsARM(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
19787
19788    /// Available if built with `prototypes`.
19789    #[cfg(any(doc, feature = "prototypes"))]
19790    pub fn vkGetDeferredOperationMaxConcurrencyKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> u32;
19791
19792    /// Available if built with `prototypes`.
19793    #[cfg(any(doc, feature = "prototypes"))]
19794    pub fn vkGetDeferredOperationResultKHR(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
19795
19796    /// Available if built with `prototypes`.
19797    #[cfg(any(doc, feature = "prototypes"))]
19798    pub fn vkGetDescriptorEXT(device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: usize, pDescriptor: *mut c_void);
19799
19800    /// Available if built with `prototypes`.
19801    #[cfg(any(doc, feature = "prototypes"))]
19802    pub fn vkGetDescriptorSetHostMappingVALVE(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut c_void);
19803
19804    /// Available if built with `prototypes`.
19805    #[cfg(any(doc, feature = "prototypes"))]
19806    pub fn vkGetDescriptorSetLayoutBindingOffsetEXT(device: VkDevice, layout: VkDescriptorSetLayout, binding: u32, pOffset: *mut VkDeviceSize);
19807
19808    /// Available if built with `prototypes`.
19809    #[cfg(any(doc, feature = "prototypes"))]
19810    pub fn vkGetDescriptorSetLayoutHostMappingInfoVALVE(device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE);
19811
19812    /// Available if built with `prototypes`.
19813    #[cfg(any(doc, feature = "prototypes"))]
19814    pub fn vkGetDescriptorSetLayoutSizeEXT(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize);
19815
19816    /// Available if built with `exported-prototypes`.
19817    #[cfg(any(doc, feature = "exported-prototypes"))]
19818    pub fn vkGetDescriptorSetLayoutSupport(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
19819
19820    /// Available if built with `prototypes`.
19821    #[cfg(any(doc, feature = "prototypes"))]
19822    pub fn vkGetDescriptorSetLayoutSupportKHR(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
19823
19824    /// Available if built with `prototypes`.
19825    #[cfg(any(doc, feature = "prototypes"))]
19826    pub fn vkGetDeviceAccelerationStructureCompatibilityKHR(device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
19827
19828    /// Available if built with `exported-prototypes`.
19829    #[cfg(any(doc, feature = "exported-prototypes"))]
19830    pub fn vkGetDeviceBufferMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19831
19832    /// Available if built with `prototypes`.
19833    #[cfg(any(doc, feature = "prototypes"))]
19834    pub fn vkGetDeviceBufferMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19835
19836    /// Available if built with `prototypes`.
19837    #[cfg(any(doc, feature = "prototypes"))]
19838    pub fn vkGetDeviceCombinedImageSamplerIndexNVX(device: VkDevice, imageViewIndex: u64, samplerIndex: u64) -> u64;
19839
19840    /// Available if built with `prototypes`.
19841    #[cfg(any(doc, feature = "prototypes"))]
19842    pub fn vkGetDeviceFaultInfoEXT(device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult;
19843
19844    /// Available if built with `exported-prototypes`.
19845    #[cfg(any(doc, feature = "exported-prototypes"))]
19846    pub fn vkGetDeviceGroupPeerMemoryFeatures(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
19847
19848    /// Available if built with `prototypes`.
19849    #[cfg(any(doc, feature = "prototypes"))]
19850    pub fn vkGetDeviceGroupPeerMemoryFeaturesKHR(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
19851
19852    /// Available if built with `prototypes`.
19853    #[cfg(any(doc, feature = "prototypes"))]
19854    pub fn vkGetDeviceGroupPresentCapabilitiesKHR(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult;
19855
19856    /// Available if built with `prototypes`.
19857    #[cfg(any(doc, feature = "prototypes"))]
19858    pub fn vkGetDeviceGroupSurfacePresentModesKHR(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;
19859
19860    /// Available if built with `exported-prototypes`.
19861    #[cfg(any(doc, feature = "exported-prototypes"))]
19862    pub fn vkGetDeviceImageMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19863
19864    /// Available if built with `prototypes`.
19865    #[cfg(any(doc, feature = "prototypes"))]
19866    pub fn vkGetDeviceImageMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
19867
19868    /// Available if built with `exported-prototypes`.
19869    #[cfg(any(doc, feature = "exported-prototypes"))]
19870    pub fn vkGetDeviceImageSparseMemoryRequirements(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
19871
19872    /// Available if built with `prototypes`.
19873    #[cfg(any(doc, feature = "prototypes"))]
19874    pub fn vkGetDeviceImageSparseMemoryRequirementsKHR(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
19875
19876    /// Available if built with `exported-prototypes`.
19877    #[cfg(any(doc, feature = "exported-prototypes"))]
19878    pub fn vkGetDeviceImageSubresourceLayout(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
19879
19880    /// Available if built with `prototypes`.
19881    #[cfg(any(doc, feature = "prototypes"))]
19882    pub fn vkGetDeviceImageSubresourceLayoutKHR(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
19883
19884    /// Available if built with `exported-prototypes`.
19885    #[cfg(any(doc, feature = "exported-prototypes"))]
19886    pub fn vkGetDeviceMemoryCommitment(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize);
19887
19888    /// Available if built with `exported-prototypes`.
19889    #[cfg(any(doc, feature = "exported-prototypes"))]
19890    pub fn vkGetDeviceMemoryOpaqueCaptureAddress(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
19891
19892    /// Available if built with `prototypes`.
19893    #[cfg(any(doc, feature = "prototypes"))]
19894    pub fn vkGetDeviceMemoryOpaqueCaptureAddressKHR(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
19895
19896    /// Available if built with `prototypes`.
19897    #[cfg(any(doc, feature = "prototypes"))]
19898    pub fn vkGetDeviceMicromapCompatibilityEXT(device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
19899
19900    /// Available if built with `exported-prototypes`.
19901    #[cfg(any(doc, feature = "exported-prototypes"))]
19902    pub fn vkGetDeviceProcAddr(device: VkDevice, pName: *const c_char) -> PFN_vkVoidFunction;
19903
19904    /// Available if built with `exported-prototypes`.
19905    #[cfg(any(doc, feature = "exported-prototypes"))]
19906    pub fn vkGetDeviceQueue(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue);
19907
19908    /// Available if built with `exported-prototypes`.
19909    #[cfg(any(doc, feature = "exported-prototypes"))]
19910    pub fn vkGetDeviceQueue2(device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue);
19911
19912    /// Available if built with `prototypes`.
19913    #[cfg(any(doc, feature = "prototypes"))]
19914    pub fn vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult;
19915
19916    /// Available if built with `prototypes`.
19917    #[cfg(any(doc, feature = "prototypes"))]
19918    pub fn vkGetDeviceTensorMemoryRequirementsARM(device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2);
19919
19920    /// Available if built with `prototypes`.
19921    #[cfg(any(doc, feature = "prototypes"))]
19922    pub fn vkGetDisplayModeProperties2KHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult;
19923
19924    /// Available if built with `prototypes`.
19925    #[cfg(any(doc, feature = "prototypes"))]
19926    pub fn vkGetDisplayModePropertiesKHR(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;
19927
19928    /// Available if built with `prototypes`.
19929    #[cfg(any(doc, feature = "prototypes"))]
19930    pub fn vkGetDisplayPlaneCapabilities2KHR(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult;
19931
19932    /// Available if built with `prototypes`.
19933    #[cfg(any(doc, feature = "prototypes"))]
19934    pub fn vkGetDisplayPlaneCapabilitiesKHR(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;
19935
19936    /// Available if built with `prototypes`.
19937    #[cfg(any(doc, feature = "prototypes"))]
19938    pub fn vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult;
19939
19940    /// Available if built with `prototypes`.
19941    #[cfg(any(doc, feature = "prototypes"))]
19942    pub fn vkGetDrmDisplayEXT(physicalDevice: VkPhysicalDevice, drmFd: i32, connectorId: u32, display: *mut VkDisplayKHR) -> VkResult;
19943
19944    /// Available if built with `prototypes`.
19945    #[cfg(any(doc, feature = "prototypes"))]
19946    pub fn vkGetDynamicRenderingTilePropertiesQCOM(device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
19947
19948    /// Available if built with `prototypes`.
19949    #[cfg(any(doc, feature = "prototypes"))]
19950    pub fn vkGetEncodedVideoSessionParametersKHR(device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
19951
19952    /// Available if built with `exported-prototypes`.
19953    #[cfg(any(doc, feature = "exported-prototypes"))]
19954    pub fn vkGetEventStatus(device: VkDevice, event: VkEvent) -> VkResult;
19955
19956    /// Available if built with `prototypes`.
19957    #[cfg(any(doc, feature = "prototypes"))]
19958    pub fn vkGetExternalComputeQueueDataNV(externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut c_void);
19959
19960    /// Available if built with `prototypes`.
19961    #[cfg(any(doc, feature = "prototypes"))]
19962    pub fn vkGetFenceFdKHR(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
19963
19964    /// Available if built with `exported-prototypes`.
19965    #[cfg(any(doc, feature = "exported-prototypes"))]
19966    pub fn vkGetFenceStatus(device: VkDevice, fence: VkFence) -> VkResult;
19967
19968    /// Available if built with `prototypes`.
19969    #[cfg(any(doc, feature = "prototypes"))]
19970    pub fn vkGetFramebufferTilePropertiesQCOM(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut u32, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
19971
19972    /// Available if built with `prototypes`.
19973    #[cfg(any(doc, feature = "prototypes"))]
19974    pub fn vkGetGeneratedCommandsMemoryRequirementsEXT(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2);
19975
19976    /// Available if built with `prototypes`.
19977    #[cfg(any(doc, feature = "prototypes"))]
19978    pub fn vkGetGeneratedCommandsMemoryRequirementsNV(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2);
19979
19980    /// Available if built with `prototypes`.
19981    #[cfg(any(doc, feature = "prototypes"))]
19982    pub fn vkGetImageDrmFormatModifierPropertiesEXT(device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult;
19983
19984    /// Available if built with `exported-prototypes`.
19985    #[cfg(any(doc, feature = "exported-prototypes"))]
19986    pub fn vkGetImageMemoryRequirements(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements);
19987
19988    /// Available if built with `exported-prototypes`.
19989    #[cfg(any(doc, feature = "exported-prototypes"))]
19990    pub fn vkGetImageMemoryRequirements2(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19991
19992    /// Available if built with `prototypes`.
19993    #[cfg(any(doc, feature = "prototypes"))]
19994    pub fn vkGetImageMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
19995
19996    /// Available if built with `prototypes`.
19997    #[cfg(any(doc, feature = "prototypes"))]
19998    pub fn vkGetImageOpaqueCaptureDataEXT(device: VkDevice, imageCount: u32, pImages: *const VkImage, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
19999
20000    /// Available if built with `prototypes`.
20001    #[cfg(any(doc, feature = "prototypes"))]
20002    pub fn vkGetImageOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
20003
20004    /// Available if built with `exported-prototypes`.
20005    #[cfg(any(doc, feature = "exported-prototypes"))]
20006    pub fn vkGetImageSparseMemoryRequirements(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);
20007
20008    /// Available if built with `exported-prototypes`.
20009    #[cfg(any(doc, feature = "exported-prototypes"))]
20010    pub fn vkGetImageSparseMemoryRequirements2(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
20011
20012    /// Available if built with `prototypes`.
20013    #[cfg(any(doc, feature = "prototypes"))]
20014    pub fn vkGetImageSparseMemoryRequirements2KHR(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
20015
20016    /// Available if built with `exported-prototypes`.
20017    #[cfg(any(doc, feature = "exported-prototypes"))]
20018    pub fn vkGetImageSubresourceLayout(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout);
20019
20020    /// Available if built with `exported-prototypes`.
20021    #[cfg(any(doc, feature = "exported-prototypes"))]
20022    pub fn vkGetImageSubresourceLayout2(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
20023
20024    /// Available if built with `prototypes`.
20025    #[cfg(any(doc, feature = "prototypes"))]
20026    pub fn vkGetImageSubresourceLayout2EXT(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
20027
20028    /// Available if built with `prototypes`.
20029    #[cfg(any(doc, feature = "prototypes"))]
20030    pub fn vkGetImageSubresourceLayout2KHR(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
20031
20032    /// Available if built with `prototypes`.
20033    #[cfg(any(doc, feature = "prototypes"))]
20034    pub fn vkGetImageViewAddressNVX(device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult;
20035
20036    /// Available if built with `prototypes`.
20037    #[cfg(any(doc, feature = "prototypes"))]
20038    pub fn vkGetImageViewHandle64NVX(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u64;
20039
20040    /// Available if built with `prototypes`.
20041    #[cfg(any(doc, feature = "prototypes"))]
20042    pub fn vkGetImageViewHandleNVX(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u32;
20043
20044    /// Available if built with `prototypes`.
20045    #[cfg(any(doc, feature = "prototypes"))]
20046    pub fn vkGetImageViewOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
20047
20048    /// Available if built with `exported-prototypes`.
20049    #[cfg(any(doc, feature = "exported-prototypes"))]
20050    pub fn vkGetInstanceProcAddr(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
20051
20052    /// Available if built with `prototypes`.
20053    #[cfg(any(doc, feature = "prototypes"))]
20054    pub fn vkGetLatencyTimingsNV(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV);
20055
20056    /// Available if built with `prototypes`.
20057    #[cfg(any(doc, feature = "prototypes"))]
20058    pub fn vkGetMemoryFdKHR(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
20059
20060    /// Available if built with `prototypes`.
20061    #[cfg(any(doc, feature = "prototypes"))]
20062    pub fn vkGetMemoryFdPropertiesKHR(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: c_int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult;
20063
20064    /// Available if built with `prototypes`.
20065    #[cfg(any(doc, feature = "prototypes"))]
20066    pub fn vkGetMemoryHostPointerPropertiesEXT(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: *const c_void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult;
20067
20068    /// Available if built with `prototypes`.
20069    #[cfg(any(doc, feature = "prototypes"))]
20070    pub fn vkGetMemoryRemoteAddressNV(device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult;
20071
20072    /// Available if built with `prototypes`.
20073    #[cfg(any(doc, feature = "prototypes"))]
20074    pub fn vkGetMicromapBuildSizesEXT(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT);
20075
20076    /// Available if built with `prototypes`.
20077    #[cfg(any(doc, feature = "prototypes"))]
20078    pub fn vkGetPartitionedAccelerationStructuresBuildSizesNV(device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
20079
20080    /// Available if built with `prototypes`.
20081    #[cfg(any(doc, feature = "prototypes"))]
20082    pub fn vkGetPastPresentationTimingEXT(device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult;
20083
20084    /// Available if built with `prototypes`.
20085    #[cfg(any(doc, feature = "prototypes"))]
20086    pub fn vkGetPastPresentationTimingGOOGLE(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut u32, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult;
20087
20088    /// Available if built with `prototypes`.
20089    #[cfg(any(doc, feature = "prototypes"))]
20090    pub fn vkGetPerformanceParameterINTEL(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult;
20091
20092    /// Available if built with `prototypes`.
20093    #[cfg(any(doc, feature = "prototypes"))]
20094    pub fn vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
20095
20096    /// Available if built with `prototypes`.
20097    #[cfg(any(doc, feature = "prototypes"))]
20098    pub fn vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
20099
20100    /// Available if built with `prototypes`.
20101    #[cfg(any(doc, feature = "prototypes"))]
20102    pub fn vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult;
20103
20104    /// Available if built with `prototypes`.
20105    #[cfg(any(doc, feature = "prototypes"))]
20106    pub fn vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult;
20107
20108    /// Available if built with `prototypes`.
20109    #[cfg(any(doc, feature = "prototypes"))]
20110    pub fn vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult;
20111
20112    /// Available if built with `prototypes`.
20113    #[cfg(any(doc, feature = "prototypes"))]
20114    pub fn vkGetPhysicalDeviceCooperativeVectorPropertiesNV(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult;
20115
20116    /// Available if built with `prototypes`.
20117    #[cfg(any(doc, feature = "prototypes"))]
20118    pub fn vkGetPhysicalDeviceDescriptorSizeEXT(physicalDevice: VkPhysicalDevice, descriptorType: VkDescriptorType) -> VkDeviceSize;
20119
20120    /// Available if built with `prototypes`.
20121    #[cfg(any(doc, feature = "prototypes"))]
20122    pub fn vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult;
20123
20124    /// Available if built with `prototypes`.
20125    #[cfg(any(doc, feature = "prototypes"))]
20126    pub fn vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;
20127
20128    /// Available if built with `prototypes`.
20129    #[cfg(any(doc, feature = "prototypes"))]
20130    pub fn vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayProperties2KHR) -> VkResult;
20131
20132    /// Available if built with `prototypes`.
20133    #[cfg(any(doc, feature = "prototypes"))]
20134    pub fn vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;
20135
20136    /// Available if built with `exported-prototypes`.
20137    #[cfg(any(doc, feature = "exported-prototypes"))]
20138    pub fn vkGetPhysicalDeviceExternalBufferProperties(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
20139
20140    /// Available if built with `prototypes`.
20141    #[cfg(any(doc, feature = "prototypes"))]
20142    pub fn vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
20143
20144    /// Available if built with `exported-prototypes`.
20145    #[cfg(any(doc, feature = "exported-prototypes"))]
20146    pub fn vkGetPhysicalDeviceExternalFenceProperties(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
20147
20148    /// Available if built with `prototypes`.
20149    #[cfg(any(doc, feature = "prototypes"))]
20150    pub fn vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
20151
20152    /// Available if built with `prototypes`.
20153    #[cfg(any(doc, feature = "prototypes"))]
20154    pub fn vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, externalHandleType: VkExternalMemoryHandleTypeFlagsNV, pExternalImageFormatProperties: *mut VkExternalImageFormatPropertiesNV) -> VkResult;
20155
20156    /// Available if built with `exported-prototypes`.
20157    #[cfg(any(doc, feature = "exported-prototypes"))]
20158    pub fn vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
20159
20160    /// Available if built with `prototypes`.
20161    #[cfg(any(doc, feature = "prototypes"))]
20162    pub fn vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
20163
20164    /// Available if built with `prototypes`.
20165    #[cfg(any(doc, feature = "prototypes"))]
20166    pub fn vkGetPhysicalDeviceExternalTensorPropertiesARM(physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM);
20167
20168    /// Available if built with `exported-prototypes`.
20169    #[cfg(any(doc, feature = "exported-prototypes"))]
20170    pub fn vkGetPhysicalDeviceFeatures(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures);
20171
20172    /// Available if built with `exported-prototypes`.
20173    #[cfg(any(doc, feature = "exported-prototypes"))]
20174    pub fn vkGetPhysicalDeviceFeatures2(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
20175
20176    /// Available if built with `prototypes`.
20177    #[cfg(any(doc, feature = "prototypes"))]
20178    pub fn vkGetPhysicalDeviceFeatures2KHR(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
20179
20180    /// Available if built with `exported-prototypes`.
20181    #[cfg(any(doc, feature = "exported-prototypes"))]
20182    pub fn vkGetPhysicalDeviceFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties);
20183
20184    /// Available if built with `exported-prototypes`.
20185    #[cfg(any(doc, feature = "exported-prototypes"))]
20186    pub fn vkGetPhysicalDeviceFormatProperties2(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
20187
20188    /// Available if built with `prototypes`.
20189    #[cfg(any(doc, feature = "prototypes"))]
20190    pub fn vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
20191
20192    /// Available if built with `prototypes`.
20193    #[cfg(any(doc, feature = "prototypes"))]
20194    pub fn vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut u32, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult;
20195
20196    /// Available if built with `exported-prototypes`.
20197    #[cfg(any(doc, feature = "exported-prototypes"))]
20198    pub fn vkGetPhysicalDeviceImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;
20199
20200    /// Available if built with `exported-prototypes`.
20201    #[cfg(any(doc, feature = "exported-prototypes"))]
20202    pub fn vkGetPhysicalDeviceImageFormatProperties2(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
20203
20204    /// Available if built with `prototypes`.
20205    #[cfg(any(doc, feature = "prototypes"))]
20206    pub fn vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
20207
20208    /// Available if built with `exported-prototypes`.
20209    #[cfg(any(doc, feature = "exported-prototypes"))]
20210    pub fn vkGetPhysicalDeviceMemoryProperties(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);
20211
20212    /// Available if built with `exported-prototypes`.
20213    #[cfg(any(doc, feature = "exported-prototypes"))]
20214    pub fn vkGetPhysicalDeviceMemoryProperties2(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
20215
20216    /// Available if built with `prototypes`.
20217    #[cfg(any(doc, feature = "prototypes"))]
20218    pub fn vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
20219
20220    /// Available if built with `prototypes`.
20221    #[cfg(any(doc, feature = "prototypes"))]
20222    pub fn vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: *mut VkMultisamplePropertiesEXT);
20223
20224    /// Available if built with `prototypes`.
20225    #[cfg(any(doc, feature = "prototypes"))]
20226    pub fn vkGetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut u32, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult;
20227
20228    /// Available if built with `prototypes`.
20229    #[cfg(any(doc, feature = "prototypes"))]
20230    pub fn vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut u32, pRects: *mut VkRect2D) -> VkResult;
20231
20232    /// Available if built with `exported-prototypes`.
20233    #[cfg(any(doc, feature = "exported-prototypes"))]
20234    pub fn vkGetPhysicalDeviceProperties(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties);
20235
20236    /// Available if built with `exported-prototypes`.
20237    #[cfg(any(doc, feature = "exported-prototypes"))]
20238    pub fn vkGetPhysicalDeviceProperties2(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
20239
20240    /// Available if built with `prototypes`.
20241    #[cfg(any(doc, feature = "prototypes"))]
20242    pub fn vkGetPhysicalDeviceProperties2KHR(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
20243
20244    /// Available if built with `prototypes`.
20245    #[cfg(any(doc, feature = "prototypes"))]
20246    pub fn vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM(physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM);
20247
20248    /// Available if built with `prototypes`.
20249    #[cfg(any(doc, feature = "prototypes"))]
20250    pub fn vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pQueueFamilyDataGraphPropertyCount: *mut u32, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult;
20251
20252    /// Available if built with `prototypes`.
20253    #[cfg(any(doc, feature = "prototypes"))]
20254    pub fn vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut u32);
20255
20256    /// Available if built with `exported-prototypes`.
20257    #[cfg(any(doc, feature = "exported-prototypes"))]
20258    pub fn vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties);
20259
20260    /// Available if built with `exported-prototypes`.
20261    #[cfg(any(doc, feature = "exported-prototypes"))]
20262    pub fn vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
20263
20264    /// Available if built with `prototypes`.
20265    #[cfg(any(doc, feature = "prototypes"))]
20266    pub fn vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
20267
20268    /// Available if built with `exported-prototypes`.
20269    #[cfg(any(doc, feature = "exported-prototypes"))]
20270    pub fn vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, samples: VkSampleCountFlagBits, usage: VkImageUsageFlags, tiling: VkImageTiling, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties);
20271
20272    /// Available if built with `exported-prototypes`.
20273    #[cfg(any(doc, feature = "exported-prototypes"))]
20274    pub fn vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
20275
20276    /// Available if built with `prototypes`.
20277    #[cfg(any(doc, feature = "prototypes"))]
20278    pub fn vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
20279
20280    /// Available if built with `prototypes`.
20281    #[cfg(any(doc, feature = "prototypes"))]
20282    pub fn vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice: VkPhysicalDevice, pCombinationCount: *mut u32, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult;
20283
20284    /// Available if built with `prototypes`.
20285    #[cfg(any(doc, feature = "prototypes"))]
20286    pub fn vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult;
20287
20288    /// Available if built with `prototypes`.
20289    #[cfg(any(doc, feature = "prototypes"))]
20290    pub fn vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult;
20291
20292    /// Available if built with `prototypes`.
20293    #[cfg(any(doc, feature = "prototypes"))]
20294    pub fn vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;
20295
20296    /// Available if built with `prototypes`.
20297    #[cfg(any(doc, feature = "prototypes"))]
20298    pub fn vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult;
20299
20300    /// Available if built with `prototypes`.
20301    #[cfg(any(doc, feature = "prototypes"))]
20302    pub fn vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;
20303
20304    /// Available if built with `prototypes`.
20305    #[cfg(any(doc, feature = "prototypes"))]
20306    pub fn vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult;
20307
20308    /// Available if built with `prototypes`.
20309    #[cfg(any(doc, feature = "prototypes"))]
20310    pub fn vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;
20311
20312    /// Available if built with `exported-prototypes`.
20313    #[cfg(any(doc, feature = "exported-prototypes"))]
20314    pub fn vkGetPhysicalDeviceToolProperties(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
20315
20316    /// Available if built with `prototypes`.
20317    #[cfg(any(doc, feature = "prototypes"))]
20318    pub fn vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
20319
20320    /// Available if built with `prototypes`.
20321    #[cfg(any(doc, feature = "prototypes"))]
20322    pub fn vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult;
20323
20324    /// Available if built with `prototypes`.
20325    #[cfg(any(doc, feature = "prototypes"))]
20326    pub fn vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult;
20327
20328    /// Available if built with `prototypes`.
20329    #[cfg(any(doc, feature = "prototypes"))]
20330    pub fn vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut u32, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult;
20331
20332    /// Available if built with `prototypes`.
20333    #[cfg(any(doc, feature = "prototypes"))]
20334    pub fn vkGetPipelineBinaryDataKHR(device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut usize, pPipelineBinaryData: *mut c_void) -> VkResult;
20335
20336    /// Available if built with `exported-prototypes`.
20337    #[cfg(any(doc, feature = "exported-prototypes"))]
20338    pub fn vkGetPipelineCacheData(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
20339
20340    /// Available if built with `prototypes`.
20341    #[cfg(any(doc, feature = "prototypes"))]
20342    pub fn vkGetPipelineExecutableInternalRepresentationsKHR(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut u32, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult;
20343
20344    /// Available if built with `prototypes`.
20345    #[cfg(any(doc, feature = "prototypes"))]
20346    pub fn vkGetPipelineExecutablePropertiesKHR(device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut u32, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult;
20347
20348    /// Available if built with `prototypes`.
20349    #[cfg(any(doc, feature = "prototypes"))]
20350    pub fn vkGetPipelineExecutableStatisticsKHR(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut u32, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult;
20351
20352    /// Available if built with `prototypes`.
20353    #[cfg(any(doc, feature = "prototypes"))]
20354    pub fn vkGetPipelineIndirectDeviceAddressNV(device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress;
20355
20356    /// Available if built with `prototypes`.
20357    #[cfg(any(doc, feature = "prototypes"))]
20358    pub fn vkGetPipelineIndirectMemoryRequirementsNV(device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2);
20359
20360    /// Available if built with `prototypes`.
20361    #[cfg(any(doc, feature = "prototypes"))]
20362    pub fn vkGetPipelineKeyKHR(device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult;
20363
20364    /// Available if built with `prototypes`.
20365    #[cfg(any(doc, feature = "prototypes"))]
20366    pub fn vkGetPipelinePropertiesEXT(device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult;
20367
20368    /// Available if built with `exported-prototypes`.
20369    #[cfg(any(doc, feature = "exported-prototypes"))]
20370    pub fn vkGetPrivateData(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
20371
20372    /// Available if built with `prototypes`.
20373    #[cfg(any(doc, feature = "prototypes"))]
20374    pub fn vkGetPrivateDataEXT(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
20375
20376    /// Available if built with `exported-prototypes`.
20377    #[cfg(any(doc, feature = "exported-prototypes"))]
20378    pub fn vkGetQueryPoolResults(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dataSize: usize, pData: *mut c_void, stride: VkDeviceSize, flags: VkQueryResultFlags) -> VkResult;
20379
20380    /// Available if built with `prototypes`.
20381    #[cfg(any(doc, feature = "prototypes"))]
20382    pub fn vkGetQueueCheckpointData2NV(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointData2NV);
20383
20384    /// Available if built with `prototypes`.
20385    #[cfg(any(doc, feature = "prototypes"))]
20386    pub fn vkGetQueueCheckpointDataNV(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointDataNV);
20387
20388    /// Available if built with `prototypes`.
20389    #[cfg(any(doc, feature = "prototypes"))]
20390    pub fn vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
20391
20392    /// Available if built with `prototypes`.
20393    #[cfg(any(doc, feature = "prototypes"))]
20394    pub fn vkGetRayTracingShaderGroupHandlesKHR(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
20395
20396    /// Available if built with `prototypes`.
20397    #[cfg(any(doc, feature = "prototypes"))]
20398    pub fn vkGetRayTracingShaderGroupHandlesNV(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
20399
20400    /// Available if built with `prototypes`.
20401    #[cfg(any(doc, feature = "prototypes"))]
20402    pub fn vkGetRayTracingShaderGroupStackSizeKHR(device: VkDevice, pipeline: VkPipeline, group: u32, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize;
20403
20404    /// Available if built with `prototypes`.
20405    #[cfg(any(doc, feature = "prototypes"))]
20406    pub fn vkGetRefreshCycleDurationGOOGLE(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult;
20407
20408    /// Available if built with `exported-prototypes`.
20409    #[cfg(any(doc, feature = "exported-prototypes"))]
20410    pub fn vkGetRenderAreaGranularity(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D);
20411
20412    /// Available if built with `exported-prototypes`.
20413    #[cfg(any(doc, feature = "exported-prototypes"))]
20414    pub fn vkGetRenderingAreaGranularity(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
20415
20416    /// Available if built with `prototypes`.
20417    #[cfg(any(doc, feature = "prototypes"))]
20418    pub fn vkGetRenderingAreaGranularityKHR(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
20419
20420    /// Available if built with `prototypes`.
20421    #[cfg(any(doc, feature = "prototypes"))]
20422    pub fn vkGetSamplerOpaqueCaptureDescriptorDataEXT(device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
20423
20424    /// Available if built with `exported-prototypes`.
20425    #[cfg(any(doc, feature = "exported-prototypes"))]
20426    pub fn vkGetSemaphoreCounterValue(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
20427
20428    /// Available if built with `prototypes`.
20429    #[cfg(any(doc, feature = "prototypes"))]
20430    pub fn vkGetSemaphoreCounterValueKHR(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
20431
20432    /// Available if built with `prototypes`.
20433    #[cfg(any(doc, feature = "prototypes"))]
20434    pub fn vkGetSemaphoreFdKHR(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
20435
20436    /// Available if built with `prototypes`.
20437    #[cfg(any(doc, feature = "prototypes"))]
20438    pub fn vkGetShaderBinaryDataEXT(device: VkDevice, shader: VkShaderEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
20439
20440    /// Available if built with `prototypes`.
20441    #[cfg(any(doc, feature = "prototypes"))]
20442    pub fn vkGetShaderInfoAMD(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut usize, pInfo: *mut c_void) -> VkResult;
20443
20444    /// Available if built with `prototypes`.
20445    #[cfg(any(doc, feature = "prototypes"))]
20446    pub fn vkGetShaderModuleCreateInfoIdentifierEXT(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT);
20447
20448    /// Available if built with `prototypes`.
20449    #[cfg(any(doc, feature = "prototypes"))]
20450    pub fn vkGetShaderModuleIdentifierEXT(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT);
20451
20452    /// Available if built with `prototypes`.
20453    #[cfg(any(doc, feature = "prototypes"))]
20454    pub fn vkGetSwapchainCounterEXT(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: *mut u64) -> VkResult;
20455
20456    /// Available if built with `prototypes`.
20457    #[cfg(any(doc, feature = "prototypes"))]
20458    pub fn vkGetSwapchainImagesKHR(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult;
20459
20460    /// Available if built with `prototypes`.
20461    #[cfg(any(doc, feature = "prototypes"))]
20462    pub fn vkGetSwapchainStatusKHR(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;
20463
20464    /// Available if built with `prototypes`.
20465    #[cfg(any(doc, feature = "prototypes"))]
20466    pub fn vkGetSwapchainTimeDomainPropertiesEXT(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut u64) -> VkResult;
20467
20468    /// Available if built with `prototypes`.
20469    #[cfg(any(doc, feature = "prototypes"))]
20470    pub fn vkGetSwapchainTimingPropertiesEXT(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut u64) -> VkResult;
20471
20472    /// Available if built with `prototypes`.
20473    #[cfg(any(doc, feature = "prototypes"))]
20474    pub fn vkGetTensorMemoryRequirementsARM(device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
20475
20476    /// Available if built with `prototypes`.
20477    #[cfg(any(doc, feature = "prototypes"))]
20478    pub fn vkGetTensorOpaqueCaptureDataARM(device: VkDevice, tensorCount: u32, pTensors: *const VkTensorARM, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
20479
20480    /// Available if built with `prototypes`.
20481    #[cfg(any(doc, feature = "prototypes"))]
20482    pub fn vkGetTensorOpaqueCaptureDescriptorDataARM(device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
20483
20484    /// Available if built with `prototypes`.
20485    #[cfg(any(doc, feature = "prototypes"))]
20486    pub fn vkGetTensorViewOpaqueCaptureDescriptorDataARM(device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
20487
20488    /// Available if built with `prototypes`.
20489    #[cfg(any(doc, feature = "prototypes"))]
20490    pub fn vkGetValidationCacheDataEXT(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
20491
20492    /// Available if built with `prototypes`.
20493    #[cfg(any(doc, feature = "prototypes"))]
20494    pub fn vkGetVideoSessionMemoryRequirementsKHR(device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut u32, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult;
20495
20496    /// Available if built with `prototypes`.
20497    #[cfg(any(doc, feature = "prototypes"))]
20498    pub fn vkImportFenceFdKHR(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult;
20499
20500    /// Available if built with `prototypes`.
20501    #[cfg(any(doc, feature = "prototypes"))]
20502    pub fn vkImportSemaphoreFdKHR(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult;
20503
20504    /// Available if built with `prototypes`.
20505    #[cfg(any(doc, feature = "prototypes"))]
20506    pub fn vkInitializePerformanceApiINTEL(device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult;
20507
20508    /// Available if built with `exported-prototypes`.
20509    #[cfg(any(doc, feature = "exported-prototypes"))]
20510    pub fn vkInvalidateMappedMemoryRanges(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
20511
20512    /// Available if built with `prototypes`.
20513    #[cfg(any(doc, feature = "prototypes"))]
20514    pub fn vkLatencySleepNV(device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult;
20515
20516    /// Available if built with `exported-prototypes`.
20517    #[cfg(any(doc, feature = "exported-prototypes"))]
20518    pub fn vkMapMemory(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut c_void) -> VkResult;
20519
20520    /// Available if built with `exported-prototypes`.
20521    #[cfg(any(doc, feature = "exported-prototypes"))]
20522    pub fn vkMapMemory2(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
20523
20524    /// Available if built with `prototypes`.
20525    #[cfg(any(doc, feature = "prototypes"))]
20526    pub fn vkMapMemory2KHR(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
20527
20528    /// Available if built with `exported-prototypes`.
20529    #[cfg(any(doc, feature = "exported-prototypes"))]
20530    pub fn vkMergePipelineCaches(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult;
20531
20532    /// Available if built with `prototypes`.
20533    #[cfg(any(doc, feature = "prototypes"))]
20534    pub fn vkMergeValidationCachesEXT(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: u32, pSrcCaches: *const VkValidationCacheEXT) -> VkResult;
20535
20536    /// Available if built with `prototypes`.
20537    #[cfg(any(doc, feature = "prototypes"))]
20538    pub fn vkQueueBeginDebugUtilsLabelEXT(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
20539
20540    /// Available if built with `exported-prototypes`.
20541    #[cfg(any(doc, feature = "exported-prototypes"))]
20542    pub fn vkQueueBindSparse(queue: VkQueue, bindInfoCount: u32, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult;
20543
20544    /// Available if built with `prototypes`.
20545    #[cfg(any(doc, feature = "prototypes"))]
20546    pub fn vkQueueEndDebugUtilsLabelEXT(queue: VkQueue);
20547
20548    /// Available if built with `prototypes`.
20549    #[cfg(any(doc, feature = "prototypes"))]
20550    pub fn vkQueueInsertDebugUtilsLabelEXT(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
20551
20552    /// Available if built with `prototypes`.
20553    #[cfg(any(doc, feature = "prototypes"))]
20554    pub fn vkQueueNotifyOutOfBandNV(queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV);
20555
20556    /// Available if built with `prototypes`.
20557    #[cfg(any(doc, feature = "prototypes"))]
20558    pub fn vkQueuePresentKHR(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;
20559
20560    /// Available if built with `prototypes`.
20561    #[cfg(any(doc, feature = "prototypes"))]
20562    pub fn vkQueueSetPerformanceConfigurationINTEL(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
20563
20564    /// Available if built with `exported-prototypes`.
20565    #[cfg(any(doc, feature = "exported-prototypes"))]
20566    pub fn vkQueueSubmit(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;
20567
20568    /// Available if built with `exported-prototypes`.
20569    #[cfg(any(doc, feature = "exported-prototypes"))]
20570    pub fn vkQueueSubmit2(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
20571
20572    /// Available if built with `prototypes`.
20573    #[cfg(any(doc, feature = "prototypes"))]
20574    pub fn vkQueueSubmit2KHR(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
20575
20576    /// Available if built with `exported-prototypes`.
20577    #[cfg(any(doc, feature = "exported-prototypes"))]
20578    pub fn vkQueueWaitIdle(queue: VkQueue) -> VkResult;
20579
20580    /// Available if built with `prototypes`.
20581    #[cfg(any(doc, feature = "prototypes"))]
20582    pub fn vkRegisterCustomBorderColorEXT(device: VkDevice, pBorderColor: *const VkSamplerCustomBorderColorCreateInfoEXT, requestIndex: VkBool32, pIndex: *mut u32) -> VkResult;
20583
20584    /// Available if built with `prototypes`.
20585    #[cfg(any(doc, feature = "prototypes"))]
20586    pub fn vkRegisterDeviceEventEXT(device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
20587
20588    /// Available if built with `prototypes`.
20589    #[cfg(any(doc, feature = "prototypes"))]
20590    pub fn vkRegisterDisplayEventEXT(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
20591
20592    /// Available if built with `prototypes`.
20593    #[cfg(any(doc, feature = "prototypes"))]
20594    pub fn vkReleaseCapturedPipelineDataKHR(device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult;
20595
20596    /// Available if built with `prototypes`.
20597    #[cfg(any(doc, feature = "prototypes"))]
20598    pub fn vkReleaseDisplayEXT(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;
20599
20600    /// Available if built with `prototypes`.
20601    #[cfg(any(doc, feature = "prototypes"))]
20602    pub fn vkReleasePerformanceConfigurationINTEL(device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
20603
20604    /// Available if built with `prototypes`.
20605    #[cfg(any(doc, feature = "prototypes"))]
20606    pub fn vkReleaseProfilingLockKHR(device: VkDevice);
20607
20608    /// Available if built with `prototypes`.
20609    #[cfg(any(doc, feature = "prototypes"))]
20610    pub fn vkReleaseSwapchainImagesEXT(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
20611
20612    /// Available if built with `prototypes`.
20613    #[cfg(any(doc, feature = "prototypes"))]
20614    pub fn vkReleaseSwapchainImagesKHR(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
20615
20616    /// Available if built with `exported-prototypes`.
20617    #[cfg(any(doc, feature = "exported-prototypes"))]
20618    pub fn vkResetCommandBuffer(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;
20619
20620    /// Available if built with `exported-prototypes`.
20621    #[cfg(any(doc, feature = "exported-prototypes"))]
20622    pub fn vkResetCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;
20623
20624    /// Available if built with `exported-prototypes`.
20625    #[cfg(any(doc, feature = "exported-prototypes"))]
20626    pub fn vkResetDescriptorPool(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;
20627
20628    /// Available if built with `exported-prototypes`.
20629    #[cfg(any(doc, feature = "exported-prototypes"))]
20630    pub fn vkResetEvent(device: VkDevice, event: VkEvent) -> VkResult;
20631
20632    /// Available if built with `exported-prototypes`.
20633    #[cfg(any(doc, feature = "exported-prototypes"))]
20634    pub fn vkResetFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult;
20635
20636    /// Available if built with `exported-prototypes`.
20637    #[cfg(any(doc, feature = "exported-prototypes"))]
20638    pub fn vkResetQueryPool(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
20639
20640    /// Available if built with `prototypes`.
20641    #[cfg(any(doc, feature = "prototypes"))]
20642    pub fn vkResetQueryPoolEXT(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
20643
20644    /// Available if built with `prototypes`.
20645    #[cfg(any(doc, feature = "prototypes"))]
20646    pub fn vkSetDebugUtilsObjectNameEXT(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult;
20647
20648    /// Available if built with `prototypes`.
20649    #[cfg(any(doc, feature = "prototypes"))]
20650    pub fn vkSetDebugUtilsObjectTagEXT(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult;
20651
20652    /// Available if built with `prototypes`.
20653    #[cfg(any(doc, feature = "prototypes"))]
20654    pub fn vkSetDeviceMemoryPriorityEXT(device: VkDevice, memory: VkDeviceMemory, priority: f32);
20655
20656    /// Available if built with `exported-prototypes`.
20657    #[cfg(any(doc, feature = "exported-prototypes"))]
20658    pub fn vkSetEvent(device: VkDevice, event: VkEvent) -> VkResult;
20659
20660    /// Available if built with `prototypes`.
20661    #[cfg(any(doc, feature = "prototypes"))]
20662    pub fn vkSetHdrMetadataEXT(device: VkDevice, swapchainCount: u32, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT);
20663
20664    /// Available if built with `prototypes`.
20665    #[cfg(any(doc, feature = "prototypes"))]
20666    pub fn vkSetLatencyMarkerNV(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV);
20667
20668    /// Available if built with `prototypes`.
20669    #[cfg(any(doc, feature = "prototypes"))]
20670    pub fn vkSetLatencySleepModeNV(device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult;
20671
20672    /// Available if built with `prototypes`.
20673    #[cfg(any(doc, feature = "prototypes"))]
20674    pub fn vkSetLocalDimmingAMD(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32);
20675
20676    /// Available if built with `exported-prototypes`.
20677    #[cfg(any(doc, feature = "exported-prototypes"))]
20678    pub fn vkSetPrivateData(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
20679
20680    /// Available if built with `prototypes`.
20681    #[cfg(any(doc, feature = "prototypes"))]
20682    pub fn vkSetPrivateDataEXT(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
20683
20684    /// Available if built with `prototypes`.
20685    #[cfg(any(doc, feature = "prototypes"))]
20686    pub fn vkSetSwapchainPresentTimingQueueSizeEXT(device: VkDevice, swapchain: VkSwapchainKHR, size: u32) -> VkResult;
20687
20688    /// Available if built with `exported-prototypes`.
20689    #[cfg(any(doc, feature = "exported-prototypes"))]
20690    pub fn vkSignalSemaphore(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
20691
20692    /// Available if built with `prototypes`.
20693    #[cfg(any(doc, feature = "prototypes"))]
20694    pub fn vkSignalSemaphoreKHR(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
20695
20696    /// Available if built with `prototypes`.
20697    #[cfg(any(doc, feature = "prototypes"))]
20698    pub fn vkSubmitDebugUtilsMessageEXT(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT);
20699
20700    /// Available if built with `exported-prototypes`.
20701    #[cfg(any(doc, feature = "exported-prototypes"))]
20702    pub fn vkTransitionImageLayout(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
20703
20704    /// Available if built with `prototypes`.
20705    #[cfg(any(doc, feature = "prototypes"))]
20706    pub fn vkTransitionImageLayoutEXT(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
20707
20708    /// Available if built with `exported-prototypes`.
20709    #[cfg(any(doc, feature = "exported-prototypes"))]
20710    pub fn vkTrimCommandPool(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
20711
20712    /// Available if built with `prototypes`.
20713    #[cfg(any(doc, feature = "prototypes"))]
20714    pub fn vkTrimCommandPoolKHR(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
20715
20716    /// Available if built with `prototypes`.
20717    #[cfg(any(doc, feature = "prototypes"))]
20718    pub fn vkUninitializePerformanceApiINTEL(device: VkDevice);
20719
20720    /// Available if built with `exported-prototypes`.
20721    #[cfg(any(doc, feature = "exported-prototypes"))]
20722    pub fn vkUnmapMemory(device: VkDevice, memory: VkDeviceMemory);
20723
20724    /// Available if built with `exported-prototypes`.
20725    #[cfg(any(doc, feature = "exported-prototypes"))]
20726    pub fn vkUnmapMemory2(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
20727
20728    /// Available if built with `prototypes`.
20729    #[cfg(any(doc, feature = "prototypes"))]
20730    pub fn vkUnmapMemory2KHR(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
20731
20732    /// Available if built with `prototypes`.
20733    #[cfg(any(doc, feature = "prototypes"))]
20734    pub fn vkUnregisterCustomBorderColorEXT(device: VkDevice, index: u32);
20735
20736    /// Available if built with `exported-prototypes`.
20737    #[cfg(any(doc, feature = "exported-prototypes"))]
20738    pub fn vkUpdateDescriptorSetWithTemplate(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
20739
20740    /// Available if built with `prototypes`.
20741    #[cfg(any(doc, feature = "prototypes"))]
20742    pub fn vkUpdateDescriptorSetWithTemplateKHR(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
20743
20744    /// Available if built with `exported-prototypes`.
20745    #[cfg(any(doc, feature = "exported-prototypes"))]
20746    pub fn vkUpdateDescriptorSets(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet);
20747
20748    /// Available if built with `prototypes`.
20749    #[cfg(any(doc, feature = "prototypes"))]
20750    pub fn vkUpdateIndirectExecutionSetPipelineEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT);
20751
20752    /// Available if built with `prototypes`.
20753    #[cfg(any(doc, feature = "prototypes"))]
20754    pub fn vkUpdateIndirectExecutionSetShaderEXT(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT);
20755
20756    /// Available if built with `prototypes`.
20757    #[cfg(any(doc, feature = "prototypes"))]
20758    pub fn vkUpdateVideoSessionParametersKHR(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult;
20759
20760    /// Available if built with `exported-prototypes`.
20761    #[cfg(any(doc, feature = "exported-prototypes"))]
20762    pub fn vkWaitForFences(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult;
20763
20764    /// Available if built with `prototypes`.
20765    #[cfg(any(doc, feature = "prototypes"))]
20766    pub fn vkWaitForPresent2KHR(device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult;
20767
20768    /// Available if built with `prototypes`.
20769    #[cfg(any(doc, feature = "prototypes"))]
20770    pub fn vkWaitForPresentKHR(device: VkDevice, swapchain: VkSwapchainKHR, presentId: u64, timeout: u64) -> VkResult;
20771
20772    /// Available if built with `exported-prototypes`.
20773    #[cfg(any(doc, feature = "exported-prototypes"))]
20774    pub fn vkWaitSemaphores(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
20775
20776    /// Available if built with `prototypes`.
20777    #[cfg(any(doc, feature = "prototypes"))]
20778    pub fn vkWaitSemaphoresKHR(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
20779
20780    /// Available if built with `prototypes`.
20781    #[cfg(any(doc, feature = "prototypes"))]
20782    pub fn vkWriteAccelerationStructuresPropertiesKHR(device: VkDevice, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
20783
20784    /// Available if built with `prototypes`.
20785    #[cfg(any(doc, feature = "prototypes"))]
20786    pub fn vkWriteMicromapsPropertiesEXT(device: VkDevice, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, dataSize: usize, pData: *mut c_void, stride: usize) -> VkResult;
20787
20788    /// Available if built with `prototypes`.
20789    #[cfg(any(doc, feature = "prototypes"))]
20790    pub fn vkWriteResourceDescriptorsEXT(device: VkDevice, resourceCount: u32, pResources: *const VkResourceDescriptorInfoEXT, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
20791
20792    /// Available if built with `prototypes`.
20793    #[cfg(any(doc, feature = "prototypes"))]
20794    pub fn vkWriteSamplerDescriptorsEXT(device: VkDevice, samplerCount: u32, pSamplers: *const VkSamplerCreateInfo, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
20795}
20796
20797pub type NonNullPFN_vkAcquireDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, display: VkDisplayKHR) -> VkResult;
20798pub type NonNullPFN_vkAcquireNextImage2KHR = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkAcquireNextImageInfoKHR, pImageIndex: *mut u32) -> VkResult;
20799pub type NonNullPFN_vkAcquireNextImageKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, timeout: u64, semaphore: VkSemaphore, fence: VkFence, pImageIndex: *mut u32) -> VkResult;
20800pub type NonNullPFN_vkAcquirePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, pAcquireInfo: *const VkPerformanceConfigurationAcquireInfoINTEL, pConfiguration: *mut VkPerformanceConfigurationINTEL) -> VkResult;
20801pub type NonNullPFN_vkAcquireProfilingLockKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAcquireProfilingLockInfoKHR) -> VkResult;
20802pub type NonNullPFN_vkAllocateCommandBuffers = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkCommandBufferAllocateInfo, pCommandBuffers: *mut VkCommandBuffer) -> VkResult;
20803pub type NonNullPFN_vkAllocateDescriptorSets = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkDescriptorSetAllocateInfo, pDescriptorSets: *mut VkDescriptorSet) -> VkResult;
20804pub type NonNullPFN_vkAllocateMemory = unsafe extern "system" fn(device: VkDevice, pAllocateInfo: *const VkMemoryAllocateInfo, pAllocator: *const VkAllocationCallbacks, pMemory: *mut VkDeviceMemory) -> VkResult;
20805pub type NonNullPFN_vkAllocationFunction = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut c_void;
20806pub type NonNullPFN_vkAntiLagUpdateAMD = unsafe extern "system" fn(device: VkDevice, pData: *const VkAntiLagDataAMD);
20807pub type NonNullPFN_vkBeginCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkCommandBufferBeginInfo) -> VkResult;
20808pub type NonNullPFN_vkBindAccelerationStructureMemoryNV = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindAccelerationStructureMemoryInfoNV) -> VkResult;
20809pub type NonNullPFN_vkBindBufferMemory = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
20810pub type NonNullPFN_vkBindBufferMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
20811pub type NonNullPFN_vkBindBufferMemory2KHR = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindBufferMemoryInfo) -> VkResult;
20812pub type NonNullPFN_vkBindDataGraphPipelineSessionMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindDataGraphPipelineSessionMemoryInfoARM) -> VkResult;
20813pub type NonNullPFN_vkBindImageMemory = unsafe extern "system" fn(device: VkDevice, image: VkImage, memory: VkDeviceMemory, memoryOffset: VkDeviceSize) -> VkResult;
20814pub type NonNullPFN_vkBindImageMemory2 = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
20815pub type NonNullPFN_vkBindImageMemory2KHR = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindImageMemoryInfo) -> VkResult;
20816pub type NonNullPFN_vkBindOpticalFlowSessionImageNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, bindingPoint: VkOpticalFlowSessionBindingPointNV, view: VkImageView, layout: VkImageLayout) -> VkResult;
20817pub type NonNullPFN_vkBindTensorMemoryARM = unsafe extern "system" fn(device: VkDevice, bindInfoCount: u32, pBindInfos: *const VkBindTensorMemoryInfoARM) -> VkResult;
20818pub type NonNullPFN_vkBindVideoSessionMemoryKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, bindSessionMemoryInfoCount: u32, pBindSessionMemoryInfos: *const VkBindVideoSessionMemoryInfoKHR) -> VkResult;
20819pub type NonNullPFN_vkBuildAccelerationStructuresKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR) -> VkResult;
20820pub type NonNullPFN_vkBuildMicromapsEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT) -> VkResult;
20821pub type NonNullPFN_vkCmdBeginConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pConditionalRenderingBegin: *const VkConditionalRenderingBeginInfoEXT);
20822pub type NonNullPFN_vkCmdBeginCustomResolveEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginCustomResolveInfo: *const VkBeginCustomResolveInfoEXT);
20823pub type NonNullPFN_vkCmdBeginDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
20824pub type NonNullPFN_vkCmdBeginPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileBeginInfo: *const VkPerTileBeginInfoQCOM);
20825pub type NonNullPFN_vkCmdBeginQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags);
20826pub type NonNullPFN_vkCmdBeginQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, flags: VkQueryControlFlags, index: u32);
20827pub type NonNullPFN_vkCmdBeginRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, contents: VkSubpassContents);
20828pub type NonNullPFN_vkCmdBeginRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
20829pub type NonNullPFN_vkCmdBeginRenderPass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderPassBegin: *const VkRenderPassBeginInfo, pSubpassBeginInfo: *const VkSubpassBeginInfo);
20830pub type NonNullPFN_vkCmdBeginRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
20831pub type NonNullPFN_vkCmdBeginRenderingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingInfo: *const VkRenderingInfo);
20832pub type NonNullPFN_vkCmdBeginTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
20833pub type NonNullPFN_vkCmdBeginVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBeginInfo: *const VkVideoBeginCodingInfoKHR);
20834pub type NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo: *const VkBindDescriptorBufferEmbeddedSamplersInfoEXT);
20835pub type NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32);
20836pub type NonNullPFN_vkCmdBindDescriptorBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, bufferCount: u32, pBindingInfos: *const VkDescriptorBufferBindingInfoEXT);
20837pub 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);
20838pub type NonNullPFN_vkCmdBindDescriptorSets2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
20839pub type NonNullPFN_vkCmdBindDescriptorSets2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindDescriptorSetsInfo: *const VkBindDescriptorSetsInfo);
20840pub type NonNullPFN_vkCmdBindIndexBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, indexType: VkIndexType);
20841pub type NonNullPFN_vkCmdBindIndexBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
20842pub type NonNullPFN_vkCmdBindIndexBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, size: VkDeviceSize, indexType: VkIndexType);
20843pub type NonNullPFN_vkCmdBindInvocationMaskHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
20844pub type NonNullPFN_vkCmdBindPipeline = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
20845pub type NonNullPFN_vkCmdBindPipelineShaderGroupNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline, groupIndex: u32);
20846pub type NonNullPFN_vkCmdBindResourceHeapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
20847pub type NonNullPFN_vkCmdBindSamplerHeapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBindInfo: *const VkBindHeapInfoEXT);
20848pub type NonNullPFN_vkCmdBindShadersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stageCount: u32, pStages: *const VkShaderStageFlagBits, pShaders: *const VkShaderEXT);
20849pub type NonNullPFN_vkCmdBindShadingRateImageNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, imageView: VkImageView, imageLayout: VkImageLayout);
20850pub type NonNullPFN_vkCmdBindTileMemoryQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pTileMemoryBindInfo: *const VkTileMemoryBindInfoQCOM);
20851pub type NonNullPFN_vkCmdBindTransformFeedbackBuffersEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize, pSizes: *const VkDeviceSize);
20852pub type NonNullPFN_vkCmdBindVertexBuffers = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstBinding: u32, bindingCount: u32, pBuffers: *const VkBuffer, pOffsets: *const VkDeviceSize);
20853pub 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);
20854pub 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);
20855pub type NonNullPFN_vkCmdBlitImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageBlit, filter: VkFilter);
20856pub type NonNullPFN_vkCmdBlitImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
20857pub type NonNullPFN_vkCmdBlitImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBlitImageInfo: *const VkBlitImageInfo2);
20858pub 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);
20859pub type NonNullPFN_vkCmdBuildAccelerationStructuresIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, pIndirectDeviceAddresses: *const VkDeviceAddress, pIndirectStrides: *const u32, ppMaxPrimitiveCounts: *const *const u32);
20860pub type NonNullPFN_vkCmdBuildAccelerationStructuresKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkAccelerationStructureBuildGeometryInfoKHR, ppBuildRangeInfos: *const *const VkAccelerationStructureBuildRangeInfoKHR);
20861pub type NonNullPFN_vkCmdBuildClusterAccelerationStructureIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCommandInfos: *const VkClusterAccelerationStructureCommandsInfoNV);
20862pub type NonNullPFN_vkCmdBuildMicromapsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkMicromapBuildInfoEXT);
20863pub type NonNullPFN_vkCmdBuildPartitionedAccelerationStructuresNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pBuildInfo: *const VkBuildPartitionedAccelerationStructureInfoNV);
20864pub type NonNullPFN_vkCmdClearAttachments = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pAttachments: *const VkClearAttachment, rectCount: u32, pRects: *const VkClearRect);
20865pub type NonNullPFN_vkCmdClearColorImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pColor: *const VkClearColorValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
20866pub type NonNullPFN_vkCmdClearDepthStencilImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, image: VkImage, imageLayout: VkImageLayout, pDepthStencil: *const VkClearDepthStencilValue, rangeCount: u32, pRanges: *const VkImageSubresourceRange);
20867pub type NonNullPFN_vkCmdControlVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCodingControlInfo: *const VkVideoCodingControlInfoKHR);
20868pub type NonNullPFN_vkCmdConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, infoCount: u32, pInfos: *const VkConvertCooperativeVectorMatrixInfoNV);
20869pub type NonNullPFN_vkCmdCopyAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureInfoKHR);
20870pub type NonNullPFN_vkCmdCopyAccelerationStructureNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dst: VkAccelerationStructureNV, src: VkAccelerationStructureNV, mode: VkCopyAccelerationStructureModeKHR);
20871pub type NonNullPFN_vkCmdCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR);
20872pub type NonNullPFN_vkCmdCopyBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferCopy);
20873pub type NonNullPFN_vkCmdCopyBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
20874pub type NonNullPFN_vkCmdCopyBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferInfo: *const VkCopyBufferInfo2);
20875pub type NonNullPFN_vkCmdCopyBufferToImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcBuffer: VkBuffer, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkBufferImageCopy);
20876pub type NonNullPFN_vkCmdCopyBufferToImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
20877pub type NonNullPFN_vkCmdCopyBufferToImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyBufferToImageInfo: *const VkCopyBufferToImageInfo2);
20878pub type NonNullPFN_vkCmdCopyImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageCopy);
20879pub type NonNullPFN_vkCmdCopyImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
20880pub type NonNullPFN_vkCmdCopyImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageInfo: *const VkCopyImageInfo2);
20881pub type NonNullPFN_vkCmdCopyImageToBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstBuffer: VkBuffer, regionCount: u32, pRegions: *const VkBufferImageCopy);
20882pub type NonNullPFN_vkCmdCopyImageToBuffer2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
20883pub type NonNullPFN_vkCmdCopyImageToBuffer2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyImageToBufferInfo: *const VkCopyImageToBufferInfo2);
20884pub type NonNullPFN_vkCmdCopyMemoryIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryIndirectInfo: *const VkCopyMemoryIndirectInfoKHR);
20885pub type NonNullPFN_vkCmdCopyMemoryIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32);
20886pub type NonNullPFN_vkCmdCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR);
20887pub type NonNullPFN_vkCmdCopyMemoryToImageIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyMemoryToImageIndirectInfo: *const VkCopyMemoryToImageIndirectInfoKHR);
20888pub type NonNullPFN_vkCmdCopyMemoryToImageIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, copyBufferAddress: VkDeviceAddress, copyCount: u32, stride: u32, dstImage: VkImage, dstImageLayout: VkImageLayout, pImageSubresources: *const VkImageSubresourceLayers);
20889pub type NonNullPFN_vkCmdCopyMemoryToMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMemoryToMicromapInfoEXT);
20890pub type NonNullPFN_vkCmdCopyMicromapEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapInfoEXT);
20891pub type NonNullPFN_vkCmdCopyMicromapToMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInfo: *const VkCopyMicromapToMemoryInfoEXT);
20892pub type NonNullPFN_vkCmdCopyQueryPoolResults = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, stride: VkDeviceSize, flags: VkQueryResultFlags);
20893pub type NonNullPFN_vkCmdCopyTensorARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCopyTensorInfo: *const VkCopyTensorInfoARM);
20894pub type NonNullPFN_vkCmdCuLaunchKernelNVX = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLaunchInfo: *const VkCuLaunchInfoNVX);
20895pub type NonNullPFN_vkCmdDebugMarkerBeginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
20896pub type NonNullPFN_vkCmdDebugMarkerEndEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20897pub type NonNullPFN_vkCmdDebugMarkerInsertEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkDebugMarkerMarkerInfoEXT);
20898pub type NonNullPFN_vkCmdDecodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecodeInfo: *const VkVideoDecodeInfoKHR);
20899pub type NonNullPFN_vkCmdDecompressMemoryEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDecompressMemoryInfoEXT: *const VkDecompressMemoryInfoEXT);
20900pub type NonNullPFN_vkCmdDecompressMemoryIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressionMethod: VkMemoryDecompressionMethodFlagsEXT, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, maxDecompressionCount: u32, stride: u32);
20901pub type NonNullPFN_vkCmdDecompressMemoryIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectCommandsAddress: VkDeviceAddress, indirectCommandsCountAddress: VkDeviceAddress, stride: u32);
20902pub type NonNullPFN_vkCmdDecompressMemoryNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, decompressRegionCount: u32, pDecompressMemoryRegions: *const VkDecompressMemoryRegionNV);
20903pub type NonNullPFN_vkCmdDispatch = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20904pub type NonNullPFN_vkCmdDispatchBase = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20905pub type NonNullPFN_vkCmdDispatchBaseKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, baseGroupX: u32, baseGroupY: u32, baseGroupZ: u32, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20906pub type NonNullPFN_vkCmdDispatchDataGraphARM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkDataGraphPipelineSessionARM, pInfo: *const VkDataGraphPipelineDispatchInfoARM);
20907pub type NonNullPFN_vkCmdDispatchIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
20908pub type NonNullPFN_vkCmdDispatchTileQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDispatchTileInfo: *const VkDispatchTileInfoQCOM);
20909pub type NonNullPFN_vkCmdDraw = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexCount: u32, instanceCount: u32, firstVertex: u32, firstInstance: u32);
20910pub type NonNullPFN_vkCmdDrawClusterHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20911pub type NonNullPFN_vkCmdDrawClusterIndirectHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize);
20912pub type NonNullPFN_vkCmdDrawIndexed = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indexCount: u32, instanceCount: u32, firstIndex: u32, vertexOffset: i32, firstInstance: u32);
20913pub type NonNullPFN_vkCmdDrawIndexedIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20914pub type NonNullPFN_vkCmdDrawIndexedIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20915pub type NonNullPFN_vkCmdDrawIndexedIndirectCountAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20916pub type NonNullPFN_vkCmdDrawIndexedIndirectCountKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20917pub type NonNullPFN_vkCmdDrawIndirect = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20918pub type NonNullPFN_vkCmdDrawIndirectByteCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, instanceCount: u32, firstInstance: u32, counterBuffer: VkBuffer, counterBufferOffset: VkDeviceSize, counterOffset: u32, vertexStride: u32);
20919pub type NonNullPFN_vkCmdDrawIndirectCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20920pub type NonNullPFN_vkCmdDrawIndirectCountAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20921pub type NonNullPFN_vkCmdDrawIndirectCountKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20922pub type NonNullPFN_vkCmdDrawMeshTasksEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, groupCountX: u32, groupCountY: u32, groupCountZ: u32);
20923pub type NonNullPFN_vkCmdDrawMeshTasksIndirectCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20924pub type NonNullPFN_vkCmdDrawMeshTasksIndirectCountNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, countBuffer: VkBuffer, countBufferOffset: VkDeviceSize, maxDrawCount: u32, stride: u32);
20925pub type NonNullPFN_vkCmdDrawMeshTasksIndirectEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20926pub type NonNullPFN_vkCmdDrawMeshTasksIndirectNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, buffer: VkBuffer, offset: VkDeviceSize, drawCount: u32, stride: u32);
20927pub type NonNullPFN_vkCmdDrawMeshTasksNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, taskCount: u32, firstTask: u32);
20928pub type NonNullPFN_vkCmdDrawMultiEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: u32, pVertexInfo: *const VkMultiDrawInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32);
20929pub type NonNullPFN_vkCmdDrawMultiIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, drawCount: u32, pIndexInfo: *const VkMultiDrawIndexedInfoEXT, instanceCount: u32, firstInstance: u32, stride: u32, pVertexOffset: *const i32);
20930pub type NonNullPFN_vkCmdEncodeVideoKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEncodeInfo: *const VkVideoEncodeInfoKHR);
20931pub type NonNullPFN_vkCmdEndConditionalRenderingEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20932pub type NonNullPFN_vkCmdEndDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20933pub type NonNullPFN_vkCmdEndPerTileExecutionQCOM = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPerTileEndInfo: *const VkPerTileEndInfoQCOM);
20934pub type NonNullPFN_vkCmdEndQuery = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32);
20935pub type NonNullPFN_vkCmdEndQueryIndexedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, query: u32, index: u32);
20936pub type NonNullPFN_vkCmdEndRenderPass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20937pub type NonNullPFN_vkCmdEndRenderPass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
20938pub type NonNullPFN_vkCmdEndRenderPass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassEndInfo: *const VkSubpassEndInfo);
20939pub type NonNullPFN_vkCmdEndRendering = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20940pub type NonNullPFN_vkCmdEndRendering2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
20941pub type NonNullPFN_vkCmdEndRendering2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRenderingEndInfo: *const VkRenderingEndInfoKHR);
20942pub type NonNullPFN_vkCmdEndRenderingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
20943pub type NonNullPFN_vkCmdEndTransformFeedbackEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstCounterBuffer: u32, counterBufferCount: u32, pCounterBuffers: *const VkBuffer, pCounterBufferOffsets: *const VkDeviceSize);
20944pub type NonNullPFN_vkCmdEndVideoCodingKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pEndCodingInfo: *const VkVideoEndCodingInfoKHR);
20945pub type NonNullPFN_vkCmdExecuteCommands = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
20946pub type NonNullPFN_vkCmdExecuteGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT);
20947pub type NonNullPFN_vkCmdExecuteGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, isPreprocessed: VkBool32, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
20948pub type NonNullPFN_vkCmdFillBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, size: VkDeviceSize, data: u32);
20949pub type NonNullPFN_vkCmdInsertDebugUtilsLabelEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLabelInfo: *const VkDebugUtilsLabelEXT);
20950pub type NonNullPFN_vkCmdNextSubpass = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, contents: VkSubpassContents);
20951pub type NonNullPFN_vkCmdNextSubpass2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
20952pub type NonNullPFN_vkCmdNextSubpass2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSubpassBeginInfo: *const VkSubpassBeginInfo, pSubpassEndInfo: *const VkSubpassEndInfo);
20953pub type NonNullPFN_vkCmdOpticalFlowExecuteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, session: VkOpticalFlowSessionNV, pExecuteInfo: *const VkOpticalFlowExecuteInfoNV);
20954pub 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);
20955pub type NonNullPFN_vkCmdPipelineBarrier2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
20956pub type NonNullPFN_vkCmdPipelineBarrier2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDependencyInfo: *const VkDependencyInfo);
20957pub type NonNullPFN_vkCmdPreprocessGeneratedCommandsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoEXT, stateCommandBuffer: VkCommandBuffer);
20958pub type NonNullPFN_vkCmdPreprocessGeneratedCommandsNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pGeneratedCommandsInfo: *const VkGeneratedCommandsInfoNV);
20959pub type NonNullPFN_vkCmdPushConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, layout: VkPipelineLayout, stageFlags: VkShaderStageFlags, offset: u32, size: u32, pValues: *const c_void);
20960pub type NonNullPFN_vkCmdPushConstants2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
20961pub type NonNullPFN_vkCmdPushConstants2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushConstantsInfo: *const VkPushConstantsInfo);
20962pub type NonNullPFN_vkCmdPushDataEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDataInfo: *const VkPushDataInfoEXT);
20963pub type NonNullPFN_vkCmdPushDescriptorSet = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
20964pub type NonNullPFN_vkCmdPushDescriptorSet2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
20965pub type NonNullPFN_vkCmdPushDescriptorSet2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetInfo: *const VkPushDescriptorSetInfo);
20966pub type NonNullPFN_vkCmdPushDescriptorSetKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, set: u32, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet);
20967pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
20968pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
20969pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplate2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pPushDescriptorSetWithTemplateInfo: *const VkPushDescriptorSetWithTemplateInfo);
20970pub type NonNullPFN_vkCmdPushDescriptorSetWithTemplateKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, layout: VkPipelineLayout, set: u32, pData: *const c_void);
20971pub type NonNullPFN_vkCmdResetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
20972pub type NonNullPFN_vkCmdResetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
20973pub type NonNullPFN_vkCmdResetEvent2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags2);
20974pub type NonNullPFN_vkCmdResetQueryPool = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
20975pub type NonNullPFN_vkCmdResolveImage = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, srcImage: VkImage, srcImageLayout: VkImageLayout, dstImage: VkImage, dstImageLayout: VkImageLayout, regionCount: u32, pRegions: *const VkImageResolve);
20976pub type NonNullPFN_vkCmdResolveImage2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
20977pub type NonNullPFN_vkCmdResolveImage2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pResolveImageInfo: *const VkResolveImageInfo2);
20978pub type NonNullPFN_vkCmdSetAlphaToCoverageEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToCoverageEnable: VkBool32);
20979pub type NonNullPFN_vkCmdSetAlphaToOneEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, alphaToOneEnable: VkBool32);
20980pub type NonNullPFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, aspectMask: VkImageAspectFlags);
20981pub type NonNullPFN_vkCmdSetBlendConstants = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, blendConstants: *const f32);
20982pub type NonNullPFN_vkCmdSetCheckpointNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pCheckpointMarker: *const c_void);
20983pub type NonNullPFN_vkCmdSetCoarseSampleOrderNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleOrderType: VkCoarseSampleOrderTypeNV, customSampleOrderCount: u32, pCustomSampleOrders: *const VkCoarseSampleOrderCustomNV);
20984pub type NonNullPFN_vkCmdSetColorBlendAdvancedEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendAdvanced: *const VkColorBlendAdvancedEXT);
20985pub type NonNullPFN_vkCmdSetColorBlendEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEnables: *const VkBool32);
20986pub type NonNullPFN_vkCmdSetColorBlendEquationEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorBlendEquations: *const VkColorBlendEquationEXT);
20987pub type NonNullPFN_vkCmdSetColorWriteEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, attachmentCount: u32, pColorWriteEnables: *const VkBool32);
20988pub type NonNullPFN_vkCmdSetColorWriteMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstAttachment: u32, attachmentCount: u32, pColorWriteMasks: *const VkColorComponentFlags);
20989pub type NonNullPFN_vkCmdSetComputeOccupancyPriorityNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pParameters: *const VkComputeOccupancyPriorityParametersNV);
20990pub type NonNullPFN_vkCmdSetConservativeRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, conservativeRasterizationMode: VkConservativeRasterizationModeEXT);
20991pub type NonNullPFN_vkCmdSetCoverageModulationModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationMode: VkCoverageModulationModeNV);
20992pub type NonNullPFN_vkCmdSetCoverageModulationTableEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableEnable: VkBool32);
20993pub type NonNullPFN_vkCmdSetCoverageModulationTableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageModulationTableCount: u32, pCoverageModulationTable: *const f32);
20994pub type NonNullPFN_vkCmdSetCoverageReductionModeNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageReductionMode: VkCoverageReductionModeNV);
20995pub type NonNullPFN_vkCmdSetCoverageToColorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorEnable: VkBool32);
20996pub type NonNullPFN_vkCmdSetCoverageToColorLocationNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, coverageToColorLocation: u32);
20997pub type NonNullPFN_vkCmdSetCullMode = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
20998pub type NonNullPFN_vkCmdSetCullModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, cullMode: VkCullModeFlags);
20999pub type NonNullPFN_vkCmdSetDepthBias = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasConstantFactor: f32, depthBiasClamp: f32, depthBiasSlopeFactor: f32);
21000pub type NonNullPFN_vkCmdSetDepthBias2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pDepthBiasInfo: *const VkDepthBiasInfoEXT);
21001pub type NonNullPFN_vkCmdSetDepthBiasEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
21002pub type NonNullPFN_vkCmdSetDepthBiasEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBiasEnable: VkBool32);
21003pub type NonNullPFN_vkCmdSetDepthBounds = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, minDepthBounds: f32, maxDepthBounds: f32);
21004pub type NonNullPFN_vkCmdSetDepthBoundsTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
21005pub type NonNullPFN_vkCmdSetDepthBoundsTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthBoundsTestEnable: VkBool32);
21006pub type NonNullPFN_vkCmdSetDepthClampEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampEnable: VkBool32);
21007pub type NonNullPFN_vkCmdSetDepthClampRangeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClampMode: VkDepthClampModeEXT, pDepthClampRange: *const VkDepthClampRangeEXT);
21008pub type NonNullPFN_vkCmdSetDepthClipEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthClipEnable: VkBool32);
21009pub type NonNullPFN_vkCmdSetDepthClipNegativeOneToOneEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, negativeOneToOne: VkBool32);
21010pub type NonNullPFN_vkCmdSetDepthCompareOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
21011pub type NonNullPFN_vkCmdSetDepthCompareOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthCompareOp: VkCompareOp);
21012pub type NonNullPFN_vkCmdSetDepthTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
21013pub type NonNullPFN_vkCmdSetDepthTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthTestEnable: VkBool32);
21014pub type NonNullPFN_vkCmdSetDepthWriteEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
21015pub type NonNullPFN_vkCmdSetDepthWriteEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, depthWriteEnable: VkBool32);
21016pub type NonNullPFN_vkCmdSetDescriptorBufferOffsets2EXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSetDescriptorBufferOffsetsInfo: *const VkSetDescriptorBufferOffsetsInfoEXT);
21017pub type NonNullPFN_vkCmdSetDescriptorBufferOffsetsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, layout: VkPipelineLayout, firstSet: u32, setCount: u32, pBufferIndices: *const u32, pOffsets: *const VkDeviceSize);
21018pub type NonNullPFN_vkCmdSetDeviceMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32);
21019pub type NonNullPFN_vkCmdSetDeviceMaskKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, deviceMask: u32);
21020pub type NonNullPFN_vkCmdSetDiscardRectangleEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstDiscardRectangle: u32, discardRectangleCount: u32, pDiscardRectangles: *const VkRect2D);
21021pub type NonNullPFN_vkCmdSetDiscardRectangleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleEnable: VkBool32);
21022pub type NonNullPFN_vkCmdSetDiscardRectangleModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, discardRectangleMode: VkDiscardRectangleModeEXT);
21023pub type NonNullPFN_vkCmdSetEvent = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, stageMask: VkPipelineStageFlags);
21024pub type NonNullPFN_vkCmdSetEvent2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
21025pub type NonNullPFN_vkCmdSetEvent2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, event: VkEvent, pDependencyInfo: *const VkDependencyInfo);
21026pub type NonNullPFN_vkCmdSetExclusiveScissorEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissorEnables: *const VkBool32);
21027pub type NonNullPFN_vkCmdSetExclusiveScissorNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstExclusiveScissor: u32, exclusiveScissorCount: u32, pExclusiveScissors: *const VkRect2D);
21028pub type NonNullPFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, extraPrimitiveOverestimationSize: f32);
21029pub type NonNullPFN_vkCmdSetFragmentShadingRateEnumNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRate: VkFragmentShadingRateNV, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
21030pub type NonNullPFN_vkCmdSetFragmentShadingRateKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pFragmentSize: *const VkExtent2D, combinerOps: *const VkFragmentShadingRateCombinerOpKHR);
21031pub type NonNullPFN_vkCmdSetFrontFace = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
21032pub type NonNullPFN_vkCmdSetFrontFaceEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, frontFace: VkFrontFace);
21033pub type NonNullPFN_vkCmdSetLineRasterizationModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineRasterizationMode: VkLineRasterizationModeEXT);
21034pub type NonNullPFN_vkCmdSetLineStipple = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
21035pub type NonNullPFN_vkCmdSetLineStippleEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
21036pub type NonNullPFN_vkCmdSetLineStippleEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stippledLineEnable: VkBool32);
21037pub type NonNullPFN_vkCmdSetLineStippleKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineStippleFactor: u32, lineStipplePattern: u16);
21038pub type NonNullPFN_vkCmdSetLineWidth = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, lineWidth: f32);
21039pub type NonNullPFN_vkCmdSetLogicOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOp: VkLogicOp);
21040pub type NonNullPFN_vkCmdSetLogicOpEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, logicOpEnable: VkBool32);
21041pub type NonNullPFN_vkCmdSetPatchControlPointsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, patchControlPoints: u32);
21042pub type NonNullPFN_vkCmdSetPerformanceMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceMarkerInfoINTEL) -> VkResult;
21043pub type NonNullPFN_vkCmdSetPerformanceOverrideINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pOverrideInfo: *const VkPerformanceOverrideInfoINTEL) -> VkResult;
21044pub type NonNullPFN_vkCmdSetPerformanceStreamMarkerINTEL = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pMarkerInfo: *const VkPerformanceStreamMarkerInfoINTEL) -> VkResult;
21045pub type NonNullPFN_vkCmdSetPolygonModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, polygonMode: VkPolygonMode);
21046pub type NonNullPFN_vkCmdSetPrimitiveRestartEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
21047pub type NonNullPFN_vkCmdSetPrimitiveRestartEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveRestartEnable: VkBool32);
21048pub type NonNullPFN_vkCmdSetPrimitiveTopology = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
21049pub type NonNullPFN_vkCmdSetPrimitiveTopologyEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, primitiveTopology: VkPrimitiveTopology);
21050pub type NonNullPFN_vkCmdSetProvokingVertexModeEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, provokingVertexMode: VkProvokingVertexModeEXT);
21051pub type NonNullPFN_vkCmdSetRasterizationSamplesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationSamples: VkSampleCountFlagBits);
21052pub type NonNullPFN_vkCmdSetRasterizationStreamEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizationStream: u32);
21053pub type NonNullPFN_vkCmdSetRasterizerDiscardEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
21054pub type NonNullPFN_vkCmdSetRasterizerDiscardEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, rasterizerDiscardEnable: VkBool32);
21055pub type NonNullPFN_vkCmdSetRayTracingPipelineStackSizeKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStackSize: u32);
21056pub type NonNullPFN_vkCmdSetRenderingAttachmentLocations = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
21057pub type NonNullPFN_vkCmdSetRenderingAttachmentLocationsKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pLocationInfo: *const VkRenderingAttachmentLocationInfo);
21058pub type NonNullPFN_vkCmdSetRenderingInputAttachmentIndices = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
21059pub type NonNullPFN_vkCmdSetRenderingInputAttachmentIndicesKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pInputAttachmentIndexInfo: *const VkRenderingInputAttachmentIndexInfo);
21060pub type NonNullPFN_vkCmdSetRepresentativeFragmentTestEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, representativeFragmentTestEnable: VkBool32);
21061pub type NonNullPFN_vkCmdSetSampleLocationsEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pSampleLocationsInfo: *const VkSampleLocationsInfoEXT);
21062pub type NonNullPFN_vkCmdSetSampleLocationsEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, sampleLocationsEnable: VkBool32);
21063pub type NonNullPFN_vkCmdSetSampleMaskEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, samples: VkSampleCountFlagBits, pSampleMask: *const VkSampleMask);
21064pub type NonNullPFN_vkCmdSetScissor = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstScissor: u32, scissorCount: u32, pScissors: *const VkRect2D);
21065pub type NonNullPFN_vkCmdSetScissorWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
21066pub type NonNullPFN_vkCmdSetScissorWithCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, scissorCount: u32, pScissors: *const VkRect2D);
21067pub type NonNullPFN_vkCmdSetShadingRateImageEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, shadingRateImageEnable: VkBool32);
21068pub type NonNullPFN_vkCmdSetStencilCompareMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, compareMask: u32);
21069pub type NonNullPFN_vkCmdSetStencilOp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
21070pub type NonNullPFN_vkCmdSetStencilOpEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, failOp: VkStencilOp, passOp: VkStencilOp, depthFailOp: VkStencilOp, compareOp: VkCompareOp);
21071pub type NonNullPFN_vkCmdSetStencilReference = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, reference: u32);
21072pub type NonNullPFN_vkCmdSetStencilTestEnable = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
21073pub type NonNullPFN_vkCmdSetStencilTestEnableEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stencilTestEnable: VkBool32);
21074pub type NonNullPFN_vkCmdSetStencilWriteMask = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, faceMask: VkStencilFaceFlags, writeMask: u32);
21075pub type NonNullPFN_vkCmdSetTessellationDomainOriginEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, domainOrigin: VkTessellationDomainOrigin);
21076pub type NonNullPFN_vkCmdSetVertexInputEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, vertexBindingDescriptionCount: u32, pVertexBindingDescriptions: *const VkVertexInputBindingDescription2EXT, vertexAttributeDescriptionCount: u32, pVertexAttributeDescriptions: *const VkVertexInputAttributeDescription2EXT);
21077pub type NonNullPFN_vkCmdSetViewport = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewports: *const VkViewport);
21078pub type NonNullPFN_vkCmdSetViewportShadingRatePaletteNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pShadingRatePalettes: *const VkShadingRatePaletteNV);
21079pub type NonNullPFN_vkCmdSetViewportSwizzleNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportSwizzles: *const VkViewportSwizzleNV);
21080pub type NonNullPFN_vkCmdSetViewportWScalingEnableNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportWScalingEnable: VkBool32);
21081pub type NonNullPFN_vkCmdSetViewportWScalingNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, firstViewport: u32, viewportCount: u32, pViewportWScalings: *const VkViewportWScalingNV);
21082pub type NonNullPFN_vkCmdSetViewportWithCount = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
21083pub type NonNullPFN_vkCmdSetViewportWithCountEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, viewportCount: u32, pViewports: *const VkViewport);
21084pub type NonNullPFN_vkCmdSubpassShadingHUAWEI = unsafe extern "system" fn(commandBuffer: VkCommandBuffer);
21085pub type NonNullPFN_vkCmdTraceRaysIndirect2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, indirectDeviceAddress: VkDeviceAddress);
21086pub type NonNullPFN_vkCmdTraceRaysIndirectKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pRaygenShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pMissShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pHitShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, pCallableShaderBindingTable: *const VkStridedDeviceAddressRegionKHR, indirectDeviceAddress: VkDeviceAddress);
21087pub 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);
21088pub 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);
21089pub type NonNullPFN_vkCmdUpdateBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, dataSize: VkDeviceSize, pData: *const c_void);
21090pub type NonNullPFN_vkCmdUpdatePipelineIndirectBufferNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineBindPoint: VkPipelineBindPoint, pipeline: VkPipeline);
21091pub 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);
21092pub type NonNullPFN_vkCmdWaitEvents2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
21093pub type NonNullPFN_vkCmdWaitEvents2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, eventCount: u32, pEvents: *const VkEvent, pDependencyInfos: *const VkDependencyInfo);
21094pub type NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesKHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureKHR, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
21095pub type NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesNV = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, accelerationStructureCount: u32, pAccelerationStructures: *const VkAccelerationStructureNV, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
21096pub type NonNullPFN_vkCmdWriteBufferMarker2AMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
21097pub type NonNullPFN_vkCmdWriteBufferMarkerAMD = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, dstBuffer: VkBuffer, dstOffset: VkDeviceSize, marker: u32);
21098pub type NonNullPFN_vkCmdWriteMicromapsPropertiesEXT = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, micromapCount: u32, pMicromaps: *const VkMicromapEXT, queryType: VkQueryType, queryPool: VkQueryPool, firstQuery: u32);
21099pub type NonNullPFN_vkCmdWriteTimestamp = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, pipelineStage: VkPipelineStageFlagBits, queryPool: VkQueryPool, query: u32);
21100pub type NonNullPFN_vkCmdWriteTimestamp2 = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
21101pub type NonNullPFN_vkCmdWriteTimestamp2KHR = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, stage: VkPipelineStageFlags2, queryPool: VkQueryPool, query: u32);
21102pub type NonNullPFN_vkCompileDeferredNV = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shader: u32) -> VkResult;
21103pub type NonNullPFN_vkConvertCooperativeVectorMatrixNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkConvertCooperativeVectorMatrixInfoNV) -> VkResult;
21104pub type NonNullPFN_vkCopyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureInfoKHR) -> VkResult;
21105pub type NonNullPFN_vkCopyAccelerationStructureToMemoryKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyAccelerationStructureToMemoryInfoKHR) -> VkResult;
21106pub type NonNullPFN_vkCopyImageToImage = unsafe extern "system" fn(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
21107pub type NonNullPFN_vkCopyImageToImageEXT = unsafe extern "system" fn(device: VkDevice, pCopyImageToImageInfo: *const VkCopyImageToImageInfo) -> VkResult;
21108pub type NonNullPFN_vkCopyImageToMemory = unsafe extern "system" fn(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
21109pub type NonNullPFN_vkCopyImageToMemoryEXT = unsafe extern "system" fn(device: VkDevice, pCopyImageToMemoryInfo: *const VkCopyImageToMemoryInfo) -> VkResult;
21110pub type NonNullPFN_vkCopyMemoryToAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToAccelerationStructureInfoKHR) -> VkResult;
21111pub type NonNullPFN_vkCopyMemoryToImage = unsafe extern "system" fn(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
21112pub type NonNullPFN_vkCopyMemoryToImageEXT = unsafe extern "system" fn(device: VkDevice, pCopyMemoryToImageInfo: *const VkCopyMemoryToImageInfo) -> VkResult;
21113pub type NonNullPFN_vkCopyMemoryToMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMemoryToMicromapInfoEXT) -> VkResult;
21114pub type NonNullPFN_vkCopyMicromapEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapInfoEXT) -> VkResult;
21115pub type NonNullPFN_vkCopyMicromapToMemoryEXT = unsafe extern "system" fn(device: VkDevice, deferredOperation: VkDeferredOperationKHR, pInfo: *const VkCopyMicromapToMemoryInfoEXT) -> VkResult;
21116pub type NonNullPFN_vkCreateAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureKHR) -> VkResult;
21117pub type NonNullPFN_vkCreateAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkAccelerationStructureCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pAccelerationStructure: *mut VkAccelerationStructureNV) -> VkResult;
21118pub type NonNullPFN_vkCreateBuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pBuffer: *mut VkBuffer) -> VkResult;
21119pub type NonNullPFN_vkCreateBufferView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkBufferViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkBufferView) -> VkResult;
21120pub type NonNullPFN_vkCreateCommandPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCommandPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pCommandPool: *mut VkCommandPool) -> VkResult;
21121pub type NonNullPFN_vkCreateComputePipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkComputePipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21122pub type NonNullPFN_vkCreateCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuFunctionCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pFunction: *mut VkCuFunctionNVX) -> VkResult;
21123pub type NonNullPFN_vkCreateCuModuleNVX = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkCuModuleCreateInfoNVX, pAllocator: *const VkAllocationCallbacks, pModule: *mut VkCuModuleNVX) -> VkResult;
21124pub type NonNullPFN_vkCreateDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDataGraphPipelineSessionCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkDataGraphPipelineSessionARM) -> VkResult;
21125pub 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;
21126pub type NonNullPFN_vkCreateDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugReportCallbackCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pCallback: *mut VkDebugReportCallbackEXT) -> VkResult;
21127pub type NonNullPFN_vkCreateDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDebugUtilsMessengerCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMessenger: *mut VkDebugUtilsMessengerEXT) -> VkResult;
21128pub type NonNullPFN_vkCreateDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks, pDeferredOperation: *mut VkDeferredOperationKHR) -> VkResult;
21129pub type NonNullPFN_vkCreateDescriptorPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorPool: *mut VkDescriptorPool) -> VkResult;
21130pub type NonNullPFN_vkCreateDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pSetLayout: *mut VkDescriptorSetLayout) -> VkResult;
21131pub type NonNullPFN_vkCreateDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
21132pub type NonNullPFN_vkCreateDescriptorUpdateTemplateKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorUpdateTemplateCreateInfo, pAllocator: *const VkAllocationCallbacks, pDescriptorUpdateTemplate: *mut VkDescriptorUpdateTemplate) -> VkResult;
21133pub type NonNullPFN_vkCreateDevice = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCreateInfo: *const VkDeviceCreateInfo, pAllocator: *const VkAllocationCallbacks, pDevice: *mut VkDevice) -> VkResult;
21134pub type NonNullPFN_vkCreateDisplayModeKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pCreateInfo: *const VkDisplayModeCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pMode: *mut VkDisplayModeKHR) -> VkResult;
21135pub type NonNullPFN_vkCreateDisplayPlaneSurfaceKHR = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkDisplaySurfaceCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
21136pub type NonNullPFN_vkCreateEvent = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkEventCreateInfo, pAllocator: *const VkAllocationCallbacks, pEvent: *mut VkEvent) -> VkResult;
21137pub type NonNullPFN_vkCreateExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkExternalComputeQueueCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pExternalQueue: *mut VkExternalComputeQueueNV) -> VkResult;
21138pub type NonNullPFN_vkCreateFence = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFenceCreateInfo, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
21139pub type NonNullPFN_vkCreateFramebuffer = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkFramebufferCreateInfo, pAllocator: *const VkAllocationCallbacks, pFramebuffer: *mut VkFramebuffer) -> VkResult;
21140pub type NonNullPFN_vkCreateGraphicsPipelines = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkGraphicsPipelineCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21141pub type NonNullPFN_vkCreateHeadlessSurfaceEXT = unsafe extern "system" fn(instance: VkInstance, pCreateInfo: *const VkHeadlessSurfaceCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pSurface: *mut VkSurfaceKHR) -> VkResult;
21142pub type NonNullPFN_vkCreateImage = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageCreateInfo, pAllocator: *const VkAllocationCallbacks, pImage: *mut VkImage) -> VkResult;
21143pub type NonNullPFN_vkCreateImageView = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkImageViewCreateInfo, pAllocator: *const VkAllocationCallbacks, pView: *mut VkImageView) -> VkResult;
21144pub type NonNullPFN_vkCreateIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutEXT) -> VkResult;
21145pub type NonNullPFN_vkCreateIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectCommandsLayoutCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pIndirectCommandsLayout: *mut VkIndirectCommandsLayoutNV) -> VkResult;
21146pub type NonNullPFN_vkCreateIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkIndirectExecutionSetCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pIndirectExecutionSet: *mut VkIndirectExecutionSetEXT) -> VkResult;
21147pub type NonNullPFN_vkCreateInstance = unsafe extern "system" fn(pCreateInfo: *const VkInstanceCreateInfo, pAllocator: *const VkAllocationCallbacks, pInstance: *mut VkInstance) -> VkResult;
21148pub type NonNullPFN_vkCreateMicromapEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkMicromapCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pMicromap: *mut VkMicromapEXT) -> VkResult;
21149pub type NonNullPFN_vkCreateOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkOpticalFlowSessionCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pSession: *mut VkOpticalFlowSessionNV) -> VkResult;
21150pub type NonNullPFN_vkCreatePipelineBinariesKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineBinaryCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pBinaries: *mut VkPipelineBinaryHandlesInfoKHR) -> VkResult;
21151pub type NonNullPFN_vkCreatePipelineCache = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineCacheCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineCache: *mut VkPipelineCache) -> VkResult;
21152pub type NonNullPFN_vkCreatePipelineLayout = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPipelineLayoutCreateInfo, pAllocator: *const VkAllocationCallbacks, pPipelineLayout: *mut VkPipelineLayout) -> VkResult;
21153pub type NonNullPFN_vkCreatePrivateDataSlot = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
21154pub type NonNullPFN_vkCreatePrivateDataSlotEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkPrivateDataSlotCreateInfo, pAllocator: *const VkAllocationCallbacks, pPrivateDataSlot: *mut VkPrivateDataSlot) -> VkResult;
21155pub type NonNullPFN_vkCreateQueryPool = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkQueryPoolCreateInfo, pAllocator: *const VkAllocationCallbacks, pQueryPool: *mut VkQueryPool) -> VkResult;
21156pub 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;
21157pub type NonNullPFN_vkCreateRayTracingPipelinesNV = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, createInfoCount: u32, pCreateInfos: *const VkRayTracingPipelineCreateInfoNV, pAllocator: *const VkAllocationCallbacks, pPipelines: *mut VkPipeline) -> VkResult;
21158pub type NonNullPFN_vkCreateRenderPass = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
21159pub type NonNullPFN_vkCreateRenderPass2 = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
21160pub type NonNullPFN_vkCreateRenderPass2KHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkRenderPassCreateInfo2, pAllocator: *const VkAllocationCallbacks, pRenderPass: *mut VkRenderPass) -> VkResult;
21161pub type NonNullPFN_vkCreateSampler = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerCreateInfo, pAllocator: *const VkAllocationCallbacks, pSampler: *mut VkSampler) -> VkResult;
21162pub type NonNullPFN_vkCreateSamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
21163pub type NonNullPFN_vkCreateSamplerYcbcrConversionKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSamplerYcbcrConversionCreateInfo, pAllocator: *const VkAllocationCallbacks, pYcbcrConversion: *mut VkSamplerYcbcrConversion) -> VkResult;
21164pub type NonNullPFN_vkCreateSemaphore = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSemaphoreCreateInfo, pAllocator: *const VkAllocationCallbacks, pSemaphore: *mut VkSemaphore) -> VkResult;
21165pub type NonNullPFN_vkCreateShaderModule = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pAllocator: *const VkAllocationCallbacks, pShaderModule: *mut VkShaderModule) -> VkResult;
21166pub type NonNullPFN_vkCreateShadersEXT = unsafe extern "system" fn(device: VkDevice, createInfoCount: u32, pCreateInfos: *const VkShaderCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pShaders: *mut VkShaderEXT) -> VkResult;
21167pub type NonNullPFN_vkCreateSharedSwapchainsKHR = unsafe extern "system" fn(device: VkDevice, swapchainCount: u32, pCreateInfos: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchains: *mut VkSwapchainKHR) -> VkResult;
21168pub type NonNullPFN_vkCreateSwapchainKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkSwapchainCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pSwapchain: *mut VkSwapchainKHR) -> VkResult;
21169pub type NonNullPFN_vkCreateTensorARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pTensor: *mut VkTensorARM) -> VkResult;
21170pub type NonNullPFN_vkCreateTensorViewARM = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkTensorViewCreateInfoARM, pAllocator: *const VkAllocationCallbacks, pView: *mut VkTensorViewARM) -> VkResult;
21171pub type NonNullPFN_vkCreateValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkValidationCacheCreateInfoEXT, pAllocator: *const VkAllocationCallbacks, pValidationCache: *mut VkValidationCacheEXT) -> VkResult;
21172pub type NonNullPFN_vkCreateVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSession: *mut VkVideoSessionKHR) -> VkResult;
21173pub type NonNullPFN_vkCreateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkVideoSessionParametersCreateInfoKHR, pAllocator: *const VkAllocationCallbacks, pVideoSessionParameters: *mut VkVideoSessionParametersKHR) -> VkResult;
21174pub type NonNullPFN_vkDebugMarkerSetObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugMarkerObjectNameInfoEXT) -> VkResult;
21175pub type NonNullPFN_vkDebugMarkerSetObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugMarkerObjectTagInfoEXT) -> VkResult;
21176pub 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;
21177pub 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);
21178pub type NonNullPFN_vkDebugUtilsMessengerCallbackEXT = unsafe extern "system" fn(messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT, pUserData: *mut c_void) -> VkBool32;
21179pub type NonNullPFN_vkDeferredOperationJoinKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
21180pub type NonNullPFN_vkDestroyAccelerationStructureKHR = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureKHR, pAllocator: *const VkAllocationCallbacks);
21181pub type NonNullPFN_vkDestroyAccelerationStructureNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, pAllocator: *const VkAllocationCallbacks);
21182pub type NonNullPFN_vkDestroyBuffer = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pAllocator: *const VkAllocationCallbacks);
21183pub type NonNullPFN_vkDestroyBufferView = unsafe extern "system" fn(device: VkDevice, bufferView: VkBufferView, pAllocator: *const VkAllocationCallbacks);
21184pub type NonNullPFN_vkDestroyCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, pAllocator: *const VkAllocationCallbacks);
21185pub type NonNullPFN_vkDestroyCuFunctionNVX = unsafe extern "system" fn(device: VkDevice, function: VkCuFunctionNVX, pAllocator: *const VkAllocationCallbacks);
21186pub type NonNullPFN_vkDestroyCuModuleNVX = unsafe extern "system" fn(device: VkDevice, module: VkCuModuleNVX, pAllocator: *const VkAllocationCallbacks);
21187pub type NonNullPFN_vkDestroyDataGraphPipelineSessionARM = unsafe extern "system" fn(device: VkDevice, session: VkDataGraphPipelineSessionARM, pAllocator: *const VkAllocationCallbacks);
21188pub type NonNullPFN_vkDestroyDebugReportCallbackEXT = unsafe extern "system" fn(instance: VkInstance, callback: VkDebugReportCallbackEXT, pAllocator: *const VkAllocationCallbacks);
21189pub type NonNullPFN_vkDestroyDebugUtilsMessengerEXT = unsafe extern "system" fn(instance: VkInstance, messenger: VkDebugUtilsMessengerEXT, pAllocator: *const VkAllocationCallbacks);
21190pub type NonNullPFN_vkDestroyDeferredOperationKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR, pAllocator: *const VkAllocationCallbacks);
21191pub type NonNullPFN_vkDestroyDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, pAllocator: *const VkAllocationCallbacks);
21192pub type NonNullPFN_vkDestroyDescriptorSetLayout = unsafe extern "system" fn(device: VkDevice, descriptorSetLayout: VkDescriptorSetLayout, pAllocator: *const VkAllocationCallbacks);
21193pub type NonNullPFN_vkDestroyDescriptorUpdateTemplate = unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
21194pub type NonNullPFN_vkDestroyDescriptorUpdateTemplateKHR = unsafe extern "system" fn(device: VkDevice, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pAllocator: *const VkAllocationCallbacks);
21195pub type NonNullPFN_vkDestroyDevice = unsafe extern "system" fn(device: VkDevice, pAllocator: *const VkAllocationCallbacks);
21196pub type NonNullPFN_vkDestroyEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent, pAllocator: *const VkAllocationCallbacks);
21197pub type NonNullPFN_vkDestroyExternalComputeQueueNV = unsafe extern "system" fn(device: VkDevice, externalQueue: VkExternalComputeQueueNV, pAllocator: *const VkAllocationCallbacks);
21198pub type NonNullPFN_vkDestroyFence = unsafe extern "system" fn(device: VkDevice, fence: VkFence, pAllocator: *const VkAllocationCallbacks);
21199pub type NonNullPFN_vkDestroyFramebuffer = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pAllocator: *const VkAllocationCallbacks);
21200pub type NonNullPFN_vkDestroyImage = unsafe extern "system" fn(device: VkDevice, image: VkImage, pAllocator: *const VkAllocationCallbacks);
21201pub type NonNullPFN_vkDestroyImageView = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pAllocator: *const VkAllocationCallbacks);
21202pub type NonNullPFN_vkDestroyIndirectCommandsLayoutEXT = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutEXT, pAllocator: *const VkAllocationCallbacks);
21203pub type NonNullPFN_vkDestroyIndirectCommandsLayoutNV = unsafe extern "system" fn(device: VkDevice, indirectCommandsLayout: VkIndirectCommandsLayoutNV, pAllocator: *const VkAllocationCallbacks);
21204pub type NonNullPFN_vkDestroyIndirectExecutionSetEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, pAllocator: *const VkAllocationCallbacks);
21205pub type NonNullPFN_vkDestroyInstance = unsafe extern "system" fn(instance: VkInstance, pAllocator: *const VkAllocationCallbacks);
21206pub type NonNullPFN_vkDestroyMicromapEXT = unsafe extern "system" fn(device: VkDevice, micromap: VkMicromapEXT, pAllocator: *const VkAllocationCallbacks);
21207pub type NonNullPFN_vkDestroyOpticalFlowSessionNV = unsafe extern "system" fn(device: VkDevice, session: VkOpticalFlowSessionNV, pAllocator: *const VkAllocationCallbacks);
21208pub type NonNullPFN_vkDestroyPipeline = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, pAllocator: *const VkAllocationCallbacks);
21209pub type NonNullPFN_vkDestroyPipelineBinaryKHR = unsafe extern "system" fn(device: VkDevice, pipelineBinary: VkPipelineBinaryKHR, pAllocator: *const VkAllocationCallbacks);
21210pub type NonNullPFN_vkDestroyPipelineCache = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pAllocator: *const VkAllocationCallbacks);
21211pub type NonNullPFN_vkDestroyPipelineLayout = unsafe extern "system" fn(device: VkDevice, pipelineLayout: VkPipelineLayout, pAllocator: *const VkAllocationCallbacks);
21212pub type NonNullPFN_vkDestroyPrivateDataSlot = unsafe extern "system" fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
21213pub type NonNullPFN_vkDestroyPrivateDataSlotEXT = unsafe extern "system" fn(device: VkDevice, privateDataSlot: VkPrivateDataSlot, pAllocator: *const VkAllocationCallbacks);
21214pub type NonNullPFN_vkDestroyQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, pAllocator: *const VkAllocationCallbacks);
21215pub type NonNullPFN_vkDestroyRenderPass = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pAllocator: *const VkAllocationCallbacks);
21216pub type NonNullPFN_vkDestroySampler = unsafe extern "system" fn(device: VkDevice, sampler: VkSampler, pAllocator: *const VkAllocationCallbacks);
21217pub type NonNullPFN_vkDestroySamplerYcbcrConversion = unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
21218pub type NonNullPFN_vkDestroySamplerYcbcrConversionKHR = unsafe extern "system" fn(device: VkDevice, ycbcrConversion: VkSamplerYcbcrConversion, pAllocator: *const VkAllocationCallbacks);
21219pub type NonNullPFN_vkDestroySemaphore = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pAllocator: *const VkAllocationCallbacks);
21220pub type NonNullPFN_vkDestroyShaderEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pAllocator: *const VkAllocationCallbacks);
21221pub type NonNullPFN_vkDestroyShaderModule = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pAllocator: *const VkAllocationCallbacks);
21222pub type NonNullPFN_vkDestroySurfaceKHR = unsafe extern "system" fn(instance: VkInstance, surface: VkSurfaceKHR, pAllocator: *const VkAllocationCallbacks);
21223pub type NonNullPFN_vkDestroySwapchainKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pAllocator: *const VkAllocationCallbacks);
21224pub type NonNullPFN_vkDestroyTensorARM = unsafe extern "system" fn(device: VkDevice, tensor: VkTensorARM, pAllocator: *const VkAllocationCallbacks);
21225pub type NonNullPFN_vkDestroyTensorViewARM = unsafe extern "system" fn(device: VkDevice, tensorView: VkTensorViewARM, pAllocator: *const VkAllocationCallbacks);
21226pub type NonNullPFN_vkDestroyValidationCacheEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pAllocator: *const VkAllocationCallbacks);
21227pub type NonNullPFN_vkDestroyVideoSessionKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pAllocator: *const VkAllocationCallbacks);
21228pub type NonNullPFN_vkDestroyVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pAllocator: *const VkAllocationCallbacks);
21229pub type NonNullPFN_vkDeviceMemoryReportCallbackEXT = unsafe extern "system" fn(pCallbackData: *const VkDeviceMemoryReportCallbackDataEXT, pUserData: *mut c_void);
21230pub type NonNullPFN_vkDeviceWaitIdle = unsafe extern "system" fn(device: VkDevice) -> VkResult;
21231pub type NonNullPFN_vkDisplayPowerControlEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayPowerInfo: *const VkDisplayPowerInfoEXT) -> VkResult;
21232pub type NonNullPFN_vkEndCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer) -> VkResult;
21233pub type NonNullPFN_vkEnumerateDeviceExtensionProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
21234pub type NonNullPFN_vkEnumerateDeviceLayerProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
21235pub type NonNullPFN_vkEnumerateInstanceExtensionProperties = unsafe extern "system" fn(pLayerName: *const c_char, pPropertyCount: *mut u32, pProperties: *mut VkExtensionProperties) -> VkResult;
21236pub type NonNullPFN_vkEnumerateInstanceLayerProperties = unsafe extern "system" fn(pPropertyCount: *mut u32, pProperties: *mut VkLayerProperties) -> VkResult;
21237pub type NonNullPFN_vkEnumerateInstanceVersion = unsafe extern "system" fn(pApiVersion: *mut u32) -> VkResult;
21238pub type NonNullPFN_vkEnumeratePhysicalDeviceGroups = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
21239pub type NonNullPFN_vkEnumeratePhysicalDeviceGroupsKHR = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceGroupCount: *mut u32, pPhysicalDeviceGroupProperties: *mut VkPhysicalDeviceGroupProperties) -> VkResult;
21240pub type NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterARM, pCounterDescriptions: *mut VkPerformanceCounterDescriptionARM) -> VkResult;
21241pub type NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pCounterCount: *mut u32, pCounters: *mut VkPerformanceCounterKHR, pCounterDescriptions: *mut VkPerformanceCounterDescriptionKHR) -> VkResult;
21242pub type NonNullPFN_vkEnumeratePhysicalDevices = unsafe extern "system" fn(instance: VkInstance, pPhysicalDeviceCount: *mut u32, pPhysicalDevices: *mut VkPhysicalDevice) -> VkResult;
21243pub type NonNullPFN_vkFlushMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
21244pub type NonNullPFN_vkFreeCommandBuffers = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, commandBufferCount: u32, pCommandBuffers: *const VkCommandBuffer);
21245pub type NonNullPFN_vkFreeDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, descriptorSetCount: u32, pDescriptorSets: *const VkDescriptorSet) -> VkResult;
21246pub type NonNullPFN_vkFreeFunction = unsafe extern "system" fn(pUserData: *mut c_void, pMemory: *mut c_void);
21247pub type NonNullPFN_vkFreeMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pAllocator: *const VkAllocationCallbacks);
21248pub type NonNullPFN_vkGetAccelerationStructureBuildSizesKHR = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkAccelerationStructureBuildGeometryInfoKHR, pMaxPrimitiveCounts: *const u32, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
21249pub type NonNullPFN_vkGetAccelerationStructureDeviceAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureDeviceAddressInfoKHR) -> VkDeviceAddress;
21250pub type NonNullPFN_vkGetAccelerationStructureHandleNV = unsafe extern "system" fn(device: VkDevice, accelerationStructure: VkAccelerationStructureNV, dataSize: usize, pData: *mut c_void) -> VkResult;
21251pub type NonNullPFN_vkGetAccelerationStructureMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2KHR);
21252pub type NonNullPFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkAccelerationStructureCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21253pub type NonNullPFN_vkGetBufferDeviceAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
21254pub type NonNullPFN_vkGetBufferDeviceAddressEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
21255pub type NonNullPFN_vkGetBufferDeviceAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> VkDeviceAddress;
21256pub type NonNullPFN_vkGetBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, buffer: VkBuffer, pMemoryRequirements: *mut VkMemoryRequirements);
21257pub type NonNullPFN_vkGetBufferMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21258pub type NonNullPFN_vkGetBufferMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21259pub type NonNullPFN_vkGetBufferOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
21260pub type NonNullPFN_vkGetBufferOpaqueCaptureAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferDeviceAddressInfo) -> u64;
21261pub type NonNullPFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkBufferCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21262pub type NonNullPFN_vkGetCalibratedTimestampsEXT = unsafe extern "system" fn(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
21263pub type NonNullPFN_vkGetCalibratedTimestampsKHR = unsafe extern "system" fn(device: VkDevice, timestampCount: u32, pTimestampInfos: *const VkCalibratedTimestampInfoKHR, pTimestamps: *mut u64, pMaxDeviation: *mut u64) -> VkResult;
21264pub type NonNullPFN_vkGetClusterAccelerationStructureBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkClusterAccelerationStructureInputInfoNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
21265pub type NonNullPFN_vkGetDataGraphPipelineAvailablePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, pPropertiesCount: *mut u32, pProperties: *mut VkDataGraphPipelinePropertyARM) -> VkResult;
21266pub type NonNullPFN_vkGetDataGraphPipelinePropertiesARM = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkDataGraphPipelineInfoARM, propertiesCount: u32, pProperties: *mut VkDataGraphPipelinePropertyQueryResultARM) -> VkResult;
21267pub type NonNullPFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionBindPointRequirementsInfoARM, pBindPointRequirementCount: *mut u32, pBindPointRequirements: *mut VkDataGraphPipelineSessionBindPointRequirementARM) -> VkResult;
21268pub type NonNullPFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDataGraphPipelineSessionMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
21269pub type NonNullPFN_vkGetDeferredOperationMaxConcurrencyKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> u32;
21270pub type NonNullPFN_vkGetDeferredOperationResultKHR = unsafe extern "system" fn(device: VkDevice, operation: VkDeferredOperationKHR) -> VkResult;
21271pub type NonNullPFN_vkGetDescriptorEXT = unsafe extern "system" fn(device: VkDevice, pDescriptorInfo: *const VkDescriptorGetInfoEXT, dataSize: usize, pDescriptor: *mut c_void);
21272pub type NonNullPFN_vkGetDescriptorSetHostMappingVALVE = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, ppData: *mut *mut c_void);
21273pub type NonNullPFN_vkGetDescriptorSetLayoutBindingOffsetEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, binding: u32, pOffset: *mut VkDeviceSize);
21274pub type NonNullPFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = unsafe extern "system" fn(device: VkDevice, pBindingReference: *const VkDescriptorSetBindingReferenceVALVE, pHostMapping: *mut VkDescriptorSetLayoutHostMappingInfoVALVE);
21275pub type NonNullPFN_vkGetDescriptorSetLayoutSizeEXT = unsafe extern "system" fn(device: VkDevice, layout: VkDescriptorSetLayout, pLayoutSizeInBytes: *mut VkDeviceSize);
21276pub type NonNullPFN_vkGetDescriptorSetLayoutSupport = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
21277pub type NonNullPFN_vkGetDescriptorSetLayoutSupportKHR = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkDescriptorSetLayoutCreateInfo, pSupport: *mut VkDescriptorSetLayoutSupport);
21278pub type NonNullPFN_vkGetDeviceAccelerationStructureCompatibilityKHR = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkAccelerationStructureVersionInfoKHR, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
21279pub type NonNullPFN_vkGetDeviceBufferMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21280pub type NonNullPFN_vkGetDeviceBufferMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceBufferMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21281pub type NonNullPFN_vkGetDeviceCombinedImageSamplerIndexNVX = unsafe extern "system" fn(device: VkDevice, imageViewIndex: u64, samplerIndex: u64) -> u64;
21282pub type NonNullPFN_vkGetDeviceFaultInfoEXT = unsafe extern "system" fn(device: VkDevice, pFaultCounts: *mut VkDeviceFaultCountsEXT, pFaultInfo: *mut VkDeviceFaultInfoEXT) -> VkResult;
21283pub type NonNullPFN_vkGetDeviceGroupPeerMemoryFeatures = unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
21284pub type NonNullPFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = unsafe extern "system" fn(device: VkDevice, heapIndex: u32, localDeviceIndex: u32, remoteDeviceIndex: u32, pPeerMemoryFeatures: *mut VkPeerMemoryFeatureFlags);
21285pub type NonNullPFN_vkGetDeviceGroupPresentCapabilitiesKHR = unsafe extern "system" fn(device: VkDevice, pDeviceGroupPresentCapabilities: *mut VkDeviceGroupPresentCapabilitiesKHR) -> VkResult;
21286pub type NonNullPFN_vkGetDeviceGroupSurfacePresentModesKHR = unsafe extern "system" fn(device: VkDevice, surface: VkSurfaceKHR, pModes: *mut VkDeviceGroupPresentModeFlagsKHR) -> VkResult;
21287pub type NonNullPFN_vkGetDeviceImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21288pub type NonNullPFN_vkGetDeviceImageMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pMemoryRequirements: *mut VkMemoryRequirements2);
21289pub type NonNullPFN_vkGetDeviceImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21290pub type NonNullPFN_vkGetDeviceImageSparseMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageMemoryRequirements, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21291pub type NonNullPFN_vkGetDeviceImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
21292pub type NonNullPFN_vkGetDeviceImageSubresourceLayoutKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceImageSubresourceInfo, pLayout: *mut VkSubresourceLayout2);
21293pub type NonNullPFN_vkGetDeviceMemoryCommitment = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, pCommittedMemoryInBytes: *mut VkDeviceSize);
21294pub type NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddress = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
21295pub type NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceMemoryOpaqueCaptureAddressInfo) -> u64;
21296pub type NonNullPFN_vkGetDeviceMicromapCompatibilityEXT = unsafe extern "system" fn(device: VkDevice, pVersionInfo: *const VkMicromapVersionInfoEXT, pCompatibility: *mut VkAccelerationStructureCompatibilityKHR);
21297pub type NonNullPFN_vkGetDeviceProcAddr = unsafe extern "system" fn(device: VkDevice, pName: *const c_char) -> PFN_vkVoidFunction;
21298pub type NonNullPFN_vkGetDeviceQueue = unsafe extern "system" fn(device: VkDevice, queueFamilyIndex: u32, queueIndex: u32, pQueue: *mut VkQueue);
21299pub type NonNullPFN_vkGetDeviceQueue2 = unsafe extern "system" fn(device: VkDevice, pQueueInfo: *const VkDeviceQueueInfo2, pQueue: *mut VkQueue);
21300pub type NonNullPFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = unsafe extern "system" fn(device: VkDevice, renderpass: VkRenderPass, pMaxWorkgroupSize: *mut VkExtent2D) -> VkResult;
21301pub type NonNullPFN_vkGetDeviceTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkDeviceTensorMemoryRequirementsARM, pMemoryRequirements: *mut VkMemoryRequirements2);
21302pub type NonNullPFN_vkGetDisplayModeProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModeProperties2KHR) -> VkResult;
21303pub type NonNullPFN_vkGetDisplayModePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR, pPropertyCount: *mut u32, pProperties: *mut VkDisplayModePropertiesKHR) -> VkResult;
21304pub type NonNullPFN_vkGetDisplayPlaneCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pDisplayPlaneInfo: *const VkDisplayPlaneInfo2KHR, pCapabilities: *mut VkDisplayPlaneCapabilities2KHR) -> VkResult;
21305pub type NonNullPFN_vkGetDisplayPlaneCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, mode: VkDisplayModeKHR, planeIndex: u32, pCapabilities: *mut VkDisplayPlaneCapabilitiesKHR) -> VkResult;
21306pub type NonNullPFN_vkGetDisplayPlaneSupportedDisplaysKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, planeIndex: u32, pDisplayCount: *mut u32, pDisplays: *mut VkDisplayKHR) -> VkResult;
21307pub type NonNullPFN_vkGetDrmDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, drmFd: i32, connectorId: u32, display: *mut VkDisplayKHR) -> VkResult;
21308pub type NonNullPFN_vkGetDynamicRenderingTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, pRenderingInfo: *const VkRenderingInfo, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
21309pub type NonNullPFN_vkGetEncodedVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, pVideoSessionParametersInfo: *const VkVideoEncodeSessionParametersGetInfoKHR, pFeedbackInfo: *mut VkVideoEncodeSessionParametersFeedbackInfoKHR, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21310pub type NonNullPFN_vkGetEventStatus = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
21311pub type NonNullPFN_vkGetExternalComputeQueueDataNV = unsafe extern "system" fn(externalQueue: VkExternalComputeQueueNV, params: *mut VkExternalComputeQueueDataParamsNV, pData: *mut c_void);
21312pub type NonNullPFN_vkGetFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkFenceGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
21313pub type NonNullPFN_vkGetFenceStatus = unsafe extern "system" fn(device: VkDevice, fence: VkFence) -> VkResult;
21314pub type NonNullPFN_vkGetFramebufferTilePropertiesQCOM = unsafe extern "system" fn(device: VkDevice, framebuffer: VkFramebuffer, pPropertiesCount: *mut u32, pProperties: *mut VkTilePropertiesQCOM) -> VkResult;
21315pub type NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoEXT, pMemoryRequirements: *mut VkMemoryRequirements2);
21316pub type NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkGeneratedCommandsMemoryRequirementsInfoNV, pMemoryRequirements: *mut VkMemoryRequirements2);
21317pub type NonNullPFN_vkGetImageDrmFormatModifierPropertiesEXT = unsafe extern "system" fn(device: VkDevice, image: VkImage, pProperties: *mut VkImageDrmFormatModifierPropertiesEXT) -> VkResult;
21318pub type NonNullPFN_vkGetImageMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pMemoryRequirements: *mut VkMemoryRequirements);
21319pub type NonNullPFN_vkGetImageMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21320pub type NonNullPFN_vkGetImageMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageMemoryRequirementsInfo2, pMemoryRequirements: *mut VkMemoryRequirements2);
21321pub type NonNullPFN_vkGetImageOpaqueCaptureDataEXT = unsafe extern "system" fn(device: VkDevice, imageCount: u32, pImages: *const VkImage, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
21322pub type NonNullPFN_vkGetImageOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21323pub type NonNullPFN_vkGetImageSparseMemoryRequirements = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements);
21324pub type NonNullPFN_vkGetImageSparseMemoryRequirements2 = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21325pub type NonNullPFN_vkGetImageSparseMemoryRequirements2KHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageSparseMemoryRequirementsInfo2, pSparseMemoryRequirementCount: *mut u32, pSparseMemoryRequirements: *mut VkSparseImageMemoryRequirements2);
21326pub type NonNullPFN_vkGetImageSubresourceLayout = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource, pLayout: *mut VkSubresourceLayout);
21327pub type NonNullPFN_vkGetImageSubresourceLayout2 = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
21328pub type NonNullPFN_vkGetImageSubresourceLayout2EXT = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
21329pub type NonNullPFN_vkGetImageSubresourceLayout2KHR = unsafe extern "system" fn(device: VkDevice, image: VkImage, pSubresource: *const VkImageSubresource2, pLayout: *mut VkSubresourceLayout2);
21330pub type NonNullPFN_vkGetImageViewAddressNVX = unsafe extern "system" fn(device: VkDevice, imageView: VkImageView, pProperties: *mut VkImageViewAddressPropertiesNVX) -> VkResult;
21331pub type NonNullPFN_vkGetImageViewHandle64NVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u64;
21332pub type NonNullPFN_vkGetImageViewHandleNVX = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewHandleInfoNVX) -> u32;
21333pub type NonNullPFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkImageViewCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21334pub type NonNullPFN_vkGetInstanceProcAddr = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
21335pub type NonNullPFN_vkGetInstanceProcAddrLUNARG = unsafe extern "system" fn(instance: VkInstance, pName: *const c_char) -> PFN_vkVoidFunction;
21336pub type NonNullPFN_vkGetLatencyTimingsNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *mut VkGetLatencyMarkerInfoNV);
21337pub type NonNullPFN_vkGetMemoryFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkMemoryGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
21338pub type NonNullPFN_vkGetMemoryFdPropertiesKHR = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, fd: c_int, pMemoryFdProperties: *mut VkMemoryFdPropertiesKHR) -> VkResult;
21339pub type NonNullPFN_vkGetMemoryHostPointerPropertiesEXT = unsafe extern "system" fn(device: VkDevice, handleType: VkExternalMemoryHandleTypeFlagBits, pHostPointer: *const c_void, pMemoryHostPointerProperties: *mut VkMemoryHostPointerPropertiesEXT) -> VkResult;
21340pub type NonNullPFN_vkGetMemoryRemoteAddressNV = unsafe extern "system" fn(device: VkDevice, pMemoryGetRemoteAddressInfo: *const VkMemoryGetRemoteAddressInfoNV, pAddress: *mut VkRemoteAddressNV) -> VkResult;
21341pub type NonNullPFN_vkGetMicromapBuildSizesEXT = unsafe extern "system" fn(device: VkDevice, buildType: VkAccelerationStructureBuildTypeKHR, pBuildInfo: *const VkMicromapBuildInfoEXT, pSizeInfo: *mut VkMicromapBuildSizesInfoEXT);
21342pub type NonNullPFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPartitionedAccelerationStructureInstancesInputNV, pSizeInfo: *mut VkAccelerationStructureBuildSizesInfoKHR);
21343pub type NonNullPFN_vkGetPastPresentationTimingEXT = unsafe extern "system" fn(device: VkDevice, pPastPresentationTimingInfo: *const VkPastPresentationTimingInfoEXT, pPastPresentationTimingProperties: *mut VkPastPresentationTimingPropertiesEXT) -> VkResult;
21344pub type NonNullPFN_vkGetPastPresentationTimingGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentationTimingCount: *mut u32, pPresentationTimings: *mut VkPastPresentationTimingGOOGLE) -> VkResult;
21345pub type NonNullPFN_vkGetPerformanceParameterINTEL = unsafe extern "system" fn(device: VkDevice, parameter: VkPerformanceParameterTypeINTEL, pValue: *mut VkPerformanceValueINTEL) -> VkResult;
21346pub type NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
21347pub type NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pTimeDomainCount: *mut u32, pTimeDomains: *mut VkTimeDomainKHR) -> VkResult;
21348pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixFlexibleDimensionsPropertiesNV) -> VkResult;
21349pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesKHR) -> VkResult;
21350pub type NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeMatrixPropertiesNV) -> VkResult;
21351pub type NonNullPFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkCooperativeVectorPropertiesNV) -> VkResult;
21352pub type NonNullPFN_vkGetPhysicalDeviceDescriptorSizeEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, descriptorType: VkDescriptorType) -> VkDeviceSize;
21353pub type NonNullPFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlaneProperties2KHR) -> VkResult;
21354pub type NonNullPFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPlanePropertiesKHR) -> VkResult;
21355pub type NonNullPFN_vkGetPhysicalDeviceDisplayProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayProperties2KHR) -> VkResult;
21356pub type NonNullPFN_vkGetPhysicalDeviceDisplayPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPropertyCount: *mut u32, pProperties: *mut VkDisplayPropertiesKHR) -> VkResult;
21357pub type NonNullPFN_vkGetPhysicalDeviceExternalBufferProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
21358pub type NonNullPFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalBufferInfo: *const VkPhysicalDeviceExternalBufferInfo, pExternalBufferProperties: *mut VkExternalBufferProperties);
21359pub type NonNullPFN_vkGetPhysicalDeviceExternalFenceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
21360pub type NonNullPFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalFenceInfo: *const VkPhysicalDeviceExternalFenceInfo, pExternalFenceProperties: *mut VkExternalFenceProperties);
21361pub 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;
21362pub type NonNullPFN_vkGetPhysicalDeviceExternalSemaphoreProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
21363pub type NonNullPFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalSemaphoreInfo: *const VkPhysicalDeviceExternalSemaphoreInfo, pExternalSemaphoreProperties: *mut VkExternalSemaphoreProperties);
21364pub type NonNullPFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pExternalTensorInfo: *const VkPhysicalDeviceExternalTensorInfoARM, pExternalTensorProperties: *mut VkExternalTensorPropertiesARM);
21365pub type NonNullPFN_vkGetPhysicalDeviceFeatures = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures);
21366pub type NonNullPFN_vkGetPhysicalDeviceFeatures2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
21367pub type NonNullPFN_vkGetPhysicalDeviceFeatures2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFeatures: *mut VkPhysicalDeviceFeatures2);
21368pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties);
21369pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
21370pub type NonNullPFN_vkGetPhysicalDeviceFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, pFormatProperties: *mut VkFormatProperties2);
21371pub type NonNullPFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFragmentShadingRateCount: *mut u32, pFragmentShadingRates: *mut VkPhysicalDeviceFragmentShadingRateKHR) -> VkResult;
21372pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, format: VkFormat, typ: VkImageType, tiling: VkImageTiling, usage: VkImageUsageFlags, flags: VkImageCreateFlags, pImageFormatProperties: *mut VkImageFormatProperties) -> VkResult;
21373pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
21374pub type NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pImageFormatInfo: *const VkPhysicalDeviceImageFormatInfo2, pImageFormatProperties: *mut VkImageFormatProperties2) -> VkResult;
21375pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties);
21376pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
21377pub type NonNullPFN_vkGetPhysicalDeviceMemoryProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pMemoryProperties: *mut VkPhysicalDeviceMemoryProperties2);
21378pub type NonNullPFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, samples: VkSampleCountFlagBits, pMultisampleProperties: *mut VkMultisamplePropertiesEXT);
21379pub type NonNullPFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pOpticalFlowImageFormatInfo: *const VkOpticalFlowImageFormatInfoNV, pFormatCount: *mut u32, pImageFormatProperties: *mut VkOpticalFlowImageFormatPropertiesNV) -> VkResult;
21380pub type NonNullPFN_vkGetPhysicalDevicePresentRectanglesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pRectCount: *mut u32, pRects: *mut VkRect2D) -> VkResult;
21381pub type NonNullPFN_vkGetPhysicalDeviceProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties);
21382pub type NonNullPFN_vkGetPhysicalDeviceProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
21383pub type NonNullPFN_vkGetPhysicalDeviceProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pProperties: *mut VkPhysicalDeviceProperties2);
21384pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyDataGraphProcessingEngineInfo: *const VkPhysicalDeviceQueueFamilyDataGraphProcessingEngineInfoARM, pQueueFamilyDataGraphProcessingEngineProperties: *mut VkQueueFamilyDataGraphProcessingEnginePropertiesARM);
21385pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, pQueueFamilyDataGraphPropertyCount: *mut u32, pQueueFamilyDataGraphProperties: *mut VkQueueFamilyDataGraphPropertiesARM) -> VkResult;
21386pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pPerformanceQueryCreateInfo: *const VkQueryPoolPerformanceCreateInfoKHR, pNumPasses: *mut u32);
21387pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties);
21388pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
21389pub type NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQueueFamilyPropertyCount: *mut u32, pQueueFamilyProperties: *mut VkQueueFamilyProperties2);
21390pub 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);
21391pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
21392pub type NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pFormatInfo: *const VkPhysicalDeviceSparseImageFormatInfo2, pPropertyCount: *mut u32, pProperties: *mut VkSparseImageFormatProperties2);
21393pub type NonNullPFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pCombinationCount: *mut u32, pCombinations: *mut VkFramebufferMixedSamplesCombinationNV) -> VkResult;
21394pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2EXT) -> VkResult;
21395pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceCapabilities: *mut VkSurfaceCapabilities2KHR) -> VkResult;
21396pub type NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceCapabilities: *mut VkSurfaceCapabilitiesKHR) -> VkResult;
21397pub type NonNullPFN_vkGetPhysicalDeviceSurfaceFormats2KHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pSurfaceInfo: *const VkPhysicalDeviceSurfaceInfo2KHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormat2KHR) -> VkResult;
21398pub type NonNullPFN_vkGetPhysicalDeviceSurfaceFormatsKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pSurfaceFormatCount: *mut u32, pSurfaceFormats: *mut VkSurfaceFormatKHR) -> VkResult;
21399pub type NonNullPFN_vkGetPhysicalDeviceSurfacePresentModesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, surface: VkSurfaceKHR, pPresentModeCount: *mut u32, pPresentModes: *mut VkPresentModeKHR) -> VkResult;
21400pub type NonNullPFN_vkGetPhysicalDeviceSurfaceSupportKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, queueFamilyIndex: u32, surface: VkSurfaceKHR, pSupported: *mut VkBool32) -> VkResult;
21401pub type NonNullPFN_vkGetPhysicalDeviceToolProperties = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
21402pub type NonNullPFN_vkGetPhysicalDeviceToolPropertiesEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pToolCount: *mut u32, pToolProperties: *mut VkPhysicalDeviceToolProperties) -> VkResult;
21403pub type NonNullPFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoProfile: *const VkVideoProfileInfoKHR, pCapabilities: *mut VkVideoCapabilitiesKHR) -> VkResult;
21404pub type NonNullPFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pQualityLevelInfo: *const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR, pQualityLevelProperties: *mut VkVideoEncodeQualityLevelPropertiesKHR) -> VkResult;
21405pub type NonNullPFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, pVideoFormatInfo: *const VkPhysicalDeviceVideoFormatInfoKHR, pVideoFormatPropertyCount: *mut u32, pVideoFormatProperties: *mut VkVideoFormatPropertiesKHR) -> VkResult;
21406pub type NonNullPFN_vkGetPipelineBinaryDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineBinaryDataInfoKHR, pPipelineBinaryKey: *mut VkPipelineBinaryKeyKHR, pPipelineBinaryDataSize: *mut usize, pPipelineBinaryData: *mut c_void) -> VkResult;
21407pub type NonNullPFN_vkGetPipelineCacheData = unsafe extern "system" fn(device: VkDevice, pipelineCache: VkPipelineCache, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21408pub type NonNullPFN_vkGetPipelineExecutableInternalRepresentationsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pInternalRepresentationCount: *mut u32, pInternalRepresentations: *mut VkPipelineExecutableInternalRepresentationKHR) -> VkResult;
21409pub type NonNullPFN_vkGetPipelineExecutablePropertiesKHR = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoKHR, pExecutableCount: *mut u32, pProperties: *mut VkPipelineExecutablePropertiesKHR) -> VkResult;
21410pub type NonNullPFN_vkGetPipelineExecutableStatisticsKHR = unsafe extern "system" fn(device: VkDevice, pExecutableInfo: *const VkPipelineExecutableInfoKHR, pStatisticCount: *mut u32, pStatistics: *mut VkPipelineExecutableStatisticKHR) -> VkResult;
21411pub type NonNullPFN_vkGetPipelineIndirectDeviceAddressNV = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkPipelineIndirectDeviceAddressInfoNV) -> VkDeviceAddress;
21412pub type NonNullPFN_vkGetPipelineIndirectMemoryRequirementsNV = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkComputePipelineCreateInfo, pMemoryRequirements: *mut VkMemoryRequirements2);
21413pub type NonNullPFN_vkGetPipelineKeyKHR = unsafe extern "system" fn(device: VkDevice, pPipelineCreateInfo: *const VkPipelineCreateInfoKHR, pPipelineKey: *mut VkPipelineBinaryKeyKHR) -> VkResult;
21414pub type NonNullPFN_vkGetPipelinePropertiesEXT = unsafe extern "system" fn(device: VkDevice, pPipelineInfo: *const VkPipelineInfoEXT, pPipelineProperties: *mut VkBaseOutStructure) -> VkResult;
21415pub type NonNullPFN_vkGetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
21416pub type NonNullPFN_vkGetPrivateDataEXT = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, pData: *mut u64);
21417pub 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;
21418pub type NonNullPFN_vkGetQueueCheckpointData2NV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointData2NV);
21419pub type NonNullPFN_vkGetQueueCheckpointDataNV = unsafe extern "system" fn(queue: VkQueue, pCheckpointDataCount: *mut u32, pCheckpointData: *mut VkCheckpointDataNV);
21420pub type NonNullPFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
21421pub type NonNullPFN_vkGetRayTracingShaderGroupHandlesKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
21422pub type NonNullPFN_vkGetRayTracingShaderGroupHandlesNV = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, firstGroup: u32, groupCount: u32, dataSize: usize, pData: *mut c_void) -> VkResult;
21423pub type NonNullPFN_vkGetRayTracingShaderGroupStackSizeKHR = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, group: u32, groupShader: VkShaderGroupShaderKHR) -> VkDeviceSize;
21424pub type NonNullPFN_vkGetRefreshCycleDurationGOOGLE = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pDisplayTimingProperties: *mut VkRefreshCycleDurationGOOGLE) -> VkResult;
21425pub type NonNullPFN_vkGetRenderAreaGranularity = unsafe extern "system" fn(device: VkDevice, renderPass: VkRenderPass, pGranularity: *mut VkExtent2D);
21426pub type NonNullPFN_vkGetRenderingAreaGranularity = unsafe extern "system" fn(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
21427pub type NonNullPFN_vkGetRenderingAreaGranularityKHR = unsafe extern "system" fn(device: VkDevice, pRenderingAreaInfo: *const VkRenderingAreaInfo, pGranularity: *mut VkExtent2D);
21428pub type NonNullPFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkSamplerCaptureDescriptorDataInfoEXT, pData: *mut c_void) -> VkResult;
21429pub type NonNullPFN_vkGetSemaphoreCounterValue = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
21430pub type NonNullPFN_vkGetSemaphoreCounterValueKHR = unsafe extern "system" fn(device: VkDevice, semaphore: VkSemaphore, pValue: *mut u64) -> VkResult;
21431pub type NonNullPFN_vkGetSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pGetFdInfo: *const VkSemaphoreGetFdInfoKHR, pFd: *mut c_int) -> VkResult;
21432pub type NonNullPFN_vkGetShaderBinaryDataEXT = unsafe extern "system" fn(device: VkDevice, shader: VkShaderEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21433pub type NonNullPFN_vkGetShaderInfoAMD = unsafe extern "system" fn(device: VkDevice, pipeline: VkPipeline, shaderStage: VkShaderStageFlagBits, infoType: VkShaderInfoTypeAMD, pInfoSize: *mut usize, pInfo: *mut c_void) -> VkResult;
21434pub type NonNullPFN_vkGetShaderModuleCreateInfoIdentifierEXT = unsafe extern "system" fn(device: VkDevice, pCreateInfo: *const VkShaderModuleCreateInfo, pIdentifier: *mut VkShaderModuleIdentifierEXT);
21435pub type NonNullPFN_vkGetShaderModuleIdentifierEXT = unsafe extern "system" fn(device: VkDevice, shaderModule: VkShaderModule, pIdentifier: *mut VkShaderModuleIdentifierEXT);
21436pub type NonNullPFN_vkGetSwapchainCounterEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, counter: VkSurfaceCounterFlagBitsEXT, pCounterValue: *mut u64) -> VkResult;
21437pub type NonNullPFN_vkGetSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainImageCount: *mut u32, pSwapchainImages: *mut VkImage) -> VkResult;
21438pub type NonNullPFN_vkGetSwapchainStatusKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR) -> VkResult;
21439pub type NonNullPFN_vkGetSwapchainTimeDomainPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimeDomainProperties: *mut VkSwapchainTimeDomainPropertiesEXT, pTimeDomainsCounter: *mut u64) -> VkResult;
21440pub type NonNullPFN_vkGetSwapchainTimingPropertiesEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSwapchainTimingProperties: *mut VkSwapchainTimingPropertiesEXT, pSwapchainTimingPropertiesCounter: *mut u64) -> VkResult;
21441pub type NonNullPFN_vkGetTensorMemoryRequirementsARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorMemoryRequirementsInfoARM, pMemoryRequirements: *mut VkMemoryRequirements2);
21442pub type NonNullPFN_vkGetTensorOpaqueCaptureDataARM = unsafe extern "system" fn(device: VkDevice, tensorCount: u32, pTensors: *const VkTensorARM, pDatas: *mut VkHostAddressRangeEXT) -> VkResult;
21443pub type NonNullPFN_vkGetTensorOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
21444pub type NonNullPFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkTensorViewCaptureDescriptorDataInfoARM, pData: *mut c_void) -> VkResult;
21445pub type NonNullPFN_vkGetValidationCacheDataEXT = unsafe extern "system" fn(device: VkDevice, validationCache: VkValidationCacheEXT, pDataSize: *mut usize, pData: *mut c_void) -> VkResult;
21446pub type NonNullPFN_vkGetVideoSessionMemoryRequirementsKHR = unsafe extern "system" fn(device: VkDevice, videoSession: VkVideoSessionKHR, pMemoryRequirementsCount: *mut u32, pMemoryRequirements: *mut VkVideoSessionMemoryRequirementsKHR) -> VkResult;
21447pub type NonNullPFN_vkImportFenceFdKHR = unsafe extern "system" fn(device: VkDevice, pImportFenceFdInfo: *const VkImportFenceFdInfoKHR) -> VkResult;
21448pub type NonNullPFN_vkImportSemaphoreFdKHR = unsafe extern "system" fn(device: VkDevice, pImportSemaphoreFdInfo: *const VkImportSemaphoreFdInfoKHR) -> VkResult;
21449pub type NonNullPFN_vkInitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice, pInitializeInfo: *const VkInitializePerformanceApiInfoINTEL) -> VkResult;
21450pub type NonNullPFN_vkInternalAllocationNotification = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
21451pub type NonNullPFN_vkInternalFreeNotification = unsafe extern "system" fn(pUserData: *mut c_void, size: usize, allocationType: VkInternalAllocationType, allocationScope: VkSystemAllocationScope);
21452pub type NonNullPFN_vkInvalidateMappedMemoryRanges = unsafe extern "system" fn(device: VkDevice, memoryRangeCount: u32, pMemoryRanges: *const VkMappedMemoryRange) -> VkResult;
21453pub type NonNullPFN_vkLatencySleepNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepInfo: *const VkLatencySleepInfoNV) -> VkResult;
21454pub type NonNullPFN_vkMapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, offset: VkDeviceSize, size: VkDeviceSize, flags: VkMemoryMapFlags, ppData: *mut *mut c_void) -> VkResult;
21455pub type NonNullPFN_vkMapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
21456pub type NonNullPFN_vkMapMemory2KHR = unsafe extern "system" fn(device: VkDevice, pMemoryMapInfo: *const VkMemoryMapInfo, ppData: *mut *mut c_void) -> VkResult;
21457pub type NonNullPFN_vkMergePipelineCaches = unsafe extern "system" fn(device: VkDevice, dstCache: VkPipelineCache, srcCacheCount: u32, pSrcCaches: *const VkPipelineCache) -> VkResult;
21458pub type NonNullPFN_vkMergeValidationCachesEXT = unsafe extern "system" fn(device: VkDevice, dstCache: VkValidationCacheEXT, srcCacheCount: u32, pSrcCaches: *const VkValidationCacheEXT) -> VkResult;
21459pub type NonNullPFN_vkQueueBeginDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
21460pub type NonNullPFN_vkQueueBindSparse = unsafe extern "system" fn(queue: VkQueue, bindInfoCount: u32, pBindInfo: *const VkBindSparseInfo, fence: VkFence) -> VkResult;
21461pub type NonNullPFN_vkQueueEndDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue);
21462pub type NonNullPFN_vkQueueInsertDebugUtilsLabelEXT = unsafe extern "system" fn(queue: VkQueue, pLabelInfo: *const VkDebugUtilsLabelEXT);
21463pub type NonNullPFN_vkQueueNotifyOutOfBandNV = unsafe extern "system" fn(queue: VkQueue, pQueueTypeInfo: *const VkOutOfBandQueueTypeInfoNV);
21464pub type NonNullPFN_vkQueuePresentKHR = unsafe extern "system" fn(queue: VkQueue, pPresentInfo: *const VkPresentInfoKHR) -> VkResult;
21465pub type NonNullPFN_vkQueueSetPerformanceConfigurationINTEL = unsafe extern "system" fn(queue: VkQueue, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
21466pub type NonNullPFN_vkQueueSubmit = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo, fence: VkFence) -> VkResult;
21467pub type NonNullPFN_vkQueueSubmit2 = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
21468pub type NonNullPFN_vkQueueSubmit2KHR = unsafe extern "system" fn(queue: VkQueue, submitCount: u32, pSubmits: *const VkSubmitInfo2, fence: VkFence) -> VkResult;
21469pub type NonNullPFN_vkQueueWaitIdle = unsafe extern "system" fn(queue: VkQueue) -> VkResult;
21470pub type NonNullPFN_vkReallocationFunction = unsafe extern "system" fn(pUserData: *mut c_void, pOriginal: *mut c_void, size: usize, alignment: usize, allocationScope: VkSystemAllocationScope) -> *mut c_void;
21471pub type NonNullPFN_vkRegisterCustomBorderColorEXT = unsafe extern "system" fn(device: VkDevice, pBorderColor: *const VkSamplerCustomBorderColorCreateInfoEXT, requestIndex: VkBool32, pIndex: *mut u32) -> VkResult;
21472pub type NonNullPFN_vkRegisterDeviceEventEXT = unsafe extern "system" fn(device: VkDevice, pDeviceEventInfo: *const VkDeviceEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
21473pub type NonNullPFN_vkRegisterDisplayEventEXT = unsafe extern "system" fn(device: VkDevice, display: VkDisplayKHR, pDisplayEventInfo: *const VkDisplayEventInfoEXT, pAllocator: *const VkAllocationCallbacks, pFence: *mut VkFence) -> VkResult;
21474pub type NonNullPFN_vkReleaseCapturedPipelineDataKHR = unsafe extern "system" fn(device: VkDevice, pInfo: *const VkReleaseCapturedPipelineDataInfoKHR, pAllocator: *const VkAllocationCallbacks) -> VkResult;
21475pub type NonNullPFN_vkReleaseDisplayEXT = unsafe extern "system" fn(physicalDevice: VkPhysicalDevice, display: VkDisplayKHR) -> VkResult;
21476pub type NonNullPFN_vkReleasePerformanceConfigurationINTEL = unsafe extern "system" fn(device: VkDevice, configuration: VkPerformanceConfigurationINTEL) -> VkResult;
21477pub type NonNullPFN_vkReleaseProfilingLockKHR = unsafe extern "system" fn(device: VkDevice);
21478pub type NonNullPFN_vkReleaseSwapchainImagesEXT = unsafe extern "system" fn(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
21479pub type NonNullPFN_vkReleaseSwapchainImagesKHR = unsafe extern "system" fn(device: VkDevice, pReleaseInfo: *const VkReleaseSwapchainImagesInfoKHR) -> VkResult;
21480pub type NonNullPFN_vkResetCommandBuffer = unsafe extern "system" fn(commandBuffer: VkCommandBuffer, flags: VkCommandBufferResetFlags) -> VkResult;
21481pub type NonNullPFN_vkResetCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolResetFlags) -> VkResult;
21482pub type NonNullPFN_vkResetDescriptorPool = unsafe extern "system" fn(device: VkDevice, descriptorPool: VkDescriptorPool, flags: VkDescriptorPoolResetFlags) -> VkResult;
21483pub type NonNullPFN_vkResetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
21484pub type NonNullPFN_vkResetFences = unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence) -> VkResult;
21485pub type NonNullPFN_vkResetQueryPool = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
21486pub type NonNullPFN_vkResetQueryPoolEXT = unsafe extern "system" fn(device: VkDevice, queryPool: VkQueryPool, firstQuery: u32, queryCount: u32);
21487pub type NonNullPFN_vkSetDebugUtilsObjectNameEXT = unsafe extern "system" fn(device: VkDevice, pNameInfo: *const VkDebugUtilsObjectNameInfoEXT) -> VkResult;
21488pub type NonNullPFN_vkSetDebugUtilsObjectTagEXT = unsafe extern "system" fn(device: VkDevice, pTagInfo: *const VkDebugUtilsObjectTagInfoEXT) -> VkResult;
21489pub type NonNullPFN_vkSetDeviceMemoryPriorityEXT = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory, priority: f32);
21490pub type NonNullPFN_vkSetEvent = unsafe extern "system" fn(device: VkDevice, event: VkEvent) -> VkResult;
21491pub type NonNullPFN_vkSetHdrMetadataEXT = unsafe extern "system" fn(device: VkDevice, swapchainCount: u32, pSwapchains: *const VkSwapchainKHR, pMetadata: *const VkHdrMetadataEXT);
21492pub type NonNullPFN_vkSetLatencyMarkerNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pLatencyMarkerInfo: *const VkSetLatencyMarkerInfoNV);
21493pub type NonNullPFN_vkSetLatencySleepModeNV = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pSleepModeInfo: *const VkLatencySleepModeInfoNV) -> VkResult;
21494pub type NonNullPFN_vkSetLocalDimmingAMD = unsafe extern "system" fn(device: VkDevice, swapChain: VkSwapchainKHR, localDimmingEnable: VkBool32);
21495pub type NonNullPFN_vkSetPrivateData = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
21496pub type NonNullPFN_vkSetPrivateDataEXT = unsafe extern "system" fn(device: VkDevice, objectType: VkObjectType, objectHandle: u64, privateDataSlot: VkPrivateDataSlot, data: u64) -> VkResult;
21497pub type NonNullPFN_vkSetSwapchainPresentTimingQueueSizeEXT = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, size: u32) -> VkResult;
21498pub type NonNullPFN_vkSignalSemaphore = unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
21499pub type NonNullPFN_vkSignalSemaphoreKHR = unsafe extern "system" fn(device: VkDevice, pSignalInfo: *const VkSemaphoreSignalInfo) -> VkResult;
21500pub type NonNullPFN_vkSubmitDebugUtilsMessageEXT = unsafe extern "system" fn(instance: VkInstance, messageSeverity: VkDebugUtilsMessageSeverityFlagBitsEXT, messageTypes: VkDebugUtilsMessageTypeFlagsEXT, pCallbackData: *const VkDebugUtilsMessengerCallbackDataEXT);
21501pub type NonNullPFN_vkTransitionImageLayout = unsafe extern "system" fn(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
21502pub type NonNullPFN_vkTransitionImageLayoutEXT = unsafe extern "system" fn(device: VkDevice, transitionCount: u32, pTransitions: *const VkHostImageLayoutTransitionInfo) -> VkResult;
21503pub type NonNullPFN_vkTrimCommandPool = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
21504pub type NonNullPFN_vkTrimCommandPoolKHR = unsafe extern "system" fn(device: VkDevice, commandPool: VkCommandPool, flags: VkCommandPoolTrimFlags);
21505pub type NonNullPFN_vkUninitializePerformanceApiINTEL = unsafe extern "system" fn(device: VkDevice);
21506pub type NonNullPFN_vkUnmapMemory = unsafe extern "system" fn(device: VkDevice, memory: VkDeviceMemory);
21507pub type NonNullPFN_vkUnmapMemory2 = unsafe extern "system" fn(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
21508pub type NonNullPFN_vkUnmapMemory2KHR = unsafe extern "system" fn(device: VkDevice, pMemoryUnmapInfo: *const VkMemoryUnmapInfo) -> VkResult;
21509pub type NonNullPFN_vkUnregisterCustomBorderColorEXT = unsafe extern "system" fn(device: VkDevice, index: u32);
21510pub type NonNullPFN_vkUpdateDescriptorSetWithTemplate = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
21511pub type NonNullPFN_vkUpdateDescriptorSetWithTemplateKHR = unsafe extern "system" fn(device: VkDevice, descriptorSet: VkDescriptorSet, descriptorUpdateTemplate: VkDescriptorUpdateTemplate, pData: *const c_void);
21512pub type NonNullPFN_vkUpdateDescriptorSets = unsafe extern "system" fn(device: VkDevice, descriptorWriteCount: u32, pDescriptorWrites: *const VkWriteDescriptorSet, descriptorCopyCount: u32, pDescriptorCopies: *const VkCopyDescriptorSet);
21513pub type NonNullPFN_vkUpdateIndirectExecutionSetPipelineEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetPipelineEXT);
21514pub type NonNullPFN_vkUpdateIndirectExecutionSetShaderEXT = unsafe extern "system" fn(device: VkDevice, indirectExecutionSet: VkIndirectExecutionSetEXT, executionSetWriteCount: u32, pExecutionSetWrites: *const VkWriteIndirectExecutionSetShaderEXT);
21515pub type NonNullPFN_vkUpdateVideoSessionParametersKHR = unsafe extern "system" fn(device: VkDevice, videoSessionParameters: VkVideoSessionParametersKHR, pUpdateInfo: *const VkVideoSessionParametersUpdateInfoKHR) -> VkResult;
21516pub type NonNullPFN_vkVoidFunction = unsafe extern "system" fn();
21517pub type NonNullPFN_vkWaitForFences = unsafe extern "system" fn(device: VkDevice, fenceCount: u32, pFences: *const VkFence, waitAll: VkBool32, timeout: u64) -> VkResult;
21518pub type NonNullPFN_vkWaitForPresent2KHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, pPresentWait2Info: *const VkPresentWait2InfoKHR) -> VkResult;
21519pub type NonNullPFN_vkWaitForPresentKHR = unsafe extern "system" fn(device: VkDevice, swapchain: VkSwapchainKHR, presentId: u64, timeout: u64) -> VkResult;
21520pub type NonNullPFN_vkWaitSemaphores = unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
21521pub type NonNullPFN_vkWaitSemaphoresKHR = unsafe extern "system" fn(device: VkDevice, pWaitInfo: *const VkSemaphoreWaitInfo, timeout: u64) -> VkResult;
21522pub 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;
21523pub 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;
21524pub type NonNullPFN_vkWriteResourceDescriptorsEXT = unsafe extern "system" fn(device: VkDevice, resourceCount: u32, pResources: *const VkResourceDescriptorInfoEXT, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
21525pub type NonNullPFN_vkWriteSamplerDescriptorsEXT = unsafe extern "system" fn(device: VkDevice, samplerCount: u32, pSamplers: *const VkSamplerCreateInfo, pDescriptors: *const VkHostAddressRangeEXT) -> VkResult;
21526pub type NonNullVkAccelerationStructureKHR = NonNull<VkAccelerationStructureKHR_T>;
21527pub type NonNullVkAccelerationStructureNV = NonNull<VkAccelerationStructureNV_T>;
21528pub type NonNullVkBuffer = NonNull<VkBuffer_T>;
21529pub type NonNullVkBufferView = NonNull<VkBufferView_T>;
21530pub type NonNullVkCommandBuffer = NonNull<VkCommandBuffer_T>;
21531pub type NonNullVkCommandPool = NonNull<VkCommandPool_T>;
21532pub type NonNullVkCuFunctionNVX = NonNull<VkCuFunctionNVX_T>;
21533pub type NonNullVkCuModuleNVX = NonNull<VkCuModuleNVX_T>;
21534pub type NonNullVkDataGraphPipelineSessionARM = NonNull<VkDataGraphPipelineSessionARM_T>;
21535pub type NonNullVkDebugReportCallbackEXT = NonNull<VkDebugReportCallbackEXT_T>;
21536pub type NonNullVkDebugUtilsMessengerEXT = NonNull<VkDebugUtilsMessengerEXT_T>;
21537pub type NonNullVkDeferredOperationKHR = NonNull<VkDeferredOperationKHR_T>;
21538pub type NonNullVkDescriptorPool = NonNull<VkDescriptorPool_T>;
21539pub type NonNullVkDescriptorSet = NonNull<VkDescriptorSet_T>;
21540pub type NonNullVkDescriptorSetLayout = NonNull<VkDescriptorSetLayout_T>;
21541pub type NonNullVkDescriptorUpdateTemplate = NonNull<VkDescriptorUpdateTemplate_T>;
21542pub type NonNullVkDescriptorUpdateTemplateKHR = NonNull<VkDescriptorUpdateTemplateKHR_T>;
21543pub type NonNullVkDevice = NonNull<VkDevice_T>;
21544pub type NonNullVkDeviceMemory = NonNull<VkDeviceMemory_T>;
21545pub type NonNullVkDisplayKHR = NonNull<VkDisplayKHR_T>;
21546pub type NonNullVkDisplayModeKHR = NonNull<VkDisplayModeKHR_T>;
21547pub type NonNullVkEvent = NonNull<VkEvent_T>;
21548pub type NonNullVkExternalComputeQueueNV = NonNull<VkExternalComputeQueueNV_T>;
21549pub type NonNullVkFence = NonNull<VkFence_T>;
21550pub type NonNullVkFramebuffer = NonNull<VkFramebuffer_T>;
21551pub type NonNullVkImage = NonNull<VkImage_T>;
21552pub type NonNullVkImageView = NonNull<VkImageView_T>;
21553pub type NonNullVkIndirectCommandsLayoutEXT = NonNull<VkIndirectCommandsLayoutEXT_T>;
21554pub type NonNullVkIndirectCommandsLayoutNV = NonNull<VkIndirectCommandsLayoutNV_T>;
21555pub type NonNullVkIndirectExecutionSetEXT = NonNull<VkIndirectExecutionSetEXT_T>;
21556pub type NonNullVkInstance = NonNull<VkInstance_T>;
21557pub type NonNullVkMicromapEXT = NonNull<VkMicromapEXT_T>;
21558pub type NonNullVkOpticalFlowSessionNV = NonNull<VkOpticalFlowSessionNV_T>;
21559pub type NonNullVkPerformanceConfigurationINTEL = NonNull<VkPerformanceConfigurationINTEL_T>;
21560pub type NonNullVkPhysicalDevice = NonNull<VkPhysicalDevice_T>;
21561pub type NonNullVkPipeline = NonNull<VkPipeline_T>;
21562pub type NonNullVkPipelineBinaryKHR = NonNull<VkPipelineBinaryKHR_T>;
21563pub type NonNullVkPipelineCache = NonNull<VkPipelineCache_T>;
21564pub type NonNullVkPipelineLayout = NonNull<VkPipelineLayout_T>;
21565pub type NonNullVkPrivateDataSlot = NonNull<VkPrivateDataSlot_T>;
21566pub type NonNullVkPrivateDataSlotEXT = NonNull<VkPrivateDataSlotEXT_T>;
21567pub type NonNullVkQueryPool = NonNull<VkQueryPool_T>;
21568pub type NonNullVkQueue = NonNull<VkQueue_T>;
21569pub type NonNullVkRenderPass = NonNull<VkRenderPass_T>;
21570pub type NonNullVkSampler = NonNull<VkSampler_T>;
21571pub type NonNullVkSamplerYcbcrConversion = NonNull<VkSamplerYcbcrConversion_T>;
21572pub type NonNullVkSamplerYcbcrConversionKHR = NonNull<VkSamplerYcbcrConversionKHR_T>;
21573pub type NonNullVkSemaphore = NonNull<VkSemaphore_T>;
21574pub type NonNullVkShaderEXT = NonNull<VkShaderEXT_T>;
21575pub type NonNullVkShaderModule = NonNull<VkShaderModule_T>;
21576pub type NonNullVkSurfaceKHR = NonNull<VkSurfaceKHR_T>;
21577pub type NonNullVkSwapchainKHR = NonNull<VkSwapchainKHR_T>;
21578pub type NonNullVkTensorARM = NonNull<VkTensorARM_T>;
21579pub type NonNullVkTensorViewARM = NonNull<VkTensorViewARM_T>;
21580pub type NonNullVkValidationCacheEXT = NonNull<VkValidationCacheEXT_T>;
21581pub type NonNullVkVideoSessionKHR = NonNull<VkVideoSessionKHR_T>;
21582pub type NonNullVkVideoSessionParametersKHR = NonNull<VkVideoSessionParametersKHR_T>;
21583pub type PFN_vkAcquireDrmDisplayEXT = Option<NonNullPFN_vkAcquireDrmDisplayEXT>;
21584pub type PFN_vkAcquireNextImage2KHR = Option<NonNullPFN_vkAcquireNextImage2KHR>;
21585pub type PFN_vkAcquireNextImageKHR = Option<NonNullPFN_vkAcquireNextImageKHR>;
21586pub type PFN_vkAcquirePerformanceConfigurationINTEL = Option<NonNullPFN_vkAcquirePerformanceConfigurationINTEL>;
21587pub type PFN_vkAcquireProfilingLockKHR = Option<NonNullPFN_vkAcquireProfilingLockKHR>;
21588pub type PFN_vkAllocateCommandBuffers = Option<NonNullPFN_vkAllocateCommandBuffers>;
21589pub type PFN_vkAllocateDescriptorSets = Option<NonNullPFN_vkAllocateDescriptorSets>;
21590pub type PFN_vkAllocateMemory = Option<NonNullPFN_vkAllocateMemory>;
21591pub type PFN_vkAllocationFunction = Option<NonNullPFN_vkAllocationFunction>;
21592pub type PFN_vkAntiLagUpdateAMD = Option<NonNullPFN_vkAntiLagUpdateAMD>;
21593pub type PFN_vkBeginCommandBuffer = Option<NonNullPFN_vkBeginCommandBuffer>;
21594pub type PFN_vkBindAccelerationStructureMemoryNV = Option<NonNullPFN_vkBindAccelerationStructureMemoryNV>;
21595pub type PFN_vkBindBufferMemory = Option<NonNullPFN_vkBindBufferMemory>;
21596pub type PFN_vkBindBufferMemory2 = Option<NonNullPFN_vkBindBufferMemory2>;
21597pub type PFN_vkBindBufferMemory2KHR = Option<NonNullPFN_vkBindBufferMemory2KHR>;
21598pub type PFN_vkBindDataGraphPipelineSessionMemoryARM = Option<NonNullPFN_vkBindDataGraphPipelineSessionMemoryARM>;
21599pub type PFN_vkBindImageMemory = Option<NonNullPFN_vkBindImageMemory>;
21600pub type PFN_vkBindImageMemory2 = Option<NonNullPFN_vkBindImageMemory2>;
21601pub type PFN_vkBindImageMemory2KHR = Option<NonNullPFN_vkBindImageMemory2KHR>;
21602pub type PFN_vkBindOpticalFlowSessionImageNV = Option<NonNullPFN_vkBindOpticalFlowSessionImageNV>;
21603pub type PFN_vkBindTensorMemoryARM = Option<NonNullPFN_vkBindTensorMemoryARM>;
21604pub type PFN_vkBindVideoSessionMemoryKHR = Option<NonNullPFN_vkBindVideoSessionMemoryKHR>;
21605pub type PFN_vkBuildAccelerationStructuresKHR = Option<NonNullPFN_vkBuildAccelerationStructuresKHR>;
21606pub type PFN_vkBuildMicromapsEXT = Option<NonNullPFN_vkBuildMicromapsEXT>;
21607pub type PFN_vkCmdBeginConditionalRenderingEXT = Option<NonNullPFN_vkCmdBeginConditionalRenderingEXT>;
21608pub type PFN_vkCmdBeginCustomResolveEXT = Option<NonNullPFN_vkCmdBeginCustomResolveEXT>;
21609pub type PFN_vkCmdBeginDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdBeginDebugUtilsLabelEXT>;
21610pub type PFN_vkCmdBeginPerTileExecutionQCOM = Option<NonNullPFN_vkCmdBeginPerTileExecutionQCOM>;
21611pub type PFN_vkCmdBeginQuery = Option<NonNullPFN_vkCmdBeginQuery>;
21612pub type PFN_vkCmdBeginQueryIndexedEXT = Option<NonNullPFN_vkCmdBeginQueryIndexedEXT>;
21613pub type PFN_vkCmdBeginRenderPass = Option<NonNullPFN_vkCmdBeginRenderPass>;
21614pub type PFN_vkCmdBeginRenderPass2 = Option<NonNullPFN_vkCmdBeginRenderPass2>;
21615pub type PFN_vkCmdBeginRenderPass2KHR = Option<NonNullPFN_vkCmdBeginRenderPass2KHR>;
21616pub type PFN_vkCmdBeginRendering = Option<NonNullPFN_vkCmdBeginRendering>;
21617pub type PFN_vkCmdBeginRenderingKHR = Option<NonNullPFN_vkCmdBeginRenderingKHR>;
21618pub type PFN_vkCmdBeginTransformFeedbackEXT = Option<NonNullPFN_vkCmdBeginTransformFeedbackEXT>;
21619pub type PFN_vkCmdBeginVideoCodingKHR = Option<NonNullPFN_vkCmdBeginVideoCodingKHR>;
21620pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = Option<NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT>;
21621pub type PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = Option<NonNullPFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT>;
21622pub type PFN_vkCmdBindDescriptorBuffersEXT = Option<NonNullPFN_vkCmdBindDescriptorBuffersEXT>;
21623pub type PFN_vkCmdBindDescriptorSets = Option<NonNullPFN_vkCmdBindDescriptorSets>;
21624pub type PFN_vkCmdBindDescriptorSets2 = Option<NonNullPFN_vkCmdBindDescriptorSets2>;
21625pub type PFN_vkCmdBindDescriptorSets2KHR = Option<NonNullPFN_vkCmdBindDescriptorSets2KHR>;
21626pub type PFN_vkCmdBindIndexBuffer = Option<NonNullPFN_vkCmdBindIndexBuffer>;
21627pub type PFN_vkCmdBindIndexBuffer2 = Option<NonNullPFN_vkCmdBindIndexBuffer2>;
21628pub type PFN_vkCmdBindIndexBuffer2KHR = Option<NonNullPFN_vkCmdBindIndexBuffer2KHR>;
21629pub type PFN_vkCmdBindInvocationMaskHUAWEI = Option<NonNullPFN_vkCmdBindInvocationMaskHUAWEI>;
21630pub type PFN_vkCmdBindPipeline = Option<NonNullPFN_vkCmdBindPipeline>;
21631pub type PFN_vkCmdBindPipelineShaderGroupNV = Option<NonNullPFN_vkCmdBindPipelineShaderGroupNV>;
21632pub type PFN_vkCmdBindResourceHeapEXT = Option<NonNullPFN_vkCmdBindResourceHeapEXT>;
21633pub type PFN_vkCmdBindSamplerHeapEXT = Option<NonNullPFN_vkCmdBindSamplerHeapEXT>;
21634pub type PFN_vkCmdBindShadersEXT = Option<NonNullPFN_vkCmdBindShadersEXT>;
21635pub type PFN_vkCmdBindShadingRateImageNV = Option<NonNullPFN_vkCmdBindShadingRateImageNV>;
21636pub type PFN_vkCmdBindTileMemoryQCOM = Option<NonNullPFN_vkCmdBindTileMemoryQCOM>;
21637pub type PFN_vkCmdBindTransformFeedbackBuffersEXT = Option<NonNullPFN_vkCmdBindTransformFeedbackBuffersEXT>;
21638pub type PFN_vkCmdBindVertexBuffers = Option<NonNullPFN_vkCmdBindVertexBuffers>;
21639pub type PFN_vkCmdBindVertexBuffers2 = Option<NonNullPFN_vkCmdBindVertexBuffers2>;
21640pub type PFN_vkCmdBindVertexBuffers2EXT = Option<NonNullPFN_vkCmdBindVertexBuffers2EXT>;
21641pub type PFN_vkCmdBlitImage = Option<NonNullPFN_vkCmdBlitImage>;
21642pub type PFN_vkCmdBlitImage2 = Option<NonNullPFN_vkCmdBlitImage2>;
21643pub type PFN_vkCmdBlitImage2KHR = Option<NonNullPFN_vkCmdBlitImage2KHR>;
21644pub type PFN_vkCmdBuildAccelerationStructureNV = Option<NonNullPFN_vkCmdBuildAccelerationStructureNV>;
21645pub type PFN_vkCmdBuildAccelerationStructuresIndirectKHR = Option<NonNullPFN_vkCmdBuildAccelerationStructuresIndirectKHR>;
21646pub type PFN_vkCmdBuildAccelerationStructuresKHR = Option<NonNullPFN_vkCmdBuildAccelerationStructuresKHR>;
21647pub type PFN_vkCmdBuildClusterAccelerationStructureIndirectNV = Option<NonNullPFN_vkCmdBuildClusterAccelerationStructureIndirectNV>;
21648pub type PFN_vkCmdBuildMicromapsEXT = Option<NonNullPFN_vkCmdBuildMicromapsEXT>;
21649pub type PFN_vkCmdBuildPartitionedAccelerationStructuresNV = Option<NonNullPFN_vkCmdBuildPartitionedAccelerationStructuresNV>;
21650pub type PFN_vkCmdClearAttachments = Option<NonNullPFN_vkCmdClearAttachments>;
21651pub type PFN_vkCmdClearColorImage = Option<NonNullPFN_vkCmdClearColorImage>;
21652pub type PFN_vkCmdClearDepthStencilImage = Option<NonNullPFN_vkCmdClearDepthStencilImage>;
21653pub type PFN_vkCmdControlVideoCodingKHR = Option<NonNullPFN_vkCmdControlVideoCodingKHR>;
21654pub type PFN_vkCmdConvertCooperativeVectorMatrixNV = Option<NonNullPFN_vkCmdConvertCooperativeVectorMatrixNV>;
21655pub type PFN_vkCmdCopyAccelerationStructureKHR = Option<NonNullPFN_vkCmdCopyAccelerationStructureKHR>;
21656pub type PFN_vkCmdCopyAccelerationStructureNV = Option<NonNullPFN_vkCmdCopyAccelerationStructureNV>;
21657pub type PFN_vkCmdCopyAccelerationStructureToMemoryKHR = Option<NonNullPFN_vkCmdCopyAccelerationStructureToMemoryKHR>;
21658pub type PFN_vkCmdCopyBuffer = Option<NonNullPFN_vkCmdCopyBuffer>;
21659pub type PFN_vkCmdCopyBuffer2 = Option<NonNullPFN_vkCmdCopyBuffer2>;
21660pub type PFN_vkCmdCopyBuffer2KHR = Option<NonNullPFN_vkCmdCopyBuffer2KHR>;
21661pub type PFN_vkCmdCopyBufferToImage = Option<NonNullPFN_vkCmdCopyBufferToImage>;
21662pub type PFN_vkCmdCopyBufferToImage2 = Option<NonNullPFN_vkCmdCopyBufferToImage2>;
21663pub type PFN_vkCmdCopyBufferToImage2KHR = Option<NonNullPFN_vkCmdCopyBufferToImage2KHR>;
21664pub type PFN_vkCmdCopyImage = Option<NonNullPFN_vkCmdCopyImage>;
21665pub type PFN_vkCmdCopyImage2 = Option<NonNullPFN_vkCmdCopyImage2>;
21666pub type PFN_vkCmdCopyImage2KHR = Option<NonNullPFN_vkCmdCopyImage2KHR>;
21667pub type PFN_vkCmdCopyImageToBuffer = Option<NonNullPFN_vkCmdCopyImageToBuffer>;
21668pub type PFN_vkCmdCopyImageToBuffer2 = Option<NonNullPFN_vkCmdCopyImageToBuffer2>;
21669pub type PFN_vkCmdCopyImageToBuffer2KHR = Option<NonNullPFN_vkCmdCopyImageToBuffer2KHR>;
21670pub type PFN_vkCmdCopyMemoryIndirectKHR = Option<NonNullPFN_vkCmdCopyMemoryIndirectKHR>;
21671pub type PFN_vkCmdCopyMemoryIndirectNV = Option<NonNullPFN_vkCmdCopyMemoryIndirectNV>;
21672pub type PFN_vkCmdCopyMemoryToAccelerationStructureKHR = Option<NonNullPFN_vkCmdCopyMemoryToAccelerationStructureKHR>;
21673pub type PFN_vkCmdCopyMemoryToImageIndirectKHR = Option<NonNullPFN_vkCmdCopyMemoryToImageIndirectKHR>;
21674pub type PFN_vkCmdCopyMemoryToImageIndirectNV = Option<NonNullPFN_vkCmdCopyMemoryToImageIndirectNV>;
21675pub type PFN_vkCmdCopyMemoryToMicromapEXT = Option<NonNullPFN_vkCmdCopyMemoryToMicromapEXT>;
21676pub type PFN_vkCmdCopyMicromapEXT = Option<NonNullPFN_vkCmdCopyMicromapEXT>;
21677pub type PFN_vkCmdCopyMicromapToMemoryEXT = Option<NonNullPFN_vkCmdCopyMicromapToMemoryEXT>;
21678pub type PFN_vkCmdCopyQueryPoolResults = Option<NonNullPFN_vkCmdCopyQueryPoolResults>;
21679pub type PFN_vkCmdCopyTensorARM = Option<NonNullPFN_vkCmdCopyTensorARM>;
21680pub type PFN_vkCmdCuLaunchKernelNVX = Option<NonNullPFN_vkCmdCuLaunchKernelNVX>;
21681pub type PFN_vkCmdDebugMarkerBeginEXT = Option<NonNullPFN_vkCmdDebugMarkerBeginEXT>;
21682pub type PFN_vkCmdDebugMarkerEndEXT = Option<NonNullPFN_vkCmdDebugMarkerEndEXT>;
21683pub type PFN_vkCmdDebugMarkerInsertEXT = Option<NonNullPFN_vkCmdDebugMarkerInsertEXT>;
21684pub type PFN_vkCmdDecodeVideoKHR = Option<NonNullPFN_vkCmdDecodeVideoKHR>;
21685pub type PFN_vkCmdDecompressMemoryEXT = Option<NonNullPFN_vkCmdDecompressMemoryEXT>;
21686pub type PFN_vkCmdDecompressMemoryIndirectCountEXT = Option<NonNullPFN_vkCmdDecompressMemoryIndirectCountEXT>;
21687pub type PFN_vkCmdDecompressMemoryIndirectCountNV = Option<NonNullPFN_vkCmdDecompressMemoryIndirectCountNV>;
21688pub type PFN_vkCmdDecompressMemoryNV = Option<NonNullPFN_vkCmdDecompressMemoryNV>;
21689pub type PFN_vkCmdDispatch = Option<NonNullPFN_vkCmdDispatch>;
21690pub type PFN_vkCmdDispatchBase = Option<NonNullPFN_vkCmdDispatchBase>;
21691pub type PFN_vkCmdDispatchBaseKHR = Option<NonNullPFN_vkCmdDispatchBaseKHR>;
21692pub type PFN_vkCmdDispatchDataGraphARM = Option<NonNullPFN_vkCmdDispatchDataGraphARM>;
21693pub type PFN_vkCmdDispatchIndirect = Option<NonNullPFN_vkCmdDispatchIndirect>;
21694pub type PFN_vkCmdDispatchTileQCOM = Option<NonNullPFN_vkCmdDispatchTileQCOM>;
21695pub type PFN_vkCmdDraw = Option<NonNullPFN_vkCmdDraw>;
21696pub type PFN_vkCmdDrawClusterHUAWEI = Option<NonNullPFN_vkCmdDrawClusterHUAWEI>;
21697pub type PFN_vkCmdDrawClusterIndirectHUAWEI = Option<NonNullPFN_vkCmdDrawClusterIndirectHUAWEI>;
21698pub type PFN_vkCmdDrawIndexed = Option<NonNullPFN_vkCmdDrawIndexed>;
21699pub type PFN_vkCmdDrawIndexedIndirect = Option<NonNullPFN_vkCmdDrawIndexedIndirect>;
21700pub type PFN_vkCmdDrawIndexedIndirectCount = Option<NonNullPFN_vkCmdDrawIndexedIndirectCount>;
21701pub type PFN_vkCmdDrawIndexedIndirectCountAMD = Option<NonNullPFN_vkCmdDrawIndexedIndirectCountAMD>;
21702pub type PFN_vkCmdDrawIndexedIndirectCountKHR = Option<NonNullPFN_vkCmdDrawIndexedIndirectCountKHR>;
21703pub type PFN_vkCmdDrawIndirect = Option<NonNullPFN_vkCmdDrawIndirect>;
21704pub type PFN_vkCmdDrawIndirectByteCountEXT = Option<NonNullPFN_vkCmdDrawIndirectByteCountEXT>;
21705pub type PFN_vkCmdDrawIndirectCount = Option<NonNullPFN_vkCmdDrawIndirectCount>;
21706pub type PFN_vkCmdDrawIndirectCountAMD = Option<NonNullPFN_vkCmdDrawIndirectCountAMD>;
21707pub type PFN_vkCmdDrawIndirectCountKHR = Option<NonNullPFN_vkCmdDrawIndirectCountKHR>;
21708pub type PFN_vkCmdDrawMeshTasksEXT = Option<NonNullPFN_vkCmdDrawMeshTasksEXT>;
21709pub type PFN_vkCmdDrawMeshTasksIndirectCountEXT = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectCountEXT>;
21710pub type PFN_vkCmdDrawMeshTasksIndirectCountNV = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectCountNV>;
21711pub type PFN_vkCmdDrawMeshTasksIndirectEXT = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectEXT>;
21712pub type PFN_vkCmdDrawMeshTasksIndirectNV = Option<NonNullPFN_vkCmdDrawMeshTasksIndirectNV>;
21713pub type PFN_vkCmdDrawMeshTasksNV = Option<NonNullPFN_vkCmdDrawMeshTasksNV>;
21714pub type PFN_vkCmdDrawMultiEXT = Option<NonNullPFN_vkCmdDrawMultiEXT>;
21715pub type PFN_vkCmdDrawMultiIndexedEXT = Option<NonNullPFN_vkCmdDrawMultiIndexedEXT>;
21716pub type PFN_vkCmdEncodeVideoKHR = Option<NonNullPFN_vkCmdEncodeVideoKHR>;
21717pub type PFN_vkCmdEndConditionalRenderingEXT = Option<NonNullPFN_vkCmdEndConditionalRenderingEXT>;
21718pub type PFN_vkCmdEndDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdEndDebugUtilsLabelEXT>;
21719pub type PFN_vkCmdEndPerTileExecutionQCOM = Option<NonNullPFN_vkCmdEndPerTileExecutionQCOM>;
21720pub type PFN_vkCmdEndQuery = Option<NonNullPFN_vkCmdEndQuery>;
21721pub type PFN_vkCmdEndQueryIndexedEXT = Option<NonNullPFN_vkCmdEndQueryIndexedEXT>;
21722pub type PFN_vkCmdEndRenderPass = Option<NonNullPFN_vkCmdEndRenderPass>;
21723pub type PFN_vkCmdEndRenderPass2 = Option<NonNullPFN_vkCmdEndRenderPass2>;
21724pub type PFN_vkCmdEndRenderPass2KHR = Option<NonNullPFN_vkCmdEndRenderPass2KHR>;
21725pub type PFN_vkCmdEndRendering = Option<NonNullPFN_vkCmdEndRendering>;
21726pub type PFN_vkCmdEndRendering2EXT = Option<NonNullPFN_vkCmdEndRendering2EXT>;
21727pub type PFN_vkCmdEndRendering2KHR = Option<NonNullPFN_vkCmdEndRendering2KHR>;
21728pub type PFN_vkCmdEndRenderingKHR = Option<NonNullPFN_vkCmdEndRenderingKHR>;
21729pub type PFN_vkCmdEndTransformFeedbackEXT = Option<NonNullPFN_vkCmdEndTransformFeedbackEXT>;
21730pub type PFN_vkCmdEndVideoCodingKHR = Option<NonNullPFN_vkCmdEndVideoCodingKHR>;
21731pub type PFN_vkCmdExecuteCommands = Option<NonNullPFN_vkCmdExecuteCommands>;
21732pub type PFN_vkCmdExecuteGeneratedCommandsEXT = Option<NonNullPFN_vkCmdExecuteGeneratedCommandsEXT>;
21733pub type PFN_vkCmdExecuteGeneratedCommandsNV = Option<NonNullPFN_vkCmdExecuteGeneratedCommandsNV>;
21734pub type PFN_vkCmdFillBuffer = Option<NonNullPFN_vkCmdFillBuffer>;
21735pub type PFN_vkCmdInsertDebugUtilsLabelEXT = Option<NonNullPFN_vkCmdInsertDebugUtilsLabelEXT>;
21736pub type PFN_vkCmdNextSubpass = Option<NonNullPFN_vkCmdNextSubpass>;
21737pub type PFN_vkCmdNextSubpass2 = Option<NonNullPFN_vkCmdNextSubpass2>;
21738pub type PFN_vkCmdNextSubpass2KHR = Option<NonNullPFN_vkCmdNextSubpass2KHR>;
21739pub type PFN_vkCmdOpticalFlowExecuteNV = Option<NonNullPFN_vkCmdOpticalFlowExecuteNV>;
21740pub type PFN_vkCmdPipelineBarrier = Option<NonNullPFN_vkCmdPipelineBarrier>;
21741pub type PFN_vkCmdPipelineBarrier2 = Option<NonNullPFN_vkCmdPipelineBarrier2>;
21742pub type PFN_vkCmdPipelineBarrier2KHR = Option<NonNullPFN_vkCmdPipelineBarrier2KHR>;
21743pub type PFN_vkCmdPreprocessGeneratedCommandsEXT = Option<NonNullPFN_vkCmdPreprocessGeneratedCommandsEXT>;
21744pub type PFN_vkCmdPreprocessGeneratedCommandsNV = Option<NonNullPFN_vkCmdPreprocessGeneratedCommandsNV>;
21745pub type PFN_vkCmdPushConstants = Option<NonNullPFN_vkCmdPushConstants>;
21746pub type PFN_vkCmdPushConstants2 = Option<NonNullPFN_vkCmdPushConstants2>;
21747pub type PFN_vkCmdPushConstants2KHR = Option<NonNullPFN_vkCmdPushConstants2KHR>;
21748pub type PFN_vkCmdPushDataEXT = Option<NonNullPFN_vkCmdPushDataEXT>;
21749pub type PFN_vkCmdPushDescriptorSet = Option<NonNullPFN_vkCmdPushDescriptorSet>;
21750pub type PFN_vkCmdPushDescriptorSet2 = Option<NonNullPFN_vkCmdPushDescriptorSet2>;
21751pub type PFN_vkCmdPushDescriptorSet2KHR = Option<NonNullPFN_vkCmdPushDescriptorSet2KHR>;
21752pub type PFN_vkCmdPushDescriptorSetKHR = Option<NonNullPFN_vkCmdPushDescriptorSetKHR>;
21753pub type PFN_vkCmdPushDescriptorSetWithTemplate = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate>;
21754pub type PFN_vkCmdPushDescriptorSetWithTemplate2 = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate2>;
21755pub type PFN_vkCmdPushDescriptorSetWithTemplate2KHR = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplate2KHR>;
21756pub type PFN_vkCmdPushDescriptorSetWithTemplateKHR = Option<NonNullPFN_vkCmdPushDescriptorSetWithTemplateKHR>;
21757pub type PFN_vkCmdResetEvent = Option<NonNullPFN_vkCmdResetEvent>;
21758pub type PFN_vkCmdResetEvent2 = Option<NonNullPFN_vkCmdResetEvent2>;
21759pub type PFN_vkCmdResetEvent2KHR = Option<NonNullPFN_vkCmdResetEvent2KHR>;
21760pub type PFN_vkCmdResetQueryPool = Option<NonNullPFN_vkCmdResetQueryPool>;
21761pub type PFN_vkCmdResolveImage = Option<NonNullPFN_vkCmdResolveImage>;
21762pub type PFN_vkCmdResolveImage2 = Option<NonNullPFN_vkCmdResolveImage2>;
21763pub type PFN_vkCmdResolveImage2KHR = Option<NonNullPFN_vkCmdResolveImage2KHR>;
21764pub type PFN_vkCmdSetAlphaToCoverageEnableEXT = Option<NonNullPFN_vkCmdSetAlphaToCoverageEnableEXT>;
21765pub type PFN_vkCmdSetAlphaToOneEnableEXT = Option<NonNullPFN_vkCmdSetAlphaToOneEnableEXT>;
21766pub type PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT = Option<NonNullPFN_vkCmdSetAttachmentFeedbackLoopEnableEXT>;
21767pub type PFN_vkCmdSetBlendConstants = Option<NonNullPFN_vkCmdSetBlendConstants>;
21768pub type PFN_vkCmdSetCheckpointNV = Option<NonNullPFN_vkCmdSetCheckpointNV>;
21769pub type PFN_vkCmdSetCoarseSampleOrderNV = Option<NonNullPFN_vkCmdSetCoarseSampleOrderNV>;
21770pub type PFN_vkCmdSetColorBlendAdvancedEXT = Option<NonNullPFN_vkCmdSetColorBlendAdvancedEXT>;
21771pub type PFN_vkCmdSetColorBlendEnableEXT = Option<NonNullPFN_vkCmdSetColorBlendEnableEXT>;
21772pub type PFN_vkCmdSetColorBlendEquationEXT = Option<NonNullPFN_vkCmdSetColorBlendEquationEXT>;
21773pub type PFN_vkCmdSetColorWriteEnableEXT = Option<NonNullPFN_vkCmdSetColorWriteEnableEXT>;
21774pub type PFN_vkCmdSetColorWriteMaskEXT = Option<NonNullPFN_vkCmdSetColorWriteMaskEXT>;
21775pub type PFN_vkCmdSetComputeOccupancyPriorityNV = Option<NonNullPFN_vkCmdSetComputeOccupancyPriorityNV>;
21776pub type PFN_vkCmdSetConservativeRasterizationModeEXT = Option<NonNullPFN_vkCmdSetConservativeRasterizationModeEXT>;
21777pub type PFN_vkCmdSetCoverageModulationModeNV = Option<NonNullPFN_vkCmdSetCoverageModulationModeNV>;
21778pub type PFN_vkCmdSetCoverageModulationTableEnableNV = Option<NonNullPFN_vkCmdSetCoverageModulationTableEnableNV>;
21779pub type PFN_vkCmdSetCoverageModulationTableNV = Option<NonNullPFN_vkCmdSetCoverageModulationTableNV>;
21780pub type PFN_vkCmdSetCoverageReductionModeNV = Option<NonNullPFN_vkCmdSetCoverageReductionModeNV>;
21781pub type PFN_vkCmdSetCoverageToColorEnableNV = Option<NonNullPFN_vkCmdSetCoverageToColorEnableNV>;
21782pub type PFN_vkCmdSetCoverageToColorLocationNV = Option<NonNullPFN_vkCmdSetCoverageToColorLocationNV>;
21783pub type PFN_vkCmdSetCullMode = Option<NonNullPFN_vkCmdSetCullMode>;
21784pub type PFN_vkCmdSetCullModeEXT = Option<NonNullPFN_vkCmdSetCullModeEXT>;
21785pub type PFN_vkCmdSetDepthBias = Option<NonNullPFN_vkCmdSetDepthBias>;
21786pub type PFN_vkCmdSetDepthBias2EXT = Option<NonNullPFN_vkCmdSetDepthBias2EXT>;
21787pub type PFN_vkCmdSetDepthBiasEnable = Option<NonNullPFN_vkCmdSetDepthBiasEnable>;
21788pub type PFN_vkCmdSetDepthBiasEnableEXT = Option<NonNullPFN_vkCmdSetDepthBiasEnableEXT>;
21789pub type PFN_vkCmdSetDepthBounds = Option<NonNullPFN_vkCmdSetDepthBounds>;
21790pub type PFN_vkCmdSetDepthBoundsTestEnable = Option<NonNullPFN_vkCmdSetDepthBoundsTestEnable>;
21791pub type PFN_vkCmdSetDepthBoundsTestEnableEXT = Option<NonNullPFN_vkCmdSetDepthBoundsTestEnableEXT>;
21792pub type PFN_vkCmdSetDepthClampEnableEXT = Option<NonNullPFN_vkCmdSetDepthClampEnableEXT>;
21793pub type PFN_vkCmdSetDepthClampRangeEXT = Option<NonNullPFN_vkCmdSetDepthClampRangeEXT>;
21794pub type PFN_vkCmdSetDepthClipEnableEXT = Option<NonNullPFN_vkCmdSetDepthClipEnableEXT>;
21795pub type PFN_vkCmdSetDepthClipNegativeOneToOneEXT = Option<NonNullPFN_vkCmdSetDepthClipNegativeOneToOneEXT>;
21796pub type PFN_vkCmdSetDepthCompareOp = Option<NonNullPFN_vkCmdSetDepthCompareOp>;
21797pub type PFN_vkCmdSetDepthCompareOpEXT = Option<NonNullPFN_vkCmdSetDepthCompareOpEXT>;
21798pub type PFN_vkCmdSetDepthTestEnable = Option<NonNullPFN_vkCmdSetDepthTestEnable>;
21799pub type PFN_vkCmdSetDepthTestEnableEXT = Option<NonNullPFN_vkCmdSetDepthTestEnableEXT>;
21800pub type PFN_vkCmdSetDepthWriteEnable = Option<NonNullPFN_vkCmdSetDepthWriteEnable>;
21801pub type PFN_vkCmdSetDepthWriteEnableEXT = Option<NonNullPFN_vkCmdSetDepthWriteEnableEXT>;
21802pub type PFN_vkCmdSetDescriptorBufferOffsets2EXT = Option<NonNullPFN_vkCmdSetDescriptorBufferOffsets2EXT>;
21803pub type PFN_vkCmdSetDescriptorBufferOffsetsEXT = Option<NonNullPFN_vkCmdSetDescriptorBufferOffsetsEXT>;
21804pub type PFN_vkCmdSetDeviceMask = Option<NonNullPFN_vkCmdSetDeviceMask>;
21805pub type PFN_vkCmdSetDeviceMaskKHR = Option<NonNullPFN_vkCmdSetDeviceMaskKHR>;
21806pub type PFN_vkCmdSetDiscardRectangleEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleEXT>;
21807pub type PFN_vkCmdSetDiscardRectangleEnableEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleEnableEXT>;
21808pub type PFN_vkCmdSetDiscardRectangleModeEXT = Option<NonNullPFN_vkCmdSetDiscardRectangleModeEXT>;
21809pub type PFN_vkCmdSetEvent = Option<NonNullPFN_vkCmdSetEvent>;
21810pub type PFN_vkCmdSetEvent2 = Option<NonNullPFN_vkCmdSetEvent2>;
21811pub type PFN_vkCmdSetEvent2KHR = Option<NonNullPFN_vkCmdSetEvent2KHR>;
21812pub type PFN_vkCmdSetExclusiveScissorEnableNV = Option<NonNullPFN_vkCmdSetExclusiveScissorEnableNV>;
21813pub type PFN_vkCmdSetExclusiveScissorNV = Option<NonNullPFN_vkCmdSetExclusiveScissorNV>;
21814pub type PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT = Option<NonNullPFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT>;
21815pub type PFN_vkCmdSetFragmentShadingRateEnumNV = Option<NonNullPFN_vkCmdSetFragmentShadingRateEnumNV>;
21816pub type PFN_vkCmdSetFragmentShadingRateKHR = Option<NonNullPFN_vkCmdSetFragmentShadingRateKHR>;
21817pub type PFN_vkCmdSetFrontFace = Option<NonNullPFN_vkCmdSetFrontFace>;
21818pub type PFN_vkCmdSetFrontFaceEXT = Option<NonNullPFN_vkCmdSetFrontFaceEXT>;
21819pub type PFN_vkCmdSetLineRasterizationModeEXT = Option<NonNullPFN_vkCmdSetLineRasterizationModeEXT>;
21820pub type PFN_vkCmdSetLineStipple = Option<NonNullPFN_vkCmdSetLineStipple>;
21821pub type PFN_vkCmdSetLineStippleEXT = Option<NonNullPFN_vkCmdSetLineStippleEXT>;
21822pub type PFN_vkCmdSetLineStippleEnableEXT = Option<NonNullPFN_vkCmdSetLineStippleEnableEXT>;
21823pub type PFN_vkCmdSetLineStippleKHR = Option<NonNullPFN_vkCmdSetLineStippleKHR>;
21824pub type PFN_vkCmdSetLineWidth = Option<NonNullPFN_vkCmdSetLineWidth>;
21825pub type PFN_vkCmdSetLogicOpEXT = Option<NonNullPFN_vkCmdSetLogicOpEXT>;
21826pub type PFN_vkCmdSetLogicOpEnableEXT = Option<NonNullPFN_vkCmdSetLogicOpEnableEXT>;
21827pub type PFN_vkCmdSetPatchControlPointsEXT = Option<NonNullPFN_vkCmdSetPatchControlPointsEXT>;
21828pub type PFN_vkCmdSetPerformanceMarkerINTEL = Option<NonNullPFN_vkCmdSetPerformanceMarkerINTEL>;
21829pub type PFN_vkCmdSetPerformanceOverrideINTEL = Option<NonNullPFN_vkCmdSetPerformanceOverrideINTEL>;
21830pub type PFN_vkCmdSetPerformanceStreamMarkerINTEL = Option<NonNullPFN_vkCmdSetPerformanceStreamMarkerINTEL>;
21831pub type PFN_vkCmdSetPolygonModeEXT = Option<NonNullPFN_vkCmdSetPolygonModeEXT>;
21832pub type PFN_vkCmdSetPrimitiveRestartEnable = Option<NonNullPFN_vkCmdSetPrimitiveRestartEnable>;
21833pub type PFN_vkCmdSetPrimitiveRestartEnableEXT = Option<NonNullPFN_vkCmdSetPrimitiveRestartEnableEXT>;
21834pub type PFN_vkCmdSetPrimitiveTopology = Option<NonNullPFN_vkCmdSetPrimitiveTopology>;
21835pub type PFN_vkCmdSetPrimitiveTopologyEXT = Option<NonNullPFN_vkCmdSetPrimitiveTopologyEXT>;
21836pub type PFN_vkCmdSetProvokingVertexModeEXT = Option<NonNullPFN_vkCmdSetProvokingVertexModeEXT>;
21837pub type PFN_vkCmdSetRasterizationSamplesEXT = Option<NonNullPFN_vkCmdSetRasterizationSamplesEXT>;
21838pub type PFN_vkCmdSetRasterizationStreamEXT = Option<NonNullPFN_vkCmdSetRasterizationStreamEXT>;
21839pub type PFN_vkCmdSetRasterizerDiscardEnable = Option<NonNullPFN_vkCmdSetRasterizerDiscardEnable>;
21840pub type PFN_vkCmdSetRasterizerDiscardEnableEXT = Option<NonNullPFN_vkCmdSetRasterizerDiscardEnableEXT>;
21841pub type PFN_vkCmdSetRayTracingPipelineStackSizeKHR = Option<NonNullPFN_vkCmdSetRayTracingPipelineStackSizeKHR>;
21842pub type PFN_vkCmdSetRenderingAttachmentLocations = Option<NonNullPFN_vkCmdSetRenderingAttachmentLocations>;
21843pub type PFN_vkCmdSetRenderingAttachmentLocationsKHR = Option<NonNullPFN_vkCmdSetRenderingAttachmentLocationsKHR>;
21844pub type PFN_vkCmdSetRenderingInputAttachmentIndices = Option<NonNullPFN_vkCmdSetRenderingInputAttachmentIndices>;
21845pub type PFN_vkCmdSetRenderingInputAttachmentIndicesKHR = Option<NonNullPFN_vkCmdSetRenderingInputAttachmentIndicesKHR>;
21846pub type PFN_vkCmdSetRepresentativeFragmentTestEnableNV = Option<NonNullPFN_vkCmdSetRepresentativeFragmentTestEnableNV>;
21847pub type PFN_vkCmdSetSampleLocationsEXT = Option<NonNullPFN_vkCmdSetSampleLocationsEXT>;
21848pub type PFN_vkCmdSetSampleLocationsEnableEXT = Option<NonNullPFN_vkCmdSetSampleLocationsEnableEXT>;
21849pub type PFN_vkCmdSetSampleMaskEXT = Option<NonNullPFN_vkCmdSetSampleMaskEXT>;
21850pub type PFN_vkCmdSetScissor = Option<NonNullPFN_vkCmdSetScissor>;
21851pub type PFN_vkCmdSetScissorWithCount = Option<NonNullPFN_vkCmdSetScissorWithCount>;
21852pub type PFN_vkCmdSetScissorWithCountEXT = Option<NonNullPFN_vkCmdSetScissorWithCountEXT>;
21853pub type PFN_vkCmdSetShadingRateImageEnableNV = Option<NonNullPFN_vkCmdSetShadingRateImageEnableNV>;
21854pub type PFN_vkCmdSetStencilCompareMask = Option<NonNullPFN_vkCmdSetStencilCompareMask>;
21855pub type PFN_vkCmdSetStencilOp = Option<NonNullPFN_vkCmdSetStencilOp>;
21856pub type PFN_vkCmdSetStencilOpEXT = Option<NonNullPFN_vkCmdSetStencilOpEXT>;
21857pub type PFN_vkCmdSetStencilReference = Option<NonNullPFN_vkCmdSetStencilReference>;
21858pub type PFN_vkCmdSetStencilTestEnable = Option<NonNullPFN_vkCmdSetStencilTestEnable>;
21859pub type PFN_vkCmdSetStencilTestEnableEXT = Option<NonNullPFN_vkCmdSetStencilTestEnableEXT>;
21860pub type PFN_vkCmdSetStencilWriteMask = Option<NonNullPFN_vkCmdSetStencilWriteMask>;
21861pub type PFN_vkCmdSetTessellationDomainOriginEXT = Option<NonNullPFN_vkCmdSetTessellationDomainOriginEXT>;
21862pub type PFN_vkCmdSetVertexInputEXT = Option<NonNullPFN_vkCmdSetVertexInputEXT>;
21863pub type PFN_vkCmdSetViewport = Option<NonNullPFN_vkCmdSetViewport>;
21864pub type PFN_vkCmdSetViewportShadingRatePaletteNV = Option<NonNullPFN_vkCmdSetViewportShadingRatePaletteNV>;
21865pub type PFN_vkCmdSetViewportSwizzleNV = Option<NonNullPFN_vkCmdSetViewportSwizzleNV>;
21866pub type PFN_vkCmdSetViewportWScalingEnableNV = Option<NonNullPFN_vkCmdSetViewportWScalingEnableNV>;
21867pub type PFN_vkCmdSetViewportWScalingNV = Option<NonNullPFN_vkCmdSetViewportWScalingNV>;
21868pub type PFN_vkCmdSetViewportWithCount = Option<NonNullPFN_vkCmdSetViewportWithCount>;
21869pub type PFN_vkCmdSetViewportWithCountEXT = Option<NonNullPFN_vkCmdSetViewportWithCountEXT>;
21870pub type PFN_vkCmdSubpassShadingHUAWEI = Option<NonNullPFN_vkCmdSubpassShadingHUAWEI>;
21871pub type PFN_vkCmdTraceRaysIndirect2KHR = Option<NonNullPFN_vkCmdTraceRaysIndirect2KHR>;
21872pub type PFN_vkCmdTraceRaysIndirectKHR = Option<NonNullPFN_vkCmdTraceRaysIndirectKHR>;
21873pub type PFN_vkCmdTraceRaysKHR = Option<NonNullPFN_vkCmdTraceRaysKHR>;
21874pub type PFN_vkCmdTraceRaysNV = Option<NonNullPFN_vkCmdTraceRaysNV>;
21875pub type PFN_vkCmdUpdateBuffer = Option<NonNullPFN_vkCmdUpdateBuffer>;
21876pub type PFN_vkCmdUpdatePipelineIndirectBufferNV = Option<NonNullPFN_vkCmdUpdatePipelineIndirectBufferNV>;
21877pub type PFN_vkCmdWaitEvents = Option<NonNullPFN_vkCmdWaitEvents>;
21878pub type PFN_vkCmdWaitEvents2 = Option<NonNullPFN_vkCmdWaitEvents2>;
21879pub type PFN_vkCmdWaitEvents2KHR = Option<NonNullPFN_vkCmdWaitEvents2KHR>;
21880pub type PFN_vkCmdWriteAccelerationStructuresPropertiesKHR = Option<NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesKHR>;
21881pub type PFN_vkCmdWriteAccelerationStructuresPropertiesNV = Option<NonNullPFN_vkCmdWriteAccelerationStructuresPropertiesNV>;
21882pub type PFN_vkCmdWriteBufferMarker2AMD = Option<NonNullPFN_vkCmdWriteBufferMarker2AMD>;
21883pub type PFN_vkCmdWriteBufferMarkerAMD = Option<NonNullPFN_vkCmdWriteBufferMarkerAMD>;
21884pub type PFN_vkCmdWriteMicromapsPropertiesEXT = Option<NonNullPFN_vkCmdWriteMicromapsPropertiesEXT>;
21885pub type PFN_vkCmdWriteTimestamp = Option<NonNullPFN_vkCmdWriteTimestamp>;
21886pub type PFN_vkCmdWriteTimestamp2 = Option<NonNullPFN_vkCmdWriteTimestamp2>;
21887pub type PFN_vkCmdWriteTimestamp2KHR = Option<NonNullPFN_vkCmdWriteTimestamp2KHR>;
21888pub type PFN_vkCompileDeferredNV = Option<NonNullPFN_vkCompileDeferredNV>;
21889pub type PFN_vkConvertCooperativeVectorMatrixNV = Option<NonNullPFN_vkConvertCooperativeVectorMatrixNV>;
21890pub type PFN_vkCopyAccelerationStructureKHR = Option<NonNullPFN_vkCopyAccelerationStructureKHR>;
21891pub type PFN_vkCopyAccelerationStructureToMemoryKHR = Option<NonNullPFN_vkCopyAccelerationStructureToMemoryKHR>;
21892pub type PFN_vkCopyImageToImage = Option<NonNullPFN_vkCopyImageToImage>;
21893pub type PFN_vkCopyImageToImageEXT = Option<NonNullPFN_vkCopyImageToImageEXT>;
21894pub type PFN_vkCopyImageToMemory = Option<NonNullPFN_vkCopyImageToMemory>;
21895pub type PFN_vkCopyImageToMemoryEXT = Option<NonNullPFN_vkCopyImageToMemoryEXT>;
21896pub type PFN_vkCopyMemoryToAccelerationStructureKHR = Option<NonNullPFN_vkCopyMemoryToAccelerationStructureKHR>;
21897pub type PFN_vkCopyMemoryToImage = Option<NonNullPFN_vkCopyMemoryToImage>;
21898pub type PFN_vkCopyMemoryToImageEXT = Option<NonNullPFN_vkCopyMemoryToImageEXT>;
21899pub type PFN_vkCopyMemoryToMicromapEXT = Option<NonNullPFN_vkCopyMemoryToMicromapEXT>;
21900pub type PFN_vkCopyMicromapEXT = Option<NonNullPFN_vkCopyMicromapEXT>;
21901pub type PFN_vkCopyMicromapToMemoryEXT = Option<NonNullPFN_vkCopyMicromapToMemoryEXT>;
21902pub type PFN_vkCreateAccelerationStructureKHR = Option<NonNullPFN_vkCreateAccelerationStructureKHR>;
21903pub type PFN_vkCreateAccelerationStructureNV = Option<NonNullPFN_vkCreateAccelerationStructureNV>;
21904pub type PFN_vkCreateBuffer = Option<NonNullPFN_vkCreateBuffer>;
21905pub type PFN_vkCreateBufferView = Option<NonNullPFN_vkCreateBufferView>;
21906pub type PFN_vkCreateCommandPool = Option<NonNullPFN_vkCreateCommandPool>;
21907pub type PFN_vkCreateComputePipelines = Option<NonNullPFN_vkCreateComputePipelines>;
21908pub type PFN_vkCreateCuFunctionNVX = Option<NonNullPFN_vkCreateCuFunctionNVX>;
21909pub type PFN_vkCreateCuModuleNVX = Option<NonNullPFN_vkCreateCuModuleNVX>;
21910pub type PFN_vkCreateDataGraphPipelineSessionARM = Option<NonNullPFN_vkCreateDataGraphPipelineSessionARM>;
21911pub type PFN_vkCreateDataGraphPipelinesARM = Option<NonNullPFN_vkCreateDataGraphPipelinesARM>;
21912pub type PFN_vkCreateDebugReportCallbackEXT = Option<NonNullPFN_vkCreateDebugReportCallbackEXT>;
21913pub type PFN_vkCreateDebugUtilsMessengerEXT = Option<NonNullPFN_vkCreateDebugUtilsMessengerEXT>;
21914pub type PFN_vkCreateDeferredOperationKHR = Option<NonNullPFN_vkCreateDeferredOperationKHR>;
21915pub type PFN_vkCreateDescriptorPool = Option<NonNullPFN_vkCreateDescriptorPool>;
21916pub type PFN_vkCreateDescriptorSetLayout = Option<NonNullPFN_vkCreateDescriptorSetLayout>;
21917pub type PFN_vkCreateDescriptorUpdateTemplate = Option<NonNullPFN_vkCreateDescriptorUpdateTemplate>;
21918pub type PFN_vkCreateDescriptorUpdateTemplateKHR = Option<NonNullPFN_vkCreateDescriptorUpdateTemplateKHR>;
21919pub type PFN_vkCreateDevice = Option<NonNullPFN_vkCreateDevice>;
21920pub type PFN_vkCreateDisplayModeKHR = Option<NonNullPFN_vkCreateDisplayModeKHR>;
21921pub type PFN_vkCreateDisplayPlaneSurfaceKHR = Option<NonNullPFN_vkCreateDisplayPlaneSurfaceKHR>;
21922pub type PFN_vkCreateEvent = Option<NonNullPFN_vkCreateEvent>;
21923pub type PFN_vkCreateExternalComputeQueueNV = Option<NonNullPFN_vkCreateExternalComputeQueueNV>;
21924pub type PFN_vkCreateFence = Option<NonNullPFN_vkCreateFence>;
21925pub type PFN_vkCreateFramebuffer = Option<NonNullPFN_vkCreateFramebuffer>;
21926pub type PFN_vkCreateGraphicsPipelines = Option<NonNullPFN_vkCreateGraphicsPipelines>;
21927pub type PFN_vkCreateHeadlessSurfaceEXT = Option<NonNullPFN_vkCreateHeadlessSurfaceEXT>;
21928pub type PFN_vkCreateImage = Option<NonNullPFN_vkCreateImage>;
21929pub type PFN_vkCreateImageView = Option<NonNullPFN_vkCreateImageView>;
21930pub type PFN_vkCreateIndirectCommandsLayoutEXT = Option<NonNullPFN_vkCreateIndirectCommandsLayoutEXT>;
21931pub type PFN_vkCreateIndirectCommandsLayoutNV = Option<NonNullPFN_vkCreateIndirectCommandsLayoutNV>;
21932pub type PFN_vkCreateIndirectExecutionSetEXT = Option<NonNullPFN_vkCreateIndirectExecutionSetEXT>;
21933pub type PFN_vkCreateInstance = Option<NonNullPFN_vkCreateInstance>;
21934pub type PFN_vkCreateMicromapEXT = Option<NonNullPFN_vkCreateMicromapEXT>;
21935pub type PFN_vkCreateOpticalFlowSessionNV = Option<NonNullPFN_vkCreateOpticalFlowSessionNV>;
21936pub type PFN_vkCreatePipelineBinariesKHR = Option<NonNullPFN_vkCreatePipelineBinariesKHR>;
21937pub type PFN_vkCreatePipelineCache = Option<NonNullPFN_vkCreatePipelineCache>;
21938pub type PFN_vkCreatePipelineLayout = Option<NonNullPFN_vkCreatePipelineLayout>;
21939pub type PFN_vkCreatePrivateDataSlot = Option<NonNullPFN_vkCreatePrivateDataSlot>;
21940pub type PFN_vkCreatePrivateDataSlotEXT = Option<NonNullPFN_vkCreatePrivateDataSlotEXT>;
21941pub type PFN_vkCreateQueryPool = Option<NonNullPFN_vkCreateQueryPool>;
21942pub type PFN_vkCreateRayTracingPipelinesKHR = Option<NonNullPFN_vkCreateRayTracingPipelinesKHR>;
21943pub type PFN_vkCreateRayTracingPipelinesNV = Option<NonNullPFN_vkCreateRayTracingPipelinesNV>;
21944pub type PFN_vkCreateRenderPass = Option<NonNullPFN_vkCreateRenderPass>;
21945pub type PFN_vkCreateRenderPass2 = Option<NonNullPFN_vkCreateRenderPass2>;
21946pub type PFN_vkCreateRenderPass2KHR = Option<NonNullPFN_vkCreateRenderPass2KHR>;
21947pub type PFN_vkCreateSampler = Option<NonNullPFN_vkCreateSampler>;
21948pub type PFN_vkCreateSamplerYcbcrConversion = Option<NonNullPFN_vkCreateSamplerYcbcrConversion>;
21949pub type PFN_vkCreateSamplerYcbcrConversionKHR = Option<NonNullPFN_vkCreateSamplerYcbcrConversionKHR>;
21950pub type PFN_vkCreateSemaphore = Option<NonNullPFN_vkCreateSemaphore>;
21951pub type PFN_vkCreateShaderModule = Option<NonNullPFN_vkCreateShaderModule>;
21952pub type PFN_vkCreateShadersEXT = Option<NonNullPFN_vkCreateShadersEXT>;
21953pub type PFN_vkCreateSharedSwapchainsKHR = Option<NonNullPFN_vkCreateSharedSwapchainsKHR>;
21954pub type PFN_vkCreateSwapchainKHR = Option<NonNullPFN_vkCreateSwapchainKHR>;
21955pub type PFN_vkCreateTensorARM = Option<NonNullPFN_vkCreateTensorARM>;
21956pub type PFN_vkCreateTensorViewARM = Option<NonNullPFN_vkCreateTensorViewARM>;
21957pub type PFN_vkCreateValidationCacheEXT = Option<NonNullPFN_vkCreateValidationCacheEXT>;
21958pub type PFN_vkCreateVideoSessionKHR = Option<NonNullPFN_vkCreateVideoSessionKHR>;
21959pub type PFN_vkCreateVideoSessionParametersKHR = Option<NonNullPFN_vkCreateVideoSessionParametersKHR>;
21960pub type PFN_vkDebugMarkerSetObjectNameEXT = Option<NonNullPFN_vkDebugMarkerSetObjectNameEXT>;
21961pub type PFN_vkDebugMarkerSetObjectTagEXT = Option<NonNullPFN_vkDebugMarkerSetObjectTagEXT>;
21962pub type PFN_vkDebugReportCallbackEXT = Option<NonNullPFN_vkDebugReportCallbackEXT>;
21963pub type PFN_vkDebugReportMessageEXT = Option<NonNullPFN_vkDebugReportMessageEXT>;
21964pub type PFN_vkDebugUtilsMessengerCallbackEXT = Option<NonNullPFN_vkDebugUtilsMessengerCallbackEXT>;
21965pub type PFN_vkDeferredOperationJoinKHR = Option<NonNullPFN_vkDeferredOperationJoinKHR>;
21966pub type PFN_vkDestroyAccelerationStructureKHR = Option<NonNullPFN_vkDestroyAccelerationStructureKHR>;
21967pub type PFN_vkDestroyAccelerationStructureNV = Option<NonNullPFN_vkDestroyAccelerationStructureNV>;
21968pub type PFN_vkDestroyBuffer = Option<NonNullPFN_vkDestroyBuffer>;
21969pub type PFN_vkDestroyBufferView = Option<NonNullPFN_vkDestroyBufferView>;
21970pub type PFN_vkDestroyCommandPool = Option<NonNullPFN_vkDestroyCommandPool>;
21971pub type PFN_vkDestroyCuFunctionNVX = Option<NonNullPFN_vkDestroyCuFunctionNVX>;
21972pub type PFN_vkDestroyCuModuleNVX = Option<NonNullPFN_vkDestroyCuModuleNVX>;
21973pub type PFN_vkDestroyDataGraphPipelineSessionARM = Option<NonNullPFN_vkDestroyDataGraphPipelineSessionARM>;
21974pub type PFN_vkDestroyDebugReportCallbackEXT = Option<NonNullPFN_vkDestroyDebugReportCallbackEXT>;
21975pub type PFN_vkDestroyDebugUtilsMessengerEXT = Option<NonNullPFN_vkDestroyDebugUtilsMessengerEXT>;
21976pub type PFN_vkDestroyDeferredOperationKHR = Option<NonNullPFN_vkDestroyDeferredOperationKHR>;
21977pub type PFN_vkDestroyDescriptorPool = Option<NonNullPFN_vkDestroyDescriptorPool>;
21978pub type PFN_vkDestroyDescriptorSetLayout = Option<NonNullPFN_vkDestroyDescriptorSetLayout>;
21979pub type PFN_vkDestroyDescriptorUpdateTemplate = Option<NonNullPFN_vkDestroyDescriptorUpdateTemplate>;
21980pub type PFN_vkDestroyDescriptorUpdateTemplateKHR = Option<NonNullPFN_vkDestroyDescriptorUpdateTemplateKHR>;
21981pub type PFN_vkDestroyDevice = Option<NonNullPFN_vkDestroyDevice>;
21982pub type PFN_vkDestroyEvent = Option<NonNullPFN_vkDestroyEvent>;
21983pub type PFN_vkDestroyExternalComputeQueueNV = Option<NonNullPFN_vkDestroyExternalComputeQueueNV>;
21984pub type PFN_vkDestroyFence = Option<NonNullPFN_vkDestroyFence>;
21985pub type PFN_vkDestroyFramebuffer = Option<NonNullPFN_vkDestroyFramebuffer>;
21986pub type PFN_vkDestroyImage = Option<NonNullPFN_vkDestroyImage>;
21987pub type PFN_vkDestroyImageView = Option<NonNullPFN_vkDestroyImageView>;
21988pub type PFN_vkDestroyIndirectCommandsLayoutEXT = Option<NonNullPFN_vkDestroyIndirectCommandsLayoutEXT>;
21989pub type PFN_vkDestroyIndirectCommandsLayoutNV = Option<NonNullPFN_vkDestroyIndirectCommandsLayoutNV>;
21990pub type PFN_vkDestroyIndirectExecutionSetEXT = Option<NonNullPFN_vkDestroyIndirectExecutionSetEXT>;
21991pub type PFN_vkDestroyInstance = Option<NonNullPFN_vkDestroyInstance>;
21992pub type PFN_vkDestroyMicromapEXT = Option<NonNullPFN_vkDestroyMicromapEXT>;
21993pub type PFN_vkDestroyOpticalFlowSessionNV = Option<NonNullPFN_vkDestroyOpticalFlowSessionNV>;
21994pub type PFN_vkDestroyPipeline = Option<NonNullPFN_vkDestroyPipeline>;
21995pub type PFN_vkDestroyPipelineBinaryKHR = Option<NonNullPFN_vkDestroyPipelineBinaryKHR>;
21996pub type PFN_vkDestroyPipelineCache = Option<NonNullPFN_vkDestroyPipelineCache>;
21997pub type PFN_vkDestroyPipelineLayout = Option<NonNullPFN_vkDestroyPipelineLayout>;
21998pub type PFN_vkDestroyPrivateDataSlot = Option<NonNullPFN_vkDestroyPrivateDataSlot>;
21999pub type PFN_vkDestroyPrivateDataSlotEXT = Option<NonNullPFN_vkDestroyPrivateDataSlotEXT>;
22000pub type PFN_vkDestroyQueryPool = Option<NonNullPFN_vkDestroyQueryPool>;
22001pub type PFN_vkDestroyRenderPass = Option<NonNullPFN_vkDestroyRenderPass>;
22002pub type PFN_vkDestroySampler = Option<NonNullPFN_vkDestroySampler>;
22003pub type PFN_vkDestroySamplerYcbcrConversion = Option<NonNullPFN_vkDestroySamplerYcbcrConversion>;
22004pub type PFN_vkDestroySamplerYcbcrConversionKHR = Option<NonNullPFN_vkDestroySamplerYcbcrConversionKHR>;
22005pub type PFN_vkDestroySemaphore = Option<NonNullPFN_vkDestroySemaphore>;
22006pub type PFN_vkDestroyShaderEXT = Option<NonNullPFN_vkDestroyShaderEXT>;
22007pub type PFN_vkDestroyShaderModule = Option<NonNullPFN_vkDestroyShaderModule>;
22008pub type PFN_vkDestroySurfaceKHR = Option<NonNullPFN_vkDestroySurfaceKHR>;
22009pub type PFN_vkDestroySwapchainKHR = Option<NonNullPFN_vkDestroySwapchainKHR>;
22010pub type PFN_vkDestroyTensorARM = Option<NonNullPFN_vkDestroyTensorARM>;
22011pub type PFN_vkDestroyTensorViewARM = Option<NonNullPFN_vkDestroyTensorViewARM>;
22012pub type PFN_vkDestroyValidationCacheEXT = Option<NonNullPFN_vkDestroyValidationCacheEXT>;
22013pub type PFN_vkDestroyVideoSessionKHR = Option<NonNullPFN_vkDestroyVideoSessionKHR>;
22014pub type PFN_vkDestroyVideoSessionParametersKHR = Option<NonNullPFN_vkDestroyVideoSessionParametersKHR>;
22015pub type PFN_vkDeviceMemoryReportCallbackEXT = Option<NonNullPFN_vkDeviceMemoryReportCallbackEXT>;
22016pub type PFN_vkDeviceWaitIdle = Option<NonNullPFN_vkDeviceWaitIdle>;
22017pub type PFN_vkDisplayPowerControlEXT = Option<NonNullPFN_vkDisplayPowerControlEXT>;
22018pub type PFN_vkEndCommandBuffer = Option<NonNullPFN_vkEndCommandBuffer>;
22019pub type PFN_vkEnumerateDeviceExtensionProperties = Option<NonNullPFN_vkEnumerateDeviceExtensionProperties>;
22020pub type PFN_vkEnumerateDeviceLayerProperties = Option<NonNullPFN_vkEnumerateDeviceLayerProperties>;
22021pub type PFN_vkEnumerateInstanceExtensionProperties = Option<NonNullPFN_vkEnumerateInstanceExtensionProperties>;
22022pub type PFN_vkEnumerateInstanceLayerProperties = Option<NonNullPFN_vkEnumerateInstanceLayerProperties>;
22023pub type PFN_vkEnumerateInstanceVersion = Option<NonNullPFN_vkEnumerateInstanceVersion>;
22024pub type PFN_vkEnumeratePhysicalDeviceGroups = Option<NonNullPFN_vkEnumeratePhysicalDeviceGroups>;
22025pub type PFN_vkEnumeratePhysicalDeviceGroupsKHR = Option<NonNullPFN_vkEnumeratePhysicalDeviceGroupsKHR>;
22026pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM = Option<NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceCountersByRegionARM>;
22027pub type PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = Option<NonNullPFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR>;
22028pub type PFN_vkEnumeratePhysicalDevices = Option<NonNullPFN_vkEnumeratePhysicalDevices>;
22029pub type PFN_vkFlushMappedMemoryRanges = Option<NonNullPFN_vkFlushMappedMemoryRanges>;
22030pub type PFN_vkFreeCommandBuffers = Option<NonNullPFN_vkFreeCommandBuffers>;
22031pub type PFN_vkFreeDescriptorSets = Option<NonNullPFN_vkFreeDescriptorSets>;
22032pub type PFN_vkFreeFunction = Option<NonNullPFN_vkFreeFunction>;
22033pub type PFN_vkFreeMemory = Option<NonNullPFN_vkFreeMemory>;
22034pub type PFN_vkGetAccelerationStructureBuildSizesKHR = Option<NonNullPFN_vkGetAccelerationStructureBuildSizesKHR>;
22035pub type PFN_vkGetAccelerationStructureDeviceAddressKHR = Option<NonNullPFN_vkGetAccelerationStructureDeviceAddressKHR>;
22036pub type PFN_vkGetAccelerationStructureHandleNV = Option<NonNullPFN_vkGetAccelerationStructureHandleNV>;
22037pub type PFN_vkGetAccelerationStructureMemoryRequirementsNV = Option<NonNullPFN_vkGetAccelerationStructureMemoryRequirementsNV>;
22038pub type PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT>;
22039pub type PFN_vkGetBufferDeviceAddress = Option<NonNullPFN_vkGetBufferDeviceAddress>;
22040pub type PFN_vkGetBufferDeviceAddressEXT = Option<NonNullPFN_vkGetBufferDeviceAddressEXT>;
22041pub type PFN_vkGetBufferDeviceAddressKHR = Option<NonNullPFN_vkGetBufferDeviceAddressKHR>;
22042pub type PFN_vkGetBufferMemoryRequirements = Option<NonNullPFN_vkGetBufferMemoryRequirements>;
22043pub type PFN_vkGetBufferMemoryRequirements2 = Option<NonNullPFN_vkGetBufferMemoryRequirements2>;
22044pub type PFN_vkGetBufferMemoryRequirements2KHR = Option<NonNullPFN_vkGetBufferMemoryRequirements2KHR>;
22045pub type PFN_vkGetBufferOpaqueCaptureAddress = Option<NonNullPFN_vkGetBufferOpaqueCaptureAddress>;
22046pub type PFN_vkGetBufferOpaqueCaptureAddressKHR = Option<NonNullPFN_vkGetBufferOpaqueCaptureAddressKHR>;
22047pub type PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetBufferOpaqueCaptureDescriptorDataEXT>;
22048pub type PFN_vkGetCalibratedTimestampsEXT = Option<NonNullPFN_vkGetCalibratedTimestampsEXT>;
22049pub type PFN_vkGetCalibratedTimestampsKHR = Option<NonNullPFN_vkGetCalibratedTimestampsKHR>;
22050pub type PFN_vkGetClusterAccelerationStructureBuildSizesNV = Option<NonNullPFN_vkGetClusterAccelerationStructureBuildSizesNV>;
22051pub type PFN_vkGetDataGraphPipelineAvailablePropertiesARM = Option<NonNullPFN_vkGetDataGraphPipelineAvailablePropertiesARM>;
22052pub type PFN_vkGetDataGraphPipelinePropertiesARM = Option<NonNullPFN_vkGetDataGraphPipelinePropertiesARM>;
22053pub type PFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM = Option<NonNullPFN_vkGetDataGraphPipelineSessionBindPointRequirementsARM>;
22054pub type PFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM = Option<NonNullPFN_vkGetDataGraphPipelineSessionMemoryRequirementsARM>;
22055pub type PFN_vkGetDeferredOperationMaxConcurrencyKHR = Option<NonNullPFN_vkGetDeferredOperationMaxConcurrencyKHR>;
22056pub type PFN_vkGetDeferredOperationResultKHR = Option<NonNullPFN_vkGetDeferredOperationResultKHR>;
22057pub type PFN_vkGetDescriptorEXT = Option<NonNullPFN_vkGetDescriptorEXT>;
22058pub type PFN_vkGetDescriptorSetHostMappingVALVE = Option<NonNullPFN_vkGetDescriptorSetHostMappingVALVE>;
22059pub type PFN_vkGetDescriptorSetLayoutBindingOffsetEXT = Option<NonNullPFN_vkGetDescriptorSetLayoutBindingOffsetEXT>;
22060pub type PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE = Option<NonNullPFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE>;
22061pub type PFN_vkGetDescriptorSetLayoutSizeEXT = Option<NonNullPFN_vkGetDescriptorSetLayoutSizeEXT>;
22062pub type PFN_vkGetDescriptorSetLayoutSupport = Option<NonNullPFN_vkGetDescriptorSetLayoutSupport>;
22063pub type PFN_vkGetDescriptorSetLayoutSupportKHR = Option<NonNullPFN_vkGetDescriptorSetLayoutSupportKHR>;
22064pub type PFN_vkGetDeviceAccelerationStructureCompatibilityKHR = Option<NonNullPFN_vkGetDeviceAccelerationStructureCompatibilityKHR>;
22065pub type PFN_vkGetDeviceBufferMemoryRequirements = Option<NonNullPFN_vkGetDeviceBufferMemoryRequirements>;
22066pub type PFN_vkGetDeviceBufferMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceBufferMemoryRequirementsKHR>;
22067pub type PFN_vkGetDeviceCombinedImageSamplerIndexNVX = Option<NonNullPFN_vkGetDeviceCombinedImageSamplerIndexNVX>;
22068pub type PFN_vkGetDeviceFaultInfoEXT = Option<NonNullPFN_vkGetDeviceFaultInfoEXT>;
22069pub type PFN_vkGetDeviceGroupPeerMemoryFeatures = Option<NonNullPFN_vkGetDeviceGroupPeerMemoryFeatures>;
22070pub type PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR = Option<NonNullPFN_vkGetDeviceGroupPeerMemoryFeaturesKHR>;
22071pub type PFN_vkGetDeviceGroupPresentCapabilitiesKHR = Option<NonNullPFN_vkGetDeviceGroupPresentCapabilitiesKHR>;
22072pub type PFN_vkGetDeviceGroupSurfacePresentModesKHR = Option<NonNullPFN_vkGetDeviceGroupSurfacePresentModesKHR>;
22073pub type PFN_vkGetDeviceImageMemoryRequirements = Option<NonNullPFN_vkGetDeviceImageMemoryRequirements>;
22074pub type PFN_vkGetDeviceImageMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceImageMemoryRequirementsKHR>;
22075pub type PFN_vkGetDeviceImageSparseMemoryRequirements = Option<NonNullPFN_vkGetDeviceImageSparseMemoryRequirements>;
22076pub type PFN_vkGetDeviceImageSparseMemoryRequirementsKHR = Option<NonNullPFN_vkGetDeviceImageSparseMemoryRequirementsKHR>;
22077pub type PFN_vkGetDeviceImageSubresourceLayout = Option<NonNullPFN_vkGetDeviceImageSubresourceLayout>;
22078pub type PFN_vkGetDeviceImageSubresourceLayoutKHR = Option<NonNullPFN_vkGetDeviceImageSubresourceLayoutKHR>;
22079pub type PFN_vkGetDeviceMemoryCommitment = Option<NonNullPFN_vkGetDeviceMemoryCommitment>;
22080pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddress = Option<NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddress>;
22081pub type PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR = Option<NonNullPFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR>;
22082pub type PFN_vkGetDeviceMicromapCompatibilityEXT = Option<NonNullPFN_vkGetDeviceMicromapCompatibilityEXT>;
22083pub type PFN_vkGetDeviceProcAddr = Option<NonNullPFN_vkGetDeviceProcAddr>;
22084pub type PFN_vkGetDeviceQueue = Option<NonNullPFN_vkGetDeviceQueue>;
22085pub type PFN_vkGetDeviceQueue2 = Option<NonNullPFN_vkGetDeviceQueue2>;
22086pub type PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = Option<NonNullPFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI>;
22087pub type PFN_vkGetDeviceTensorMemoryRequirementsARM = Option<NonNullPFN_vkGetDeviceTensorMemoryRequirementsARM>;
22088pub type PFN_vkGetDisplayModeProperties2KHR = Option<NonNullPFN_vkGetDisplayModeProperties2KHR>;
22089pub type PFN_vkGetDisplayModePropertiesKHR = Option<NonNullPFN_vkGetDisplayModePropertiesKHR>;
22090pub type PFN_vkGetDisplayPlaneCapabilities2KHR = Option<NonNullPFN_vkGetDisplayPlaneCapabilities2KHR>;
22091pub type PFN_vkGetDisplayPlaneCapabilitiesKHR = Option<NonNullPFN_vkGetDisplayPlaneCapabilitiesKHR>;
22092pub type PFN_vkGetDisplayPlaneSupportedDisplaysKHR = Option<NonNullPFN_vkGetDisplayPlaneSupportedDisplaysKHR>;
22093pub type PFN_vkGetDrmDisplayEXT = Option<NonNullPFN_vkGetDrmDisplayEXT>;
22094pub type PFN_vkGetDynamicRenderingTilePropertiesQCOM = Option<NonNullPFN_vkGetDynamicRenderingTilePropertiesQCOM>;
22095pub type PFN_vkGetEncodedVideoSessionParametersKHR = Option<NonNullPFN_vkGetEncodedVideoSessionParametersKHR>;
22096pub type PFN_vkGetEventStatus = Option<NonNullPFN_vkGetEventStatus>;
22097pub type PFN_vkGetExternalComputeQueueDataNV = Option<NonNullPFN_vkGetExternalComputeQueueDataNV>;
22098pub type PFN_vkGetFenceFdKHR = Option<NonNullPFN_vkGetFenceFdKHR>;
22099pub type PFN_vkGetFenceStatus = Option<NonNullPFN_vkGetFenceStatus>;
22100pub type PFN_vkGetFramebufferTilePropertiesQCOM = Option<NonNullPFN_vkGetFramebufferTilePropertiesQCOM>;
22101pub type PFN_vkGetGeneratedCommandsMemoryRequirementsEXT = Option<NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsEXT>;
22102pub type PFN_vkGetGeneratedCommandsMemoryRequirementsNV = Option<NonNullPFN_vkGetGeneratedCommandsMemoryRequirementsNV>;
22103pub type PFN_vkGetImageDrmFormatModifierPropertiesEXT = Option<NonNullPFN_vkGetImageDrmFormatModifierPropertiesEXT>;
22104pub type PFN_vkGetImageMemoryRequirements = Option<NonNullPFN_vkGetImageMemoryRequirements>;
22105pub type PFN_vkGetImageMemoryRequirements2 = Option<NonNullPFN_vkGetImageMemoryRequirements2>;
22106pub type PFN_vkGetImageMemoryRequirements2KHR = Option<NonNullPFN_vkGetImageMemoryRequirements2KHR>;
22107pub type PFN_vkGetImageOpaqueCaptureDataEXT = Option<NonNullPFN_vkGetImageOpaqueCaptureDataEXT>;
22108pub type PFN_vkGetImageOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetImageOpaqueCaptureDescriptorDataEXT>;
22109pub type PFN_vkGetImageSparseMemoryRequirements = Option<NonNullPFN_vkGetImageSparseMemoryRequirements>;
22110pub type PFN_vkGetImageSparseMemoryRequirements2 = Option<NonNullPFN_vkGetImageSparseMemoryRequirements2>;
22111pub type PFN_vkGetImageSparseMemoryRequirements2KHR = Option<NonNullPFN_vkGetImageSparseMemoryRequirements2KHR>;
22112pub type PFN_vkGetImageSubresourceLayout = Option<NonNullPFN_vkGetImageSubresourceLayout>;
22113pub type PFN_vkGetImageSubresourceLayout2 = Option<NonNullPFN_vkGetImageSubresourceLayout2>;
22114pub type PFN_vkGetImageSubresourceLayout2EXT = Option<NonNullPFN_vkGetImageSubresourceLayout2EXT>;
22115pub type PFN_vkGetImageSubresourceLayout2KHR = Option<NonNullPFN_vkGetImageSubresourceLayout2KHR>;
22116pub type PFN_vkGetImageViewAddressNVX = Option<NonNullPFN_vkGetImageViewAddressNVX>;
22117pub type PFN_vkGetImageViewHandle64NVX = Option<NonNullPFN_vkGetImageViewHandle64NVX>;
22118pub type PFN_vkGetImageViewHandleNVX = Option<NonNullPFN_vkGetImageViewHandleNVX>;
22119pub type PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT>;
22120pub type PFN_vkGetInstanceProcAddr = Option<NonNullPFN_vkGetInstanceProcAddr>;
22121pub type PFN_vkGetInstanceProcAddrLUNARG = Option<NonNullPFN_vkGetInstanceProcAddrLUNARG>;
22122pub type PFN_vkGetLatencyTimingsNV = Option<NonNullPFN_vkGetLatencyTimingsNV>;
22123pub type PFN_vkGetMemoryFdKHR = Option<NonNullPFN_vkGetMemoryFdKHR>;
22124pub type PFN_vkGetMemoryFdPropertiesKHR = Option<NonNullPFN_vkGetMemoryFdPropertiesKHR>;
22125pub type PFN_vkGetMemoryHostPointerPropertiesEXT = Option<NonNullPFN_vkGetMemoryHostPointerPropertiesEXT>;
22126pub type PFN_vkGetMemoryRemoteAddressNV = Option<NonNullPFN_vkGetMemoryRemoteAddressNV>;
22127pub type PFN_vkGetMicromapBuildSizesEXT = Option<NonNullPFN_vkGetMicromapBuildSizesEXT>;
22128pub type PFN_vkGetPartitionedAccelerationStructuresBuildSizesNV = Option<NonNullPFN_vkGetPartitionedAccelerationStructuresBuildSizesNV>;
22129pub type PFN_vkGetPastPresentationTimingEXT = Option<NonNullPFN_vkGetPastPresentationTimingEXT>;
22130pub type PFN_vkGetPastPresentationTimingGOOGLE = Option<NonNullPFN_vkGetPastPresentationTimingGOOGLE>;
22131pub type PFN_vkGetPerformanceParameterINTEL = Option<NonNullPFN_vkGetPerformanceParameterINTEL>;
22132pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = Option<NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT>;
22133pub type PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = Option<NonNullPFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR>;
22134pub type PFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixFlexibleDimensionsPropertiesNV>;
22135pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR>;
22136pub type PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV>;
22137pub type PFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceCooperativeVectorPropertiesNV>;
22138pub type PFN_vkGetPhysicalDeviceDescriptorSizeEXT = Option<NonNullPFN_vkGetPhysicalDeviceDescriptorSizeEXT>;
22139pub type PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR>;
22140pub type PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR>;
22141pub type PFN_vkGetPhysicalDeviceDisplayProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayProperties2KHR>;
22142pub type PFN_vkGetPhysicalDeviceDisplayPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceDisplayPropertiesKHR>;
22143pub type PFN_vkGetPhysicalDeviceExternalBufferProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalBufferProperties>;
22144pub type PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR>;
22145pub type PFN_vkGetPhysicalDeviceExternalFenceProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalFenceProperties>;
22146pub type PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalFencePropertiesKHR>;
22147pub type PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = Option<NonNullPFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV>;
22148pub type PFN_vkGetPhysicalDeviceExternalSemaphoreProperties = Option<NonNullPFN_vkGetPhysicalDeviceExternalSemaphoreProperties>;
22149pub type PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR>;
22150pub type PFN_vkGetPhysicalDeviceExternalTensorPropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceExternalTensorPropertiesARM>;
22151pub type PFN_vkGetPhysicalDeviceFeatures = Option<NonNullPFN_vkGetPhysicalDeviceFeatures>;
22152pub type PFN_vkGetPhysicalDeviceFeatures2 = Option<NonNullPFN_vkGetPhysicalDeviceFeatures2>;
22153pub type PFN_vkGetPhysicalDeviceFeatures2KHR = Option<NonNullPFN_vkGetPhysicalDeviceFeatures2KHR>;
22154pub type PFN_vkGetPhysicalDeviceFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties>;
22155pub type PFN_vkGetPhysicalDeviceFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties2>;
22156pub type PFN_vkGetPhysicalDeviceFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceFormatProperties2KHR>;
22157pub type PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR = Option<NonNullPFN_vkGetPhysicalDeviceFragmentShadingRatesKHR>;
22158pub type PFN_vkGetPhysicalDeviceImageFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties>;
22159pub type PFN_vkGetPhysicalDeviceImageFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2>;
22160pub type PFN_vkGetPhysicalDeviceImageFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceImageFormatProperties2KHR>;
22161pub type PFN_vkGetPhysicalDeviceMemoryProperties = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties>;
22162pub type PFN_vkGetPhysicalDeviceMemoryProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties2>;
22163pub type PFN_vkGetPhysicalDeviceMemoryProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceMemoryProperties2KHR>;
22164pub type PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT = Option<NonNullPFN_vkGetPhysicalDeviceMultisamplePropertiesEXT>;
22165pub type PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = Option<NonNullPFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV>;
22166pub type PFN_vkGetPhysicalDevicePresentRectanglesKHR = Option<NonNullPFN_vkGetPhysicalDevicePresentRectanglesKHR>;
22167pub type PFN_vkGetPhysicalDeviceProperties = Option<NonNullPFN_vkGetPhysicalDeviceProperties>;
22168pub type PFN_vkGetPhysicalDeviceProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceProperties2>;
22169pub type PFN_vkGetPhysicalDeviceProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceProperties2KHR>;
22170pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphProcessingEnginePropertiesARM>;
22171pub type PFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyDataGraphPropertiesARM>;
22172pub type PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR>;
22173pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties>;
22174pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2>;
22175pub type PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR>;
22176pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties>;
22177pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2>;
22178pub type PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR>;
22179pub type PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = Option<NonNullPFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV>;
22180pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT>;
22181pub type PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR>;
22182pub type PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR>;
22183pub type PFN_vkGetPhysicalDeviceSurfaceFormats2KHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceFormats2KHR>;
22184pub type PFN_vkGetPhysicalDeviceSurfaceFormatsKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceFormatsKHR>;
22185pub type PFN_vkGetPhysicalDeviceSurfacePresentModesKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfacePresentModesKHR>;
22186pub type PFN_vkGetPhysicalDeviceSurfaceSupportKHR = Option<NonNullPFN_vkGetPhysicalDeviceSurfaceSupportKHR>;
22187pub type PFN_vkGetPhysicalDeviceToolProperties = Option<NonNullPFN_vkGetPhysicalDeviceToolProperties>;
22188pub type PFN_vkGetPhysicalDeviceToolPropertiesEXT = Option<NonNullPFN_vkGetPhysicalDeviceToolPropertiesEXT>;
22189pub type PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoCapabilitiesKHR>;
22190pub type PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR>;
22191pub type PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR = Option<NonNullPFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR>;
22192pub type PFN_vkGetPipelineBinaryDataKHR = Option<NonNullPFN_vkGetPipelineBinaryDataKHR>;
22193pub type PFN_vkGetPipelineCacheData = Option<NonNullPFN_vkGetPipelineCacheData>;
22194pub type PFN_vkGetPipelineExecutableInternalRepresentationsKHR = Option<NonNullPFN_vkGetPipelineExecutableInternalRepresentationsKHR>;
22195pub type PFN_vkGetPipelineExecutablePropertiesKHR = Option<NonNullPFN_vkGetPipelineExecutablePropertiesKHR>;
22196pub type PFN_vkGetPipelineExecutableStatisticsKHR = Option<NonNullPFN_vkGetPipelineExecutableStatisticsKHR>;
22197pub type PFN_vkGetPipelineIndirectDeviceAddressNV = Option<NonNullPFN_vkGetPipelineIndirectDeviceAddressNV>;
22198pub type PFN_vkGetPipelineIndirectMemoryRequirementsNV = Option<NonNullPFN_vkGetPipelineIndirectMemoryRequirementsNV>;
22199pub type PFN_vkGetPipelineKeyKHR = Option<NonNullPFN_vkGetPipelineKeyKHR>;
22200pub type PFN_vkGetPipelinePropertiesEXT = Option<NonNullPFN_vkGetPipelinePropertiesEXT>;
22201pub type PFN_vkGetPrivateData = Option<NonNullPFN_vkGetPrivateData>;
22202pub type PFN_vkGetPrivateDataEXT = Option<NonNullPFN_vkGetPrivateDataEXT>;
22203pub type PFN_vkGetQueryPoolResults = Option<NonNullPFN_vkGetQueryPoolResults>;
22204pub type PFN_vkGetQueueCheckpointData2NV = Option<NonNullPFN_vkGetQueueCheckpointData2NV>;
22205pub type PFN_vkGetQueueCheckpointDataNV = Option<NonNullPFN_vkGetQueueCheckpointDataNV>;
22206pub type PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = Option<NonNullPFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR>;
22207pub type PFN_vkGetRayTracingShaderGroupHandlesKHR = Option<NonNullPFN_vkGetRayTracingShaderGroupHandlesKHR>;
22208pub type PFN_vkGetRayTracingShaderGroupHandlesNV = Option<NonNullPFN_vkGetRayTracingShaderGroupHandlesNV>;
22209pub type PFN_vkGetRayTracingShaderGroupStackSizeKHR = Option<NonNullPFN_vkGetRayTracingShaderGroupStackSizeKHR>;
22210pub type PFN_vkGetRefreshCycleDurationGOOGLE = Option<NonNullPFN_vkGetRefreshCycleDurationGOOGLE>;
22211pub type PFN_vkGetRenderAreaGranularity = Option<NonNullPFN_vkGetRenderAreaGranularity>;
22212pub type PFN_vkGetRenderingAreaGranularity = Option<NonNullPFN_vkGetRenderingAreaGranularity>;
22213pub type PFN_vkGetRenderingAreaGranularityKHR = Option<NonNullPFN_vkGetRenderingAreaGranularityKHR>;
22214pub type PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT = Option<NonNullPFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT>;
22215pub type PFN_vkGetSemaphoreCounterValue = Option<NonNullPFN_vkGetSemaphoreCounterValue>;
22216pub type PFN_vkGetSemaphoreCounterValueKHR = Option<NonNullPFN_vkGetSemaphoreCounterValueKHR>;
22217pub type PFN_vkGetSemaphoreFdKHR = Option<NonNullPFN_vkGetSemaphoreFdKHR>;
22218pub type PFN_vkGetShaderBinaryDataEXT = Option<NonNullPFN_vkGetShaderBinaryDataEXT>;
22219pub type PFN_vkGetShaderInfoAMD = Option<NonNullPFN_vkGetShaderInfoAMD>;
22220pub type PFN_vkGetShaderModuleCreateInfoIdentifierEXT = Option<NonNullPFN_vkGetShaderModuleCreateInfoIdentifierEXT>;
22221pub type PFN_vkGetShaderModuleIdentifierEXT = Option<NonNullPFN_vkGetShaderModuleIdentifierEXT>;
22222pub type PFN_vkGetSwapchainCounterEXT = Option<NonNullPFN_vkGetSwapchainCounterEXT>;
22223pub type PFN_vkGetSwapchainImagesKHR = Option<NonNullPFN_vkGetSwapchainImagesKHR>;
22224pub type PFN_vkGetSwapchainStatusKHR = Option<NonNullPFN_vkGetSwapchainStatusKHR>;
22225pub type PFN_vkGetSwapchainTimeDomainPropertiesEXT = Option<NonNullPFN_vkGetSwapchainTimeDomainPropertiesEXT>;
22226pub type PFN_vkGetSwapchainTimingPropertiesEXT = Option<NonNullPFN_vkGetSwapchainTimingPropertiesEXT>;
22227pub type PFN_vkGetTensorMemoryRequirementsARM = Option<NonNullPFN_vkGetTensorMemoryRequirementsARM>;
22228pub type PFN_vkGetTensorOpaqueCaptureDataARM = Option<NonNullPFN_vkGetTensorOpaqueCaptureDataARM>;
22229pub type PFN_vkGetTensorOpaqueCaptureDescriptorDataARM = Option<NonNullPFN_vkGetTensorOpaqueCaptureDescriptorDataARM>;
22230pub type PFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM = Option<NonNullPFN_vkGetTensorViewOpaqueCaptureDescriptorDataARM>;
22231pub type PFN_vkGetValidationCacheDataEXT = Option<NonNullPFN_vkGetValidationCacheDataEXT>;
22232pub type PFN_vkGetVideoSessionMemoryRequirementsKHR = Option<NonNullPFN_vkGetVideoSessionMemoryRequirementsKHR>;
22233pub type PFN_vkImportFenceFdKHR = Option<NonNullPFN_vkImportFenceFdKHR>;
22234pub type PFN_vkImportSemaphoreFdKHR = Option<NonNullPFN_vkImportSemaphoreFdKHR>;
22235pub type PFN_vkInitializePerformanceApiINTEL = Option<NonNullPFN_vkInitializePerformanceApiINTEL>;
22236pub type PFN_vkInternalAllocationNotification = Option<NonNullPFN_vkInternalAllocationNotification>;
22237pub type PFN_vkInternalFreeNotification = Option<NonNullPFN_vkInternalFreeNotification>;
22238pub type PFN_vkInvalidateMappedMemoryRanges = Option<NonNullPFN_vkInvalidateMappedMemoryRanges>;
22239pub type PFN_vkLatencySleepNV = Option<NonNullPFN_vkLatencySleepNV>;
22240pub type PFN_vkMapMemory = Option<NonNullPFN_vkMapMemory>;
22241pub type PFN_vkMapMemory2 = Option<NonNullPFN_vkMapMemory2>;
22242pub type PFN_vkMapMemory2KHR = Option<NonNullPFN_vkMapMemory2KHR>;
22243pub type PFN_vkMergePipelineCaches = Option<NonNullPFN_vkMergePipelineCaches>;
22244pub type PFN_vkMergeValidationCachesEXT = Option<NonNullPFN_vkMergeValidationCachesEXT>;
22245pub type PFN_vkQueueBeginDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueBeginDebugUtilsLabelEXT>;
22246pub type PFN_vkQueueBindSparse = Option<NonNullPFN_vkQueueBindSparse>;
22247pub type PFN_vkQueueEndDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueEndDebugUtilsLabelEXT>;
22248pub type PFN_vkQueueInsertDebugUtilsLabelEXT = Option<NonNullPFN_vkQueueInsertDebugUtilsLabelEXT>;
22249pub type PFN_vkQueueNotifyOutOfBandNV = Option<NonNullPFN_vkQueueNotifyOutOfBandNV>;
22250pub type PFN_vkQueuePresentKHR = Option<NonNullPFN_vkQueuePresentKHR>;
22251pub type PFN_vkQueueSetPerformanceConfigurationINTEL = Option<NonNullPFN_vkQueueSetPerformanceConfigurationINTEL>;
22252pub type PFN_vkQueueSubmit = Option<NonNullPFN_vkQueueSubmit>;
22253pub type PFN_vkQueueSubmit2 = Option<NonNullPFN_vkQueueSubmit2>;
22254pub type PFN_vkQueueSubmit2KHR = Option<NonNullPFN_vkQueueSubmit2KHR>;
22255pub type PFN_vkQueueWaitIdle = Option<NonNullPFN_vkQueueWaitIdle>;
22256pub type PFN_vkReallocationFunction = Option<NonNullPFN_vkReallocationFunction>;
22257pub type PFN_vkRegisterCustomBorderColorEXT = Option<NonNullPFN_vkRegisterCustomBorderColorEXT>;
22258pub type PFN_vkRegisterDeviceEventEXT = Option<NonNullPFN_vkRegisterDeviceEventEXT>;
22259pub type PFN_vkRegisterDisplayEventEXT = Option<NonNullPFN_vkRegisterDisplayEventEXT>;
22260pub type PFN_vkReleaseCapturedPipelineDataKHR = Option<NonNullPFN_vkReleaseCapturedPipelineDataKHR>;
22261pub type PFN_vkReleaseDisplayEXT = Option<NonNullPFN_vkReleaseDisplayEXT>;
22262pub type PFN_vkReleasePerformanceConfigurationINTEL = Option<NonNullPFN_vkReleasePerformanceConfigurationINTEL>;
22263pub type PFN_vkReleaseProfilingLockKHR = Option<NonNullPFN_vkReleaseProfilingLockKHR>;
22264pub type PFN_vkReleaseSwapchainImagesEXT = Option<NonNullPFN_vkReleaseSwapchainImagesEXT>;
22265pub type PFN_vkReleaseSwapchainImagesKHR = Option<NonNullPFN_vkReleaseSwapchainImagesKHR>;
22266pub type PFN_vkResetCommandBuffer = Option<NonNullPFN_vkResetCommandBuffer>;
22267pub type PFN_vkResetCommandPool = Option<NonNullPFN_vkResetCommandPool>;
22268pub type PFN_vkResetDescriptorPool = Option<NonNullPFN_vkResetDescriptorPool>;
22269pub type PFN_vkResetEvent = Option<NonNullPFN_vkResetEvent>;
22270pub type PFN_vkResetFences = Option<NonNullPFN_vkResetFences>;
22271pub type PFN_vkResetQueryPool = Option<NonNullPFN_vkResetQueryPool>;
22272pub type PFN_vkResetQueryPoolEXT = Option<NonNullPFN_vkResetQueryPoolEXT>;
22273pub type PFN_vkSetDebugUtilsObjectNameEXT = Option<NonNullPFN_vkSetDebugUtilsObjectNameEXT>;
22274pub type PFN_vkSetDebugUtilsObjectTagEXT = Option<NonNullPFN_vkSetDebugUtilsObjectTagEXT>;
22275pub type PFN_vkSetDeviceMemoryPriorityEXT = Option<NonNullPFN_vkSetDeviceMemoryPriorityEXT>;
22276pub type PFN_vkSetEvent = Option<NonNullPFN_vkSetEvent>;
22277pub type PFN_vkSetHdrMetadataEXT = Option<NonNullPFN_vkSetHdrMetadataEXT>;
22278pub type PFN_vkSetLatencyMarkerNV = Option<NonNullPFN_vkSetLatencyMarkerNV>;
22279pub type PFN_vkSetLatencySleepModeNV = Option<NonNullPFN_vkSetLatencySleepModeNV>;
22280pub type PFN_vkSetLocalDimmingAMD = Option<NonNullPFN_vkSetLocalDimmingAMD>;
22281pub type PFN_vkSetPrivateData = Option<NonNullPFN_vkSetPrivateData>;
22282pub type PFN_vkSetPrivateDataEXT = Option<NonNullPFN_vkSetPrivateDataEXT>;
22283pub type PFN_vkSetSwapchainPresentTimingQueueSizeEXT = Option<NonNullPFN_vkSetSwapchainPresentTimingQueueSizeEXT>;
22284pub type PFN_vkSignalSemaphore = Option<NonNullPFN_vkSignalSemaphore>;
22285pub type PFN_vkSignalSemaphoreKHR = Option<NonNullPFN_vkSignalSemaphoreKHR>;
22286pub type PFN_vkSubmitDebugUtilsMessageEXT = Option<NonNullPFN_vkSubmitDebugUtilsMessageEXT>;
22287pub type PFN_vkTransitionImageLayout = Option<NonNullPFN_vkTransitionImageLayout>;
22288pub type PFN_vkTransitionImageLayoutEXT = Option<NonNullPFN_vkTransitionImageLayoutEXT>;
22289pub type PFN_vkTrimCommandPool = Option<NonNullPFN_vkTrimCommandPool>;
22290pub type PFN_vkTrimCommandPoolKHR = Option<NonNullPFN_vkTrimCommandPoolKHR>;
22291pub type PFN_vkUninitializePerformanceApiINTEL = Option<NonNullPFN_vkUninitializePerformanceApiINTEL>;
22292pub type PFN_vkUnmapMemory = Option<NonNullPFN_vkUnmapMemory>;
22293pub type PFN_vkUnmapMemory2 = Option<NonNullPFN_vkUnmapMemory2>;
22294pub type PFN_vkUnmapMemory2KHR = Option<NonNullPFN_vkUnmapMemory2KHR>;
22295pub type PFN_vkUnregisterCustomBorderColorEXT = Option<NonNullPFN_vkUnregisterCustomBorderColorEXT>;
22296pub type PFN_vkUpdateDescriptorSetWithTemplate = Option<NonNullPFN_vkUpdateDescriptorSetWithTemplate>;
22297pub type PFN_vkUpdateDescriptorSetWithTemplateKHR = Option<NonNullPFN_vkUpdateDescriptorSetWithTemplateKHR>;
22298pub type PFN_vkUpdateDescriptorSets = Option<NonNullPFN_vkUpdateDescriptorSets>;
22299pub type PFN_vkUpdateIndirectExecutionSetPipelineEXT = Option<NonNullPFN_vkUpdateIndirectExecutionSetPipelineEXT>;
22300pub type PFN_vkUpdateIndirectExecutionSetShaderEXT = Option<NonNullPFN_vkUpdateIndirectExecutionSetShaderEXT>;
22301pub type PFN_vkUpdateVideoSessionParametersKHR = Option<NonNullPFN_vkUpdateVideoSessionParametersKHR>;
22302pub type PFN_vkVoidFunction = Option<NonNullPFN_vkVoidFunction>;
22303pub type PFN_vkWaitForFences = Option<NonNullPFN_vkWaitForFences>;
22304pub type PFN_vkWaitForPresent2KHR = Option<NonNullPFN_vkWaitForPresent2KHR>;
22305pub type PFN_vkWaitForPresentKHR = Option<NonNullPFN_vkWaitForPresentKHR>;
22306pub type PFN_vkWaitSemaphores = Option<NonNullPFN_vkWaitSemaphores>;
22307pub type PFN_vkWaitSemaphoresKHR = Option<NonNullPFN_vkWaitSemaphoresKHR>;
22308pub type PFN_vkWriteAccelerationStructuresPropertiesKHR = Option<NonNullPFN_vkWriteAccelerationStructuresPropertiesKHR>;
22309pub type PFN_vkWriteMicromapsPropertiesEXT = Option<NonNullPFN_vkWriteMicromapsPropertiesEXT>;
22310pub type PFN_vkWriteResourceDescriptorsEXT = Option<NonNullPFN_vkWriteResourceDescriptorsEXT>;
22311pub type PFN_vkWriteSamplerDescriptorsEXT = Option<NonNullPFN_vkWriteSamplerDescriptorsEXT>;
22312pub type VkAabbPositionsNV = VkAabbPositionsKHR;
22313pub type VkAccelerationStructureBuildTypeKHR = i32;
22314pub type VkAccelerationStructureCompatibilityKHR = i32;
22315pub type VkAccelerationStructureCreateFlagBitsKHR = VkFlags;
22316pub type VkAccelerationStructureCreateFlagsKHR = VkFlags;
22317pub type VkAccelerationStructureInstanceNV = VkAccelerationStructureInstanceKHR;
22318pub type VkAccelerationStructureKHR = *mut VkAccelerationStructureKHR_T;
22319pub type VkAccelerationStructureMemoryRequirementsTypeNV = i32;
22320pub type VkAccelerationStructureMotionInfoFlagsNV = VkFlags;
22321pub type VkAccelerationStructureMotionInstanceFlagsNV = VkFlags;
22322pub type VkAccelerationStructureMotionInstanceTypeNV = i32;
22323pub type VkAccelerationStructureNV = *mut VkAccelerationStructureNV_T;
22324pub type VkAccelerationStructureTypeKHR = i32;
22325pub type VkAccelerationStructureTypeNV = VkAccelerationStructureTypeKHR;
22326pub type VkAccessFlagBits = VkFlags;
22327pub type VkAccessFlagBits2 = VkFlags64;
22328pub type VkAccessFlagBits2KHR = VkAccessFlagBits2;
22329pub type VkAccessFlagBits3KHR = VkFlags64;
22330pub type VkAccessFlags = VkFlags;
22331pub type VkAccessFlags2 = VkFlags64;
22332pub type VkAccessFlags2KHR = VkAccessFlags2;
22333pub type VkAccessFlags3KHR = VkFlags64;
22334pub type VkAcquireProfilingLockFlagBitsKHR = VkFlags;
22335pub type VkAcquireProfilingLockFlagsKHR = VkFlags;
22336pub type VkAddressCopyFlagBitsKHR = VkFlags;
22337pub type VkAddressCopyFlagsKHR = VkFlags;
22338pub type VkAntiLagModeAMD = i32;
22339pub type VkAntiLagStageAMD = i32;
22340pub type VkAttachmentDescription2KHR = VkAttachmentDescription2;
22341pub type VkAttachmentDescriptionFlagBits = VkFlags;
22342pub type VkAttachmentDescriptionFlags = VkFlags;
22343pub type VkAttachmentDescriptionStencilLayoutKHR = VkAttachmentDescriptionStencilLayout;
22344pub type VkAttachmentLoadOp = i32;
22345pub type VkAttachmentReference2KHR = VkAttachmentReference2;
22346pub type VkAttachmentReferenceStencilLayoutKHR = VkAttachmentReferenceStencilLayout;
22347pub type VkAttachmentSampleCountInfoNV = VkAttachmentSampleCountInfoAMD;
22348pub type VkAttachmentStoreOp = i32;
22349pub type VkBindBufferMemoryDeviceGroupInfoKHR = VkBindBufferMemoryDeviceGroupInfo;
22350pub type VkBindBufferMemoryInfoKHR = VkBindBufferMemoryInfo;
22351pub type VkBindDescriptorSetsInfoKHR = VkBindDescriptorSetsInfo;
22352pub type VkBindImageMemoryDeviceGroupInfoKHR = VkBindImageMemoryDeviceGroupInfo;
22353pub type VkBindImageMemoryInfoKHR = VkBindImageMemoryInfo;
22354pub type VkBindImagePlaneMemoryInfoKHR = VkBindImagePlaneMemoryInfo;
22355pub type VkBindMemoryStatusKHR = VkBindMemoryStatus;
22356pub type VkBlendFactor = i32;
22357pub type VkBlendOp = i32;
22358pub type VkBlendOverlapEXT = i32;
22359pub type VkBlitImageInfo2KHR = VkBlitImageInfo2;
22360pub type VkBlockMatchWindowCompareModeQCOM = i32;
22361pub type VkBool32 = u32;
22362pub type VkBorderColor = i32;
22363pub type VkBuffer = *mut VkBuffer_T;
22364pub type VkBufferCopy2KHR = VkBufferCopy2;
22365pub type VkBufferCreateFlagBits = VkFlags;
22366pub type VkBufferCreateFlags = VkFlags;
22367pub type VkBufferDeviceAddressInfoEXT = VkBufferDeviceAddressInfo;
22368pub type VkBufferDeviceAddressInfoKHR = VkBufferDeviceAddressInfo;
22369pub type VkBufferImageCopy2KHR = VkBufferImageCopy2;
22370pub type VkBufferMemoryBarrier2KHR = VkBufferMemoryBarrier2;
22371pub type VkBufferMemoryRequirementsInfo2KHR = VkBufferMemoryRequirementsInfo2;
22372pub type VkBufferOpaqueCaptureAddressCreateInfoKHR = VkBufferOpaqueCaptureAddressCreateInfo;
22373pub type VkBufferUsageFlagBits = VkFlags;
22374pub type VkBufferUsageFlagBits2 = VkFlags64;
22375pub type VkBufferUsageFlagBits2KHR = VkBufferUsageFlagBits2;
22376pub type VkBufferUsageFlags = VkFlags;
22377pub type VkBufferUsageFlags2 = VkFlags64;
22378pub type VkBufferUsageFlags2CreateInfoKHR = VkBufferUsageFlags2CreateInfo;
22379pub type VkBufferUsageFlags2KHR = VkBufferUsageFlags2;
22380pub type VkBufferView = *mut VkBufferView_T;
22381pub type VkBufferViewCreateFlags = VkFlags;
22382pub type VkBuildAccelerationStructureFlagBitsKHR = VkFlags;
22383pub type VkBuildAccelerationStructureFlagBitsNV = VkBuildAccelerationStructureFlagBitsKHR;
22384pub type VkBuildAccelerationStructureFlagsKHR = VkFlags;
22385pub type VkBuildAccelerationStructureFlagsNV = VkBuildAccelerationStructureFlagsKHR;
22386pub type VkBuildAccelerationStructureModeKHR = i32;
22387pub type VkBuildMicromapFlagBitsEXT = VkFlags;
22388pub type VkBuildMicromapFlagsEXT = VkFlags;
22389pub type VkBuildMicromapModeEXT = i32;
22390pub type VkCalibratedTimestampInfoEXT = VkCalibratedTimestampInfoKHR;
22391pub type VkChromaLocation = i32;
22392pub type VkChromaLocationKHR = VkChromaLocation;
22393pub type VkClusterAccelerationStructureAddressResolutionFlagBitsNV = VkFlags;
22394pub type VkClusterAccelerationStructureAddressResolutionFlagsNV = VkFlags;
22395pub type VkClusterAccelerationStructureClusterFlagBitsNV = VkFlags;
22396pub type VkClusterAccelerationStructureClusterFlagsNV = VkFlags;
22397pub type VkClusterAccelerationStructureGeometryFlagBitsNV = VkFlags;
22398pub type VkClusterAccelerationStructureGeometryFlagsNV = VkFlags;
22399pub type VkClusterAccelerationStructureIndexFormatFlagBitsNV = VkFlags;
22400pub type VkClusterAccelerationStructureIndexFormatFlagsNV = VkFlags;
22401pub type VkClusterAccelerationStructureOpModeNV = i32;
22402pub type VkClusterAccelerationStructureOpTypeNV = i32;
22403pub type VkClusterAccelerationStructureTypeNV = i32;
22404pub type VkCoarseSampleOrderTypeNV = i32;
22405pub type VkColorComponentFlagBits = VkFlags;
22406pub type VkColorComponentFlags = VkFlags;
22407pub type VkColorSpaceKHR = i32;
22408pub type VkCommandBuffer = *mut VkCommandBuffer_T;
22409pub type VkCommandBufferInheritanceRenderingInfoKHR = VkCommandBufferInheritanceRenderingInfo;
22410pub type VkCommandBufferLevel = i32;
22411pub type VkCommandBufferResetFlagBits = VkFlags;
22412pub type VkCommandBufferResetFlags = VkFlags;
22413pub type VkCommandBufferSubmitInfoKHR = VkCommandBufferSubmitInfo;
22414pub type VkCommandBufferUsageFlagBits = VkFlags;
22415pub type VkCommandBufferUsageFlags = VkFlags;
22416pub type VkCommandPool = *mut VkCommandPool_T;
22417pub type VkCommandPoolCreateFlagBits = VkFlags;
22418pub type VkCommandPoolCreateFlags = VkFlags;
22419pub type VkCommandPoolResetFlagBits = VkFlags;
22420pub type VkCommandPoolResetFlags = VkFlags;
22421pub type VkCommandPoolTrimFlags = VkFlags;
22422pub type VkCommandPoolTrimFlagsKHR = VkCommandPoolTrimFlags;
22423pub type VkCompareOp = i32;
22424pub type VkComponentSwizzle = i32;
22425pub type VkComponentTypeKHR = i32;
22426pub type VkComponentTypeNV = VkComponentTypeKHR;
22427pub type VkCompositeAlphaFlagBitsKHR = VkFlags;
22428pub type VkCompositeAlphaFlagsKHR = VkFlags;
22429pub type VkConditionalRenderingFlagBitsEXT = VkFlags;
22430pub type VkConditionalRenderingFlagsEXT = VkFlags;
22431pub type VkConformanceVersionKHR = VkConformanceVersion;
22432pub type VkConservativeRasterizationModeEXT = i32;
22433pub type VkCooperativeVectorMatrixLayoutNV = i32;
22434pub type VkCopyAccelerationStructureModeKHR = i32;
22435pub type VkCopyAccelerationStructureModeNV = VkCopyAccelerationStructureModeKHR;
22436pub type VkCopyBufferInfo2KHR = VkCopyBufferInfo2;
22437pub type VkCopyBufferToImageInfo2KHR = VkCopyBufferToImageInfo2;
22438pub type VkCopyImageInfo2KHR = VkCopyImageInfo2;
22439pub type VkCopyImageToBufferInfo2KHR = VkCopyImageToBufferInfo2;
22440pub type VkCopyImageToImageInfoEXT = VkCopyImageToImageInfo;
22441pub type VkCopyImageToMemoryInfoEXT = VkCopyImageToMemoryInfo;
22442pub type VkCopyMemoryIndirectCommandNV = VkCopyMemoryIndirectCommandKHR;
22443pub type VkCopyMemoryToImageIndirectCommandNV = VkCopyMemoryToImageIndirectCommandKHR;
22444pub type VkCopyMemoryToImageInfoEXT = VkCopyMemoryToImageInfo;
22445pub type VkCopyMicromapModeEXT = i32;
22446pub type VkCoverageModulationModeNV = i32;
22447pub type VkCoverageReductionModeNV = i32;
22448pub type VkCuFunctionNVX = *mut VkCuFunctionNVX_T;
22449pub type VkCuModuleNVX = *mut VkCuModuleNVX_T;
22450pub type VkCubicFilterWeightsQCOM = i32;
22451pub type VkCullModeFlagBits = VkFlags;
22452pub type VkCullModeFlags = VkFlags;
22453pub type VkDataGraphModelCacheTypeQCOM = i32;
22454pub type VkDataGraphPipelineDispatchFlagBitsARM = VkFlags64;
22455pub type VkDataGraphPipelineDispatchFlagsARM = VkFlags64;
22456pub type VkDataGraphPipelinePropertyARM = i32;
22457pub type VkDataGraphPipelineSessionARM = *mut VkDataGraphPipelineSessionARM_T;
22458pub type VkDataGraphPipelineSessionBindPointARM = i32;
22459pub type VkDataGraphPipelineSessionBindPointTypeARM = i32;
22460pub type VkDataGraphPipelineSessionCreateFlagBitsARM = VkFlags64;
22461pub type VkDataGraphPipelineSessionCreateFlagsARM = VkFlags64;
22462pub type VkDebugReportCallbackEXT = *mut VkDebugReportCallbackEXT_T;
22463pub type VkDebugReportFlagBitsEXT = VkFlags;
22464pub type VkDebugReportFlagsEXT = VkFlags;
22465pub type VkDebugReportObjectTypeEXT = i32;
22466pub type VkDebugUtilsMessageSeverityFlagBitsEXT = VkFlags;
22467pub type VkDebugUtilsMessageSeverityFlagsEXT = VkFlags;
22468pub type VkDebugUtilsMessageTypeFlagBitsEXT = VkFlags;
22469pub type VkDebugUtilsMessageTypeFlagsEXT = VkFlags;
22470pub type VkDebugUtilsMessengerCallbackDataFlagsEXT = VkFlags;
22471pub type VkDebugUtilsMessengerCreateFlagsEXT = VkFlags;
22472pub type VkDebugUtilsMessengerEXT = *mut VkDebugUtilsMessengerEXT_T;
22473pub type VkDefaultVertexAttributeValueKHR = i32;
22474pub type VkDeferredOperationKHR = *mut VkDeferredOperationKHR_T;
22475pub type VkDependencyFlagBits = VkFlags;
22476pub type VkDependencyFlags = VkFlags;
22477pub type VkDependencyInfoKHR = VkDependencyInfo;
22478pub type VkDepthBiasRepresentationEXT = i32;
22479pub type VkDepthClampModeEXT = i32;
22480pub type VkDescriptorBindingFlagBits = VkFlags;
22481pub type VkDescriptorBindingFlagBitsEXT = VkDescriptorBindingFlagBits;
22482pub type VkDescriptorBindingFlags = VkFlags;
22483pub type VkDescriptorBindingFlagsEXT = VkDescriptorBindingFlags;
22484pub type VkDescriptorMappingSourceEXT = i32;
22485pub type VkDescriptorPool = *mut VkDescriptorPool_T;
22486pub type VkDescriptorPoolCreateFlagBits = VkFlags;
22487pub type VkDescriptorPoolCreateFlags = VkFlags;
22488pub type VkDescriptorPoolInlineUniformBlockCreateInfoEXT = VkDescriptorPoolInlineUniformBlockCreateInfo;
22489pub type VkDescriptorPoolResetFlags = VkFlags;
22490pub type VkDescriptorSet = *mut VkDescriptorSet_T;
22491pub type VkDescriptorSetLayout = *mut VkDescriptorSetLayout_T;
22492pub type VkDescriptorSetLayoutBindingFlagsCreateInfoEXT = VkDescriptorSetLayoutBindingFlagsCreateInfo;
22493pub type VkDescriptorSetLayoutCreateFlagBits = VkFlags;
22494pub type VkDescriptorSetLayoutCreateFlags = VkFlags;
22495pub type VkDescriptorSetLayoutSupportKHR = VkDescriptorSetLayoutSupport;
22496pub type VkDescriptorSetVariableDescriptorCountAllocateInfoEXT = VkDescriptorSetVariableDescriptorCountAllocateInfo;
22497pub type VkDescriptorSetVariableDescriptorCountLayoutSupportEXT = VkDescriptorSetVariableDescriptorCountLayoutSupport;
22498pub type VkDescriptorType = i32;
22499pub type VkDescriptorUpdateTemplate = *mut VkDescriptorUpdateTemplate_T;
22500pub type VkDescriptorUpdateTemplateCreateFlags = VkFlags;
22501pub type VkDescriptorUpdateTemplateCreateFlagsKHR = VkDescriptorUpdateTemplateCreateFlags;
22502pub type VkDescriptorUpdateTemplateCreateInfoKHR = VkDescriptorUpdateTemplateCreateInfo;
22503pub type VkDescriptorUpdateTemplateEntryKHR = VkDescriptorUpdateTemplateEntry;
22504pub type VkDescriptorUpdateTemplateKHR = *mut VkDescriptorUpdateTemplateKHR_T;
22505pub type VkDescriptorUpdateTemplateKHR_T = VkDescriptorUpdateTemplate_T;
22506pub type VkDescriptorUpdateTemplateType = i32;
22507pub type VkDescriptorUpdateTemplateTypeKHR = VkDescriptorUpdateTemplateType;
22508pub type VkDevice = *mut VkDevice_T;
22509pub type VkDeviceAddress = u64;
22510pub type VkDeviceAddressBindingFlagBitsEXT = VkFlags;
22511pub type VkDeviceAddressBindingFlagsEXT = VkFlags;
22512pub type VkDeviceAddressBindingTypeEXT = i32;
22513pub type VkDeviceBufferMemoryRequirementsKHR = VkDeviceBufferMemoryRequirements;
22514pub type VkDeviceCreateFlags = VkFlags;
22515pub type VkDeviceDiagnosticsConfigFlagBitsNV = VkFlags;
22516pub type VkDeviceDiagnosticsConfigFlagsNV = VkFlags;
22517pub type VkDeviceEventTypeEXT = i32;
22518pub type VkDeviceFaultAddressTypeEXT = i32;
22519pub type VkDeviceFaultVendorBinaryHeaderVersionEXT = i32;
22520pub type VkDeviceGroupBindSparseInfoKHR = VkDeviceGroupBindSparseInfo;
22521pub type VkDeviceGroupCommandBufferBeginInfoKHR = VkDeviceGroupCommandBufferBeginInfo;
22522pub type VkDeviceGroupDeviceCreateInfoKHR = VkDeviceGroupDeviceCreateInfo;
22523pub type VkDeviceGroupPresentModeFlagBitsKHR = VkFlags;
22524pub type VkDeviceGroupPresentModeFlagsKHR = VkFlags;
22525pub type VkDeviceGroupRenderPassBeginInfoKHR = VkDeviceGroupRenderPassBeginInfo;
22526pub type VkDeviceGroupSubmitInfoKHR = VkDeviceGroupSubmitInfo;
22527pub type VkDeviceImageMemoryRequirementsKHR = VkDeviceImageMemoryRequirements;
22528pub type VkDeviceImageSubresourceInfoKHR = VkDeviceImageSubresourceInfo;
22529pub type VkDeviceMemory = *mut VkDeviceMemory_T;
22530pub type VkDeviceMemoryOpaqueCaptureAddressInfoKHR = VkDeviceMemoryOpaqueCaptureAddressInfo;
22531pub type VkDeviceMemoryReportEventTypeEXT = i32;
22532pub type VkDeviceMemoryReportFlagsEXT = VkFlags;
22533pub type VkDevicePrivateDataCreateInfoEXT = VkDevicePrivateDataCreateInfo;
22534pub type VkDeviceQueueCreateFlagBits = VkFlags;
22535pub type VkDeviceQueueCreateFlags = VkFlags;
22536pub type VkDeviceQueueGlobalPriorityCreateInfoEXT = VkDeviceQueueGlobalPriorityCreateInfo;
22537pub type VkDeviceQueueGlobalPriorityCreateInfoKHR = VkDeviceQueueGlobalPriorityCreateInfo;
22538pub type VkDeviceSize = u64;
22539pub type VkDirectDriverLoadingFlagsLUNARG = VkFlags;
22540pub type VkDirectDriverLoadingModeLUNARG = i32;
22541pub type VkDiscardRectangleModeEXT = i32;
22542pub type VkDisplayEventTypeEXT = i32;
22543pub type VkDisplayKHR = *mut VkDisplayKHR_T;
22544pub type VkDisplayModeCreateFlagsKHR = VkFlags;
22545pub type VkDisplayModeKHR = *mut VkDisplayModeKHR_T;
22546pub type VkDisplayPlaneAlphaFlagBitsKHR = VkFlags;
22547pub type VkDisplayPlaneAlphaFlagsKHR = VkFlags;
22548pub type VkDisplayPowerStateEXT = i32;
22549pub type VkDisplaySurfaceCreateFlagsKHR = VkFlags;
22550pub type VkDisplaySurfaceStereoTypeNV = i32;
22551pub type VkDriverId = i32;
22552pub type VkDriverIdKHR = VkDriverId;
22553pub type VkDynamicState = i32;
22554pub type VkEvent = *mut VkEvent_T;
22555pub type VkEventCreateFlagBits = VkFlags;
22556pub type VkEventCreateFlags = VkFlags;
22557pub type VkExportFenceCreateInfoKHR = VkExportFenceCreateInfo;
22558pub type VkExportMemoryAllocateInfoKHR = VkExportMemoryAllocateInfo;
22559pub type VkExportSemaphoreCreateInfoKHR = VkExportSemaphoreCreateInfo;
22560pub type VkExternalBufferPropertiesKHR = VkExternalBufferProperties;
22561pub type VkExternalComputeQueueNV = *mut VkExternalComputeQueueNV_T;
22562pub type VkExternalFenceFeatureFlagBits = VkFlags;
22563pub type VkExternalFenceFeatureFlagBitsKHR = VkExternalFenceFeatureFlagBits;
22564pub type VkExternalFenceFeatureFlags = VkFlags;
22565pub type VkExternalFenceFeatureFlagsKHR = VkExternalFenceFeatureFlags;
22566pub type VkExternalFenceHandleTypeFlagBits = VkFlags;
22567pub type VkExternalFenceHandleTypeFlagBitsKHR = VkExternalFenceHandleTypeFlagBits;
22568pub type VkExternalFenceHandleTypeFlags = VkFlags;
22569pub type VkExternalFenceHandleTypeFlagsKHR = VkExternalFenceHandleTypeFlags;
22570pub type VkExternalFencePropertiesKHR = VkExternalFenceProperties;
22571pub type VkExternalImageFormatPropertiesKHR = VkExternalImageFormatProperties;
22572pub type VkExternalMemoryBufferCreateInfoKHR = VkExternalMemoryBufferCreateInfo;
22573pub type VkExternalMemoryFeatureFlagBits = VkFlags;
22574pub type VkExternalMemoryFeatureFlagBitsKHR = VkExternalMemoryFeatureFlagBits;
22575pub type VkExternalMemoryFeatureFlagBitsNV = VkFlags;
22576pub type VkExternalMemoryFeatureFlags = VkFlags;
22577pub type VkExternalMemoryFeatureFlagsKHR = VkExternalMemoryFeatureFlags;
22578pub type VkExternalMemoryFeatureFlagsNV = VkFlags;
22579pub type VkExternalMemoryHandleTypeFlagBits = VkFlags;
22580pub type VkExternalMemoryHandleTypeFlagBitsKHR = VkExternalMemoryHandleTypeFlagBits;
22581pub type VkExternalMemoryHandleTypeFlagBitsNV = VkFlags;
22582pub type VkExternalMemoryHandleTypeFlags = VkFlags;
22583pub type VkExternalMemoryHandleTypeFlagsKHR = VkExternalMemoryHandleTypeFlags;
22584pub type VkExternalMemoryHandleTypeFlagsNV = VkFlags;
22585pub type VkExternalMemoryImageCreateInfoKHR = VkExternalMemoryImageCreateInfo;
22586pub type VkExternalMemoryPropertiesKHR = VkExternalMemoryProperties;
22587pub type VkExternalSemaphoreFeatureFlagBits = VkFlags;
22588pub type VkExternalSemaphoreFeatureFlagBitsKHR = VkExternalSemaphoreFeatureFlagBits;
22589pub type VkExternalSemaphoreFeatureFlags = VkFlags;
22590pub type VkExternalSemaphoreFeatureFlagsKHR = VkExternalSemaphoreFeatureFlags;
22591pub type VkExternalSemaphoreHandleTypeFlagBits = VkFlags;
22592pub type VkExternalSemaphoreHandleTypeFlagBitsKHR = VkExternalSemaphoreHandleTypeFlagBits;
22593pub type VkExternalSemaphoreHandleTypeFlags = VkFlags;
22594pub type VkExternalSemaphoreHandleTypeFlagsKHR = VkExternalSemaphoreHandleTypeFlags;
22595pub type VkExternalSemaphorePropertiesKHR = VkExternalSemaphoreProperties;
22596pub type VkFence = *mut VkFence_T;
22597pub type VkFenceCreateFlagBits = VkFlags;
22598pub type VkFenceCreateFlags = VkFlags;
22599pub type VkFenceImportFlagBits = VkFlags;
22600pub type VkFenceImportFlagBitsKHR = VkFenceImportFlagBits;
22601pub type VkFenceImportFlags = VkFlags;
22602pub type VkFenceImportFlagsKHR = VkFenceImportFlags;
22603pub type VkFilter = i32;
22604pub type VkFlags = u32;
22605pub type VkFlags64 = u64;
22606pub type VkFormat = i32;
22607pub type VkFormatFeatureFlagBits = VkFlags;
22608pub type VkFormatFeatureFlagBits2 = VkFlags64;
22609pub type VkFormatFeatureFlagBits2KHR = VkFormatFeatureFlagBits2;
22610pub type VkFormatFeatureFlags = VkFlags;
22611pub type VkFormatFeatureFlags2 = VkFlags64;
22612pub type VkFormatFeatureFlags2KHR = VkFormatFeatureFlags2;
22613pub type VkFormatProperties2KHR = VkFormatProperties2;
22614pub type VkFormatProperties3KHR = VkFormatProperties3;
22615pub type VkFragmentShadingRateCombinerOpKHR = i32;
22616pub type VkFragmentShadingRateNV = i32;
22617pub type VkFragmentShadingRateTypeNV = i32;
22618pub type VkFrameBoundaryFlagBitsEXT = VkFlags;
22619pub type VkFrameBoundaryFlagsEXT = VkFlags;
22620pub type VkFramebuffer = *mut VkFramebuffer_T;
22621pub type VkFramebufferAttachmentImageInfoKHR = VkFramebufferAttachmentImageInfo;
22622pub type VkFramebufferAttachmentsCreateInfoKHR = VkFramebufferAttachmentsCreateInfo;
22623pub type VkFramebufferCreateFlagBits = VkFlags;
22624pub type VkFramebufferCreateFlags = VkFlags;
22625pub type VkFrontFace = i32;
22626pub type VkGeometryFlagBitsKHR = VkFlags;
22627pub type VkGeometryFlagBitsNV = VkGeometryFlagBitsKHR;
22628pub type VkGeometryFlagsKHR = VkFlags;
22629pub type VkGeometryFlagsNV = VkGeometryFlagsKHR;
22630pub type VkGeometryInstanceFlagBitsKHR = VkFlags;
22631pub type VkGeometryInstanceFlagBitsNV = VkGeometryInstanceFlagBitsKHR;
22632pub type VkGeometryInstanceFlagsKHR = VkFlags;
22633pub type VkGeometryInstanceFlagsNV = VkGeometryInstanceFlagsKHR;
22634pub type VkGeometryTypeKHR = i32;
22635pub type VkGeometryTypeNV = VkGeometryTypeKHR;
22636pub type VkGraphicsPipelineLibraryFlagBitsEXT = VkFlags;
22637pub type VkGraphicsPipelineLibraryFlagsEXT = VkFlags;
22638pub type VkHeadlessSurfaceCreateFlagsEXT = VkFlags;
22639pub type VkHostImageCopyDevicePerformanceQueryEXT = VkHostImageCopyDevicePerformanceQuery;
22640pub type VkHostImageCopyFlagBits = VkFlags;
22641pub type VkHostImageCopyFlagBitsEXT = VkHostImageCopyFlagBits;
22642pub type VkHostImageCopyFlags = VkFlags;
22643pub type VkHostImageCopyFlagsEXT = VkHostImageCopyFlags;
22644pub type VkHostImageLayoutTransitionInfoEXT = VkHostImageLayoutTransitionInfo;
22645pub type VkImage = *mut VkImage_T;
22646pub type VkImageAspectFlagBits = VkFlags;
22647pub type VkImageAspectFlags = VkFlags;
22648pub type VkImageBlit2KHR = VkImageBlit2;
22649pub type VkImageCompressionFixedRateFlagBitsEXT = VkFlags;
22650pub type VkImageCompressionFixedRateFlagsEXT = VkFlags;
22651pub type VkImageCompressionFlagBitsEXT = VkFlags;
22652pub type VkImageCompressionFlagsEXT = VkFlags;
22653pub type VkImageCopy2KHR = VkImageCopy2;
22654pub type VkImageCreateFlagBits = VkFlags;
22655pub type VkImageCreateFlags = VkFlags;
22656pub type VkImageFormatListCreateInfoKHR = VkImageFormatListCreateInfo;
22657pub type VkImageFormatProperties2KHR = VkImageFormatProperties2;
22658pub type VkImageLayout = i32;
22659pub type VkImageMemoryBarrier2KHR = VkImageMemoryBarrier2;
22660pub type VkImageMemoryRequirementsInfo2KHR = VkImageMemoryRequirementsInfo2;
22661pub type VkImagePlaneMemoryRequirementsInfoKHR = VkImagePlaneMemoryRequirementsInfo;
22662pub type VkImageResolve2KHR = VkImageResolve2;
22663pub type VkImageSparseMemoryRequirementsInfo2KHR = VkImageSparseMemoryRequirementsInfo2;
22664pub type VkImageStencilUsageCreateInfoEXT = VkImageStencilUsageCreateInfo;
22665pub type VkImageSubresource2EXT = VkImageSubresource2;
22666pub type VkImageSubresource2KHR = VkImageSubresource2;
22667pub type VkImageTiling = i32;
22668pub type VkImageToMemoryCopyEXT = VkImageToMemoryCopy;
22669pub type VkImageType = i32;
22670pub type VkImageUsageFlagBits = VkFlags;
22671pub type VkImageUsageFlags = VkFlags;
22672pub type VkImageView = *mut VkImageView_T;
22673pub type VkImageViewCreateFlagBits = VkFlags;
22674pub type VkImageViewCreateFlags = VkFlags;
22675pub type VkImageViewType = i32;
22676pub type VkImageViewUsageCreateInfoKHR = VkImageViewUsageCreateInfo;
22677pub type VkIndexType = i32;
22678pub type VkIndirectCommandsInputModeFlagBitsEXT = VkFlags;
22679pub type VkIndirectCommandsInputModeFlagsEXT = VkFlags;
22680pub type VkIndirectCommandsLayoutEXT = *mut VkIndirectCommandsLayoutEXT_T;
22681pub type VkIndirectCommandsLayoutNV = *mut VkIndirectCommandsLayoutNV_T;
22682pub type VkIndirectCommandsLayoutUsageFlagBitsEXT = VkFlags;
22683pub type VkIndirectCommandsLayoutUsageFlagBitsNV = VkFlags;
22684pub type VkIndirectCommandsLayoutUsageFlagsEXT = VkFlags;
22685pub type VkIndirectCommandsLayoutUsageFlagsNV = VkFlags;
22686pub type VkIndirectCommandsTokenTypeEXT = i32;
22687pub type VkIndirectCommandsTokenTypeNV = i32;
22688pub type VkIndirectExecutionSetEXT = *mut VkIndirectExecutionSetEXT_T;
22689pub type VkIndirectExecutionSetInfoTypeEXT = i32;
22690pub type VkIndirectStateFlagBitsNV = VkFlags;
22691pub type VkIndirectStateFlagsNV = VkFlags;
22692pub type VkInputAttachmentAspectReferenceKHR = VkInputAttachmentAspectReference;
22693pub type VkInstance = *mut VkInstance_T;
22694pub type VkInstanceCreateFlagBits = VkFlags;
22695pub type VkInstanceCreateFlags = VkFlags;
22696pub type VkInternalAllocationType = i32;
22697pub type VkLatencyMarkerNV = i32;
22698pub type VkLayerSettingTypeEXT = i32;
22699pub type VkLayeredDriverUnderlyingApiMSFT = i32;
22700pub type VkLineRasterizationMode = i32;
22701pub type VkLineRasterizationModeEXT = VkLineRasterizationMode;
22702pub type VkLineRasterizationModeKHR = VkLineRasterizationMode;
22703pub type VkLogicOp = i32;
22704pub type VkMemoryAllocateFlagBits = VkFlags;
22705pub type VkMemoryAllocateFlagBitsKHR = VkMemoryAllocateFlagBits;
22706pub type VkMemoryAllocateFlags = VkFlags;
22707pub type VkMemoryAllocateFlagsInfoKHR = VkMemoryAllocateFlagsInfo;
22708pub type VkMemoryAllocateFlagsKHR = VkMemoryAllocateFlags;
22709pub type VkMemoryBarrier2KHR = VkMemoryBarrier2;
22710pub type VkMemoryDecompressionMethodFlagBitsEXT = VkFlags64;
22711pub type VkMemoryDecompressionMethodFlagBitsNV = VkMemoryDecompressionMethodFlagBitsEXT;
22712pub type VkMemoryDecompressionMethodFlagsEXT = VkFlags64;
22713pub type VkMemoryDecompressionMethodFlagsNV = VkMemoryDecompressionMethodFlagsEXT;
22714pub type VkMemoryDedicatedAllocateInfoKHR = VkMemoryDedicatedAllocateInfo;
22715pub type VkMemoryDedicatedRequirementsKHR = VkMemoryDedicatedRequirements;
22716pub type VkMemoryHeapFlagBits = VkFlags;
22717pub type VkMemoryHeapFlags = VkFlags;
22718pub type VkMemoryMapFlagBits = VkFlags;
22719pub type VkMemoryMapFlags = VkFlags;
22720pub type VkMemoryMapInfoKHR = VkMemoryMapInfo;
22721pub type VkMemoryOpaqueCaptureAddressAllocateInfoKHR = VkMemoryOpaqueCaptureAddressAllocateInfo;
22722pub type VkMemoryOverallocationBehaviorAMD = i32;
22723pub type VkMemoryPropertyFlagBits = VkFlags;
22724pub type VkMemoryPropertyFlags = VkFlags;
22725pub type VkMemoryRequirements2KHR = VkMemoryRequirements2;
22726pub type VkMemoryToImageCopyEXT = VkMemoryToImageCopy;
22727pub type VkMemoryUnmapFlagBits = VkFlags;
22728pub type VkMemoryUnmapFlagBitsKHR = VkMemoryUnmapFlagBits;
22729pub type VkMemoryUnmapFlags = VkFlags;
22730pub type VkMemoryUnmapFlagsKHR = VkMemoryUnmapFlags;
22731pub type VkMemoryUnmapInfoKHR = VkMemoryUnmapInfo;
22732pub type VkMicromapCreateFlagBitsEXT = VkFlags;
22733pub type VkMicromapCreateFlagsEXT = VkFlags;
22734pub type VkMicromapEXT = *mut VkMicromapEXT_T;
22735pub type VkMicromapTypeEXT = i32;
22736pub type VkMutableDescriptorTypeCreateInfoVALVE = VkMutableDescriptorTypeCreateInfoEXT;
22737pub type VkMutableDescriptorTypeListVALVE = VkMutableDescriptorTypeListEXT;
22738pub type VkObjectType = i32;
22739pub type VkOpacityMicromapFormatEXT = i32;
22740pub type VkOpacityMicromapSpecialIndexEXT = i32;
22741pub type VkOpticalFlowExecuteFlagBitsNV = VkFlags;
22742pub type VkOpticalFlowExecuteFlagsNV = VkFlags;
22743pub type VkOpticalFlowGridSizeFlagBitsNV = VkFlags;
22744pub type VkOpticalFlowGridSizeFlagsNV = VkFlags;
22745pub type VkOpticalFlowPerformanceLevelNV = i32;
22746pub type VkOpticalFlowSessionBindingPointNV = i32;
22747pub type VkOpticalFlowSessionCreateFlagBitsNV = VkFlags;
22748pub type VkOpticalFlowSessionCreateFlagsNV = VkFlags;
22749pub type VkOpticalFlowSessionNV = *mut VkOpticalFlowSessionNV_T;
22750pub type VkOpticalFlowUsageFlagBitsNV = VkFlags;
22751pub type VkOpticalFlowUsageFlagsNV = VkFlags;
22752pub type VkOutOfBandQueueTypeNV = i32;
22753pub type VkPartitionedAccelerationStructureInstanceFlagBitsNV = VkFlags;
22754pub type VkPartitionedAccelerationStructureInstanceFlagsNV = VkFlags;
22755pub type VkPartitionedAccelerationStructureOpTypeNV = i32;
22756pub type VkPastPresentationTimingFlagBitsEXT = VkFlags;
22757pub type VkPastPresentationTimingFlagsEXT = VkFlags;
22758pub type VkPeerMemoryFeatureFlagBits = VkFlags;
22759pub type VkPeerMemoryFeatureFlagBitsKHR = VkPeerMemoryFeatureFlagBits;
22760pub type VkPeerMemoryFeatureFlags = VkFlags;
22761pub type VkPeerMemoryFeatureFlagsKHR = VkPeerMemoryFeatureFlags;
22762pub type VkPerformanceConfigurationINTEL = *mut VkPerformanceConfigurationINTEL_T;
22763pub type VkPerformanceConfigurationTypeINTEL = i32;
22764pub type VkPerformanceCounterDescriptionFlagBitsKHR = VkFlags;
22765pub type VkPerformanceCounterDescriptionFlagsARM = VkFlags;
22766pub type VkPerformanceCounterDescriptionFlagsKHR = VkFlags;
22767pub type VkPerformanceCounterScopeKHR = i32;
22768pub type VkPerformanceCounterStorageKHR = i32;
22769pub type VkPerformanceCounterUnitKHR = i32;
22770pub type VkPerformanceOverrideTypeINTEL = i32;
22771pub type VkPerformanceParameterTypeINTEL = i32;
22772pub type VkPerformanceValueTypeINTEL = i32;
22773pub type VkPhysicalDevice = *mut VkPhysicalDevice_T;
22774pub type VkPhysicalDevice16BitStorageFeaturesKHR = VkPhysicalDevice16BitStorageFeatures;
22775pub type VkPhysicalDevice8BitStorageFeaturesKHR = VkPhysicalDevice8BitStorageFeatures;
22776pub type VkPhysicalDeviceBufferAddressFeaturesEXT = VkPhysicalDeviceBufferDeviceAddressFeaturesEXT;
22777pub type VkPhysicalDeviceBufferDeviceAddressFeaturesKHR = VkPhysicalDeviceBufferDeviceAddressFeatures;
22778pub type VkPhysicalDeviceComputeShaderDerivativesFeaturesNV = VkPhysicalDeviceComputeShaderDerivativesFeaturesKHR;
22779pub type VkPhysicalDeviceCopyMemoryIndirectPropertiesNV = VkPhysicalDeviceCopyMemoryIndirectPropertiesKHR;
22780pub type VkPhysicalDeviceDataGraphOperationTypeARM = i32;
22781pub type VkPhysicalDeviceDataGraphProcessingEngineTypeARM = i32;
22782pub type VkPhysicalDeviceDepthClampZeroOneFeaturesEXT = VkPhysicalDeviceDepthClampZeroOneFeaturesKHR;
22783pub type VkPhysicalDeviceDepthStencilResolvePropertiesKHR = VkPhysicalDeviceDepthStencilResolveProperties;
22784pub type VkPhysicalDeviceDescriptorIndexingFeaturesEXT = VkPhysicalDeviceDescriptorIndexingFeatures;
22785pub type VkPhysicalDeviceDescriptorIndexingPropertiesEXT = VkPhysicalDeviceDescriptorIndexingProperties;
22786pub type VkPhysicalDeviceDriverPropertiesKHR = VkPhysicalDeviceDriverProperties;
22787pub type VkPhysicalDeviceDynamicRenderingFeaturesKHR = VkPhysicalDeviceDynamicRenderingFeatures;
22788pub type VkPhysicalDeviceDynamicRenderingLocalReadFeaturesKHR = VkPhysicalDeviceDynamicRenderingLocalReadFeatures;
22789pub type VkPhysicalDeviceExternalBufferInfoKHR = VkPhysicalDeviceExternalBufferInfo;
22790pub type VkPhysicalDeviceExternalFenceInfoKHR = VkPhysicalDeviceExternalFenceInfo;
22791pub type VkPhysicalDeviceExternalImageFormatInfoKHR = VkPhysicalDeviceExternalImageFormatInfo;
22792pub type VkPhysicalDeviceExternalSemaphoreInfoKHR = VkPhysicalDeviceExternalSemaphoreInfo;
22793pub type VkPhysicalDeviceFeatures2KHR = VkPhysicalDeviceFeatures2;
22794pub type VkPhysicalDeviceFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;
22795pub type VkPhysicalDeviceFloatControlsPropertiesKHR = VkPhysicalDeviceFloatControlsProperties;
22796pub type VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetFeaturesEXT;
22797pub type VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM = VkPhysicalDeviceFragmentDensityMapOffsetPropertiesEXT;
22798pub type VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV = VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
22799pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT = VkPhysicalDeviceGlobalPriorityQueryFeatures;
22800pub type VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR = VkPhysicalDeviceGlobalPriorityQueryFeatures;
22801pub type VkPhysicalDeviceGroupPropertiesKHR = VkPhysicalDeviceGroupProperties;
22802pub type VkPhysicalDeviceHostImageCopyFeaturesEXT = VkPhysicalDeviceHostImageCopyFeatures;
22803pub type VkPhysicalDeviceHostImageCopyPropertiesEXT = VkPhysicalDeviceHostImageCopyProperties;
22804pub type VkPhysicalDeviceHostQueryResetFeaturesEXT = VkPhysicalDeviceHostQueryResetFeatures;
22805pub type VkPhysicalDeviceIDPropertiesKHR = VkPhysicalDeviceIDProperties;
22806pub type VkPhysicalDeviceImageFormatInfo2KHR = VkPhysicalDeviceImageFormatInfo2;
22807pub type VkPhysicalDeviceImageRobustnessFeaturesEXT = VkPhysicalDeviceImageRobustnessFeatures;
22808pub type VkPhysicalDeviceImagelessFramebufferFeaturesKHR = VkPhysicalDeviceImagelessFramebufferFeatures;
22809pub type VkPhysicalDeviceIndexTypeUint8FeaturesEXT = VkPhysicalDeviceIndexTypeUint8Features;
22810pub type VkPhysicalDeviceIndexTypeUint8FeaturesKHR = VkPhysicalDeviceIndexTypeUint8Features;
22811pub type VkPhysicalDeviceInlineUniformBlockFeaturesEXT = VkPhysicalDeviceInlineUniformBlockFeatures;
22812pub type VkPhysicalDeviceInlineUniformBlockPropertiesEXT = VkPhysicalDeviceInlineUniformBlockProperties;
22813pub type VkPhysicalDeviceLayeredApiKHR = i32;
22814pub type VkPhysicalDeviceLineRasterizationFeaturesEXT = VkPhysicalDeviceLineRasterizationFeatures;
22815pub type VkPhysicalDeviceLineRasterizationFeaturesKHR = VkPhysicalDeviceLineRasterizationFeatures;
22816pub type VkPhysicalDeviceLineRasterizationPropertiesEXT = VkPhysicalDeviceLineRasterizationProperties;
22817pub type VkPhysicalDeviceLineRasterizationPropertiesKHR = VkPhysicalDeviceLineRasterizationProperties;
22818pub type VkPhysicalDeviceMaintenance3PropertiesKHR = VkPhysicalDeviceMaintenance3Properties;
22819pub type VkPhysicalDeviceMaintenance4FeaturesKHR = VkPhysicalDeviceMaintenance4Features;
22820pub type VkPhysicalDeviceMaintenance4PropertiesKHR = VkPhysicalDeviceMaintenance4Properties;
22821pub type VkPhysicalDeviceMaintenance5FeaturesKHR = VkPhysicalDeviceMaintenance5Features;
22822pub type VkPhysicalDeviceMaintenance5PropertiesKHR = VkPhysicalDeviceMaintenance5Properties;
22823pub type VkPhysicalDeviceMaintenance6FeaturesKHR = VkPhysicalDeviceMaintenance6Features;
22824pub type VkPhysicalDeviceMaintenance6PropertiesKHR = VkPhysicalDeviceMaintenance6Properties;
22825pub type VkPhysicalDeviceMemoryDecompressionFeaturesNV = VkPhysicalDeviceMemoryDecompressionFeaturesEXT;
22826pub type VkPhysicalDeviceMemoryDecompressionPropertiesNV = VkPhysicalDeviceMemoryDecompressionPropertiesEXT;
22827pub type VkPhysicalDeviceMemoryProperties2KHR = VkPhysicalDeviceMemoryProperties2;
22828pub type VkPhysicalDeviceMultiviewFeaturesKHR = VkPhysicalDeviceMultiviewFeatures;
22829pub type VkPhysicalDeviceMultiviewPropertiesKHR = VkPhysicalDeviceMultiviewProperties;
22830pub type VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE = VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT;
22831pub type VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT = VkPhysicalDevicePipelineCreationCacheControlFeatures;
22832pub type VkPhysicalDevicePipelineProtectedAccessFeaturesEXT = VkPhysicalDevicePipelineProtectedAccessFeatures;
22833pub type VkPhysicalDevicePipelineRobustnessFeaturesEXT = VkPhysicalDevicePipelineRobustnessFeatures;
22834pub type VkPhysicalDevicePipelineRobustnessPropertiesEXT = VkPhysicalDevicePipelineRobustnessProperties;
22835pub type VkPhysicalDevicePointClippingPropertiesKHR = VkPhysicalDevicePointClippingProperties;
22836pub type VkPhysicalDevicePresentModeFifoLatestReadyFeaturesEXT = VkPhysicalDevicePresentModeFifoLatestReadyFeaturesKHR;
22837pub type VkPhysicalDevicePrivateDataFeaturesEXT = VkPhysicalDevicePrivateDataFeatures;
22838pub type VkPhysicalDeviceProperties2KHR = VkPhysicalDeviceProperties2;
22839pub type VkPhysicalDevicePushDescriptorPropertiesKHR = VkPhysicalDevicePushDescriptorProperties;
22840pub type VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM = VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT;
22841pub type VkPhysicalDeviceRobustness2FeaturesEXT = VkPhysicalDeviceRobustness2FeaturesKHR;
22842pub type VkPhysicalDeviceRobustness2PropertiesEXT = VkPhysicalDeviceRobustness2PropertiesKHR;
22843pub type VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT = VkPhysicalDeviceSamplerFilterMinmaxProperties;
22844pub type VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR = VkPhysicalDeviceSamplerYcbcrConversionFeatures;
22845pub type VkPhysicalDeviceScalarBlockLayoutFeaturesEXT = VkPhysicalDeviceScalarBlockLayoutFeatures;
22846pub type VkPhysicalDeviceSchedulingControlsFlagBitsARM = VkFlags64;
22847pub type VkPhysicalDeviceSchedulingControlsFlagsARM = VkFlags64;
22848pub type VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR = VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures;
22849pub type VkPhysicalDeviceShaderAtomicInt64FeaturesKHR = VkPhysicalDeviceShaderAtomicInt64Features;
22850pub type VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT = VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures;
22851pub type VkPhysicalDeviceShaderDrawParameterFeatures = VkPhysicalDeviceShaderDrawParametersFeatures;
22852pub type VkPhysicalDeviceShaderExpectAssumeFeaturesKHR = VkPhysicalDeviceShaderExpectAssumeFeatures;
22853pub type VkPhysicalDeviceShaderFloat16Int8FeaturesKHR = VkPhysicalDeviceShaderFloat16Int8Features;
22854pub type VkPhysicalDeviceShaderFloatControls2FeaturesKHR = VkPhysicalDeviceShaderFloatControls2Features;
22855pub type VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR = VkPhysicalDeviceShaderIntegerDotProductFeatures;
22856pub type VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR = VkPhysicalDeviceShaderIntegerDotProductProperties;
22857pub type VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR = VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures;
22858pub type VkPhysicalDeviceShaderSubgroupRotateFeaturesKHR = VkPhysicalDeviceShaderSubgroupRotateFeatures;
22859pub type VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR = VkPhysicalDeviceShaderTerminateInvocationFeatures;
22860pub type VkPhysicalDeviceSparseImageFormatInfo2KHR = VkPhysicalDeviceSparseImageFormatInfo2;
22861pub type VkPhysicalDeviceSubgroupSizeControlFeaturesEXT = VkPhysicalDeviceSubgroupSizeControlFeatures;
22862pub type VkPhysicalDeviceSubgroupSizeControlPropertiesEXT = VkPhysicalDeviceSubgroupSizeControlProperties;
22863pub type VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT = VkPhysicalDeviceSwapchainMaintenance1FeaturesKHR;
22864pub type VkPhysicalDeviceSynchronization2FeaturesKHR = VkPhysicalDeviceSynchronization2Features;
22865pub type VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT = VkPhysicalDeviceTexelBufferAlignmentProperties;
22866pub type VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT = VkPhysicalDeviceTextureCompressionASTCHDRFeatures;
22867pub type VkPhysicalDeviceTimelineSemaphoreFeaturesKHR = VkPhysicalDeviceTimelineSemaphoreFeatures;
22868pub type VkPhysicalDeviceTimelineSemaphorePropertiesKHR = VkPhysicalDeviceTimelineSemaphoreProperties;
22869pub type VkPhysicalDeviceToolPropertiesEXT = VkPhysicalDeviceToolProperties;
22870pub type VkPhysicalDeviceType = i32;
22871pub type VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR = VkPhysicalDeviceUniformBufferStandardLayoutFeatures;
22872pub type VkPhysicalDeviceVariablePointerFeatures = VkPhysicalDeviceVariablePointersFeatures;
22873pub type VkPhysicalDeviceVariablePointerFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;
22874pub type VkPhysicalDeviceVariablePointersFeaturesKHR = VkPhysicalDeviceVariablePointersFeatures;
22875pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT = VkPhysicalDeviceVertexAttributeDivisorFeatures;
22876pub type VkPhysicalDeviceVertexAttributeDivisorFeaturesKHR = VkPhysicalDeviceVertexAttributeDivisorFeatures;
22877pub type VkPhysicalDeviceVertexAttributeDivisorPropertiesKHR = VkPhysicalDeviceVertexAttributeDivisorProperties;
22878pub type VkPhysicalDeviceVulkanMemoryModelFeaturesKHR = VkPhysicalDeviceVulkanMemoryModelFeatures;
22879pub type VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR = VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures;
22880pub type VkPipeline = *mut VkPipeline_T;
22881pub type VkPipelineBinaryKHR = *mut VkPipelineBinaryKHR_T;
22882pub type VkPipelineBindPoint = i32;
22883pub type VkPipelineCache = *mut VkPipelineCache_T;
22884pub type VkPipelineCacheCreateFlagBits = VkFlags;
22885pub type VkPipelineCacheCreateFlags = VkFlags;
22886pub type VkPipelineCacheHeaderVersion = i32;
22887pub type VkPipelineColorBlendStateCreateFlagBits = VkFlags;
22888pub type VkPipelineColorBlendStateCreateFlags = VkFlags;
22889pub type VkPipelineCompilerControlFlagBitsAMD = VkFlags;
22890pub type VkPipelineCompilerControlFlagsAMD = VkFlags;
22891pub type VkPipelineCoverageModulationStateCreateFlagsNV = VkFlags;
22892pub type VkPipelineCoverageReductionStateCreateFlagsNV = VkFlags;
22893pub type VkPipelineCoverageToColorStateCreateFlagsNV = VkFlags;
22894pub type VkPipelineCreateFlagBits = VkFlags;
22895pub type VkPipelineCreateFlagBits2 = VkFlags64;
22896pub type VkPipelineCreateFlagBits2KHR = VkPipelineCreateFlagBits2;
22897pub type VkPipelineCreateFlags = VkFlags;
22898pub type VkPipelineCreateFlags2 = VkFlags64;
22899pub type VkPipelineCreateFlags2CreateInfoKHR = VkPipelineCreateFlags2CreateInfo;
22900pub type VkPipelineCreateFlags2KHR = VkPipelineCreateFlags2;
22901pub type VkPipelineCreationFeedbackCreateInfoEXT = VkPipelineCreationFeedbackCreateInfo;
22902pub type VkPipelineCreationFeedbackEXT = VkPipelineCreationFeedback;
22903pub type VkPipelineCreationFeedbackFlagBits = VkFlags;
22904pub type VkPipelineCreationFeedbackFlagBitsEXT = VkPipelineCreationFeedbackFlagBits;
22905pub type VkPipelineCreationFeedbackFlags = VkFlags;
22906pub type VkPipelineCreationFeedbackFlagsEXT = VkPipelineCreationFeedbackFlags;
22907pub type VkPipelineDepthStencilStateCreateFlagBits = VkFlags;
22908pub type VkPipelineDepthStencilStateCreateFlags = VkFlags;
22909pub type VkPipelineDiscardRectangleStateCreateFlagsEXT = VkFlags;
22910pub type VkPipelineDynamicStateCreateFlags = VkFlags;
22911pub type VkPipelineExecutableStatisticFormatKHR = i32;
22912pub type VkPipelineInfoEXT = VkPipelineInfoKHR;
22913pub type VkPipelineInputAssemblyStateCreateFlags = VkFlags;
22914pub type VkPipelineLayout = *mut VkPipelineLayout_T;
22915pub type VkPipelineLayoutCreateFlagBits = VkFlags;
22916pub type VkPipelineLayoutCreateFlags = VkFlags;
22917pub type VkPipelineMultisampleStateCreateFlags = VkFlags;
22918pub type VkPipelineRasterizationConservativeStateCreateFlagsEXT = VkFlags;
22919pub type VkPipelineRasterizationDepthClipStateCreateFlagsEXT = VkFlags;
22920pub type VkPipelineRasterizationLineStateCreateInfoEXT = VkPipelineRasterizationLineStateCreateInfo;
22921pub type VkPipelineRasterizationLineStateCreateInfoKHR = VkPipelineRasterizationLineStateCreateInfo;
22922pub type VkPipelineRasterizationStateCreateFlags = VkFlags;
22923pub type VkPipelineRasterizationStateStreamCreateFlagsEXT = VkFlags;
22924pub type VkPipelineRenderingCreateInfoKHR = VkPipelineRenderingCreateInfo;
22925pub type VkPipelineRobustnessBufferBehavior = i32;
22926pub type VkPipelineRobustnessBufferBehaviorEXT = VkPipelineRobustnessBufferBehavior;
22927pub type VkPipelineRobustnessCreateInfoEXT = VkPipelineRobustnessCreateInfo;
22928pub type VkPipelineRobustnessImageBehavior = i32;
22929pub type VkPipelineRobustnessImageBehaviorEXT = VkPipelineRobustnessImageBehavior;
22930pub type VkPipelineShaderStageCreateFlagBits = VkFlags;
22931pub type VkPipelineShaderStageCreateFlags = VkFlags;
22932pub type VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
22933pub type VkPipelineStageFlagBits = VkFlags;
22934pub type VkPipelineStageFlagBits2 = VkFlags64;
22935pub type VkPipelineStageFlagBits2KHR = VkPipelineStageFlagBits2;
22936pub type VkPipelineStageFlags = VkFlags;
22937pub type VkPipelineStageFlags2 = VkFlags64;
22938pub type VkPipelineStageFlags2KHR = VkPipelineStageFlags2;
22939pub type VkPipelineTessellationDomainOriginStateCreateInfoKHR = VkPipelineTessellationDomainOriginStateCreateInfo;
22940pub type VkPipelineTessellationStateCreateFlags = VkFlags;
22941pub type VkPipelineVertexInputDivisorStateCreateInfoEXT = VkPipelineVertexInputDivisorStateCreateInfo;
22942pub type VkPipelineVertexInputDivisorStateCreateInfoKHR = VkPipelineVertexInputDivisorStateCreateInfo;
22943pub type VkPipelineVertexInputStateCreateFlags = VkFlags;
22944pub type VkPipelineViewportStateCreateFlags = VkFlags;
22945pub type VkPipelineViewportSwizzleStateCreateFlagsNV = VkFlags;
22946pub type VkPointClippingBehavior = i32;
22947pub type VkPointClippingBehaviorKHR = VkPointClippingBehavior;
22948pub type VkPolygonMode = i32;
22949pub type VkPresentGravityFlagBitsEXT = VkPresentGravityFlagBitsKHR;
22950pub type VkPresentGravityFlagBitsKHR = VkFlags;
22951pub type VkPresentGravityFlagsEXT = VkPresentGravityFlagsKHR;
22952pub type VkPresentGravityFlagsKHR = VkFlags;
22953pub type VkPresentModeKHR = i32;
22954pub type VkPresentScalingFlagBitsEXT = VkPresentScalingFlagBitsKHR;
22955pub type VkPresentScalingFlagBitsKHR = VkFlags;
22956pub type VkPresentScalingFlagsEXT = VkPresentScalingFlagsKHR;
22957pub type VkPresentScalingFlagsKHR = VkFlags;
22958pub type VkPresentStageFlagBitsEXT = VkFlags;
22959pub type VkPresentStageFlagsEXT = VkFlags;
22960pub type VkPresentTimingInfoFlagBitsEXT = VkFlags;
22961pub type VkPresentTimingInfoFlagsEXT = VkFlags;
22962pub type VkPrimitiveTopology = i32;
22963pub type VkPrivateDataSlot = *mut VkPrivateDataSlot_T;
22964pub type VkPrivateDataSlotCreateFlags = VkFlags;
22965pub type VkPrivateDataSlotCreateFlagsEXT = VkPrivateDataSlotCreateFlags;
22966pub type VkPrivateDataSlotCreateInfoEXT = VkPrivateDataSlotCreateInfo;
22967pub type VkPrivateDataSlotEXT = *mut VkPrivateDataSlotEXT_T;
22968pub type VkPrivateDataSlotEXT_T = VkPrivateDataSlot_T;
22969pub type VkProvokingVertexModeEXT = i32;
22970pub type VkPushConstantsInfoKHR = VkPushConstantsInfo;
22971pub type VkPushDescriptorSetInfoKHR = VkPushDescriptorSetInfo;
22972pub type VkPushDescriptorSetWithTemplateInfoKHR = VkPushDescriptorSetWithTemplateInfo;
22973pub type VkQueryControlFlagBits = VkFlags;
22974pub type VkQueryControlFlags = VkFlags;
22975pub type VkQueryPipelineStatisticFlagBits = VkFlags;
22976pub type VkQueryPipelineStatisticFlags = VkFlags;
22977pub type VkQueryPool = *mut VkQueryPool_T;
22978pub type VkQueryPoolCreateFlagBits = VkFlags;
22979pub type VkQueryPoolCreateFlags = VkFlags;
22980pub type VkQueryPoolCreateInfoINTEL = VkQueryPoolPerformanceQueryCreateInfoINTEL;
22981pub type VkQueryPoolSamplingModeINTEL = i32;
22982pub type VkQueryResultFlagBits = VkFlags;
22983pub type VkQueryResultFlags = VkFlags;
22984pub type VkQueryResultStatusKHR = i32;
22985pub type VkQueryType = i32;
22986pub type VkQueue = *mut VkQueue_T;
22987pub type VkQueueFamilyGlobalPriorityPropertiesEXT = VkQueueFamilyGlobalPriorityProperties;
22988pub type VkQueueFamilyGlobalPriorityPropertiesKHR = VkQueueFamilyGlobalPriorityProperties;
22989pub type VkQueueFamilyProperties2KHR = VkQueueFamilyProperties2;
22990pub type VkQueueFlagBits = VkFlags;
22991pub type VkQueueFlags = VkFlags;
22992pub type VkQueueGlobalPriority = i32;
22993pub type VkQueueGlobalPriorityEXT = VkQueueGlobalPriority;
22994pub type VkQueueGlobalPriorityKHR = VkQueueGlobalPriority;
22995pub type VkRasterizationOrderAMD = i32;
22996pub type VkRayTracingInvocationReorderModeEXT = i32;
22997pub type VkRayTracingInvocationReorderModeNV = VkRayTracingInvocationReorderModeEXT;
22998pub type VkRayTracingLssIndexingModeNV = i32;
22999pub type VkRayTracingLssPrimitiveEndCapsModeNV = i32;
23000pub type VkRayTracingShaderGroupTypeKHR = i32;
23001pub type VkRayTracingShaderGroupTypeNV = VkRayTracingShaderGroupTypeKHR;
23002pub type VkReleaseSwapchainImagesInfoEXT = VkReleaseSwapchainImagesInfoKHR;
23003pub type VkRemoteAddressNV = *mut c_void;
23004pub type VkRenderPass = *mut VkRenderPass_T;
23005pub type VkRenderPassAttachmentBeginInfoKHR = VkRenderPassAttachmentBeginInfo;
23006pub type VkRenderPassCreateFlagBits = VkFlags;
23007pub type VkRenderPassCreateFlags = VkFlags;
23008pub type VkRenderPassCreateInfo2KHR = VkRenderPassCreateInfo2;
23009pub type VkRenderPassInputAttachmentAspectCreateInfoKHR = VkRenderPassInputAttachmentAspectCreateInfo;
23010pub type VkRenderPassMultiviewCreateInfoKHR = VkRenderPassMultiviewCreateInfo;
23011pub type VkRenderingAreaInfoKHR = VkRenderingAreaInfo;
23012pub type VkRenderingAttachmentFlagBitsKHR = VkFlags;
23013pub type VkRenderingAttachmentFlagsKHR = VkFlags;
23014pub type VkRenderingAttachmentInfoKHR = VkRenderingAttachmentInfo;
23015pub type VkRenderingAttachmentLocationInfoKHR = VkRenderingAttachmentLocationInfo;
23016pub type VkRenderingEndInfoEXT = VkRenderingEndInfoKHR;
23017pub type VkRenderingFlagBits = VkFlags;
23018pub type VkRenderingFlagBitsKHR = VkRenderingFlagBits;
23019pub type VkRenderingFlags = VkFlags;
23020pub type VkRenderingFlagsKHR = VkRenderingFlags;
23021pub type VkRenderingInfoKHR = VkRenderingInfo;
23022pub type VkRenderingInputAttachmentIndexInfoKHR = VkRenderingInputAttachmentIndexInfo;
23023pub type VkResolveImageFlagBitsKHR = VkFlags;
23024pub type VkResolveImageFlagsKHR = VkFlags;
23025pub type VkResolveImageInfo2KHR = VkResolveImageInfo2;
23026pub type VkResolveModeFlagBits = VkFlags;
23027pub type VkResolveModeFlagBitsKHR = VkResolveModeFlagBits;
23028pub type VkResolveModeFlags = VkFlags;
23029pub type VkResolveModeFlagsKHR = VkResolveModeFlags;
23030pub type VkResult = i32;
23031pub type VkSampleCountFlagBits = VkFlags;
23032pub type VkSampleCountFlags = VkFlags;
23033pub type VkSampleMask = u32;
23034pub type VkSampler = *mut VkSampler_T;
23035pub type VkSamplerAddressMode = i32;
23036pub type VkSamplerCreateFlagBits = VkFlags;
23037pub type VkSamplerCreateFlags = VkFlags;
23038pub type VkSamplerMipmapMode = i32;
23039pub type VkSamplerReductionMode = i32;
23040pub type VkSamplerReductionModeCreateInfoEXT = VkSamplerReductionModeCreateInfo;
23041pub type VkSamplerReductionModeEXT = VkSamplerReductionMode;
23042pub type VkSamplerYcbcrConversion = *mut VkSamplerYcbcrConversion_T;
23043pub type VkSamplerYcbcrConversionCreateInfoKHR = VkSamplerYcbcrConversionCreateInfo;
23044pub type VkSamplerYcbcrConversionImageFormatPropertiesKHR = VkSamplerYcbcrConversionImageFormatProperties;
23045pub type VkSamplerYcbcrConversionInfoKHR = VkSamplerYcbcrConversionInfo;
23046pub type VkSamplerYcbcrConversionKHR = *mut VkSamplerYcbcrConversionKHR_T;
23047pub type VkSamplerYcbcrConversionKHR_T = VkSamplerYcbcrConversion_T;
23048pub type VkSamplerYcbcrModelConversion = i32;
23049pub type VkSamplerYcbcrModelConversionKHR = VkSamplerYcbcrModelConversion;
23050pub type VkSamplerYcbcrRange = i32;
23051pub type VkSamplerYcbcrRangeKHR = VkSamplerYcbcrRange;
23052pub type VkScopeKHR = i32;
23053pub type VkScopeNV = VkScopeKHR;
23054pub type VkSemaphore = *mut VkSemaphore_T;
23055pub type VkSemaphoreCreateFlags = VkFlags;
23056pub type VkSemaphoreImportFlagBits = VkFlags;
23057pub type VkSemaphoreImportFlagBitsKHR = VkSemaphoreImportFlagBits;
23058pub type VkSemaphoreImportFlags = VkFlags;
23059pub type VkSemaphoreImportFlagsKHR = VkSemaphoreImportFlags;
23060pub type VkSemaphoreSignalInfoKHR = VkSemaphoreSignalInfo;
23061pub type VkSemaphoreSubmitInfoKHR = VkSemaphoreSubmitInfo;
23062pub type VkSemaphoreType = i32;
23063pub type VkSemaphoreTypeCreateInfoKHR = VkSemaphoreTypeCreateInfo;
23064pub type VkSemaphoreTypeKHR = VkSemaphoreType;
23065pub type VkSemaphoreWaitFlagBits = VkFlags;
23066pub type VkSemaphoreWaitFlagBitsKHR = VkSemaphoreWaitFlagBits;
23067pub type VkSemaphoreWaitFlags = VkFlags;
23068pub type VkSemaphoreWaitFlagsKHR = VkSemaphoreWaitFlags;
23069pub type VkSemaphoreWaitInfoKHR = VkSemaphoreWaitInfo;
23070pub type VkShaderCodeTypeEXT = i32;
23071pub type VkShaderCorePropertiesFlagBitsAMD = VkFlags;
23072pub type VkShaderCorePropertiesFlagsAMD = VkFlags;
23073pub type VkShaderCreateFlagBitsEXT = VkFlags;
23074pub type VkShaderCreateFlagsEXT = VkFlags;
23075pub type VkShaderEXT = *mut VkShaderEXT_T;
23076pub type VkShaderFloatControlsIndependence = i32;
23077pub type VkShaderFloatControlsIndependenceKHR = VkShaderFloatControlsIndependence;
23078pub type VkShaderGroupShaderKHR = i32;
23079pub type VkShaderInfoTypeAMD = i32;
23080pub type VkShaderModule = *mut VkShaderModule_T;
23081pub type VkShaderModuleCreateFlags = VkFlags;
23082pub type VkShaderRequiredSubgroupSizeCreateInfoEXT = VkPipelineShaderStageRequiredSubgroupSizeCreateInfo;
23083pub type VkShaderStageFlagBits = VkFlags;
23084pub type VkShaderStageFlags = VkFlags;
23085pub type VkShadingRatePaletteEntryNV = i32;
23086pub type VkSharingMode = i32;
23087pub type VkSparseImageFormatFlagBits = VkFlags;
23088pub type VkSparseImageFormatFlags = VkFlags;
23089pub type VkSparseImageFormatProperties2KHR = VkSparseImageFormatProperties2;
23090pub type VkSparseImageMemoryRequirements2KHR = VkSparseImageMemoryRequirements2;
23091pub type VkSparseMemoryBindFlagBits = VkFlags;
23092pub type VkSparseMemoryBindFlags = VkFlags;
23093pub type VkSpirvResourceTypeFlagBitsEXT = VkFlags;
23094pub type VkSpirvResourceTypeFlagsEXT = VkFlags;
23095pub type VkStencilFaceFlagBits = VkFlags;
23096pub type VkStencilFaceFlags = VkFlags;
23097pub type VkStencilOp = i32;
23098pub type VkStructureType = i32;
23099pub type VkSubgroupFeatureFlagBits = VkFlags;
23100pub type VkSubgroupFeatureFlags = VkFlags;
23101pub type VkSubmitFlagBits = VkFlags;
23102pub type VkSubmitFlagBitsKHR = VkSubmitFlagBits;
23103pub type VkSubmitFlags = VkFlags;
23104pub type VkSubmitFlagsKHR = VkSubmitFlags;
23105pub type VkSubmitInfo2KHR = VkSubmitInfo2;
23106pub type VkSubpassBeginInfoKHR = VkSubpassBeginInfo;
23107pub type VkSubpassContents = i32;
23108pub type VkSubpassDependency2KHR = VkSubpassDependency2;
23109pub type VkSubpassDescription2KHR = VkSubpassDescription2;
23110pub type VkSubpassDescriptionDepthStencilResolveKHR = VkSubpassDescriptionDepthStencilResolve;
23111pub type VkSubpassDescriptionFlagBits = VkFlags;
23112pub type VkSubpassDescriptionFlags = VkFlags;
23113pub type VkSubpassEndInfoKHR = VkSubpassEndInfo;
23114pub type VkSubpassFragmentDensityMapOffsetEndInfoQCOM = VkRenderPassFragmentDensityMapOffsetEndInfoEXT;
23115pub type VkSubpassMergeStatusEXT = i32;
23116pub type VkSubresourceHostMemcpySizeEXT = VkSubresourceHostMemcpySize;
23117pub type VkSubresourceLayout2EXT = VkSubresourceLayout2;
23118pub type VkSubresourceLayout2KHR = VkSubresourceLayout2;
23119pub type VkSurfaceCounterFlagBitsEXT = VkFlags;
23120pub type VkSurfaceCounterFlagsEXT = VkFlags;
23121pub type VkSurfaceKHR = *mut VkSurfaceKHR_T;
23122pub type VkSurfacePresentModeCompatibilityEXT = VkSurfacePresentModeCompatibilityKHR;
23123pub type VkSurfacePresentModeEXT = VkSurfacePresentModeKHR;
23124pub type VkSurfacePresentScalingCapabilitiesEXT = VkSurfacePresentScalingCapabilitiesKHR;
23125pub type VkSurfaceTransformFlagBitsKHR = VkFlags;
23126pub type VkSurfaceTransformFlagsKHR = VkFlags;
23127pub type VkSwapchainCreateFlagBitsKHR = VkFlags;
23128pub type VkSwapchainCreateFlagsKHR = VkFlags;
23129pub type VkSwapchainKHR = *mut VkSwapchainKHR_T;
23130pub type VkSwapchainPresentFenceInfoEXT = VkSwapchainPresentFenceInfoKHR;
23131pub type VkSwapchainPresentModeInfoEXT = VkSwapchainPresentModeInfoKHR;
23132pub type VkSwapchainPresentModesCreateInfoEXT = VkSwapchainPresentModesCreateInfoKHR;
23133pub type VkSwapchainPresentScalingCreateInfoEXT = VkSwapchainPresentScalingCreateInfoKHR;
23134pub type VkSystemAllocationScope = i32;
23135pub type VkTensorARM = *mut VkTensorARM_T;
23136pub type VkTensorCreateFlagBitsARM = VkFlags64;
23137pub type VkTensorCreateFlagsARM = VkFlags64;
23138pub type VkTensorTilingARM = i32;
23139pub type VkTensorUsageFlagBitsARM = VkFlags64;
23140pub type VkTensorUsageFlagsARM = VkFlags64;
23141pub type VkTensorViewARM = *mut VkTensorViewARM_T;
23142pub type VkTensorViewCreateFlagBitsARM = VkFlags64;
23143pub type VkTensorViewCreateFlagsARM = VkFlags64;
23144pub type VkTessellationDomainOrigin = i32;
23145pub type VkTessellationDomainOriginKHR = VkTessellationDomainOrigin;
23146pub type VkTileShadingRenderPassFlagBitsQCOM = VkFlags;
23147pub type VkTileShadingRenderPassFlagsQCOM = VkFlags;
23148pub type VkTimeDomainEXT = VkTimeDomainKHR;
23149pub type VkTimeDomainKHR = i32;
23150pub type VkTimelineSemaphoreSubmitInfoKHR = VkTimelineSemaphoreSubmitInfo;
23151pub type VkToolPurposeFlagBits = VkFlags;
23152pub type VkToolPurposeFlagBitsEXT = VkToolPurposeFlagBits;
23153pub type VkToolPurposeFlags = VkFlags;
23154pub type VkToolPurposeFlagsEXT = VkToolPurposeFlags;
23155pub type VkTransformMatrixNV = VkTransformMatrixKHR;
23156pub type VkValidationCacheCreateFlagsEXT = VkFlags;
23157pub type VkValidationCacheEXT = *mut VkValidationCacheEXT_T;
23158pub type VkValidationCacheHeaderVersionEXT = i32;
23159pub type VkValidationCheckEXT = i32;
23160pub type VkValidationFeatureDisableEXT = i32;
23161pub type VkValidationFeatureEnableEXT = i32;
23162pub type VkVendorId = i32;
23163pub type VkVertexInputBindingDivisorDescriptionEXT = VkVertexInputBindingDivisorDescription;
23164pub type VkVertexInputBindingDivisorDescriptionKHR = VkVertexInputBindingDivisorDescription;
23165pub type VkVertexInputRate = i32;
23166pub type VkVideoBeginCodingFlagsKHR = VkFlags;
23167pub type VkVideoCapabilityFlagBitsKHR = VkFlags;
23168pub type VkVideoCapabilityFlagsKHR = VkFlags;
23169pub type VkVideoChromaSubsamplingFlagBitsKHR = VkFlags;
23170pub type VkVideoChromaSubsamplingFlagsKHR = VkFlags;
23171pub type VkVideoCodecOperationFlagBitsKHR = VkFlags;
23172pub type VkVideoCodecOperationFlagsKHR = VkFlags;
23173pub type VkVideoCodingControlFlagBitsKHR = VkFlags;
23174pub type VkVideoCodingControlFlagsKHR = VkFlags;
23175pub type VkVideoComponentBitDepthFlagBitsKHR = VkFlags;
23176pub type VkVideoComponentBitDepthFlagsKHR = VkFlags;
23177pub type VkVideoDecodeCapabilityFlagBitsKHR = VkFlags;
23178pub type VkVideoDecodeCapabilityFlagsKHR = VkFlags;
23179pub type VkVideoDecodeFlagsKHR = VkFlags;
23180pub type VkVideoDecodeH264PictureLayoutFlagBitsKHR = VkFlags;
23181pub type VkVideoDecodeH264PictureLayoutFlagsKHR = VkFlags;
23182pub type VkVideoDecodeUsageFlagBitsKHR = VkFlags;
23183pub type VkVideoDecodeUsageFlagsKHR = VkFlags;
23184pub type VkVideoEncodeAV1CapabilityFlagBitsKHR = VkFlags;
23185pub type VkVideoEncodeAV1CapabilityFlagsKHR = VkFlags;
23186pub type VkVideoEncodeAV1PredictionModeKHR = i32;
23187pub type VkVideoEncodeAV1RateControlFlagBitsKHR = VkFlags;
23188pub type VkVideoEncodeAV1RateControlFlagsKHR = VkFlags;
23189pub type VkVideoEncodeAV1RateControlGroupKHR = i32;
23190pub type VkVideoEncodeAV1StdFlagBitsKHR = VkFlags;
23191pub type VkVideoEncodeAV1StdFlagsKHR = VkFlags;
23192pub type VkVideoEncodeAV1SuperblockSizeFlagBitsKHR = VkFlags;
23193pub type VkVideoEncodeAV1SuperblockSizeFlagsKHR = VkFlags;
23194pub type VkVideoEncodeCapabilityFlagBitsKHR = VkFlags;
23195pub type VkVideoEncodeCapabilityFlagsKHR = VkFlags;
23196pub type VkVideoEncodeContentFlagBitsKHR = VkFlags;
23197pub type VkVideoEncodeContentFlagsKHR = VkFlags;
23198pub type VkVideoEncodeFeedbackFlagBitsKHR = VkFlags;
23199pub type VkVideoEncodeFeedbackFlagsKHR = VkFlags;
23200pub type VkVideoEncodeFlagBitsKHR = VkFlags;
23201pub type VkVideoEncodeFlagsKHR = VkFlags;
23202pub type VkVideoEncodeH264CapabilityFlagBitsKHR = VkFlags;
23203pub type VkVideoEncodeH264CapabilityFlagsKHR = VkFlags;
23204pub type VkVideoEncodeH264RateControlFlagBitsKHR = VkFlags;
23205pub type VkVideoEncodeH264RateControlFlagsKHR = VkFlags;
23206pub type VkVideoEncodeH264StdFlagBitsKHR = VkFlags;
23207pub type VkVideoEncodeH264StdFlagsKHR = VkFlags;
23208pub type VkVideoEncodeH265CapabilityFlagBitsKHR = VkFlags;
23209pub type VkVideoEncodeH265CapabilityFlagsKHR = VkFlags;
23210pub type VkVideoEncodeH265CtbSizeFlagBitsKHR = VkFlags;
23211pub type VkVideoEncodeH265CtbSizeFlagsKHR = VkFlags;
23212pub type VkVideoEncodeH265RateControlFlagBitsKHR = VkFlags;
23213pub type VkVideoEncodeH265RateControlFlagsKHR = VkFlags;
23214pub type VkVideoEncodeH265StdFlagBitsKHR = VkFlags;
23215pub type VkVideoEncodeH265StdFlagsKHR = VkFlags;
23216pub type VkVideoEncodeH265TransformBlockSizeFlagBitsKHR = VkFlags;
23217pub type VkVideoEncodeH265TransformBlockSizeFlagsKHR = VkFlags;
23218pub type VkVideoEncodeIntraRefreshModeFlagBitsKHR = VkFlags;
23219pub type VkVideoEncodeIntraRefreshModeFlagsKHR = VkFlags;
23220pub type VkVideoEncodeRateControlFlagsKHR = VkFlags;
23221pub type VkVideoEncodeRateControlModeFlagBitsKHR = VkFlags;
23222pub type VkVideoEncodeRateControlModeFlagsKHR = VkFlags;
23223pub type VkVideoEncodeRgbChromaOffsetFlagBitsVALVE = VkFlags;
23224pub type VkVideoEncodeRgbChromaOffsetFlagsVALVE = VkFlags;
23225pub type VkVideoEncodeRgbModelConversionFlagBitsVALVE = VkFlags;
23226pub type VkVideoEncodeRgbModelConversionFlagsVALVE = VkFlags;
23227pub type VkVideoEncodeRgbRangeCompressionFlagBitsVALVE = VkFlags;
23228pub type VkVideoEncodeRgbRangeCompressionFlagsVALVE = VkFlags;
23229pub type VkVideoEncodeTuningModeKHR = i32;
23230pub type VkVideoEncodeUsageFlagBitsKHR = VkFlags;
23231pub type VkVideoEncodeUsageFlagsKHR = VkFlags;
23232pub type VkVideoEndCodingFlagsKHR = VkFlags;
23233pub type VkVideoSessionCreateFlagBitsKHR = VkFlags;
23234pub type VkVideoSessionCreateFlagsKHR = VkFlags;
23235pub type VkVideoSessionKHR = *mut VkVideoSessionKHR_T;
23236pub type VkVideoSessionParametersCreateFlagBitsKHR = VkFlags;
23237pub type VkVideoSessionParametersCreateFlagsKHR = VkFlags;
23238pub type VkVideoSessionParametersKHR = *mut VkVideoSessionParametersKHR_T;
23239pub type VkViewportCoordinateSwizzleNV = i32;
23240pub type VkWriteDescriptorSetInlineUniformBlockEXT = VkWriteDescriptorSetInlineUniformBlock;
23241
23242#[derive(Clone, Copy)]
23243#[repr(C)]
23244pub union VkAccelerationStructureGeometryDataKHR {
23245    pub triangles: VkAccelerationStructureGeometryTrianglesDataKHR,
23246    pub aabbs: VkAccelerationStructureGeometryAabbsDataKHR,
23247    pub instances: VkAccelerationStructureGeometryInstancesDataKHR,
23248}
23249
23250#[derive(Clone, Copy)]
23251#[repr(C)]
23252pub union VkAccelerationStructureMotionInstanceDataNV {
23253    pub staticInstance: VkAccelerationStructureInstanceKHR,
23254    pub matrixMotionInstance: VkAccelerationStructureMatrixMotionInstanceNV,
23255    pub srtMotionInstance: VkAccelerationStructureSRTMotionInstanceNV,
23256}
23257
23258#[derive(Clone, Copy)]
23259#[repr(C)]
23260pub union VkClearColorValue {
23261    pub float32: [f32; 4 as usize],
23262    pub int32: [i32; 4 as usize],
23263    pub uint32: [u32; 4 as usize],
23264}
23265
23266#[derive(Clone, Copy)]
23267#[repr(C)]
23268pub union VkClearValue {
23269    pub color: VkClearColorValue,
23270    pub depthStencil: VkClearDepthStencilValue,
23271}
23272
23273#[derive(Clone, Copy)]
23274#[repr(C)]
23275pub union VkClusterAccelerationStructureOpInputNV {
23276    pub pClustersBottomLevel: *mut VkClusterAccelerationStructureClustersBottomLevelInputNV,
23277    pub pTriangleClusters: *mut VkClusterAccelerationStructureTriangleClusterInputNV,
23278    pub pMoveObjects: *mut VkClusterAccelerationStructureMoveObjectsInputNV,
23279}
23280
23281#[derive(Clone, Copy)]
23282#[repr(C)]
23283pub union VkDescriptorDataEXT {
23284    pub pSampler: *const VkSampler,
23285    pub pCombinedImageSampler: *const VkDescriptorImageInfo,
23286    pub pInputAttachmentImage: *const VkDescriptorImageInfo,
23287    pub pSampledImage: *const VkDescriptorImageInfo,
23288    pub pStorageImage: *const VkDescriptorImageInfo,
23289    pub pUniformTexelBuffer: *const VkDescriptorAddressInfoEXT,
23290    pub pStorageTexelBuffer: *const VkDescriptorAddressInfoEXT,
23291    pub pUniformBuffer: *const VkDescriptorAddressInfoEXT,
23292    pub pStorageBuffer: *const VkDescriptorAddressInfoEXT,
23293    pub accelerationStructure: VkDeviceAddress,
23294}
23295
23296#[derive(Clone, Copy)]
23297#[repr(C)]
23298pub union VkDescriptorMappingSourceDataEXT {
23299    pub constantOffset: VkDescriptorMappingSourceConstantOffsetEXT,
23300    pub pushIndex: VkDescriptorMappingSourcePushIndexEXT,
23301    pub indirectIndex: VkDescriptorMappingSourceIndirectIndexEXT,
23302    pub indirectIndexArray: VkDescriptorMappingSourceIndirectIndexArrayEXT,
23303    pub heapData: VkDescriptorMappingSourceHeapDataEXT,
23304    pub pushDataOffset: u32,
23305    pub pushAddressOffset: u32,
23306    pub indirectAddress: VkDescriptorMappingSourceIndirectAddressEXT,
23307    pub shaderRecordIndex: VkDescriptorMappingSourceShaderRecordIndexEXT,
23308    pub shaderRecordDataOffset: u32,
23309    pub shaderRecordAddressOffset: u32,
23310}
23311
23312#[derive(Clone, Copy)]
23313#[repr(C)]
23314pub union VkDeviceOrHostAddressConstKHR {
23315    pub deviceAddress: VkDeviceAddress,
23316    pub hostAddress: *const c_void,
23317}
23318
23319#[derive(Clone, Copy)]
23320#[repr(C)]
23321pub union VkDeviceOrHostAddressKHR {
23322    pub deviceAddress: VkDeviceAddress,
23323    pub hostAddress: *mut c_void,
23324}
23325
23326#[derive(Clone, Copy)]
23327#[repr(C)]
23328pub union VkIndirectCommandsTokenDataEXT {
23329    pub pPushConstant: *const VkIndirectCommandsPushConstantTokenEXT,
23330    pub pVertexBuffer: *const VkIndirectCommandsVertexBufferTokenEXT,
23331    pub pIndexBuffer: *const VkIndirectCommandsIndexBufferTokenEXT,
23332    pub pExecutionSet: *const VkIndirectCommandsExecutionSetTokenEXT,
23333}
23334
23335#[derive(Clone, Copy)]
23336#[repr(C)]
23337pub union VkIndirectExecutionSetInfoEXT {
23338    pub pPipelineInfo: *const VkIndirectExecutionSetPipelineInfoEXT,
23339    pub pShaderInfo: *const VkIndirectExecutionSetShaderInfoEXT,
23340}
23341
23342#[derive(Clone, Copy)]
23343#[repr(C)]
23344pub union VkPerformanceCounterResultKHR {
23345    pub int32: i32,
23346    pub int64: i64,
23347    pub uint32: u32,
23348    pub uint64: u64,
23349    pub float32: f32,
23350    pub float64: f64,
23351}
23352
23353#[derive(Clone, Copy)]
23354#[repr(C)]
23355pub union VkPerformanceValueDataINTEL {
23356    pub value32: u32,
23357    pub value64: u64,
23358    pub valueFloat: f32,
23359    pub valueBool: VkBool32,
23360    pub valueString: *const c_char,
23361}
23362
23363#[derive(Clone, Copy)]
23364#[repr(C)]
23365pub union VkPipelineExecutableStatisticValueKHR {
23366    pub b32: VkBool32,
23367    pub i64: i64,
23368    pub u64: u64,
23369    pub f64: f64,
23370}
23371
23372#[derive(Clone, Copy)]
23373#[repr(C)]
23374pub union VkResourceDescriptorDataEXT {
23375    pub pImage: *const VkImageDescriptorInfoEXT,
23376    pub pTexelBuffer: *const VkTexelBufferDescriptorInfoEXT,
23377    pub pAddressRange: *const VkDeviceAddressRangeEXT,
23378    pub pTensorARM: *const VkTensorViewCreateInfoARM,
23379}