external/vulkancts/framework/vulkan/vkStructTypes.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  */
   4 struct VkExtent2D
   5 {
   6         uint32_t        width;
   7         uint32_t        height;
   8 };
   9
  10 struct VkExtent3D
  11 {
  12         uint32_t        width;
  13         uint32_t        height;
  14         uint32_t        depth;
  15 };
  16
  17 struct VkOffset2D
  18 {
  19         int32_t x;
  20         int32_t y;
  21 };
  22
  23 struct VkOffset3D
  24 {
  25         int32_t x;
  26         int32_t y;
  27         int32_t z;
  28 };
  29
  30 struct VkRect2D
  31 {
  32         VkOffset2D      offset;
  33         VkExtent2D      extent;
  34 };
  35
  36 struct VkBaseInStructure
  37 {
  38         VkStructureType                                 sType;
  39         const struct VkBaseInStructure* pNext;
  40 };
  41
  42 struct VkBaseOutStructure
  43 {
  44         VkStructureType                         sType;
  45         struct VkBaseOutStructure*      pNext;
  46 };
  47
  48 struct VkBufferMemoryBarrier
  49 {
  50         VkStructureType sType;
  51         const void*             pNext;
  52         VkAccessFlags   srcAccessMask;
  53         VkAccessFlags   dstAccessMask;
  54         uint32_t                srcQueueFamilyIndex;
  55         uint32_t                dstQueueFamilyIndex;
  56         VkBuffer                buffer;
  57         VkDeviceSize    offset;
  58         VkDeviceSize    size;
  59 };
  60
  61 struct VkDispatchIndirectCommand
  62 {
  63         uint32_t        x;
  64         uint32_t        y;
  65         uint32_t        z;
  66 };
  67
  68 struct VkDrawIndexedIndirectCommand
  69 {
  70         uint32_t        indexCount;
  71         uint32_t        instanceCount;
  72         uint32_t        firstIndex;
  73         int32_t         vertexOffset;
  74         uint32_t        firstInstance;
  75 };
  76
  77 struct VkDrawIndirectCommand
  78 {
  79         uint32_t        vertexCount;
  80         uint32_t        instanceCount;
  81         uint32_t        firstVertex;
  82         uint32_t        firstInstance;
  83 };
  84
  85 struct VkImageSubresourceRange
  86 {
  87         VkImageAspectFlags      aspectMask;
  88         uint32_t                        baseMipLevel;
  89         uint32_t                        levelCount;
  90         uint32_t                        baseArrayLayer;
  91         uint32_t                        layerCount;
  92 };
  93
  94 struct VkImageMemoryBarrier
  95 {
  96         VkStructureType                 sType;
  97         const void*                             pNext;
  98         VkAccessFlags                   srcAccessMask;
  99         VkAccessFlags                   dstAccessMask;
 100         VkImageLayout                   oldLayout;
 101         VkImageLayout                   newLayout;
 102         uint32_t                                srcQueueFamilyIndex;
 103         uint32_t                                dstQueueFamilyIndex;
 104         VkImage                                 image;
 105         VkImageSubresourceRange subresourceRange;
 106 };
 107
 108 struct VkMemoryBarrier
 109 {
 110         VkStructureType sType;
 111         const void*             pNext;
 112         VkAccessFlags   srcAccessMask;
 113         VkAccessFlags   dstAccessMask;
 114 };
 115
 116 struct VkPipelineCacheHeaderVersionOne
 117 {
 118         uint32_t                                                headerSize;
 119         VkPipelineCacheHeaderVersion    headerVersion;
 120         uint32_t                                                vendorID;
 121         uint32_t                                                deviceID;
 122         uint8_t                                                 pipelineCacheUUID[VK_UUID_SIZE];
 123 };
 124
 125 struct VkAllocationCallbacks
 126 {
 127         void*                                                                   pUserData;
 128         PFN_vkAllocationFunction                                pfnAllocation;
 129         PFN_vkReallocationFunction                              pfnReallocation;
 130         PFN_vkFreeFunction                                              pfnFree;
 131         PFN_vkInternalAllocationNotification    pfnInternalAllocation;
 132         PFN_vkInternalFreeNotification                  pfnInternalFree;
 133 };
 134
 135 struct VkApplicationInfo
 136 {
 137         VkStructureType sType;
 138         const void*             pNext;
 139         const char*             pApplicationName;
 140         uint32_t                applicationVersion;
 141         const char*             pEngineName;
 142         uint32_t                engineVersion;
 143         uint32_t                apiVersion;
 144 };
 145
 146 struct VkFormatProperties
 147 {
 148         VkFormatFeatureFlags    linearTilingFeatures;
 149         VkFormatFeatureFlags    optimalTilingFeatures;
 150         VkFormatFeatureFlags    bufferFeatures;
 151 };
 152
 153 struct VkImageFormatProperties
 154 {
 155         VkExtent3D                      maxExtent;
 156         uint32_t                        maxMipLevels;
 157         uint32_t                        maxArrayLayers;
 158         VkSampleCountFlags      sampleCounts;
 159         VkDeviceSize            maxResourceSize;
 160 };
 161
 162 struct VkInstanceCreateInfo
 163 {
 164         VkStructureType                         sType;
 165         const void*                                     pNext;
 166         VkInstanceCreateFlags           flags;
 167         const VkApplicationInfo*        pApplicationInfo;
 168         uint32_t                                        enabledLayerCount;
 169         const char* const*                      ppEnabledLayerNames;
 170         uint32_t                                        enabledExtensionCount;
 171         const char* const*                      ppEnabledExtensionNames;
 172 };
 173
 174 struct VkMemoryHeap
 175 {
 176         VkDeviceSize            size;
 177         VkMemoryHeapFlags       flags;
 178 };
 179
 180 struct VkMemoryType
 181 {
 182         VkMemoryPropertyFlags   propertyFlags;
 183         uint32_t                                heapIndex;
 184 };
 185
 186 struct VkPhysicalDeviceFeatures
 187 {
 188         VkBool32        robustBufferAccess;
 189         VkBool32        fullDrawIndexUint32;
 190         VkBool32        imageCubeArray;
 191         VkBool32        independentBlend;
 192         VkBool32        geometryShader;
 193         VkBool32        tessellationShader;
 194         VkBool32        sampleRateShading;
 195         VkBool32        dualSrcBlend;
 196         VkBool32        logicOp;
 197         VkBool32        multiDrawIndirect;
 198         VkBool32        drawIndirectFirstInstance;
 199         VkBool32        depthClamp;
 200         VkBool32        depthBiasClamp;
 201         VkBool32        fillModeNonSolid;
 202         VkBool32        depthBounds;
 203         VkBool32        wideLines;
 204         VkBool32        largePoints;
 205         VkBool32        alphaToOne;
 206         VkBool32        multiViewport;
 207         VkBool32        samplerAnisotropy;
 208         VkBool32        textureCompressionETC2;
 209         VkBool32        textureCompressionASTC_LDR;
 210         VkBool32        textureCompressionBC;
 211         VkBool32        occlusionQueryPrecise;
 212         VkBool32        pipelineStatisticsQuery;
 213         VkBool32        vertexPipelineStoresAndAtomics;
 214         VkBool32        fragmentStoresAndAtomics;
 215         VkBool32        shaderTessellationAndGeometryPointSize;
 216         VkBool32        shaderImageGatherExtended;
 217         VkBool32        shaderStorageImageExtendedFormats;
 218         VkBool32        shaderStorageImageMultisample;
 219         VkBool32        shaderStorageImageReadWithoutFormat;
 220         VkBool32        shaderStorageImageWriteWithoutFormat;
 221         VkBool32        shaderUniformBufferArrayDynamicIndexing;
 222         VkBool32        shaderSampledImageArrayDynamicIndexing;
 223         VkBool32        shaderStorageBufferArrayDynamicIndexing;
 224         VkBool32        shaderStorageImageArrayDynamicIndexing;
 225         VkBool32        shaderClipDistance;
 226         VkBool32        shaderCullDistance;
 227         VkBool32        shaderFloat64;
 228         VkBool32        shaderInt64;
 229         VkBool32        shaderInt16;
 230         VkBool32        shaderResourceResidency;
 231         VkBool32        shaderResourceMinLod;
 232         VkBool32        sparseBinding;
 233         VkBool32        sparseResidencyBuffer;
 234         VkBool32        sparseResidencyImage2D;
 235         VkBool32        sparseResidencyImage3D;
 236         VkBool32        sparseResidency2Samples;
 237         VkBool32        sparseResidency4Samples;
 238         VkBool32        sparseResidency8Samples;
 239         VkBool32        sparseResidency16Samples;
 240         VkBool32        sparseResidencyAliased;
 241         VkBool32        variableMultisampleRate;
 242         VkBool32        inheritedQueries;
 243 };
 244
 245 struct VkPhysicalDeviceLimits
 246 {
 247         uint32_t                        maxImageDimension1D;
 248         uint32_t                        maxImageDimension2D;
 249         uint32_t                        maxImageDimension3D;
 250         uint32_t                        maxImageDimensionCube;
 251         uint32_t                        maxImageArrayLayers;
 252         uint32_t                        maxTexelBufferElements;
 253         uint32_t                        maxUniformBufferRange;
 254         uint32_t                        maxStorageBufferRange;
 255         uint32_t                        maxPushConstantsSize;
 256         uint32_t                        maxMemoryAllocationCount;
 257         uint32_t                        maxSamplerAllocationCount;
 258         VkDeviceSize            bufferImageGranularity;
 259         VkDeviceSize            sparseAddressSpaceSize;
 260         uint32_t                        maxBoundDescriptorSets;
 261         uint32_t                        maxPerStageDescriptorSamplers;
 262         uint32_t                        maxPerStageDescriptorUniformBuffers;
 263         uint32_t                        maxPerStageDescriptorStorageBuffers;
 264         uint32_t                        maxPerStageDescriptorSampledImages;
 265         uint32_t                        maxPerStageDescriptorStorageImages;
 266         uint32_t                        maxPerStageDescriptorInputAttachments;
 267         uint32_t                        maxPerStageResources;
 268         uint32_t                        maxDescriptorSetSamplers;
 269         uint32_t                        maxDescriptorSetUniformBuffers;
 270         uint32_t                        maxDescriptorSetUniformBuffersDynamic;
 271         uint32_t                        maxDescriptorSetStorageBuffers;
 272         uint32_t                        maxDescriptorSetStorageBuffersDynamic;
 273         uint32_t                        maxDescriptorSetSampledImages;
 274         uint32_t                        maxDescriptorSetStorageImages;
 275         uint32_t                        maxDescriptorSetInputAttachments;
 276         uint32_t                        maxVertexInputAttributes;
 277         uint32_t                        maxVertexInputBindings;
 278         uint32_t                        maxVertexInputAttributeOffset;
 279         uint32_t                        maxVertexInputBindingStride;
 280         uint32_t                        maxVertexOutputComponents;
 281         uint32_t                        maxTessellationGenerationLevel;
 282         uint32_t                        maxTessellationPatchSize;
 283         uint32_t                        maxTessellationControlPerVertexInputComponents;
 284         uint32_t                        maxTessellationControlPerVertexOutputComponents;
 285         uint32_t                        maxTessellationControlPerPatchOutputComponents;
 286         uint32_t                        maxTessellationControlTotalOutputComponents;
 287         uint32_t                        maxTessellationEvaluationInputComponents;
 288         uint32_t                        maxTessellationEvaluationOutputComponents;
 289         uint32_t                        maxGeometryShaderInvocations;
 290         uint32_t                        maxGeometryInputComponents;
 291         uint32_t                        maxGeometryOutputComponents;
 292         uint32_t                        maxGeometryOutputVertices;
 293         uint32_t                        maxGeometryTotalOutputComponents;
 294         uint32_t                        maxFragmentInputComponents;
 295         uint32_t                        maxFragmentOutputAttachments;
 296         uint32_t                        maxFragmentDualSrcAttachments;
 297         uint32_t                        maxFragmentCombinedOutputResources;
 298         uint32_t                        maxComputeSharedMemorySize;
 299         uint32_t                        maxComputeWorkGroupCount[3];
 300         uint32_t                        maxComputeWorkGroupInvocations;
 301         uint32_t                        maxComputeWorkGroupSize[3];
 302         uint32_t                        subPixelPrecisionBits;
 303         uint32_t                        subTexelPrecisionBits;
 304         uint32_t                        mipmapPrecisionBits;
 305         uint32_t                        maxDrawIndexedIndexValue;
 306         uint32_t                        maxDrawIndirectCount;
 307         float                           maxSamplerLodBias;
 308         float                           maxSamplerAnisotropy;
 309         uint32_t                        maxViewports;
 310         uint32_t                        maxViewportDimensions[2];
 311         float                           viewportBoundsRange[2];
 312         uint32_t                        viewportSubPixelBits;
 313         size_t                          minMemoryMapAlignment;
 314         VkDeviceSize            minTexelBufferOffsetAlignment;
 315         VkDeviceSize            minUniformBufferOffsetAlignment;
 316         VkDeviceSize            minStorageBufferOffsetAlignment;
 317         int32_t                         minTexelOffset;
 318         uint32_t                        maxTexelOffset;
 319         int32_t                         minTexelGatherOffset;
 320         uint32_t                        maxTexelGatherOffset;
 321         float                           minInterpolationOffset;
 322         float                           maxInterpolationOffset;
 323         uint32_t                        subPixelInterpolationOffsetBits;
 324         uint32_t                        maxFramebufferWidth;
 325         uint32_t                        maxFramebufferHeight;
 326         uint32_t                        maxFramebufferLayers;
 327         VkSampleCountFlags      framebufferColorSampleCounts;
 328         VkSampleCountFlags      framebufferDepthSampleCounts;
 329         VkSampleCountFlags      framebufferStencilSampleCounts;
 330         VkSampleCountFlags      framebufferNoAttachmentsSampleCounts;
 331         uint32_t                        maxColorAttachments;
 332         VkSampleCountFlags      sampledImageColorSampleCounts;
 333         VkSampleCountFlags      sampledImageIntegerSampleCounts;
 334         VkSampleCountFlags      sampledImageDepthSampleCounts;
 335         VkSampleCountFlags      sampledImageStencilSampleCounts;
 336         VkSampleCountFlags      storageImageSampleCounts;
 337         uint32_t                        maxSampleMaskWords;
 338         VkBool32                        timestampComputeAndGraphics;
 339         float                           timestampPeriod;
 340         uint32_t                        maxClipDistances;
 341         uint32_t                        maxCullDistances;
 342         uint32_t                        maxCombinedClipAndCullDistances;
 343         uint32_t                        discreteQueuePriorities;
 344         float                           pointSizeRange[2];
 345         float                           lineWidthRange[2];
 346         float                           pointSizeGranularity;
 347         float                           lineWidthGranularity;
 348         VkBool32                        strictLines;
 349         VkBool32                        standardSampleLocations;
 350         VkDeviceSize            optimalBufferCopyOffsetAlignment;
 351         VkDeviceSize            optimalBufferCopyRowPitchAlignment;
 352         VkDeviceSize            nonCoherentAtomSize;
 353 };
 354
 355 struct VkPhysicalDeviceMemoryProperties
 356 {
 357         uint32_t                memoryTypeCount;
 358         VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
 359         uint32_t                memoryHeapCount;
 360         VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
 361 };
 362
 363 struct VkPhysicalDeviceSparseProperties
 364 {
 365         VkBool32        residencyStandard2DBlockShape;
 366         VkBool32        residencyStandard2DMultisampleBlockShape;
 367         VkBool32        residencyStandard3DBlockShape;
 368         VkBool32        residencyAlignedMipSize;
 369         VkBool32        residencyNonResidentStrict;
 370 };
 371
 372 struct VkPhysicalDeviceProperties
 373 {
 374         uint32_t                                                        apiVersion;
 375         uint32_t                                                        driverVersion;
 376         uint32_t                                                        vendorID;
 377         uint32_t                                                        deviceID;
 378         VkPhysicalDeviceType                            deviceType;
 379         char                                                            deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
 380         uint8_t                                                         pipelineCacheUUID[VK_UUID_SIZE];
 381         VkPhysicalDeviceLimits                          limits;
 382         VkPhysicalDeviceSparseProperties        sparseProperties;
 383 };
 384
 385 struct VkQueueFamilyProperties
 386 {
 387         VkQueueFlags    queueFlags;
 388         uint32_t                queueCount;
 389         uint32_t                timestampValidBits;
 390         VkExtent3D              minImageTransferGranularity;
 391 };
 392
 393 struct VkDeviceQueueCreateInfo
 394 {
 395         VkStructureType                         sType;
 396         const void*                                     pNext;
 397         VkDeviceQueueCreateFlags        flags;
 398         uint32_t                                        queueFamilyIndex;
 399         uint32_t                                        queueCount;
 400         const float*                            pQueuePriorities;
 401 };
 402
 403 struct VkDeviceCreateInfo
 404 {
 405         VkStructureType                                 sType;
 406         const void*                                             pNext;
 407         VkDeviceCreateFlags                             flags;
 408         uint32_t                                                queueCreateInfoCount;
 409         const VkDeviceQueueCreateInfo*  pQueueCreateInfos;
 410         uint32_t                                                enabledLayerCount;
 411         const char* const*                              ppEnabledLayerNames;
 412         uint32_t                                                enabledExtensionCount;
 413         const char* const*                              ppEnabledExtensionNames;
 414         const VkPhysicalDeviceFeatures* pEnabledFeatures;
 415 };
 416
 417 struct VkExtensionProperties
 418 {
 419         char            extensionName[VK_MAX_EXTENSION_NAME_SIZE];
 420         uint32_t        specVersion;
 421 };
 422
 423 struct VkLayerProperties
 424 {
 425         char            layerName[VK_MAX_EXTENSION_NAME_SIZE];
 426         uint32_t        specVersion;
 427         uint32_t        implementationVersion;
 428         char            description[VK_MAX_DESCRIPTION_SIZE];
 429 };
 430
 431 struct VkSubmitInfo
 432 {
 433         VkStructureType                         sType;
 434         const void*                                     pNext;
 435         uint32_t                                        waitSemaphoreCount;
 436         const VkSemaphore*                      pWaitSemaphores;
 437         const VkPipelineStageFlags*     pWaitDstStageMask;
 438         uint32_t                                        commandBufferCount;
 439         const VkCommandBuffer*          pCommandBuffers;
 440         uint32_t                                        signalSemaphoreCount;
 441         const VkSemaphore*                      pSignalSemaphores;
 442 };
 443
 444 struct VkMappedMemoryRange
 445 {
 446         VkStructureType sType;
 447         const void*             pNext;
 448         VkDeviceMemory  memory;
 449         VkDeviceSize    offset;
 450         VkDeviceSize    size;
 451 };
 452
 453 struct VkMemoryAllocateInfo
 454 {
 455         VkStructureType sType;
 456         const void*             pNext;
 457         VkDeviceSize    allocationSize;
 458         uint32_t                memoryTypeIndex;
 459 };
 460
 461 struct VkMemoryRequirements
 462 {
 463         VkDeviceSize    size;
 464         VkDeviceSize    alignment;
 465         uint32_t                memoryTypeBits;
 466 };
 467
 468 struct VkSparseMemoryBind
 469 {
 470         VkDeviceSize                    resourceOffset;
 471         VkDeviceSize                    size;
 472         VkDeviceMemory                  memory;
 473         VkDeviceSize                    memoryOffset;
 474         VkSparseMemoryBindFlags flags;
 475 };
 476
 477 struct VkSparseBufferMemoryBindInfo
 478 {
 479         VkBuffer                                        buffer;
 480         uint32_t                                        bindCount;
 481         const VkSparseMemoryBind*       pBinds;
 482 };
 483
 484 struct VkSparseImageOpaqueMemoryBindInfo
 485 {
 486         VkImage                                         image;
 487         uint32_t                                        bindCount;
 488         const VkSparseMemoryBind*       pBinds;
 489 };
 490
 491 struct VkImageSubresource
 492 {
 493         VkImageAspectFlags      aspectMask;
 494         uint32_t                        mipLevel;
 495         uint32_t                        arrayLayer;
 496 };
 497
 498 struct VkSparseImageMemoryBind
 499 {
 500         VkImageSubresource              subresource;
 501         VkOffset3D                              offset;
 502         VkExtent3D                              extent;
 503         VkDeviceMemory                  memory;
 504         VkDeviceSize                    memoryOffset;
 505         VkSparseMemoryBindFlags flags;
 506 };
 507
 508 struct VkSparseImageMemoryBindInfo
 509 {
 510         VkImage                                                 image;
 511         uint32_t                                                bindCount;
 512         const VkSparseImageMemoryBind*  pBinds;
 513 };
 514
 515 struct VkBindSparseInfo
 516 {
 517         VkStructureType                                                         sType;
 518         const void*                                                                     pNext;
 519         uint32_t                                                                        waitSemaphoreCount;
 520         const VkSemaphore*                                                      pWaitSemaphores;
 521         uint32_t                                                                        bufferBindCount;
 522         const VkSparseBufferMemoryBindInfo*                     pBufferBinds;
 523         uint32_t                                                                        imageOpaqueBindCount;
 524         const VkSparseImageOpaqueMemoryBindInfo*        pImageOpaqueBinds;
 525         uint32_t                                                                        imageBindCount;
 526         const VkSparseImageMemoryBindInfo*                      pImageBinds;
 527         uint32_t                                                                        signalSemaphoreCount;
 528         const VkSemaphore*                                                      pSignalSemaphores;
 529 };
 530
 531 struct VkSparseImageFormatProperties
 532 {
 533         VkImageAspectFlags                      aspectMask;
 534         VkExtent3D                                      imageGranularity;
 535         VkSparseImageFormatFlags        flags;
 536 };
 537
 538 struct VkSparseImageMemoryRequirements
 539 {
 540         VkSparseImageFormatProperties   formatProperties;
 541         uint32_t                                                imageMipTailFirstLod;
 542         VkDeviceSize                                    imageMipTailSize;
 543         VkDeviceSize                                    imageMipTailOffset;
 544         VkDeviceSize                                    imageMipTailStride;
 545 };
 546
 547 struct VkFenceCreateInfo
 548 {
 549         VkStructureType         sType;
 550         const void*                     pNext;
 551         VkFenceCreateFlags      flags;
 552 };
 553
 554 struct VkSemaphoreCreateInfo
 555 {
 556         VkStructureType                 sType;
 557         const void*                             pNext;
 558         VkSemaphoreCreateFlags  flags;
 559 };
 560
 561 struct VkEventCreateInfo
 562 {
 563         VkStructureType         sType;
 564         const void*                     pNext;
 565         VkEventCreateFlags      flags;
 566 };
 567
 568 struct VkQueryPoolCreateInfo
 569 {
 570         VkStructureType                                 sType;
 571         const void*                                             pNext;
 572         VkQueryPoolCreateFlags                  flags;
 573         VkQueryType                                             queryType;
 574         uint32_t                                                queryCount;
 575         VkQueryPipelineStatisticFlags   pipelineStatistics;
 576 };
 577
 578 struct VkBufferCreateInfo
 579 {
 580         VkStructureType         sType;
 581         const void*                     pNext;
 582         VkBufferCreateFlags     flags;
 583         VkDeviceSize            size;
 584         VkBufferUsageFlags      usage;
 585         VkSharingMode           sharingMode;
 586         uint32_t                        queueFamilyIndexCount;
 587         const uint32_t*         pQueueFamilyIndices;
 588 };
 589
 590 struct VkBufferViewCreateInfo
 591 {
 592         VkStructureType                 sType;
 593         const void*                             pNext;
 594         VkBufferViewCreateFlags flags;
 595         VkBuffer                                buffer;
 596         VkFormat                                format;
 597         VkDeviceSize                    offset;
 598         VkDeviceSize                    range;
 599 };
 600
 601 struct VkImageCreateInfo
 602 {
 603         VkStructureType                 sType;
 604         const void*                             pNext;
 605         VkImageCreateFlags              flags;
 606         VkImageType                             imageType;
 607         VkFormat                                format;
 608         VkExtent3D                              extent;
 609         uint32_t                                mipLevels;
 610         uint32_t                                arrayLayers;
 611         VkSampleCountFlagBits   samples;
 612         VkImageTiling                   tiling;
 613         VkImageUsageFlags               usage;
 614         VkSharingMode                   sharingMode;
 615         uint32_t                                queueFamilyIndexCount;
 616         const uint32_t*                 pQueueFamilyIndices;
 617         VkImageLayout                   initialLayout;
 618 };
 619
 620 struct VkSubresourceLayout
 621 {
 622         VkDeviceSize    offset;
 623         VkDeviceSize    size;
 624         VkDeviceSize    rowPitch;
 625         VkDeviceSize    arrayPitch;
 626         VkDeviceSize    depthPitch;
 627 };
 628
 629 struct VkComponentMapping
 630 {
 631         VkComponentSwizzle      r;
 632         VkComponentSwizzle      g;
 633         VkComponentSwizzle      b;
 634         VkComponentSwizzle      a;
 635 };
 636
 637 struct VkImageViewCreateInfo
 638 {
 639         VkStructureType                 sType;
 640         const void*                             pNext;
 641         VkImageViewCreateFlags  flags;
 642         VkImage                                 image;
 643         VkImageViewType                 viewType;
 644         VkFormat                                format;
 645         VkComponentMapping              components;
 646         VkImageSubresourceRange subresourceRange;
 647 };
 648
 649 struct VkShaderModuleCreateInfo
 650 {
 651         VkStructureType                         sType;
 652         const void*                                     pNext;
 653         VkShaderModuleCreateFlags       flags;
 654         size_t                                          codeSize;
 655         const uint32_t*                         pCode;
 656 };
 657
 658 struct VkPipelineCacheCreateInfo
 659 {
 660         VkStructureType                         sType;
 661         const void*                                     pNext;
 662         VkPipelineCacheCreateFlags      flags;
 663         size_t                                          initialDataSize;
 664         const void*                                     pInitialData;
 665 };
 666
 667 struct VkSpecializationMapEntry
 668 {
 669         uint32_t        constantID;
 670         uint32_t        offset;
 671         size_t          size;
 672 };
 673
 674 struct VkSpecializationInfo
 675 {
 676         uint32_t                                                mapEntryCount;
 677         const VkSpecializationMapEntry* pMapEntries;
 678         size_t                                                  dataSize;
 679         const void*                                             pData;
 680 };
 681
 682 struct VkPipelineShaderStageCreateInfo
 683 {
 684         VkStructureType                                         sType;
 685         const void*                                                     pNext;
 686         VkPipelineShaderStageCreateFlags        flags;
 687         VkShaderStageFlagBits                           stage;
 688         VkShaderModule                                          module;
 689         const char*                                                     pName;
 690         const VkSpecializationInfo*                     pSpecializationInfo;
 691 };
 692
 693 struct VkComputePipelineCreateInfo
 694 {
 695         VkStructureType                                 sType;
 696         const void*                                             pNext;
 697         VkPipelineCreateFlags                   flags;
 698         VkPipelineShaderStageCreateInfo stage;
 699         VkPipelineLayout                                layout;
 700         VkPipeline                                              basePipelineHandle;
 701         int32_t                                                 basePipelineIndex;
 702 };
 703
 704 struct VkVertexInputBindingDescription
 705 {
 706         uint32_t                        binding;
 707         uint32_t                        stride;
 708         VkVertexInputRate       inputRate;
 709 };
 710
 711 struct VkVertexInputAttributeDescription
 712 {
 713         uint32_t        location;
 714         uint32_t        binding;
 715         VkFormat        format;
 716         uint32_t        offset;
 717 };
 718
 719 struct VkPipelineVertexInputStateCreateInfo
 720 {
 721         VkStructureType                                                         sType;
 722         const void*                                                                     pNext;
 723         VkPipelineVertexInputStateCreateFlags           flags;
 724         uint32_t                                                                        vertexBindingDescriptionCount;
 725         const VkVertexInputBindingDescription*          pVertexBindingDescriptions;
 726         uint32_t                                                                        vertexAttributeDescriptionCount;
 727         const VkVertexInputAttributeDescription*        pVertexAttributeDescriptions;
 728 };
 729
 730 struct VkPipelineInputAssemblyStateCreateInfo
 731 {
 732         VkStructureType                                                 sType;
 733         const void*                                                             pNext;
 734         VkPipelineInputAssemblyStateCreateFlags flags;
 735         VkPrimitiveTopology                                             topology;
 736         VkBool32                                                                primitiveRestartEnable;
 737 };
 738
 739 struct VkPipelineTessellationStateCreateInfo
 740 {
 741         VkStructureType                                                 sType;
 742         const void*                                                             pNext;
 743         VkPipelineTessellationStateCreateFlags  flags;
 744         uint32_t                                                                patchControlPoints;
 745 };
 746
 747 struct VkViewport
 748 {
 749         float   x;
 750         float   y;
 751         float   width;
 752         float   height;
 753         float   minDepth;
 754         float   maxDepth;
 755 };
 756
 757 struct VkPipelineViewportStateCreateInfo
 758 {
 759         VkStructureType                                         sType;
 760         const void*                                                     pNext;
 761         VkPipelineViewportStateCreateFlags      flags;
 762         uint32_t                                                        viewportCount;
 763         const VkViewport*                                       pViewports;
 764         uint32_t                                                        scissorCount;
 765         const VkRect2D*                                         pScissors;
 766 };
 767
 768 struct VkPipelineRasterizationStateCreateInfo
 769 {
 770         VkStructureType                                                 sType;
 771         const void*                                                             pNext;
 772         VkPipelineRasterizationStateCreateFlags flags;
 773         VkBool32                                                                depthClampEnable;
 774         VkBool32                                                                rasterizerDiscardEnable;
 775         VkPolygonMode                                                   polygonMode;
 776         VkCullModeFlags                                                 cullMode;
 777         VkFrontFace                                                             frontFace;
 778         VkBool32                                                                depthBiasEnable;
 779         float                                                                   depthBiasConstantFactor;
 780         float                                                                   depthBiasClamp;
 781         float                                                                   depthBiasSlopeFactor;
 782         float                                                                   lineWidth;
 783 };
 784
 785 struct VkPipelineMultisampleStateCreateInfo
 786 {
 787         VkStructureType                                                 sType;
 788         const void*                                                             pNext;
 789         VkPipelineMultisampleStateCreateFlags   flags;
 790         VkSampleCountFlagBits                                   rasterizationSamples;
 791         VkBool32                                                                sampleShadingEnable;
 792         float                                                                   minSampleShading;
 793         const VkSampleMask*                                             pSampleMask;
 794         VkBool32                                                                alphaToCoverageEnable;
 795         VkBool32                                                                alphaToOneEnable;
 796 };
 797
 798 struct VkStencilOpState
 799 {
 800         VkStencilOp     failOp;
 801         VkStencilOp     passOp;
 802         VkStencilOp     depthFailOp;
 803         VkCompareOp     compareOp;
 804         uint32_t        compareMask;
 805         uint32_t        writeMask;
 806         uint32_t        reference;
 807 };
 808
 809 struct VkPipelineDepthStencilStateCreateInfo
 810 {
 811         VkStructureType                                                 sType;
 812         const void*                                                             pNext;
 813         VkPipelineDepthStencilStateCreateFlags  flags;
 814         VkBool32                                                                depthTestEnable;
 815         VkBool32                                                                depthWriteEnable;
 816         VkCompareOp                                                             depthCompareOp;
 817         VkBool32                                                                depthBoundsTestEnable;
 818         VkBool32                                                                stencilTestEnable;
 819         VkStencilOpState                                                front;
 820         VkStencilOpState                                                back;
 821         float                                                                   minDepthBounds;
 822         float                                                                   maxDepthBounds;
 823 };
 824
 825 struct VkPipelineColorBlendAttachmentState
 826 {
 827         VkBool32                                blendEnable;
 828         VkBlendFactor                   srcColorBlendFactor;
 829         VkBlendFactor                   dstColorBlendFactor;
 830         VkBlendOp                               colorBlendOp;
 831         VkBlendFactor                   srcAlphaBlendFactor;
 832         VkBlendFactor                   dstAlphaBlendFactor;
 833         VkBlendOp                               alphaBlendOp;
 834         VkColorComponentFlags   colorWriteMask;
 835 };
 836
 837 struct VkPipelineColorBlendStateCreateInfo
 838 {
 839         VkStructureType                                                         sType;
 840         const void*                                                                     pNext;
 841         VkPipelineColorBlendStateCreateFlags            flags;
 842         VkBool32                                                                        logicOpEnable;
 843         VkLogicOp                                                                       logicOp;
 844         uint32_t                                                                        attachmentCount;
 845         const VkPipelineColorBlendAttachmentState*      pAttachments;
 846         float                                                                           blendConstants[4];
 847 };
 848
 849 struct VkPipelineDynamicStateCreateInfo
 850 {
 851         VkStructureType                                         sType;
 852         const void*                                                     pNext;
 853         VkPipelineDynamicStateCreateFlags       flags;
 854         uint32_t                                                        dynamicStateCount;
 855         const VkDynamicState*                           pDynamicStates;
 856 };
 857
 858 struct VkGraphicsPipelineCreateInfo
 859 {
 860         VkStructureType                                                                 sType;
 861         const void*                                                                             pNext;
 862         VkPipelineCreateFlags                                                   flags;
 863         uint32_t                                                                                stageCount;
 864         const VkPipelineShaderStageCreateInfo*                  pStages;
 865         const VkPipelineVertexInputStateCreateInfo*             pVertexInputState;
 866         const VkPipelineInputAssemblyStateCreateInfo*   pInputAssemblyState;
 867         const VkPipelineTessellationStateCreateInfo*    pTessellationState;
 868         const VkPipelineViewportStateCreateInfo*                pViewportState;
 869         const VkPipelineRasterizationStateCreateInfo*   pRasterizationState;
 870         const VkPipelineMultisampleStateCreateInfo*             pMultisampleState;
 871         const VkPipelineDepthStencilStateCreateInfo*    pDepthStencilState;
 872         const VkPipelineColorBlendStateCreateInfo*              pColorBlendState;
 873         const VkPipelineDynamicStateCreateInfo*                 pDynamicState;
 874         VkPipelineLayout                                                                layout;
 875         VkRenderPass                                                                    renderPass;
 876         uint32_t                                                                                subpass;
 877         VkPipeline                                                                              basePipelineHandle;
 878         int32_t                                                                                 basePipelineIndex;
 879 };
 880
 881 struct VkPushConstantRange
 882 {
 883         VkShaderStageFlags      stageFlags;
 884         uint32_t                        offset;
 885         uint32_t                        size;
 886 };
 887
 888 struct VkPipelineLayoutCreateInfo
 889 {
 890         VkStructureType                                 sType;
 891         const void*                                             pNext;
 892         VkPipelineLayoutCreateFlags             flags;
 893         uint32_t                                                setLayoutCount;
 894         const VkDescriptorSetLayout*    pSetLayouts;
 895         uint32_t                                                pushConstantRangeCount;
 896         const VkPushConstantRange*              pPushConstantRanges;
 897 };
 898
 899 struct VkSamplerCreateInfo
 900 {
 901         VkStructureType                 sType;
 902         const void*                             pNext;
 903         VkSamplerCreateFlags    flags;
 904         VkFilter                                magFilter;
 905         VkFilter                                minFilter;
 906         VkSamplerMipmapMode             mipmapMode;
 907         VkSamplerAddressMode    addressModeU;
 908         VkSamplerAddressMode    addressModeV;
 909         VkSamplerAddressMode    addressModeW;
 910         float                                   mipLodBias;
 911         VkBool32                                anisotropyEnable;
 912         float                                   maxAnisotropy;
 913         VkBool32                                compareEnable;
 914         VkCompareOp                             compareOp;
 915         float                                   minLod;
 916         float                                   maxLod;
 917         VkBorderColor                   borderColor;
 918         VkBool32                                unnormalizedCoordinates;
 919 };
 920
 921 struct VkCopyDescriptorSet
 922 {
 923         VkStructureType sType;
 924         const void*             pNext;
 925         VkDescriptorSet srcSet;
 926         uint32_t                srcBinding;
 927         uint32_t                srcArrayElement;
 928         VkDescriptorSet dstSet;
 929         uint32_t                dstBinding;
 930         uint32_t                dstArrayElement;
 931         uint32_t                descriptorCount;
 932 };
 933
 934 struct VkDescriptorBufferInfo
 935 {
 936         VkBuffer                buffer;
 937         VkDeviceSize    offset;
 938         VkDeviceSize    range;
 939 };
 940
 941 struct VkDescriptorImageInfo
 942 {
 943         VkSampler               sampler;
 944         VkImageView             imageView;
 945         VkImageLayout   imageLayout;
 946 };
 947
 948 struct VkDescriptorPoolSize
 949 {
 950         VkDescriptorType        type;
 951         uint32_t                        descriptorCount;
 952 };
 953
 954 struct VkDescriptorPoolCreateInfo
 955 {
 956         VkStructureType                         sType;
 957         const void*                                     pNext;
 958         VkDescriptorPoolCreateFlags     flags;
 959         uint32_t                                        maxSets;
 960         uint32_t                                        poolSizeCount;
 961         const VkDescriptorPoolSize*     pPoolSizes;
 962 };
 963
 964 struct VkDescriptorSetAllocateInfo
 965 {
 966         VkStructureType                                 sType;
 967         const void*                                             pNext;
 968         VkDescriptorPool                                descriptorPool;
 969         uint32_t                                                descriptorSetCount;
 970         const VkDescriptorSetLayout*    pSetLayouts;
 971 };
 972
 973 struct VkDescriptorSetLayoutBinding
 974 {
 975         uint32_t                        binding;
 976         VkDescriptorType        descriptorType;
 977         uint32_t                        descriptorCount;
 978         VkShaderStageFlags      stageFlags;
 979         const VkSampler*        pImmutableSamplers;
 980 };
 981
 982 struct VkDescriptorSetLayoutCreateInfo
 983 {
 984         VkStructureType                                         sType;
 985         const void*                                                     pNext;
 986         VkDescriptorSetLayoutCreateFlags        flags;
 987         uint32_t                                                        bindingCount;
 988         const VkDescriptorSetLayoutBinding*     pBindings;
 989 };
 990
 991 struct VkWriteDescriptorSet
 992 {
 993         VkStructureType                                 sType;
 994         const void*                                             pNext;
 995         VkDescriptorSet                                 dstSet;
 996         uint32_t                                                dstBinding;
 997         uint32_t                                                dstArrayElement;
 998         uint32_t                                                descriptorCount;
 999         VkDescriptorType                                descriptorType;
1000         const VkDescriptorImageInfo*    pImageInfo;
1001         const VkDescriptorBufferInfo*   pBufferInfo;
1002         const VkBufferView*                             pTexelBufferView;
1003 };
1004
1005 struct VkAttachmentDescription
1006 {
1007         VkAttachmentDescriptionFlags    flags;
1008         VkFormat                                                format;
1009         VkSampleCountFlagBits                   samples;
1010         VkAttachmentLoadOp                              loadOp;
1011         VkAttachmentStoreOp                             storeOp;
1012         VkAttachmentLoadOp                              stencilLoadOp;
1013         VkAttachmentStoreOp                             stencilStoreOp;
1014         VkImageLayout                                   initialLayout;
1015         VkImageLayout                                   finalLayout;
1016 };
1017
1018 struct VkAttachmentReference
1019 {
1020         uint32_t                attachment;
1021         VkImageLayout   layout;
1022 };
1023
1024 struct VkFramebufferCreateInfo
1025 {
1026         VkStructureType                         sType;
1027         const void*                                     pNext;
1028         VkFramebufferCreateFlags        flags;
1029         VkRenderPass                            renderPass;
1030         uint32_t                                        attachmentCount;
1031         const VkImageView*                      pAttachments;
1032         uint32_t                                        width;
1033         uint32_t                                        height;
1034         uint32_t                                        layers;
1035 };
1036
1037 struct VkSubpassDescription
1038 {
1039         VkSubpassDescriptionFlags               flags;
1040         VkPipelineBindPoint                             pipelineBindPoint;
1041         uint32_t                                                inputAttachmentCount;
1042         const VkAttachmentReference*    pInputAttachments;
1043         uint32_t                                                colorAttachmentCount;
1044         const VkAttachmentReference*    pColorAttachments;
1045         const VkAttachmentReference*    pResolveAttachments;
1046         const VkAttachmentReference*    pDepthStencilAttachment;
1047         uint32_t                                                preserveAttachmentCount;
1048         const uint32_t*                                 pPreserveAttachments;
1049 };
1050
1051 struct VkSubpassDependency
1052 {
1053         uint32_t                                srcSubpass;
1054         uint32_t                                dstSubpass;
1055         VkPipelineStageFlags    srcStageMask;
1056         VkPipelineStageFlags    dstStageMask;
1057         VkAccessFlags                   srcAccessMask;
1058         VkAccessFlags                   dstAccessMask;
1059         VkDependencyFlags               dependencyFlags;
1060 };
1061
1062 struct VkRenderPassCreateInfo
1063 {
1064         VkStructureType                                 sType;
1065         const void*                                             pNext;
1066         VkRenderPassCreateFlags                 flags;
1067         uint32_t                                                attachmentCount;
1068         const VkAttachmentDescription*  pAttachments;
1069         uint32_t                                                subpassCount;
1070         const VkSubpassDescription*             pSubpasses;
1071         uint32_t                                                dependencyCount;
1072         const VkSubpassDependency*              pDependencies;
1073 };
1074
1075 struct VkCommandPoolCreateInfo
1076 {
1077         VkStructureType                         sType;
1078         const void*                                     pNext;
1079         VkCommandPoolCreateFlags        flags;
1080         uint32_t                                        queueFamilyIndex;
1081 };
1082
1083 struct VkCommandBufferAllocateInfo
1084 {
1085         VkStructureType                 sType;
1086         const void*                             pNext;
1087         VkCommandPool                   commandPool;
1088         VkCommandBufferLevel    level;
1089         uint32_t                                commandBufferCount;
1090 };
1091
1092 struct VkCommandBufferInheritanceInfo
1093 {
1094         VkStructureType                                 sType;
1095         const void*                                             pNext;
1096         VkRenderPass                                    renderPass;
1097         uint32_t                                                subpass;
1098         VkFramebuffer                                   framebuffer;
1099         VkBool32                                                occlusionQueryEnable;
1100         VkQueryControlFlags                             queryFlags;
1101         VkQueryPipelineStatisticFlags   pipelineStatistics;
1102 };
1103
1104 struct VkCommandBufferBeginInfo
1105 {
1106         VkStructureType                                                 sType;
1107         const void*                                                             pNext;
1108         VkCommandBufferUsageFlags                               flags;
1109         const VkCommandBufferInheritanceInfo*   pInheritanceInfo;
1110 };
1111
1112 struct VkBufferCopy
1113 {
1114         VkDeviceSize    srcOffset;
1115         VkDeviceSize    dstOffset;
1116         VkDeviceSize    size;
1117 };
1118
1119 struct VkImageSubresourceLayers
1120 {
1121         VkImageAspectFlags      aspectMask;
1122         uint32_t                        mipLevel;
1123         uint32_t                        baseArrayLayer;
1124         uint32_t                        layerCount;
1125 };
1126
1127 struct VkBufferImageCopy
1128 {
1129         VkDeviceSize                            bufferOffset;
1130         uint32_t                                        bufferRowLength;
1131         uint32_t                                        bufferImageHeight;
1132         VkImageSubresourceLayers        imageSubresource;
1133         VkOffset3D                                      imageOffset;
1134         VkExtent3D                                      imageExtent;
1135 };
1136
1137 union VkClearColorValue
1138 {
1139         float           float32[4];
1140         int32_t         int32[4];
1141         uint32_t        uint32[4];
1142 };
1143
1144 struct VkClearDepthStencilValue
1145 {
1146         float           depth;
1147         uint32_t        stencil;
1148 };
1149
1150 union VkClearValue
1151 {
1152         VkClearColorValue                       color;
1153         VkClearDepthStencilValue        depthStencil;
1154 };
1155
1156 struct VkClearAttachment
1157 {
1158         VkImageAspectFlags      aspectMask;
1159         uint32_t                        colorAttachment;
1160         VkClearValue            clearValue;
1161 };
1162
1163 struct VkClearRect
1164 {
1165         VkRect2D        rect;
1166         uint32_t        baseArrayLayer;
1167         uint32_t        layerCount;
1168 };
1169
1170 struct VkImageBlit
1171 {
1172         VkImageSubresourceLayers        srcSubresource;
1173         VkOffset3D                                      srcOffsets[2];
1174         VkImageSubresourceLayers        dstSubresource;
1175         VkOffset3D                                      dstOffsets[2];
1176 };
1177
1178 struct VkImageCopy
1179 {
1180         VkImageSubresourceLayers        srcSubresource;
1181         VkOffset3D                                      srcOffset;
1182         VkImageSubresourceLayers        dstSubresource;
1183         VkOffset3D                                      dstOffset;
1184         VkExtent3D                                      extent;
1185 };
1186
1187 struct VkImageResolve
1188 {
1189         VkImageSubresourceLayers        srcSubresource;
1190         VkOffset3D                                      srcOffset;
1191         VkImageSubresourceLayers        dstSubresource;
1192         VkOffset3D                                      dstOffset;
1193         VkExtent3D                                      extent;
1194 };
1195
1196 struct VkRenderPassBeginInfo
1197 {
1198         VkStructureType         sType;
1199         const void*                     pNext;
1200         VkRenderPass            renderPass;
1201         VkFramebuffer           framebuffer;
1202         VkRect2D                        renderArea;
1203         uint32_t                        clearValueCount;
1204         const VkClearValue*     pClearValues;
1205 };
1206
1207 struct VkPhysicalDeviceSubgroupProperties
1208 {
1209         VkStructureType                 sType;
1210         void*                                   pNext;
1211         uint32_t                                subgroupSize;
1212         VkShaderStageFlags              supportedStages;
1213         VkSubgroupFeatureFlags  supportedOperations;
1214         VkBool32                                quadOperationsInAllStages;
1215 };
1216
1217 struct VkBindBufferMemoryInfo
1218 {
1219         VkStructureType sType;
1220         const void*             pNext;
1221         VkBuffer                buffer;
1222         VkDeviceMemory  memory;
1223         VkDeviceSize    memoryOffset;
1224 };
1225
1226 struct VkBindImageMemoryInfo
1227 {
1228         VkStructureType sType;
1229         const void*             pNext;
1230         VkImage                 image;
1231         VkDeviceMemory  memory;
1232         VkDeviceSize    memoryOffset;
1233 };
1234
1235 struct VkPhysicalDevice16BitStorageFeatures
1236 {
1237         VkStructureType sType;
1238         void*                   pNext;
1239         VkBool32                storageBuffer16BitAccess;
1240         VkBool32                uniformAndStorageBuffer16BitAccess;
1241         VkBool32                storagePushConstant16;
1242         VkBool32                storageInputOutput16;
1243 };
1244
1245 struct VkMemoryDedicatedRequirements
1246 {
1247         VkStructureType sType;
1248         void*                   pNext;
1249         VkBool32                prefersDedicatedAllocation;
1250         VkBool32                requiresDedicatedAllocation;
1251 };
1252
1253 struct VkMemoryDedicatedAllocateInfo
1254 {
1255         VkStructureType sType;
1256         const void*             pNext;
1257         VkImage                 image;
1258         VkBuffer                buffer;
1259 };
1260
1261 struct VkMemoryAllocateFlagsInfo
1262 {
1263         VkStructureType                 sType;
1264         const void*                             pNext;
1265         VkMemoryAllocateFlags   flags;
1266         uint32_t                                deviceMask;
1267 };
1268
1269 struct VkDeviceGroupRenderPassBeginInfo
1270 {
1271         VkStructureType sType;
1272         const void*             pNext;
1273         uint32_t                deviceMask;
1274         uint32_t                deviceRenderAreaCount;
1275         const VkRect2D* pDeviceRenderAreas;
1276 };
1277
1278 struct VkDeviceGroupCommandBufferBeginInfo
1279 {
1280         VkStructureType sType;
1281         const void*             pNext;
1282         uint32_t                deviceMask;
1283 };
1284
1285 struct VkDeviceGroupSubmitInfo
1286 {
1287         VkStructureType sType;
1288         const void*             pNext;
1289         uint32_t                waitSemaphoreCount;
1290         const uint32_t* pWaitSemaphoreDeviceIndices;
1291         uint32_t                commandBufferCount;
1292         const uint32_t* pCommandBufferDeviceMasks;
1293         uint32_t                signalSemaphoreCount;
1294         const uint32_t* pSignalSemaphoreDeviceIndices;
1295 };
1296
1297 struct VkDeviceGroupBindSparseInfo
1298 {
1299         VkStructureType sType;
1300         const void*             pNext;
1301         uint32_t                resourceDeviceIndex;
1302         uint32_t                memoryDeviceIndex;
1303 };
1304
1305 struct VkBindBufferMemoryDeviceGroupInfo
1306 {
1307         VkStructureType sType;
1308         const void*             pNext;
1309         uint32_t                deviceIndexCount;
1310         const uint32_t* pDeviceIndices;
1311 };
1312
1313 struct VkBindImageMemoryDeviceGroupInfo
1314 {
1315         VkStructureType sType;
1316         const void*             pNext;
1317         uint32_t                deviceIndexCount;
1318         const uint32_t* pDeviceIndices;
1319         uint32_t                splitInstanceBindRegionCount;
1320         const VkRect2D* pSplitInstanceBindRegions;
1321 };
1322
1323 struct VkPhysicalDeviceGroupProperties
1324 {
1325         VkStructureType         sType;
1326         void*                           pNext;
1327         uint32_t                        physicalDeviceCount;
1328         VkPhysicalDevice        physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
1329         VkBool32                        subsetAllocation;
1330 };
1331
1332 struct VkDeviceGroupDeviceCreateInfo
1333 {
1334         VkStructureType                 sType;
1335         const void*                             pNext;
1336         uint32_t                                physicalDeviceCount;
1337         const VkPhysicalDevice* pPhysicalDevices;
1338 };
1339
1340 struct VkBufferMemoryRequirementsInfo2
1341 {
1342         VkStructureType sType;
1343         const void*             pNext;
1344         VkBuffer                buffer;
1345 };
1346
1347 struct VkImageMemoryRequirementsInfo2
1348 {
1349         VkStructureType sType;
1350         const void*             pNext;
1351         VkImage                 image;
1352 };
1353
1354 struct VkImageSparseMemoryRequirementsInfo2
1355 {
1356         VkStructureType sType;
1357         const void*             pNext;
1358         VkImage                 image;
1359 };
1360
1361 struct VkMemoryRequirements2
1362 {
1363         VkStructureType                 sType;
1364         void*                                   pNext;
1365         VkMemoryRequirements    memoryRequirements;
1366 };
1367
1368 struct VkSparseImageMemoryRequirements2
1369 {
1370         VkStructureType                                 sType;
1371         void*                                                   pNext;
1372         VkSparseImageMemoryRequirements memoryRequirements;
1373 };
1374
1375 struct VkPhysicalDeviceFeatures2
1376 {
1377         VkStructureType                         sType;
1378         void*                                           pNext;
1379         VkPhysicalDeviceFeatures        features;
1380 };
1381
1382 struct VkPhysicalDeviceProperties2
1383 {
1384         VkStructureType                         sType;
1385         void*                                           pNext;
1386         VkPhysicalDeviceProperties      properties;
1387 };
1388
1389 struct VkFormatProperties2
1390 {
1391         VkStructureType         sType;
1392         void*                           pNext;
1393         VkFormatProperties      formatProperties;
1394 };
1395
1396 struct VkImageFormatProperties2
1397 {
1398         VkStructureType                 sType;
1399         void*                                   pNext;
1400         VkImageFormatProperties imageFormatProperties;
1401 };
1402
1403 struct VkPhysicalDeviceImageFormatInfo2
1404 {
1405         VkStructureType         sType;
1406         const void*                     pNext;
1407         VkFormat                        format;
1408         VkImageType                     type;
1409         VkImageTiling           tiling;
1410         VkImageUsageFlags       usage;
1411         VkImageCreateFlags      flags;
1412 };
1413
1414 struct VkQueueFamilyProperties2
1415 {
1416         VkStructureType                 sType;
1417         void*                                   pNext;
1418         VkQueueFamilyProperties queueFamilyProperties;
1419 };
1420
1421 struct VkPhysicalDeviceMemoryProperties2
1422 {
1423         VkStructureType                                         sType;
1424         void*                                                           pNext;
1425         VkPhysicalDeviceMemoryProperties        memoryProperties;
1426 };
1427
1428 struct VkSparseImageFormatProperties2
1429 {
1430         VkStructureType                                 sType;
1431         void*                                                   pNext;
1432         VkSparseImageFormatProperties   properties;
1433 };
1434
1435 struct VkPhysicalDeviceSparseImageFormatInfo2
1436 {
1437         VkStructureType                 sType;
1438         const void*                             pNext;
1439         VkFormat                                format;
1440         VkImageType                             type;
1441         VkSampleCountFlagBits   samples;
1442         VkImageUsageFlags               usage;
1443         VkImageTiling                   tiling;
1444 };
1445
1446 struct VkPhysicalDevicePointClippingProperties
1447 {
1448         VkStructureType                 sType;
1449         void*                                   pNext;
1450         VkPointClippingBehavior pointClippingBehavior;
1451 };
1452
1453 struct VkInputAttachmentAspectReference
1454 {
1455         uint32_t                        subpass;
1456         uint32_t                        inputAttachmentIndex;
1457         VkImageAspectFlags      aspectMask;
1458 };
1459
1460 struct VkRenderPassInputAttachmentAspectCreateInfo
1461 {
1462         VkStructureType                                                 sType;
1463         const void*                                                             pNext;
1464         uint32_t                                                                aspectReferenceCount;
1465         const VkInputAttachmentAspectReference* pAspectReferences;
1466 };
1467
1468 struct VkImageViewUsageCreateInfo
1469 {
1470         VkStructureType         sType;
1471         const void*                     pNext;
1472         VkImageUsageFlags       usage;
1473 };
1474
1475 struct VkPipelineTessellationDomainOriginStateCreateInfo
1476 {
1477         VkStructureType                         sType;
1478         const void*                                     pNext;
1479         VkTessellationDomainOrigin      domainOrigin;
1480 };
1481
1482 struct VkRenderPassMultiviewCreateInfo
1483 {
1484         VkStructureType sType;
1485         const void*             pNext;
1486         uint32_t                subpassCount;
1487         const uint32_t* pViewMasks;
1488         uint32_t                dependencyCount;
1489         const int32_t*  pViewOffsets;
1490         uint32_t                correlationMaskCount;
1491         const uint32_t* pCorrelationMasks;
1492 };
1493
1494 struct VkPhysicalDeviceMultiviewFeatures
1495 {
1496         VkStructureType sType;
1497         void*                   pNext;
1498         VkBool32                multiview;
1499         VkBool32                multiviewGeometryShader;
1500         VkBool32                multiviewTessellationShader;
1501 };
1502
1503 struct VkPhysicalDeviceMultiviewProperties
1504 {
1505         VkStructureType sType;
1506         void*                   pNext;
1507         uint32_t                maxMultiviewViewCount;
1508         uint32_t                maxMultiviewInstanceIndex;
1509 };
1510
1511 struct VkPhysicalDeviceVariablePointersFeatures
1512 {
1513         VkStructureType sType;
1514         void*                   pNext;
1515         VkBool32                variablePointersStorageBuffer;
1516         VkBool32                variablePointers;
1517 };
1518
1519 struct VkPhysicalDeviceProtectedMemoryFeatures
1520 {
1521         VkStructureType sType;
1522         void*                   pNext;
1523         VkBool32                protectedMemory;
1524 };
1525
1526 struct VkPhysicalDeviceProtectedMemoryProperties
1527 {
1528         VkStructureType sType;
1529         void*                   pNext;
1530         VkBool32                protectedNoFault;
1531 };
1532
1533 struct VkDeviceQueueInfo2
1534 {
1535         VkStructureType                         sType;
1536         const void*                                     pNext;
1537         VkDeviceQueueCreateFlags        flags;
1538         uint32_t                                        queueFamilyIndex;
1539         uint32_t                                        queueIndex;
1540 };
1541
1542 struct VkProtectedSubmitInfo
1543 {
1544         VkStructureType sType;
1545         const void*             pNext;
1546         VkBool32                protectedSubmit;
1547 };
1548
1549 struct VkSamplerYcbcrConversionCreateInfo
1550 {
1551         VkStructureType                                 sType;
1552         const void*                                             pNext;
1553         VkFormat                                                format;
1554         VkSamplerYcbcrModelConversion   ycbcrModel;
1555         VkSamplerYcbcrRange                             ycbcrRange;
1556         VkComponentMapping                              components;
1557         VkChromaLocation                                xChromaOffset;
1558         VkChromaLocation                                yChromaOffset;
1559         VkFilter                                                chromaFilter;
1560         VkBool32                                                forceExplicitReconstruction;
1561 };
1562
1563 struct VkSamplerYcbcrConversionInfo
1564 {
1565         VkStructureType                         sType;
1566         const void*                                     pNext;
1567         VkSamplerYcbcrConversion        conversion;
1568 };
1569
1570 struct VkBindImagePlaneMemoryInfo
1571 {
1572         VkStructureType                 sType;
1573         const void*                             pNext;
1574         VkImageAspectFlagBits   planeAspect;
1575 };
1576
1577 struct VkImagePlaneMemoryRequirementsInfo
1578 {
1579         VkStructureType                 sType;
1580         const void*                             pNext;
1581         VkImageAspectFlagBits   planeAspect;
1582 };
1583
1584 struct VkPhysicalDeviceSamplerYcbcrConversionFeatures
1585 {
1586         VkStructureType sType;
1587         void*                   pNext;
1588         VkBool32                samplerYcbcrConversion;
1589 };
1590
1591 struct VkSamplerYcbcrConversionImageFormatProperties
1592 {
1593         VkStructureType sType;
1594         void*                   pNext;
1595         uint32_t                combinedImageSamplerDescriptorCount;
1596 };
1597
1598 struct VkDescriptorUpdateTemplateEntry
1599 {
1600         uint32_t                        dstBinding;
1601         uint32_t                        dstArrayElement;
1602         uint32_t                        descriptorCount;
1603         VkDescriptorType        descriptorType;
1604         size_t                          offset;
1605         size_t                          stride;
1606 };
1607
1608 struct VkDescriptorUpdateTemplateCreateInfo
1609 {
1610         VkStructureType                                                 sType;
1611         const void*                                                             pNext;
1612         VkDescriptorUpdateTemplateCreateFlags   flags;
1613         uint32_t                                                                descriptorUpdateEntryCount;
1614         const VkDescriptorUpdateTemplateEntry*  pDescriptorUpdateEntries;
1615         VkDescriptorUpdateTemplateType                  templateType;
1616         VkDescriptorSetLayout                                   descriptorSetLayout;
1617         VkPipelineBindPoint                                             pipelineBindPoint;
1618         VkPipelineLayout                                                pipelineLayout;
1619         uint32_t                                                                set;
1620 };
1621
1622 struct VkExternalMemoryProperties
1623 {
1624         VkExternalMemoryFeatureFlags    externalMemoryFeatures;
1625         VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
1626         VkExternalMemoryHandleTypeFlags compatibleHandleTypes;
1627 };
1628
1629 struct VkPhysicalDeviceExternalImageFormatInfo
1630 {
1631         VkStructureType                                         sType;
1632         const void*                                                     pNext;
1633         VkExternalMemoryHandleTypeFlagBits      handleType;
1634 };
1635
1636 struct VkExternalImageFormatProperties
1637 {
1638         VkStructureType                         sType;
1639         void*                                           pNext;
1640         VkExternalMemoryProperties      externalMemoryProperties;
1641 };
1642
1643 struct VkPhysicalDeviceExternalBufferInfo
1644 {
1645         VkStructureType                                         sType;
1646         const void*                                                     pNext;
1647         VkBufferCreateFlags                                     flags;
1648         VkBufferUsageFlags                                      usage;
1649         VkExternalMemoryHandleTypeFlagBits      handleType;
1650 };
1651
1652 struct VkExternalBufferProperties
1653 {
1654         VkStructureType                         sType;
1655         void*                                           pNext;
1656         VkExternalMemoryProperties      externalMemoryProperties;
1657 };
1658
1659 struct VkPhysicalDeviceIDProperties
1660 {
1661         VkStructureType sType;
1662         void*                   pNext;
1663         uint8_t                 deviceUUID[VK_UUID_SIZE];
1664         uint8_t                 driverUUID[VK_UUID_SIZE];
1665         uint8_t                 deviceLUID[VK_LUID_SIZE];
1666         uint32_t                deviceNodeMask;
1667         VkBool32                deviceLUIDValid;
1668 };
1669
1670 struct VkExternalMemoryImageCreateInfo
1671 {
1672         VkStructureType                                 sType;
1673         const void*                                             pNext;
1674         VkExternalMemoryHandleTypeFlags handleTypes;
1675 };
1676
1677 struct VkExternalMemoryBufferCreateInfo
1678 {
1679         VkStructureType                                 sType;
1680         const void*                                             pNext;
1681         VkExternalMemoryHandleTypeFlags handleTypes;
1682 };
1683
1684 struct VkExportMemoryAllocateInfo
1685 {
1686         VkStructureType                                 sType;
1687         const void*                                             pNext;
1688         VkExternalMemoryHandleTypeFlags handleTypes;
1689 };
1690
1691 struct VkPhysicalDeviceExternalFenceInfo
1692 {
1693         VkStructureType                                         sType;
1694         const void*                                                     pNext;
1695         VkExternalFenceHandleTypeFlagBits       handleType;
1696 };
1697
1698 struct VkExternalFenceProperties
1699 {
1700         VkStructureType                                 sType;
1701         void*                                                   pNext;
1702         VkExternalFenceHandleTypeFlags  exportFromImportedHandleTypes;
1703         VkExternalFenceHandleTypeFlags  compatibleHandleTypes;
1704         VkExternalFenceFeatureFlags             externalFenceFeatures;
1705 };
1706
1707 struct VkExportFenceCreateInfo
1708 {
1709         VkStructureType                                 sType;
1710         const void*                                             pNext;
1711         VkExternalFenceHandleTypeFlags  handleTypes;
1712 };
1713
1714 struct VkExportSemaphoreCreateInfo
1715 {
1716         VkStructureType                                         sType;
1717         const void*                                                     pNext;
1718         VkExternalSemaphoreHandleTypeFlags      handleTypes;
1719 };
1720
1721 struct VkPhysicalDeviceExternalSemaphoreInfo
1722 {
1723         VkStructureType                                                 sType;
1724         const void*                                                             pNext;
1725         VkExternalSemaphoreHandleTypeFlagBits   handleType;
1726 };
1727
1728 struct VkExternalSemaphoreProperties
1729 {
1730         VkStructureType                                         sType;
1731         void*                                                           pNext;
1732         VkExternalSemaphoreHandleTypeFlags      exportFromImportedHandleTypes;
1733         VkExternalSemaphoreHandleTypeFlags      compatibleHandleTypes;
1734         VkExternalSemaphoreFeatureFlags         externalSemaphoreFeatures;
1735 };
1736
1737 struct VkPhysicalDeviceMaintenance3Properties
1738 {
1739         VkStructureType sType;
1740         void*                   pNext;
1741         uint32_t                maxPerSetDescriptors;
1742         VkDeviceSize    maxMemoryAllocationSize;
1743 };
1744
1745 struct VkDescriptorSetLayoutSupport
1746 {
1747         VkStructureType sType;
1748         void*                   pNext;
1749         VkBool32                supported;
1750 };
1751
1752 struct VkPhysicalDeviceShaderDrawParametersFeatures
1753 {
1754         VkStructureType sType;
1755         void*                   pNext;
1756         VkBool32                shaderDrawParameters;
1757 };
1758
1759 struct VkPhysicalDeviceVulkan11Features
1760 {
1761         VkStructureType sType;
1762         void*                   pNext;
1763         VkBool32                storageBuffer16BitAccess;
1764         VkBool32                uniformAndStorageBuffer16BitAccess;
1765         VkBool32                storagePushConstant16;
1766         VkBool32                storageInputOutput16;
1767         VkBool32                multiview;
1768         VkBool32                multiviewGeometryShader;
1769         VkBool32                multiviewTessellationShader;
1770         VkBool32                variablePointersStorageBuffer;
1771         VkBool32                variablePointers;
1772         VkBool32                protectedMemory;
1773         VkBool32                samplerYcbcrConversion;
1774         VkBool32                shaderDrawParameters;
1775 };
1776
1777 struct VkPhysicalDeviceVulkan11Properties
1778 {
1779         VkStructureType                 sType;
1780         void*                                   pNext;
1781         uint8_t                                 deviceUUID[VK_UUID_SIZE];
1782         uint8_t                                 driverUUID[VK_UUID_SIZE];
1783         uint8_t                                 deviceLUID[VK_LUID_SIZE];
1784         uint32_t                                deviceNodeMask;
1785         VkBool32                                deviceLUIDValid;
1786         uint32_t                                subgroupSize;
1787         VkShaderStageFlags              subgroupSupportedStages;
1788         VkSubgroupFeatureFlags  subgroupSupportedOperations;
1789         VkBool32                                subgroupQuadOperationsInAllStages;
1790         VkPointClippingBehavior pointClippingBehavior;
1791         uint32_t                                maxMultiviewViewCount;
1792         uint32_t                                maxMultiviewInstanceIndex;
1793         VkBool32                                protectedNoFault;
1794         uint32_t                                maxPerSetDescriptors;
1795         VkDeviceSize                    maxMemoryAllocationSize;
1796 };
1797
1798 struct VkPhysicalDeviceVulkan12Features
1799 {
1800         VkStructureType sType;
1801         void*                   pNext;
1802         VkBool32                samplerMirrorClampToEdge;
1803         VkBool32                drawIndirectCount;
1804         VkBool32                storageBuffer8BitAccess;
1805         VkBool32                uniformAndStorageBuffer8BitAccess;
1806         VkBool32                storagePushConstant8;
1807         VkBool32                shaderBufferInt64Atomics;
1808         VkBool32                shaderSharedInt64Atomics;
1809         VkBool32                shaderFloat16;
1810         VkBool32                shaderInt8;
1811         VkBool32                descriptorIndexing;
1812         VkBool32                shaderInputAttachmentArrayDynamicIndexing;
1813         VkBool32                shaderUniformTexelBufferArrayDynamicIndexing;
1814         VkBool32                shaderStorageTexelBufferArrayDynamicIndexing;
1815         VkBool32                shaderUniformBufferArrayNonUniformIndexing;
1816         VkBool32                shaderSampledImageArrayNonUniformIndexing;
1817         VkBool32                shaderStorageBufferArrayNonUniformIndexing;
1818         VkBool32                shaderStorageImageArrayNonUniformIndexing;
1819         VkBool32                shaderInputAttachmentArrayNonUniformIndexing;
1820         VkBool32                shaderUniformTexelBufferArrayNonUniformIndexing;
1821         VkBool32                shaderStorageTexelBufferArrayNonUniformIndexing;
1822         VkBool32                descriptorBindingUniformBufferUpdateAfterBind;
1823         VkBool32                descriptorBindingSampledImageUpdateAfterBind;
1824         VkBool32                descriptorBindingStorageImageUpdateAfterBind;
1825         VkBool32                descriptorBindingStorageBufferUpdateAfterBind;
1826         VkBool32                descriptorBindingUniformTexelBufferUpdateAfterBind;
1827         VkBool32                descriptorBindingStorageTexelBufferUpdateAfterBind;
1828         VkBool32                descriptorBindingUpdateUnusedWhilePending;
1829         VkBool32                descriptorBindingPartiallyBound;
1830         VkBool32                descriptorBindingVariableDescriptorCount;
1831         VkBool32                runtimeDescriptorArray;
1832         VkBool32                samplerFilterMinmax;
1833         VkBool32                scalarBlockLayout;
1834         VkBool32                imagelessFramebuffer;
1835         VkBool32                uniformBufferStandardLayout;
1836         VkBool32                shaderSubgroupExtendedTypes;
1837         VkBool32                separateDepthStencilLayouts;
1838         VkBool32                hostQueryReset;
1839         VkBool32                timelineSemaphore;
1840         VkBool32                bufferDeviceAddress;
1841         VkBool32                bufferDeviceAddressCaptureReplay;
1842         VkBool32                bufferDeviceAddressMultiDevice;
1843         VkBool32                vulkanMemoryModel;
1844         VkBool32                vulkanMemoryModelDeviceScope;
1845         VkBool32                vulkanMemoryModelAvailabilityVisibilityChains;
1846         VkBool32                shaderOutputViewportIndex;
1847         VkBool32                shaderOutputLayer;
1848         VkBool32                subgroupBroadcastDynamicId;
1849 };
1850
1851 struct VkConformanceVersion
1852 {
1853         uint8_t major;
1854         uint8_t minor;
1855         uint8_t subminor;
1856         uint8_t patch;
1857 };
1858
1859 struct VkPhysicalDeviceVulkan12Properties
1860 {
1861         VkStructureType                                         sType;
1862         void*                                                           pNext;
1863         VkDriverId                                                      driverID;
1864         char                                                            driverName[VK_MAX_DRIVER_NAME_SIZE];
1865         char                                                            driverInfo[VK_MAX_DRIVER_INFO_SIZE];
1866         VkConformanceVersion                            conformanceVersion;
1867         VkShaderFloatControlsIndependence       denormBehaviorIndependence;
1868         VkShaderFloatControlsIndependence       roundingModeIndependence;
1869         VkBool32                                                        shaderSignedZeroInfNanPreserveFloat16;
1870         VkBool32                                                        shaderSignedZeroInfNanPreserveFloat32;
1871         VkBool32                                                        shaderSignedZeroInfNanPreserveFloat64;
1872         VkBool32                                                        shaderDenormPreserveFloat16;
1873         VkBool32                                                        shaderDenormPreserveFloat32;
1874         VkBool32                                                        shaderDenormPreserveFloat64;
1875         VkBool32                                                        shaderDenormFlushToZeroFloat16;
1876         VkBool32                                                        shaderDenormFlushToZeroFloat32;
1877         VkBool32                                                        shaderDenormFlushToZeroFloat64;
1878         VkBool32                                                        shaderRoundingModeRTEFloat16;
1879         VkBool32                                                        shaderRoundingModeRTEFloat32;
1880         VkBool32                                                        shaderRoundingModeRTEFloat64;
1881         VkBool32                                                        shaderRoundingModeRTZFloat16;
1882         VkBool32                                                        shaderRoundingModeRTZFloat32;
1883         VkBool32                                                        shaderRoundingModeRTZFloat64;
1884         uint32_t                                                        maxUpdateAfterBindDescriptorsInAllPools;
1885         VkBool32                                                        shaderUniformBufferArrayNonUniformIndexingNative;
1886         VkBool32                                                        shaderSampledImageArrayNonUniformIndexingNative;
1887         VkBool32                                                        shaderStorageBufferArrayNonUniformIndexingNative;
1888         VkBool32                                                        shaderStorageImageArrayNonUniformIndexingNative;
1889         VkBool32                                                        shaderInputAttachmentArrayNonUniformIndexingNative;
1890         VkBool32                                                        robustBufferAccessUpdateAfterBind;
1891         VkBool32                                                        quadDivergentImplicitLod;
1892         uint32_t                                                        maxPerStageDescriptorUpdateAfterBindSamplers;
1893         uint32_t                                                        maxPerStageDescriptorUpdateAfterBindUniformBuffers;
1894         uint32_t                                                        maxPerStageDescriptorUpdateAfterBindStorageBuffers;
1895         uint32_t                                                        maxPerStageDescriptorUpdateAfterBindSampledImages;
1896         uint32_t                                                        maxPerStageDescriptorUpdateAfterBindStorageImages;
1897         uint32_t                                                        maxPerStageDescriptorUpdateAfterBindInputAttachments;
1898         uint32_t                                                        maxPerStageUpdateAfterBindResources;
1899         uint32_t                                                        maxDescriptorSetUpdateAfterBindSamplers;
1900         uint32_t                                                        maxDescriptorSetUpdateAfterBindUniformBuffers;
1901         uint32_t                                                        maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
1902         uint32_t                                                        maxDescriptorSetUpdateAfterBindStorageBuffers;
1903         uint32_t                                                        maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
1904         uint32_t                                                        maxDescriptorSetUpdateAfterBindSampledImages;
1905         uint32_t                                                        maxDescriptorSetUpdateAfterBindStorageImages;
1906         uint32_t                                                        maxDescriptorSetUpdateAfterBindInputAttachments;
1907         VkResolveModeFlags                                      supportedDepthResolveModes;
1908         VkResolveModeFlags                                      supportedStencilResolveModes;
1909         VkBool32                                                        independentResolveNone;
1910         VkBool32                                                        independentResolve;
1911         VkBool32                                                        filterMinmaxSingleComponentFormats;
1912         VkBool32                                                        filterMinmaxImageComponentMapping;
1913         uint64_t                                                        maxTimelineSemaphoreValueDifference;
1914         VkSampleCountFlags                                      framebufferIntegerColorSampleCounts;
1915 };
1916
1917 struct VkImageFormatListCreateInfo
1918 {
1919         VkStructureType sType;
1920         const void*             pNext;
1921         uint32_t                viewFormatCount;
1922         const VkFormat* pViewFormats;
1923 };
1924
1925 struct VkAttachmentDescription2
1926 {
1927         VkStructureType                                 sType;
1928         const void*                                             pNext;
1929         VkAttachmentDescriptionFlags    flags;
1930         VkFormat                                                format;
1931         VkSampleCountFlagBits                   samples;
1932         VkAttachmentLoadOp                              loadOp;
1933         VkAttachmentStoreOp                             storeOp;
1934         VkAttachmentLoadOp                              stencilLoadOp;
1935         VkAttachmentStoreOp                             stencilStoreOp;
1936         VkImageLayout                                   initialLayout;
1937         VkImageLayout                                   finalLayout;
1938 };
1939
1940 struct VkAttachmentReference2
1941 {
1942         VkStructureType         sType;
1943         const void*                     pNext;
1944         uint32_t                        attachment;
1945         VkImageLayout           layout;
1946         VkImageAspectFlags      aspectMask;
1947 };
1948
1949 struct VkSubpassDescription2
1950 {
1951         VkStructureType                                 sType;
1952         const void*                                             pNext;
1953         VkSubpassDescriptionFlags               flags;
1954         VkPipelineBindPoint                             pipelineBindPoint;
1955         uint32_t                                                viewMask;
1956         uint32_t                                                inputAttachmentCount;
1957         const VkAttachmentReference2*   pInputAttachments;
1958         uint32_t                                                colorAttachmentCount;
1959         const VkAttachmentReference2*   pColorAttachments;
1960         const VkAttachmentReference2*   pResolveAttachments;
1961         const VkAttachmentReference2*   pDepthStencilAttachment;
1962         uint32_t                                                preserveAttachmentCount;
1963         const uint32_t*                                 pPreserveAttachments;
1964 };
1965
1966 struct VkSubpassDependency2
1967 {
1968         VkStructureType                 sType;
1969         const void*                             pNext;
1970         uint32_t                                srcSubpass;
1971         uint32_t                                dstSubpass;
1972         VkPipelineStageFlags    srcStageMask;
1973         VkPipelineStageFlags    dstStageMask;
1974         VkAccessFlags                   srcAccessMask;
1975         VkAccessFlags                   dstAccessMask;
1976         VkDependencyFlags               dependencyFlags;
1977         int32_t                                 viewOffset;
1978 };
1979
1980 struct VkRenderPassCreateInfo2
1981 {
1982         VkStructureType                                 sType;
1983         const void*                                             pNext;
1984         VkRenderPassCreateFlags                 flags;
1985         uint32_t                                                attachmentCount;
1986         const VkAttachmentDescription2* pAttachments;
1987         uint32_t                                                subpassCount;
1988         const VkSubpassDescription2*    pSubpasses;
1989         uint32_t                                                dependencyCount;
1990         const VkSubpassDependency2*             pDependencies;
1991         uint32_t                                                correlatedViewMaskCount;
1992         const uint32_t*                                 pCorrelatedViewMasks;
1993 };
1994
1995 struct VkSubpassBeginInfo
1996 {
1997         VkStructureType         sType;
1998         const void*                     pNext;
1999         VkSubpassContents       contents;
2000 };
2001
2002 struct VkSubpassEndInfo
2003 {
2004         VkStructureType sType;
2005         const void*             pNext;
2006 };
2007
2008 struct VkPhysicalDevice8BitStorageFeatures
2009 {
2010         VkStructureType sType;
2011         void*                   pNext;
2012         VkBool32                storageBuffer8BitAccess;
2013         VkBool32                uniformAndStorageBuffer8BitAccess;
2014         VkBool32                storagePushConstant8;
2015 };
2016
2017 struct VkPhysicalDeviceDriverProperties
2018 {
2019         VkStructureType                 sType;
2020         void*                                   pNext;
2021         VkDriverId                              driverID;
2022         char                                    driverName[VK_MAX_DRIVER_NAME_SIZE];
2023         char                                    driverInfo[VK_MAX_DRIVER_INFO_SIZE];
2024         VkConformanceVersion    conformanceVersion;
2025 };
2026
2027 struct VkPhysicalDeviceShaderAtomicInt64Features
2028 {
2029         VkStructureType sType;
2030         void*                   pNext;
2031         VkBool32                shaderBufferInt64Atomics;
2032         VkBool32                shaderSharedInt64Atomics;
2033 };
2034
2035 struct VkPhysicalDeviceShaderFloat16Int8Features
2036 {
2037         VkStructureType sType;
2038         void*                   pNext;
2039         VkBool32                shaderFloat16;
2040         VkBool32                shaderInt8;
2041 };
2042
2043 struct VkPhysicalDeviceFloatControlsProperties
2044 {
2045         VkStructureType                                         sType;
2046         void*                                                           pNext;
2047         VkShaderFloatControlsIndependence       denormBehaviorIndependence;
2048         VkShaderFloatControlsIndependence       roundingModeIndependence;
2049         VkBool32                                                        shaderSignedZeroInfNanPreserveFloat16;
2050         VkBool32                                                        shaderSignedZeroInfNanPreserveFloat32;
2051         VkBool32                                                        shaderSignedZeroInfNanPreserveFloat64;
2052         VkBool32                                                        shaderDenormPreserveFloat16;
2053         VkBool32                                                        shaderDenormPreserveFloat32;
2054         VkBool32                                                        shaderDenormPreserveFloat64;
2055         VkBool32                                                        shaderDenormFlushToZeroFloat16;
2056         VkBool32                                                        shaderDenormFlushToZeroFloat32;
2057         VkBool32                                                        shaderDenormFlushToZeroFloat64;
2058         VkBool32                                                        shaderRoundingModeRTEFloat16;
2059         VkBool32                                                        shaderRoundingModeRTEFloat32;
2060         VkBool32                                                        shaderRoundingModeRTEFloat64;
2061         VkBool32                                                        shaderRoundingModeRTZFloat16;
2062         VkBool32                                                        shaderRoundingModeRTZFloat32;
2063         VkBool32                                                        shaderRoundingModeRTZFloat64;
2064 };
2065
2066 struct VkDescriptorSetLayoutBindingFlagsCreateInfo
2067 {
2068         VkStructureType                                 sType;
2069         const void*                                             pNext;
2070         uint32_t                                                bindingCount;
2071         const VkDescriptorBindingFlags* pBindingFlags;
2072 };
2073
2074 struct VkPhysicalDeviceDescriptorIndexingFeatures
2075 {
2076         VkStructureType sType;
2077         void*                   pNext;
2078         VkBool32                shaderInputAttachmentArrayDynamicIndexing;
2079         VkBool32                shaderUniformTexelBufferArrayDynamicIndexing;
2080         VkBool32                shaderStorageTexelBufferArrayDynamicIndexing;
2081         VkBool32                shaderUniformBufferArrayNonUniformIndexing;
2082         VkBool32                shaderSampledImageArrayNonUniformIndexing;
2083         VkBool32                shaderStorageBufferArrayNonUniformIndexing;
2084         VkBool32                shaderStorageImageArrayNonUniformIndexing;
2085         VkBool32                shaderInputAttachmentArrayNonUniformIndexing;
2086         VkBool32                shaderUniformTexelBufferArrayNonUniformIndexing;
2087         VkBool32                shaderStorageTexelBufferArrayNonUniformIndexing;
2088         VkBool32                descriptorBindingUniformBufferUpdateAfterBind;
2089         VkBool32                descriptorBindingSampledImageUpdateAfterBind;
2090         VkBool32                descriptorBindingStorageImageUpdateAfterBind;
2091         VkBool32                descriptorBindingStorageBufferUpdateAfterBind;
2092         VkBool32                descriptorBindingUniformTexelBufferUpdateAfterBind;
2093         VkBool32                descriptorBindingStorageTexelBufferUpdateAfterBind;
2094         VkBool32                descriptorBindingUpdateUnusedWhilePending;
2095         VkBool32                descriptorBindingPartiallyBound;
2096         VkBool32                descriptorBindingVariableDescriptorCount;
2097         VkBool32                runtimeDescriptorArray;
2098 };
2099
2100 struct VkPhysicalDeviceDescriptorIndexingProperties
2101 {
2102         VkStructureType sType;
2103         void*                   pNext;
2104         uint32_t                maxUpdateAfterBindDescriptorsInAllPools;
2105         VkBool32                shaderUniformBufferArrayNonUniformIndexingNative;
2106         VkBool32                shaderSampledImageArrayNonUniformIndexingNative;
2107         VkBool32                shaderStorageBufferArrayNonUniformIndexingNative;
2108         VkBool32                shaderStorageImageArrayNonUniformIndexingNative;
2109         VkBool32                shaderInputAttachmentArrayNonUniformIndexingNative;
2110         VkBool32                robustBufferAccessUpdateAfterBind;
2111         VkBool32                quadDivergentImplicitLod;
2112         uint32_t                maxPerStageDescriptorUpdateAfterBindSamplers;
2113         uint32_t                maxPerStageDescriptorUpdateAfterBindUniformBuffers;
2114         uint32_t                maxPerStageDescriptorUpdateAfterBindStorageBuffers;
2115         uint32_t                maxPerStageDescriptorUpdateAfterBindSampledImages;
2116         uint32_t                maxPerStageDescriptorUpdateAfterBindStorageImages;
2117         uint32_t                maxPerStageDescriptorUpdateAfterBindInputAttachments;
2118         uint32_t                maxPerStageUpdateAfterBindResources;
2119         uint32_t                maxDescriptorSetUpdateAfterBindSamplers;
2120         uint32_t                maxDescriptorSetUpdateAfterBindUniformBuffers;
2121         uint32_t                maxDescriptorSetUpdateAfterBindUniformBuffersDynamic;
2122         uint32_t                maxDescriptorSetUpdateAfterBindStorageBuffers;
2123         uint32_t                maxDescriptorSetUpdateAfterBindStorageBuffersDynamic;
2124         uint32_t                maxDescriptorSetUpdateAfterBindSampledImages;
2125         uint32_t                maxDescriptorSetUpdateAfterBindStorageImages;
2126         uint32_t                maxDescriptorSetUpdateAfterBindInputAttachments;
2127 };
2128
2129 struct VkDescriptorSetVariableDescriptorCountAllocateInfo
2130 {
2131         VkStructureType sType;
2132         const void*             pNext;
2133         uint32_t                descriptorSetCount;
2134         const uint32_t* pDescriptorCounts;
2135 };
2136
2137 struct VkDescriptorSetVariableDescriptorCountLayoutSupport
2138 {
2139         VkStructureType sType;
2140         void*                   pNext;
2141         uint32_t                maxVariableDescriptorCount;
2142 };
2143
2144 struct VkSubpassDescriptionDepthStencilResolve
2145 {
2146         VkStructureType                                 sType;
2147         const void*                                             pNext;
2148         VkResolveModeFlagBits                   depthResolveMode;
2149         VkResolveModeFlagBits                   stencilResolveMode;
2150         const VkAttachmentReference2*   pDepthStencilResolveAttachment;
2151 };
2152
2153 struct VkPhysicalDeviceDepthStencilResolveProperties
2154 {
2155         VkStructureType         sType;
2156         void*                           pNext;
2157         VkResolveModeFlags      supportedDepthResolveModes;
2158         VkResolveModeFlags      supportedStencilResolveModes;
2159         VkBool32                        independentResolveNone;
2160         VkBool32                        independentResolve;
2161 };
2162
2163 struct VkPhysicalDeviceScalarBlockLayoutFeatures
2164 {
2165         VkStructureType sType;
2166         void*                   pNext;
2167         VkBool32                scalarBlockLayout;
2168 };
2169
2170 struct VkImageStencilUsageCreateInfo
2171 {
2172         VkStructureType         sType;
2173         const void*                     pNext;
2174         VkImageUsageFlags       stencilUsage;
2175 };
2176
2177 struct VkSamplerReductionModeCreateInfo
2178 {
2179         VkStructureType                 sType;
2180         const void*                             pNext;
2181         VkSamplerReductionMode  reductionMode;
2182 };
2183
2184 struct VkPhysicalDeviceSamplerFilterMinmaxProperties
2185 {
2186         VkStructureType sType;
2187         void*                   pNext;
2188         VkBool32                filterMinmaxSingleComponentFormats;
2189         VkBool32                filterMinmaxImageComponentMapping;
2190 };
2191
2192 struct VkPhysicalDeviceVulkanMemoryModelFeatures
2193 {
2194         VkStructureType sType;
2195         void*                   pNext;
2196         VkBool32                vulkanMemoryModel;
2197         VkBool32                vulkanMemoryModelDeviceScope;
2198         VkBool32                vulkanMemoryModelAvailabilityVisibilityChains;
2199 };
2200
2201 struct VkPhysicalDeviceImagelessFramebufferFeatures
2202 {
2203         VkStructureType sType;
2204         void*                   pNext;
2205         VkBool32                imagelessFramebuffer;
2206 };
2207
2208 struct VkFramebufferAttachmentImageInfo
2209 {
2210         VkStructureType         sType;
2211         const void*                     pNext;
2212         VkImageCreateFlags      flags;
2213         VkImageUsageFlags       usage;
2214         uint32_t                        width;
2215         uint32_t                        height;
2216         uint32_t                        layerCount;
2217         uint32_t                        viewFormatCount;
2218         const VkFormat*         pViewFormats;
2219 };
2220
2221 struct VkFramebufferAttachmentsCreateInfo
2222 {
2223         VkStructureType                                                 sType;
2224         const void*                                                             pNext;
2225         uint32_t                                                                attachmentImageInfoCount;
2226         const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos;
2227 };
2228
2229 struct VkRenderPassAttachmentBeginInfo
2230 {
2231         VkStructureType         sType;
2232         const void*                     pNext;
2233         uint32_t                        attachmentCount;
2234         const VkImageView*      pAttachments;
2235 };
2236
2237 struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures
2238 {
2239         VkStructureType sType;
2240         void*                   pNext;
2241         VkBool32                uniformBufferStandardLayout;
2242 };
2243
2244 struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures
2245 {
2246         VkStructureType sType;
2247         void*                   pNext;
2248         VkBool32                shaderSubgroupExtendedTypes;
2249 };
2250
2251 struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures
2252 {
2253         VkStructureType sType;
2254         void*                   pNext;
2255         VkBool32                separateDepthStencilLayouts;
2256 };
2257
2258 struct VkAttachmentReferenceStencilLayout
2259 {
2260         VkStructureType sType;
2261         void*                   pNext;
2262         VkImageLayout   stencilLayout;
2263 };
2264
2265 struct VkAttachmentDescriptionStencilLayout
2266 {
2267         VkStructureType sType;
2268         void*                   pNext;
2269         VkImageLayout   stencilInitialLayout;
2270         VkImageLayout   stencilFinalLayout;
2271 };
2272
2273 struct VkPhysicalDeviceHostQueryResetFeatures
2274 {
2275         VkStructureType sType;
2276         void*                   pNext;
2277         VkBool32                hostQueryReset;
2278 };
2279
2280 struct VkPhysicalDeviceTimelineSemaphoreFeatures
2281 {
2282         VkStructureType sType;
2283         void*                   pNext;
2284         VkBool32                timelineSemaphore;
2285 };
2286
2287 struct VkPhysicalDeviceTimelineSemaphoreProperties
2288 {
2289         VkStructureType sType;
2290         void*                   pNext;
2291         uint64_t                maxTimelineSemaphoreValueDifference;
2292 };
2293
2294 struct VkSemaphoreTypeCreateInfo
2295 {
2296         VkStructureType sType;
2297         const void*             pNext;
2298         VkSemaphoreType semaphoreType;
2299         uint64_t                initialValue;
2300 };
2301
2302 struct VkTimelineSemaphoreSubmitInfo
2303 {
2304         VkStructureType sType;
2305         const void*             pNext;
2306         uint32_t                waitSemaphoreValueCount;
2307         const uint64_t* pWaitSemaphoreValues;
2308         uint32_t                signalSemaphoreValueCount;
2309         const uint64_t* pSignalSemaphoreValues;
2310 };
2311
2312 struct VkSemaphoreWaitInfo
2313 {
2314         VkStructureType                 sType;
2315         const void*                             pNext;
2316         VkSemaphoreWaitFlags    flags;
2317         uint32_t                                semaphoreCount;
2318         const VkSemaphore*              pSemaphores;
2319         const uint64_t*                 pValues;
2320 };
2321
2322 struct VkSemaphoreSignalInfo
2323 {
2324         VkStructureType sType;
2325         const void*             pNext;
2326         VkSemaphore             semaphore;
2327         uint64_t                value;
2328 };
2329
2330 struct VkPhysicalDeviceBufferDeviceAddressFeatures
2331 {
2332         VkStructureType sType;
2333         void*                   pNext;
2334         VkBool32                bufferDeviceAddress;
2335         VkBool32                bufferDeviceAddressCaptureReplay;
2336         VkBool32                bufferDeviceAddressMultiDevice;
2337 };
2338
2339 struct VkBufferDeviceAddressInfo
2340 {
2341         VkStructureType sType;
2342         const void*             pNext;
2343         VkBuffer                buffer;
2344 };
2345
2346 struct VkBufferOpaqueCaptureAddressCreateInfo
2347 {
2348         VkStructureType sType;
2349         const void*             pNext;
2350         uint64_t                opaqueCaptureAddress;
2351 };
2352
2353 struct VkMemoryOpaqueCaptureAddressAllocateInfo
2354 {
2355         VkStructureType sType;
2356         const void*             pNext;
2357         uint64_t                opaqueCaptureAddress;
2358 };
2359
2360 struct VkDeviceMemoryOpaqueCaptureAddressInfo
2361 {
2362         VkStructureType sType;
2363         const void*             pNext;
2364         VkDeviceMemory  memory;
2365 };
2366
2367 struct VkSurfaceCapabilitiesKHR
2368 {
2369         uint32_t                                                minImageCount;
2370         uint32_t                                                maxImageCount;
2371         VkExtent2D                                              currentExtent;
2372         VkExtent2D                                              minImageExtent;
2373         VkExtent2D                                              maxImageExtent;
2374         uint32_t                                                maxImageArrayLayers;
2375         VkSurfaceTransformFlagsKHR              supportedTransforms;
2376         VkSurfaceTransformFlagBitsKHR   currentTransform;
2377         VkCompositeAlphaFlagsKHR                supportedCompositeAlpha;
2378         VkImageUsageFlags                               supportedUsageFlags;
2379 };
2380
2381 struct VkSurfaceFormatKHR
2382 {
2383         VkFormat                format;
2384         VkColorSpaceKHR colorSpace;
2385 };
2386
2387 struct VkSwapchainCreateInfoKHR
2388 {
2389         VkStructureType                                 sType;
2390         const void*                                             pNext;
2391         VkSwapchainCreateFlagsKHR               flags;
2392         VkSurfaceKHR                                    surface;
2393         uint32_t                                                minImageCount;
2394         VkFormat                                                imageFormat;
2395         VkColorSpaceKHR                                 imageColorSpace;
2396         VkExtent2D                                              imageExtent;
2397         uint32_t                                                imageArrayLayers;
2398         VkImageUsageFlags                               imageUsage;
2399         VkSharingMode                                   imageSharingMode;
2400         uint32_t                                                queueFamilyIndexCount;
2401         const uint32_t*                                 pQueueFamilyIndices;
2402         VkSurfaceTransformFlagBitsKHR   preTransform;
2403         VkCompositeAlphaFlagBitsKHR             compositeAlpha;
2404         VkPresentModeKHR                                presentMode;
2405         VkBool32                                                clipped;
2406         VkSwapchainKHR                                  oldSwapchain;
2407 };
2408
2409 struct VkPresentInfoKHR
2410 {
2411         VkStructureType                 sType;
2412         const void*                             pNext;
2413         uint32_t                                waitSemaphoreCount;
2414         const VkSemaphore*              pWaitSemaphores;
2415         uint32_t                                swapchainCount;
2416         const VkSwapchainKHR*   pSwapchains;
2417         const uint32_t*                 pImageIndices;
2418         VkResult*                               pResults;
2419 };
2420
2421 struct VkImageSwapchainCreateInfoKHR
2422 {
2423         VkStructureType sType;
2424         const void*             pNext;
2425         VkSwapchainKHR  swapchain;
2426 };
2427
2428 struct VkBindImageMemorySwapchainInfoKHR
2429 {
2430         VkStructureType sType;
2431         const void*             pNext;
2432         VkSwapchainKHR  swapchain;
2433         uint32_t                imageIndex;
2434 };
2435
2436 struct VkAcquireNextImageInfoKHR
2437 {
2438         VkStructureType sType;
2439         const void*             pNext;
2440         VkSwapchainKHR  swapchain;
2441         uint64_t                timeout;
2442         VkSemaphore             semaphore;
2443         VkFence                 fence;
2444         uint32_t                deviceMask;
2445 };
2446
2447 struct VkDeviceGroupPresentCapabilitiesKHR
2448 {
2449         VkStructureType                                         sType;
2450         void*                                                           pNext;
2451         uint32_t                                                        presentMask[VK_MAX_DEVICE_GROUP_SIZE];
2452         VkDeviceGroupPresentModeFlagsKHR        modes;
2453 };
2454
2455 struct VkDeviceGroupPresentInfoKHR
2456 {
2457         VkStructureType                                         sType;
2458         const void*                                                     pNext;
2459         uint32_t                                                        swapchainCount;
2460         const uint32_t*                                         pDeviceMasks;
2461         VkDeviceGroupPresentModeFlagBitsKHR     mode;
2462 };
2463
2464 struct VkDeviceGroupSwapchainCreateInfoKHR
2465 {
2466         VkStructureType                                         sType;
2467         const void*                                                     pNext;
2468         VkDeviceGroupPresentModeFlagsKHR        modes;
2469 };
2470
2471 struct VkDisplayModeParametersKHR
2472 {
2473         VkExtent2D      visibleRegion;
2474         uint32_t        refreshRate;
2475 };
2476
2477 struct VkDisplayModeCreateInfoKHR
2478 {
2479         VkStructureType                         sType;
2480         const void*                                     pNext;
2481         VkDisplayModeCreateFlagsKHR     flags;
2482         VkDisplayModeParametersKHR      parameters;
2483 };
2484
2485 struct VkDisplayModePropertiesKHR
2486 {
2487         VkDisplayModeKHR                        displayMode;
2488         VkDisplayModeParametersKHR      parameters;
2489 };
2490
2491 struct VkDisplayPlaneCapabilitiesKHR
2492 {
2493         VkDisplayPlaneAlphaFlagsKHR     supportedAlpha;
2494         VkOffset2D                                      minSrcPosition;
2495         VkOffset2D                                      maxSrcPosition;
2496         VkExtent2D                                      minSrcExtent;
2497         VkExtent2D                                      maxSrcExtent;
2498         VkOffset2D                                      minDstPosition;
2499         VkOffset2D                                      maxDstPosition;
2500         VkExtent2D                                      minDstExtent;
2501         VkExtent2D                                      maxDstExtent;
2502 };
2503
2504 struct VkDisplayPlanePropertiesKHR
2505 {
2506         VkDisplayKHR    currentDisplay;
2507         uint32_t                currentStackIndex;
2508 };
2509
2510 struct VkDisplayPropertiesKHR
2511 {
2512         VkDisplayKHR                            display;
2513         const char*                                     displayName;
2514         VkExtent2D                                      physicalDimensions;
2515         VkExtent2D                                      physicalResolution;
2516         VkSurfaceTransformFlagsKHR      supportedTransforms;
2517         VkBool32                                        planeReorderPossible;
2518         VkBool32                                        persistentContent;
2519 };
2520
2521 struct VkDisplaySurfaceCreateInfoKHR
2522 {
2523         VkStructureType                                 sType;
2524         const void*                                             pNext;
2525         VkDisplaySurfaceCreateFlagsKHR  flags;
2526         VkDisplayModeKHR                                displayMode;
2527         uint32_t                                                planeIndex;
2528         uint32_t                                                planeStackIndex;
2529         VkSurfaceTransformFlagBitsKHR   transform;
2530         float                                                   globalAlpha;
2531         VkDisplayPlaneAlphaFlagBitsKHR  alphaMode;
2532         VkExtent2D                                              imageExtent;
2533 };
2534
2535 struct VkDisplayPresentInfoKHR
2536 {
2537         VkStructureType sType;
2538         const void*             pNext;
2539         VkRect2D                srcRect;
2540         VkRect2D                dstRect;
2541         VkBool32                persistent;
2542 };
2543
2544 struct VkImportMemoryFdInfoKHR
2545 {
2546         VkStructureType                                         sType;
2547         const void*                                                     pNext;
2548         VkExternalMemoryHandleTypeFlagBits      handleType;
2549         int                                                                     fd;
2550 };
2551
2552 struct VkMemoryFdPropertiesKHR
2553 {
2554         VkStructureType sType;
2555         void*                   pNext;
2556         uint32_t                memoryTypeBits;
2557 };
2558
2559 struct VkMemoryGetFdInfoKHR
2560 {
2561         VkStructureType                                         sType;
2562         const void*                                                     pNext;
2563         VkDeviceMemory                                          memory;
2564         VkExternalMemoryHandleTypeFlagBits      handleType;
2565 };
2566
2567 struct VkImportSemaphoreFdInfoKHR
2568 {
2569         VkStructureType                                                 sType;
2570         const void*                                                             pNext;
2571         VkSemaphore                                                             semaphore;
2572         VkSemaphoreImportFlags                                  flags;
2573         VkExternalSemaphoreHandleTypeFlagBits   handleType;
2574         int                                                                             fd;
2575 };
2576
2577 struct VkSemaphoreGetFdInfoKHR
2578 {
2579         VkStructureType                                                 sType;
2580         const void*                                                             pNext;
2581         VkSemaphore                                                             semaphore;
2582         VkExternalSemaphoreHandleTypeFlagBits   handleType;
2583 };
2584
2585 struct VkPhysicalDevicePushDescriptorPropertiesKHR
2586 {
2587         VkStructureType sType;
2588         void*                   pNext;
2589         uint32_t                maxPushDescriptors;
2590 };
2591
2592 struct VkRectLayerKHR
2593 {
2594         VkOffset2D      offset;
2595         VkExtent2D      extent;
2596         uint32_t        layer;
2597 };
2598
2599 struct VkPresentRegionKHR
2600 {
2601         uint32_t                                rectangleCount;
2602         const VkRectLayerKHR*   pRectangles;
2603 };
2604
2605 struct VkPresentRegionsKHR
2606 {
2607         VkStructureType                         sType;
2608         const void*                                     pNext;
2609         uint32_t                                        swapchainCount;
2610         const VkPresentRegionKHR*       pRegions;
2611 };
2612
2613 struct VkSharedPresentSurfaceCapabilitiesKHR
2614 {
2615         VkStructureType         sType;
2616         void*                           pNext;
2617         VkImageUsageFlags       sharedPresentSupportedUsageFlags;
2618 };
2619
2620 struct VkImportFenceFdInfoKHR
2621 {
2622         VkStructureType                                         sType;
2623         const void*                                                     pNext;
2624         VkFence                                                         fence;
2625         VkFenceImportFlags                                      flags;
2626         VkExternalFenceHandleTypeFlagBits       handleType;
2627         int                                                                     fd;
2628 };
2629
2630 struct VkFenceGetFdInfoKHR
2631 {
2632         VkStructureType                                         sType;
2633         const void*                                                     pNext;
2634         VkFence                                                         fence;
2635         VkExternalFenceHandleTypeFlagBits       handleType;
2636 };
2637
2638 struct VkPhysicalDevicePerformanceQueryFeaturesKHR
2639 {
2640         VkStructureType sType;
2641         void*                   pNext;
2642         VkBool32                performanceCounterQueryPools;
2643         VkBool32                performanceCounterMultipleQueryPools;
2644 };
2645
2646 struct VkPhysicalDevicePerformanceQueryPropertiesKHR
2647 {
2648         VkStructureType sType;
2649         void*                   pNext;
2650         VkBool32                allowCommandBufferQueryCopies;
2651 };
2652
2653 struct VkPerformanceCounterKHR
2654 {
2655         VkStructureType                                 sType;
2656         void*                                                   pNext;
2657         VkPerformanceCounterUnitKHR             unit;
2658         VkPerformanceCounterScopeKHR    scope;
2659         VkPerformanceCounterStorageKHR  storage;
2660         uint8_t                                                 uuid[VK_UUID_SIZE];
2661 };
2662
2663 struct VkPerformanceCounterDescriptionKHR
2664 {
2665         VkStructureType                                                 sType;
2666         void*                                                                   pNext;
2667         VkPerformanceCounterDescriptionFlagsKHR flags;
2668         char                                                                    name[VK_MAX_DESCRIPTION_SIZE];
2669         char                                                                    category[VK_MAX_DESCRIPTION_SIZE];
2670         char                                                                    description[VK_MAX_DESCRIPTION_SIZE];
2671 };
2672
2673 struct VkQueryPoolPerformanceCreateInfoKHR
2674 {
2675         VkStructureType sType;
2676         const void*             pNext;
2677         uint32_t                queueFamilyIndex;
2678         uint32_t                counterIndexCount;
2679         const uint32_t* pCounterIndices;
2680 };
2681
2682 union VkPerformanceCounterResultKHR
2683 {
2684         int32_t         int32;
2685         int64_t         int64;
2686         uint32_t        uint32;
2687         uint64_t        uint64;
2688         float           float32;
2689         double          float64;
2690 };
2691
2692 struct VkAcquireProfilingLockInfoKHR
2693 {
2694         VkStructureType                                 sType;
2695         const void*                                             pNext;
2696         VkAcquireProfilingLockFlagsKHR  flags;
2697         uint64_t                                                timeout;
2698 };
2699
2700 struct VkPerformanceQuerySubmitInfoKHR
2701 {
2702         VkStructureType sType;
2703         const void*             pNext;
2704         uint32_t                counterPassIndex;
2705 };
2706
2707 struct VkPhysicalDeviceSurfaceInfo2KHR
2708 {
2709         VkStructureType sType;
2710         const void*             pNext;
2711         VkSurfaceKHR    surface;
2712 };
2713
2714 struct VkSurfaceCapabilities2KHR
2715 {
2716         VkStructureType                         sType;
2717         void*                                           pNext;
2718         VkSurfaceCapabilitiesKHR        surfaceCapabilities;
2719 };
2720
2721 struct VkSurfaceFormat2KHR
2722 {
2723         VkStructureType         sType;
2724         void*                           pNext;
2725         VkSurfaceFormatKHR      surfaceFormat;
2726 };
2727
2728 struct VkDisplayProperties2KHR
2729 {
2730         VkStructureType                 sType;
2731         void*                                   pNext;
2732         VkDisplayPropertiesKHR  displayProperties;
2733 };
2734
2735 struct VkDisplayPlaneProperties2KHR
2736 {
2737         VkStructureType                         sType;
2738         void*                                           pNext;
2739         VkDisplayPlanePropertiesKHR     displayPlaneProperties;
2740 };
2741
2742 struct VkDisplayModeProperties2KHR
2743 {
2744         VkStructureType                         sType;
2745         void*                                           pNext;
2746         VkDisplayModePropertiesKHR      displayModeProperties;
2747 };
2748
2749 struct VkDisplayPlaneInfo2KHR
2750 {
2751         VkStructureType         sType;
2752         const void*                     pNext;
2753         VkDisplayModeKHR        mode;
2754         uint32_t                        planeIndex;
2755 };
2756
2757 struct VkDisplayPlaneCapabilities2KHR
2758 {
2759         VkStructureType                                 sType;
2760         void*                                                   pNext;
2761         VkDisplayPlaneCapabilitiesKHR   capabilities;
2762 };
2763
2764 struct VkPhysicalDeviceShaderClockFeaturesKHR
2765 {
2766         VkStructureType sType;
2767         void*                   pNext;
2768         VkBool32                shaderSubgroupClock;
2769         VkBool32                shaderDeviceClock;
2770 };
2771
2772 struct VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR
2773 {
2774         VkStructureType sType;
2775         void*                   pNext;
2776         VkBool32                shaderTerminateInvocation;
2777 };
2778
2779 struct VkFragmentShadingRateAttachmentInfoKHR
2780 {
2781         VkStructureType                                 sType;
2782         const void*                                             pNext;
2783         const VkAttachmentReference2*   pFragmentShadingRateAttachment;
2784         VkExtent2D                                              shadingRateAttachmentTexelSize;
2785 };
2786
2787 struct VkPipelineFragmentShadingRateStateCreateInfoKHR
2788 {
2789         VkStructureType                                         sType;
2790         const void*                                                     pNext;
2791         VkExtent2D                                                      fragmentSize;
2792         VkFragmentShadingRateCombinerOpKHR      combinerOps[2];
2793 };
2794
2795 struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR
2796 {
2797         VkStructureType sType;
2798         void*                   pNext;
2799         VkBool32                pipelineFragmentShadingRate;
2800         VkBool32                primitiveFragmentShadingRate;
2801         VkBool32                attachmentFragmentShadingRate;
2802 };
2803
2804 struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR
2805 {
2806         VkStructureType                 sType;
2807         void*                                   pNext;
2808         VkExtent2D                              minFragmentShadingRateAttachmentTexelSize;
2809         VkExtent2D                              maxFragmentShadingRateAttachmentTexelSize;
2810         uint32_t                                maxFragmentShadingRateAttachmentTexelSizeAspectRatio;
2811         VkBool32                                primitiveFragmentShadingRateWithMultipleViewports;
2812         VkBool32                                layeredShadingRateAttachments;
2813         VkBool32                                fragmentShadingRateNonTrivialCombinerOps;
2814         VkExtent2D                              maxFragmentSize;
2815         uint32_t                                maxFragmentSizeAspectRatio;
2816         uint32_t                                maxFragmentShadingRateCoverageSamples;
2817         VkSampleCountFlagBits   maxFragmentShadingRateRasterizationSamples;
2818         VkBool32                                fragmentShadingRateWithShaderDepthStencilWrites;
2819         VkBool32                                fragmentShadingRateWithSampleMask;
2820         VkBool32                                fragmentShadingRateWithShaderSampleMask;
2821         VkBool32                                fragmentShadingRateWithConservativeRasterization;
2822         VkBool32                                fragmentShadingRateWithFragmentShaderInterlock;
2823         VkBool32                                fragmentShadingRateWithCustomSampleLocations;
2824         VkBool32                                fragmentShadingRateStrictMultiplyCombiner;
2825 };
2826
2827 struct VkPhysicalDeviceFragmentShadingRateKHR
2828 {
2829         VkStructureType         sType;
2830         void*                           pNext;
2831         VkSampleCountFlags      sampleCounts;
2832         VkExtent2D                      fragmentSize;
2833 };
2834
2835 struct VkSurfaceProtectedCapabilitiesKHR
2836 {
2837         VkStructureType sType;
2838         const void*             pNext;
2839         VkBool32                supportsProtected;
2840 };
2841
2842 struct VkPhysicalDevicePresentWaitFeaturesKHR
2843 {
2844         VkStructureType sType;
2845         void*                   pNext;
2846         VkBool32                presentWait;
2847 };
2848
2849 struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR
2850 {
2851         VkStructureType sType;
2852         void*                   pNext;
2853         VkBool32                pipelineExecutableInfo;
2854 };
2855
2856 struct VkPipelineInfoKHR
2857 {
2858         VkStructureType sType;
2859         const void*             pNext;
2860         VkPipeline              pipeline;
2861 };
2862
2863 struct VkPipelineExecutablePropertiesKHR
2864 {
2865         VkStructureType         sType;
2866         void*                           pNext;
2867         VkShaderStageFlags      stages;
2868         char                            name[VK_MAX_DESCRIPTION_SIZE];
2869         char                            description[VK_MAX_DESCRIPTION_SIZE];
2870         uint32_t                        subgroupSize;
2871 };
2872
2873 struct VkPipelineExecutableInfoKHR
2874 {
2875         VkStructureType sType;
2876         const void*             pNext;
2877         VkPipeline              pipeline;
2878         uint32_t                executableIndex;
2879 };
2880
2881 union VkPipelineExecutableStatisticValueKHR
2882 {
2883         VkBool32        b32;
2884         int64_t         i64;
2885         uint64_t        u64;
2886         double          f64;
2887 };
2888
2889 struct VkPipelineExecutableStatisticKHR
2890 {
2891         VkStructureType                                                 sType;
2892         void*                                                                   pNext;
2893         char                                                                    name[VK_MAX_DESCRIPTION_SIZE];
2894         char                                                                    description[VK_MAX_DESCRIPTION_SIZE];
2895         VkPipelineExecutableStatisticFormatKHR  format;
2896         VkPipelineExecutableStatisticValueKHR   value;
2897 };
2898
2899 struct VkPipelineExecutableInternalRepresentationKHR
2900 {
2901         VkStructureType sType;
2902         void*                   pNext;
2903         char                    name[VK_MAX_DESCRIPTION_SIZE];
2904         char                    description[VK_MAX_DESCRIPTION_SIZE];
2905         VkBool32                isText;
2906         size_t                  dataSize;
2907         void*                   pData;
2908 };
2909
2910 struct VkPipelineLibraryCreateInfoKHR
2911 {
2912         VkStructureType         sType;
2913         const void*                     pNext;
2914         uint32_t                        libraryCount;
2915         const VkPipeline*       pLibraries;
2916 };
2917
2918 struct VkPresentIdKHR
2919 {
2920         VkStructureType sType;
2921         const void*             pNext;
2922         uint32_t                swapchainCount;
2923         const uint64_t* pPresentIds;
2924 };
2925
2926 struct VkPhysicalDevicePresentIdFeaturesKHR
2927 {
2928         VkStructureType sType;
2929         void*                   pNext;
2930         VkBool32                presentId;
2931 };
2932
2933 struct VkMemoryBarrier2KHR
2934 {
2935         VkStructureType                         sType;
2936         const void*                                     pNext;
2937         VkPipelineStageFlags2KHR        srcStageMask;
2938         VkAccessFlags2KHR                       srcAccessMask;
2939         VkPipelineStageFlags2KHR        dstStageMask;
2940         VkAccessFlags2KHR                       dstAccessMask;
2941 };
2942
2943 struct VkBufferMemoryBarrier2KHR
2944 {
2945         VkStructureType                         sType;
2946         const void*                                     pNext;
2947         VkPipelineStageFlags2KHR        srcStageMask;
2948         VkAccessFlags2KHR                       srcAccessMask;
2949         VkPipelineStageFlags2KHR        dstStageMask;
2950         VkAccessFlags2KHR                       dstAccessMask;
2951         uint32_t                                        srcQueueFamilyIndex;
2952         uint32_t                                        dstQueueFamilyIndex;
2953         VkBuffer                                        buffer;
2954         VkDeviceSize                            offset;
2955         VkDeviceSize                            size;
2956 };
2957
2958 struct VkImageMemoryBarrier2KHR
2959 {
2960         VkStructureType                         sType;
2961         const void*                                     pNext;
2962         VkPipelineStageFlags2KHR        srcStageMask;
2963         VkAccessFlags2KHR                       srcAccessMask;
2964         VkPipelineStageFlags2KHR        dstStageMask;
2965         VkAccessFlags2KHR                       dstAccessMask;
2966         VkImageLayout                           oldLayout;
2967         VkImageLayout                           newLayout;
2968         uint32_t                                        srcQueueFamilyIndex;
2969         uint32_t                                        dstQueueFamilyIndex;
2970         VkImage                                         image;
2971         VkImageSubresourceRange         subresourceRange;
2972 };
2973
2974 struct VkDependencyInfoKHR
2975 {
2976         VkStructureType                                         sType;
2977         const void*                                                     pNext;
2978         VkDependencyFlags                                       dependencyFlags;
2979         uint32_t                                                        memoryBarrierCount;
2980         const VkMemoryBarrier2KHR*                      pMemoryBarriers;
2981         uint32_t                                                        bufferMemoryBarrierCount;
2982         const VkBufferMemoryBarrier2KHR*        pBufferMemoryBarriers;
2983         uint32_t                                                        imageMemoryBarrierCount;
2984         const VkImageMemoryBarrier2KHR*         pImageMemoryBarriers;
2985 };
2986
2987 struct VkSemaphoreSubmitInfoKHR
2988 {
2989         VkStructureType                         sType;
2990         const void*                                     pNext;
2991         VkSemaphore                                     semaphore;
2992         uint64_t                                        value;
2993         VkPipelineStageFlags2KHR        stageMask;
2994         uint32_t                                        deviceIndex;
2995 };
2996
2997 struct VkCommandBufferSubmitInfoKHR
2998 {
2999         VkStructureType sType;
3000         const void*             pNext;
3001         VkCommandBuffer commandBuffer;
3002         uint32_t                deviceMask;
3003 };
3004
3005 struct VkSubmitInfo2KHR
3006 {
3007         VkStructureType                                         sType;
3008         const void*                                                     pNext;
3009         VkSubmitFlagsKHR                                        flags;
3010         uint32_t                                                        waitSemaphoreInfoCount;
3011         const VkSemaphoreSubmitInfoKHR*         pWaitSemaphoreInfos;
3012         uint32_t                                                        commandBufferInfoCount;
3013         const VkCommandBufferSubmitInfoKHR*     pCommandBufferInfos;
3014         uint32_t                                                        signalSemaphoreInfoCount;
3015         const VkSemaphoreSubmitInfoKHR*         pSignalSemaphoreInfos;
3016 };
3017
3018 struct VkPhysicalDeviceSynchronization2FeaturesKHR
3019 {
3020         VkStructureType sType;
3021         void*                   pNext;
3022         VkBool32                synchronization2;
3023 };
3024
3025 struct VkQueueFamilyCheckpointProperties2NV
3026 {
3027         VkStructureType                         sType;
3028         void*                                           pNext;
3029         VkPipelineStageFlags2KHR        checkpointExecutionStageMask;
3030 };
3031
3032 struct VkCheckpointData2NV
3033 {
3034         VkStructureType                         sType;
3035         void*                                           pNext;
3036         VkPipelineStageFlags2KHR        stage;
3037         void*                                           pCheckpointMarker;
3038 };
3039
3040 struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR
3041 {
3042         VkStructureType sType;
3043         void*                   pNext;
3044         VkBool32                shaderSubgroupUniformControlFlow;
3045 };
3046
3047 struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR
3048 {
3049         VkStructureType sType;
3050         void*                   pNext;
3051         VkBool32                shaderZeroInitializeWorkgroupMemory;
3052 };
3053
3054 struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR
3055 {
3056         VkStructureType sType;
3057         void*                   pNext;
3058         VkBool32                workgroupMemoryExplicitLayout;
3059         VkBool32                workgroupMemoryExplicitLayoutScalarBlockLayout;
3060         VkBool32                workgroupMemoryExplicitLayout8BitAccess;
3061         VkBool32                workgroupMemoryExplicitLayout16BitAccess;
3062 };
3063
3064 struct VkBufferCopy2KHR
3065 {
3066         VkStructureType sType;
3067         const void*             pNext;
3068         VkDeviceSize    srcOffset;
3069         VkDeviceSize    dstOffset;
3070         VkDeviceSize    size;
3071 };
3072
3073 struct VkCopyBufferInfo2KHR
3074 {
3075         VkStructureType                 sType;
3076         const void*                             pNext;
3077         VkBuffer                                srcBuffer;
3078         VkBuffer                                dstBuffer;
3079         uint32_t                                regionCount;
3080         const VkBufferCopy2KHR* pRegions;
3081 };
3082
3083 struct VkImageCopy2KHR
3084 {
3085         VkStructureType                         sType;
3086         const void*                                     pNext;
3087         VkImageSubresourceLayers        srcSubresource;
3088         VkOffset3D                                      srcOffset;
3089         VkImageSubresourceLayers        dstSubresource;
3090         VkOffset3D                                      dstOffset;
3091         VkExtent3D                                      extent;
3092 };
3093
3094 struct VkCopyImageInfo2KHR
3095 {
3096         VkStructureType                 sType;
3097         const void*                             pNext;
3098         VkImage                                 srcImage;
3099         VkImageLayout                   srcImageLayout;
3100         VkImage                                 dstImage;
3101         VkImageLayout                   dstImageLayout;
3102         uint32_t                                regionCount;
3103         const VkImageCopy2KHR*  pRegions;
3104 };
3105
3106 struct VkBufferImageCopy2KHR
3107 {
3108         VkStructureType                         sType;
3109         const void*                                     pNext;
3110         VkDeviceSize                            bufferOffset;
3111         uint32_t                                        bufferRowLength;
3112         uint32_t                                        bufferImageHeight;
3113         VkImageSubresourceLayers        imageSubresource;
3114         VkOffset3D                                      imageOffset;
3115         VkExtent3D                                      imageExtent;
3116 };
3117
3118 struct VkCopyBufferToImageInfo2KHR
3119 {
3120         VkStructureType                                 sType;
3121         const void*                                             pNext;
3122         VkBuffer                                                srcBuffer;
3123         VkImage                                                 dstImage;
3124         VkImageLayout                                   dstImageLayout;
3125         uint32_t                                                regionCount;
3126         const VkBufferImageCopy2KHR*    pRegions;
3127 };
3128
3129 struct VkCopyImageToBufferInfo2KHR
3130 {
3131         VkStructureType                                 sType;
3132         const void*                                             pNext;
3133         VkImage                                                 srcImage;
3134         VkImageLayout                                   srcImageLayout;
3135         VkBuffer                                                dstBuffer;
3136         uint32_t                                                regionCount;
3137         const VkBufferImageCopy2KHR*    pRegions;
3138 };
3139
3140 struct VkImageBlit2KHR
3141 {
3142         VkStructureType                         sType;
3143         const void*                                     pNext;
3144         VkImageSubresourceLayers        srcSubresource;
3145         VkOffset3D                                      srcOffsets[2];
3146         VkImageSubresourceLayers        dstSubresource;
3147         VkOffset3D                                      dstOffsets[2];
3148 };
3149
3150 struct VkBlitImageInfo2KHR
3151 {
3152         VkStructureType                 sType;
3153         const void*                             pNext;
3154         VkImage                                 srcImage;
3155         VkImageLayout                   srcImageLayout;
3156         VkImage                                 dstImage;
3157         VkImageLayout                   dstImageLayout;
3158         uint32_t                                regionCount;
3159         const VkImageBlit2KHR*  pRegions;
3160         VkFilter                                filter;
3161 };
3162
3163 struct VkImageResolve2KHR
3164 {
3165         VkStructureType                         sType;
3166         const void*                                     pNext;
3167         VkImageSubresourceLayers        srcSubresource;
3168         VkOffset3D                                      srcOffset;
3169         VkImageSubresourceLayers        dstSubresource;
3170         VkOffset3D                                      dstOffset;
3171         VkExtent3D                                      extent;
3172 };
3173
3174 struct VkResolveImageInfo2KHR
3175 {
3176         VkStructureType                         sType;
3177         const void*                                     pNext;
3178         VkImage                                         srcImage;
3179         VkImageLayout                           srcImageLayout;
3180         VkImage                                         dstImage;
3181         VkImageLayout                           dstImageLayout;
3182         uint32_t                                        regionCount;
3183         const VkImageResolve2KHR*       pRegions;
3184 };
3185
3186 struct VkDebugReportCallbackCreateInfoEXT
3187 {
3188         VkStructureType                                 sType;
3189         const void*                                             pNext;
3190         VkDebugReportFlagsEXT                   flags;
3191         PFN_vkDebugReportCallbackEXT    pfnCallback;
3192         void*                                                   pUserData;
3193 };
3194
3195 struct VkPipelineRasterizationStateRasterizationOrderAMD
3196 {
3197         VkStructureType                 sType;
3198         const void*                             pNext;
3199         VkRasterizationOrderAMD rasterizationOrder;
3200 };
3201
3202 struct VkDebugMarkerObjectNameInfoEXT
3203 {
3204         VkStructureType                         sType;
3205         const void*                                     pNext;
3206         VkDebugReportObjectTypeEXT      objectType;
3207         uint64_t                                        object;
3208         const char*                                     pObjectName;
3209 };
3210
3211 struct VkDebugMarkerObjectTagInfoEXT
3212 {
3213         VkStructureType                         sType;
3214         const void*                                     pNext;
3215         VkDebugReportObjectTypeEXT      objectType;
3216         uint64_t                                        object;
3217         uint64_t                                        tagName;
3218         size_t                                          tagSize;
3219         const void*                                     pTag;
3220 };
3221
3222 struct VkDebugMarkerMarkerInfoEXT
3223 {
3224         VkStructureType sType;
3225         const void*             pNext;
3226         const char*             pMarkerName;
3227         float                   color[4];
3228 };
3229
3230 struct VkDedicatedAllocationImageCreateInfoNV
3231 {
3232         VkStructureType sType;
3233         const void*             pNext;
3234         VkBool32                dedicatedAllocation;
3235 };
3236
3237 struct VkDedicatedAllocationBufferCreateInfoNV
3238 {
3239         VkStructureType sType;
3240         const void*             pNext;
3241         VkBool32                dedicatedAllocation;
3242 };
3243
3244 struct VkDedicatedAllocationMemoryAllocateInfoNV
3245 {
3246         VkStructureType sType;
3247         const void*             pNext;
3248         VkImage                 image;
3249         VkBuffer                buffer;
3250 };
3251
3252 struct VkPhysicalDeviceTransformFeedbackFeaturesEXT
3253 {
3254         VkStructureType sType;
3255         void*                   pNext;
3256         VkBool32                transformFeedback;
3257         VkBool32                geometryStreams;
3258 };
3259
3260 struct VkPhysicalDeviceTransformFeedbackPropertiesEXT
3261 {
3262         VkStructureType sType;
3263         void*                   pNext;
3264         uint32_t                maxTransformFeedbackStreams;
3265         uint32_t                maxTransformFeedbackBuffers;
3266         VkDeviceSize    maxTransformFeedbackBufferSize;
3267         uint32_t                maxTransformFeedbackStreamDataSize;
3268         uint32_t                maxTransformFeedbackBufferDataSize;
3269         uint32_t                maxTransformFeedbackBufferDataStride;
3270         VkBool32                transformFeedbackQueries;
3271         VkBool32                transformFeedbackStreamsLinesTriangles;
3272         VkBool32                transformFeedbackRasterizationStreamSelect;
3273         VkBool32                transformFeedbackDraw;
3274 };
3275
3276 struct VkPipelineRasterizationStateStreamCreateInfoEXT
3277 {
3278         VkStructureType                                                                         sType;
3279         const void*                                                                                     pNext;
3280         VkPipelineRasterizationStateStreamCreateFlagsEXT        flags;
3281         uint32_t                                                                                        rasterizationStream;
3282 };
3283
3284 struct VkCuModuleCreateInfoNVX
3285 {
3286         VkStructureType sType;
3287         const void*             pNext;
3288         size_t                  dataSize;
3289         const void*             pData;
3290 };
3291
3292 struct VkCuFunctionCreateInfoNVX
3293 {
3294         VkStructureType sType;
3295         const void*             pNext;
3296         VkCuModuleNVX   module;
3297         const char*             pName;
3298 };
3299
3300 struct VkCuLaunchInfoNVX
3301 {
3302         VkStructureType         sType;
3303         const void*                     pNext;
3304         VkCuFunctionNVX         function;
3305         uint32_t                        gridDimX;
3306         uint32_t                        gridDimY;
3307         uint32_t                        gridDimZ;
3308         uint32_t                        blockDimX;
3309         uint32_t                        blockDimY;
3310         uint32_t                        blockDimZ;
3311         uint32_t                        sharedMemBytes;
3312         size_t                          paramCount;
3313         const void* const *     pParams;
3314         size_t                          extraCount;
3315         const void* const *     pExtras;
3316 };
3317
3318 struct VkImageViewHandleInfoNVX
3319 {
3320         VkStructureType         sType;
3321         const void*                     pNext;
3322         VkImageView                     imageView;
3323         VkDescriptorType        descriptorType;
3324         VkSampler                       sampler;
3325 };
3326
3327 struct VkImageViewAddressPropertiesNVX
3328 {
3329         VkStructureType sType;
3330         void*                   pNext;
3331         VkDeviceAddress deviceAddress;
3332         VkDeviceSize    size;
3333 };
3334
3335 struct VkTextureLODGatherFormatPropertiesAMD
3336 {
3337         VkStructureType sType;
3338         void*                   pNext;
3339         VkBool32                supportsTextureGatherLODBiasAMD;
3340 };
3341
3342 struct VkShaderResourceUsageAMD
3343 {
3344         uint32_t        numUsedVgprs;
3345         uint32_t        numUsedSgprs;
3346         uint32_t        ldsSizePerLocalWorkGroup;
3347         size_t          ldsUsageSizeInBytes;
3348         size_t          scratchMemUsageInBytes;
3349 };
3350
3351 struct VkShaderStatisticsInfoAMD
3352 {
3353         VkShaderStageFlags                      shaderStageMask;
3354         VkShaderResourceUsageAMD        resourceUsage;
3355         uint32_t                                        numPhysicalVgprs;
3356         uint32_t                                        numPhysicalSgprs;
3357         uint32_t                                        numAvailableVgprs;
3358         uint32_t                                        numAvailableSgprs;
3359         uint32_t                                        computeWorkGroupSize[3];
3360 };
3361
3362 struct VkPhysicalDeviceCornerSampledImageFeaturesNV
3363 {
3364         VkStructureType sType;
3365         void*                   pNext;
3366         VkBool32                cornerSampledImage;
3367 };
3368
3369 struct VkExternalImageFormatPropertiesNV
3370 {
3371         VkImageFormatProperties                         imageFormatProperties;
3372         VkExternalMemoryFeatureFlagsNV          externalMemoryFeatures;
3373         VkExternalMemoryHandleTypeFlagsNV       exportFromImportedHandleTypes;
3374         VkExternalMemoryHandleTypeFlagsNV       compatibleHandleTypes;
3375 };
3376
3377 struct VkExternalMemoryImageCreateInfoNV
3378 {
3379         VkStructureType                                         sType;
3380         const void*                                                     pNext;
3381         VkExternalMemoryHandleTypeFlagsNV       handleTypes;
3382 };
3383
3384 struct VkExportMemoryAllocateInfoNV
3385 {
3386         VkStructureType                                         sType;
3387         const void*                                                     pNext;
3388         VkExternalMemoryHandleTypeFlagsNV       handleTypes;
3389 };
3390
3391 struct VkValidationFlagsEXT
3392 {
3393         VkStructureType                         sType;
3394         const void*                                     pNext;
3395         uint32_t                                        disabledValidationCheckCount;
3396         const VkValidationCheckEXT*     pDisabledValidationChecks;
3397 };
3398
3399 struct VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT
3400 {
3401         VkStructureType sType;
3402         void*                   pNext;
3403         VkBool32                textureCompressionASTC_HDR;
3404 };
3405
3406 struct VkImageViewASTCDecodeModeEXT
3407 {
3408         VkStructureType sType;
3409         const void*             pNext;
3410         VkFormat                decodeMode;
3411 };
3412
3413 struct VkPhysicalDeviceASTCDecodeFeaturesEXT
3414 {
3415         VkStructureType sType;
3416         void*                   pNext;
3417         VkBool32                decodeModeSharedExponent;
3418 };
3419
3420 struct VkConditionalRenderingBeginInfoEXT
3421 {
3422         VkStructureType                                 sType;
3423         const void*                                             pNext;
3424         VkBuffer                                                buffer;
3425         VkDeviceSize                                    offset;
3426         VkConditionalRenderingFlagsEXT  flags;
3427 };
3428
3429 struct VkPhysicalDeviceConditionalRenderingFeaturesEXT
3430 {
3431         VkStructureType sType;
3432         void*                   pNext;
3433         VkBool32                conditionalRendering;
3434         VkBool32                inheritedConditionalRendering;
3435 };
3436
3437 struct VkCommandBufferInheritanceConditionalRenderingInfoEXT
3438 {
3439         VkStructureType sType;
3440         const void*             pNext;
3441         VkBool32                conditionalRenderingEnable;
3442 };
3443
3444 struct VkViewportWScalingNV
3445 {
3446         float   xcoeff;
3447         float   ycoeff;
3448 };
3449
3450 struct VkPipelineViewportWScalingStateCreateInfoNV
3451 {
3452         VkStructureType                         sType;
3453         const void*                                     pNext;
3454         VkBool32                                        viewportWScalingEnable;
3455         uint32_t                                        viewportCount;
3456         const VkViewportWScalingNV*     pViewportWScalings;
3457 };
3458
3459 struct VkSurfaceCapabilities2EXT
3460 {
3461         VkStructureType                                 sType;
3462         void*                                                   pNext;
3463         uint32_t                                                minImageCount;
3464         uint32_t                                                maxImageCount;
3465         VkExtent2D                                              currentExtent;
3466         VkExtent2D                                              minImageExtent;
3467         VkExtent2D                                              maxImageExtent;
3468         uint32_t                                                maxImageArrayLayers;
3469         VkSurfaceTransformFlagsKHR              supportedTransforms;
3470         VkSurfaceTransformFlagBitsKHR   currentTransform;
3471         VkCompositeAlphaFlagsKHR                supportedCompositeAlpha;
3472         VkImageUsageFlags                               supportedUsageFlags;
3473         VkSurfaceCounterFlagsEXT                supportedSurfaceCounters;
3474 };
3475
3476 struct VkDisplayPowerInfoEXT
3477 {
3478         VkStructureType                 sType;
3479         const void*                             pNext;
3480         VkDisplayPowerStateEXT  powerState;
3481 };
3482
3483 struct VkDeviceEventInfoEXT
3484 {
3485         VkStructureType                 sType;
3486         const void*                             pNext;
3487         VkDeviceEventTypeEXT    deviceEvent;
3488 };
3489
3490 struct VkDisplayEventInfoEXT
3491 {
3492         VkStructureType                 sType;
3493         const void*                             pNext;
3494         VkDisplayEventTypeEXT   displayEvent;
3495 };
3496
3497 struct VkSwapchainCounterCreateInfoEXT
3498 {
3499         VkStructureType                         sType;
3500         const void*                                     pNext;
3501         VkSurfaceCounterFlagsEXT        surfaceCounters;
3502 };
3503
3504 struct VkRefreshCycleDurationGOOGLE
3505 {
3506         uint64_t        refreshDuration;
3507 };
3508
3509 struct VkPastPresentationTimingGOOGLE
3510 {
3511         uint32_t        presentID;
3512         uint64_t        desiredPresentTime;
3513         uint64_t        actualPresentTime;
3514         uint64_t        earliestPresentTime;
3515         uint64_t        presentMargin;
3516 };
3517
3518 struct VkPresentTimeGOOGLE
3519 {
3520         uint32_t        presentID;
3521         uint64_t        desiredPresentTime;
3522 };
3523
3524 struct VkPresentTimesInfoGOOGLE
3525 {
3526         VkStructureType                         sType;
3527         const void*                                     pNext;
3528         uint32_t                                        swapchainCount;
3529         const VkPresentTimeGOOGLE*      pTimes;
3530 };
3531
3532 struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
3533 {
3534         VkStructureType sType;
3535         void*                   pNext;
3536         VkBool32                perViewPositionAllComponents;
3537 };
3538
3539 struct VkViewportSwizzleNV
3540 {
3541         VkViewportCoordinateSwizzleNV   x;
3542         VkViewportCoordinateSwizzleNV   y;
3543         VkViewportCoordinateSwizzleNV   z;
3544         VkViewportCoordinateSwizzleNV   w;
3545 };
3546
3547 struct VkPipelineViewportSwizzleStateCreateInfoNV
3548 {
3549         VkStructureType                                                         sType;
3550         const void*                                                                     pNext;
3551         VkPipelineViewportSwizzleStateCreateFlagsNV     flags;
3552         uint32_t                                                                        viewportCount;
3553         const VkViewportSwizzleNV*                                      pViewportSwizzles;
3554 };
3555
3556 struct VkPhysicalDeviceDiscardRectanglePropertiesEXT
3557 {
3558         VkStructureType sType;
3559         void*                   pNext;
3560         uint32_t                maxDiscardRectangles;
3561 };
3562
3563 struct VkPipelineDiscardRectangleStateCreateInfoEXT
3564 {
3565         VkStructureType                                                                 sType;
3566         const void*                                                                             pNext;
3567         VkPipelineDiscardRectangleStateCreateFlagsEXT   flags;
3568         VkDiscardRectangleModeEXT                                               discardRectangleMode;
3569         uint32_t                                                                                discardRectangleCount;
3570         const VkRect2D*                                                                 pDiscardRectangles;
3571 };
3572
3573 struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT
3574 {
3575         VkStructureType sType;
3576         void*                   pNext;
3577         float                   primitiveOverestimationSize;
3578         float                   maxExtraPrimitiveOverestimationSize;
3579         float                   extraPrimitiveOverestimationSizeGranularity;
3580         VkBool32                primitiveUnderestimation;
3581         VkBool32                conservativePointAndLineRasterization;
3582         VkBool32                degenerateTrianglesRasterized;
3583         VkBool32                degenerateLinesRasterized;
3584         VkBool32                fullyCoveredFragmentShaderInputVariable;
3585         VkBool32                conservativeRasterizationPostDepthCoverage;
3586 };
3587
3588 struct VkPipelineRasterizationConservativeStateCreateInfoEXT
3589 {
3590         VkStructureType                                                                                 sType;
3591         const void*                                                                                             pNext;
3592         VkPipelineRasterizationConservativeStateCreateFlagsEXT  flags;
3593         VkConservativeRasterizationModeEXT                                              conservativeRasterizationMode;
3594         float                                                                                                   extraPrimitiveOverestimationSize;
3595 };
3596
3597 struct VkPhysicalDeviceDepthClipEnableFeaturesEXT
3598 {
3599         VkStructureType sType;
3600         void*                   pNext;
3601         VkBool32                depthClipEnable;
3602 };
3603
3604 struct VkPipelineRasterizationDepthClipStateCreateInfoEXT
3605 {
3606         VkStructureType                                                                         sType;
3607         const void*                                                                                     pNext;
3608         VkPipelineRasterizationDepthClipStateCreateFlagsEXT     flags;
3609         VkBool32                                                                                        depthClipEnable;
3610 };
3611
3612 struct VkXYColorEXT
3613 {
3614         float   x;
3615         float   y;
3616 };
3617
3618 struct VkHdrMetadataEXT
3619 {
3620         VkStructureType sType;
3621         const void*             pNext;
3622         VkXYColorEXT    displayPrimaryRed;
3623         VkXYColorEXT    displayPrimaryGreen;
3624         VkXYColorEXT    displayPrimaryBlue;
3625         VkXYColorEXT    whitePoint;
3626         float                   maxLuminance;
3627         float                   minLuminance;
3628         float                   maxContentLightLevel;
3629         float                   maxFrameAverageLightLevel;
3630 };
3631
3632 struct VkDebugUtilsLabelEXT
3633 {
3634         VkStructureType sType;
3635         const void*             pNext;
3636         const char*             pLabelName;
3637         float                   color[4];
3638 };
3639
3640 struct VkDebugUtilsObjectNameInfoEXT
3641 {
3642         VkStructureType sType;
3643         const void*             pNext;
3644         VkObjectType    objectType;
3645         uint64_t                objectHandle;
3646         const char*             pObjectName;
3647 };
3648
3649 struct VkDebugUtilsMessengerCallbackDataEXT
3650 {
3651         VkStructureType                                                         sType;
3652         const void*                                                                     pNext;
3653         VkDebugUtilsMessengerCallbackDataFlagsEXT       flags;
3654         const char*                                                                     pMessageIdName;
3655         int32_t                                                                         messageIdNumber;
3656         const char*                                                                     pMessage;
3657         uint32_t                                                                        queueLabelCount;
3658         const VkDebugUtilsLabelEXT*                                     pQueueLabels;
3659         uint32_t                                                                        cmdBufLabelCount;
3660         const VkDebugUtilsLabelEXT*                                     pCmdBufLabels;
3661         uint32_t                                                                        objectCount;
3662         const VkDebugUtilsObjectNameInfoEXT*            pObjects;
3663 };
3664
3665 struct VkDebugUtilsMessengerCreateInfoEXT
3666 {
3667         VkStructureType                                                 sType;
3668         const void*                                                             pNext;
3669         VkDebugUtilsMessengerCreateFlagsEXT             flags;
3670         VkDebugUtilsMessageSeverityFlagsEXT             messageSeverity;
3671         VkDebugUtilsMessageTypeFlagsEXT                 messageType;
3672         PFN_vkDebugUtilsMessengerCallbackEXT    pfnUserCallback;
3673         void*                                                                   pUserData;
3674 };
3675
3676 struct VkDebugUtilsObjectTagInfoEXT
3677 {
3678         VkStructureType sType;
3679         const void*             pNext;
3680         VkObjectType    objectType;
3681         uint64_t                objectHandle;
3682         uint64_t                tagName;
3683         size_t                  tagSize;
3684         const void*             pTag;
3685 };
3686
3687 struct VkPhysicalDeviceInlineUniformBlockFeaturesEXT
3688 {
3689         VkStructureType sType;
3690         void*                   pNext;
3691         VkBool32                inlineUniformBlock;
3692         VkBool32                descriptorBindingInlineUniformBlockUpdateAfterBind;
3693 };
3694
3695 struct VkPhysicalDeviceInlineUniformBlockPropertiesEXT
3696 {
3697         VkStructureType sType;
3698         void*                   pNext;
3699         uint32_t                maxInlineUniformBlockSize;
3700         uint32_t                maxPerStageDescriptorInlineUniformBlocks;
3701         uint32_t                maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks;
3702         uint32_t                maxDescriptorSetInlineUniformBlocks;
3703         uint32_t                maxDescriptorSetUpdateAfterBindInlineUniformBlocks;
3704 };
3705
3706 struct VkWriteDescriptorSetInlineUniformBlockEXT
3707 {
3708         VkStructureType sType;
3709         const void*             pNext;
3710         uint32_t                dataSize;
3711         const void*             pData;
3712 };
3713
3714 struct VkDescriptorPoolInlineUniformBlockCreateInfoEXT
3715 {
3716         VkStructureType sType;
3717         const void*             pNext;
3718         uint32_t                maxInlineUniformBlockBindings;
3719 };
3720
3721 struct VkSampleLocationEXT
3722 {
3723         float   x;
3724         float   y;
3725 };
3726
3727 struct VkSampleLocationsInfoEXT
3728 {
3729         VkStructureType                         sType;
3730         const void*                                     pNext;
3731         VkSampleCountFlagBits           sampleLocationsPerPixel;
3732         VkExtent2D                                      sampleLocationGridSize;
3733         uint32_t                                        sampleLocationsCount;
3734         const VkSampleLocationEXT*      pSampleLocations;
3735 };
3736
3737 struct VkAttachmentSampleLocationsEXT
3738 {
3739         uint32_t                                        attachmentIndex;
3740         VkSampleLocationsInfoEXT        sampleLocationsInfo;
3741 };
3742
3743 struct VkSubpassSampleLocationsEXT
3744 {
3745         uint32_t                                        subpassIndex;
3746         VkSampleLocationsInfoEXT        sampleLocationsInfo;
3747 };
3748
3749 struct VkRenderPassSampleLocationsBeginInfoEXT
3750 {
3751         VkStructureType                                                 sType;
3752         const void*                                                             pNext;
3753         uint32_t                                                                attachmentInitialSampleLocationsCount;
3754         const VkAttachmentSampleLocationsEXT*   pAttachmentInitialSampleLocations;
3755         uint32_t                                                                postSubpassSampleLocationsCount;
3756         const VkSubpassSampleLocationsEXT*              pPostSubpassSampleLocations;
3757 };
3758
3759 struct VkPipelineSampleLocationsStateCreateInfoEXT
3760 {
3761         VkStructureType                         sType;
3762         const void*                                     pNext;
3763         VkBool32                                        sampleLocationsEnable;
3764         VkSampleLocationsInfoEXT        sampleLocationsInfo;
3765 };
3766
3767 struct VkPhysicalDeviceSampleLocationsPropertiesEXT
3768 {
3769         VkStructureType         sType;
3770         void*                           pNext;
3771         VkSampleCountFlags      sampleLocationSampleCounts;
3772         VkExtent2D                      maxSampleLocationGridSize;
3773         float                           sampleLocationCoordinateRange[2];
3774         uint32_t                        sampleLocationSubPixelBits;
3775         VkBool32                        variableSampleLocations;
3776 };
3777
3778 struct VkMultisamplePropertiesEXT
3779 {
3780         VkStructureType sType;
3781         void*                   pNext;
3782         VkExtent2D              maxSampleLocationGridSize;
3783 };
3784
3785 struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT
3786 {
3787         VkStructureType sType;
3788         void*                   pNext;
3789         VkBool32                advancedBlendCoherentOperations;
3790 };
3791
3792 struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT
3793 {
3794         VkStructureType sType;
3795         void*                   pNext;
3796         uint32_t                advancedBlendMaxColorAttachments;
3797         VkBool32                advancedBlendIndependentBlend;
3798         VkBool32                advancedBlendNonPremultipliedSrcColor;
3799         VkBool32                advancedBlendNonPremultipliedDstColor;
3800         VkBool32                advancedBlendCorrelatedOverlap;
3801         VkBool32                advancedBlendAllOperations;
3802 };
3803
3804 struct VkPipelineColorBlendAdvancedStateCreateInfoEXT
3805 {
3806         VkStructureType         sType;
3807         const void*                     pNext;
3808         VkBool32                        srcPremultiplied;
3809         VkBool32                        dstPremultiplied;
3810         VkBlendOverlapEXT       blendOverlap;
3811 };
3812
3813 struct VkPipelineCoverageToColorStateCreateInfoNV
3814 {
3815         VkStructureType                                                         sType;
3816         const void*                                                                     pNext;
3817         VkPipelineCoverageToColorStateCreateFlagsNV     flags;
3818         VkBool32                                                                        coverageToColorEnable;
3819         uint32_t                                                                        coverageToColorLocation;
3820 };
3821
3822 struct VkPipelineCoverageModulationStateCreateInfoNV
3823 {
3824         VkStructureType                                                                 sType;
3825         const void*                                                                             pNext;
3826         VkPipelineCoverageModulationStateCreateFlagsNV  flags;
3827         VkCoverageModulationModeNV                                              coverageModulationMode;
3828         VkBool32                                                                                coverageModulationTableEnable;
3829         uint32_t                                                                                coverageModulationTableCount;
3830         const float*                                                                    pCoverageModulationTable;
3831 };
3832
3833 struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV
3834 {
3835         VkStructureType sType;
3836         void*                   pNext;
3837         uint32_t                shaderSMCount;
3838         uint32_t                shaderWarpsPerSM;
3839 };
3840
3841 struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV
3842 {
3843         VkStructureType sType;
3844         void*                   pNext;
3845         VkBool32                shaderSMBuiltins;
3846 };
3847
3848 struct VkDrmFormatModifierPropertiesEXT
3849 {
3850         uint64_t                                drmFormatModifier;
3851         uint32_t                                drmFormatModifierPlaneCount;
3852         VkFormatFeatureFlags    drmFormatModifierTilingFeatures;
3853 };
3854
3855 struct VkDrmFormatModifierPropertiesListEXT
3856 {
3857         VkStructureType                                         sType;
3858         void*                                                           pNext;
3859         uint32_t                                                        drmFormatModifierCount;
3860         VkDrmFormatModifierPropertiesEXT*       pDrmFormatModifierProperties;
3861 };
3862
3863 struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT
3864 {
3865         VkStructureType sType;
3866         const void*             pNext;
3867         uint64_t                drmFormatModifier;
3868         VkSharingMode   sharingMode;
3869         uint32_t                queueFamilyIndexCount;
3870         const uint32_t* pQueueFamilyIndices;
3871 };
3872
3873 struct VkImageDrmFormatModifierListCreateInfoEXT
3874 {
3875         VkStructureType sType;
3876         const void*             pNext;
3877         uint32_t                drmFormatModifierCount;
3878         const uint64_t* pDrmFormatModifiers;
3879 };
3880
3881 struct VkImageDrmFormatModifierExplicitCreateInfoEXT
3882 {
3883         VkStructureType                         sType;
3884         const void*                                     pNext;
3885         uint64_t                                        drmFormatModifier;
3886         uint32_t                                        drmFormatModifierPlaneCount;
3887         const VkSubresourceLayout*      pPlaneLayouts;
3888 };
3889
3890 struct VkImageDrmFormatModifierPropertiesEXT
3891 {
3892         VkStructureType sType;
3893         void*                   pNext;
3894         uint64_t                drmFormatModifier;
3895 };
3896
3897 struct VkValidationCacheCreateInfoEXT
3898 {
3899         VkStructureType                                 sType;
3900         const void*                                             pNext;
3901         VkValidationCacheCreateFlagsEXT flags;
3902         size_t                                                  initialDataSize;
3903         const void*                                             pInitialData;
3904 };
3905
3906 struct VkShaderModuleValidationCacheCreateInfoEXT
3907 {
3908         VkStructureType                 sType;
3909         const void*                             pNext;
3910         VkValidationCacheEXT    validationCache;
3911 };
3912
3913 struct VkShadingRatePaletteNV
3914 {
3915         uint32_t                                                        shadingRatePaletteEntryCount;
3916         const VkShadingRatePaletteEntryNV*      pShadingRatePaletteEntries;
3917 };
3918
3919 struct VkPipelineViewportShadingRateImageStateCreateInfoNV
3920 {
3921         VkStructureType                                 sType;
3922         const void*                                             pNext;
3923         VkBool32                                                shadingRateImageEnable;
3924         uint32_t                                                viewportCount;
3925         const VkShadingRatePaletteNV*   pShadingRatePalettes;
3926 };
3927
3928 struct VkPhysicalDeviceShadingRateImageFeaturesNV
3929 {
3930         VkStructureType sType;
3931         void*                   pNext;
3932         VkBool32                shadingRateImage;
3933         VkBool32                shadingRateCoarseSampleOrder;
3934 };
3935
3936 struct VkPhysicalDeviceShadingRateImagePropertiesNV
3937 {
3938         VkStructureType sType;
3939         void*                   pNext;
3940         VkExtent2D              shadingRateTexelSize;
3941         uint32_t                shadingRatePaletteSize;
3942         uint32_t                shadingRateMaxCoarseSamples;
3943 };
3944
3945 struct VkCoarseSampleLocationNV
3946 {
3947         uint32_t        pixelX;
3948         uint32_t        pixelY;
3949         uint32_t        sample;
3950 };
3951
3952 struct VkCoarseSampleOrderCustomNV
3953 {
3954         VkShadingRatePaletteEntryNV             shadingRate;
3955         uint32_t                                                sampleCount;
3956         uint32_t                                                sampleLocationCount;
3957         const VkCoarseSampleLocationNV* pSampleLocations;
3958 };
3959
3960 struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV
3961 {
3962         VkStructureType                                         sType;
3963         const void*                                                     pNext;
3964         VkCoarseSampleOrderTypeNV                       sampleOrderType;
3965         uint32_t                                                        customSampleOrderCount;
3966         const VkCoarseSampleOrderCustomNV*      pCustomSampleOrders;
3967 };
3968
3969 struct VkRayTracingShaderGroupCreateInfoNV
3970 {
3971         VkStructureType                                 sType;
3972         const void*                                             pNext;
3973         VkRayTracingShaderGroupTypeKHR  type;
3974         uint32_t                                                generalShader;
3975         uint32_t                                                closestHitShader;
3976         uint32_t                                                anyHitShader;
3977         uint32_t                                                intersectionShader;
3978 };
3979
3980 struct VkRayTracingPipelineCreateInfoNV
3981 {
3982         VkStructureType                                                         sType;
3983         const void*                                                                     pNext;
3984         VkPipelineCreateFlags                                           flags;
3985         uint32_t                                                                        stageCount;
3986         const VkPipelineShaderStageCreateInfo*          pStages;
3987         uint32_t                                                                        groupCount;
3988         const VkRayTracingShaderGroupCreateInfoNV*      pGroups;
3989         uint32_t                                                                        maxRecursionDepth;
3990         VkPipelineLayout                                                        layout;
3991         VkPipeline                                                                      basePipelineHandle;
3992         int32_t                                                                         basePipelineIndex;
3993 };
3994
3995 struct VkGeometryTrianglesNV
3996 {
3997         VkStructureType sType;
3998         const void*             pNext;
3999         VkBuffer                vertexData;
4000         VkDeviceSize    vertexOffset;
4001         uint32_t                vertexCount;
4002         VkDeviceSize    vertexStride;
4003         VkFormat                vertexFormat;
4004         VkBuffer                indexData;
4005         VkDeviceSize    indexOffset;
4006         uint32_t                indexCount;
4007         VkIndexType             indexType;
4008         VkBuffer                transformData;
4009         VkDeviceSize    transformOffset;
4010 };
4011
4012 struct VkGeometryAABBNV
4013 {
4014         VkStructureType sType;
4015         const void*             pNext;
4016         VkBuffer                aabbData;
4017         uint32_t                numAABBs;
4018         uint32_t                stride;
4019         VkDeviceSize    offset;
4020 };
4021
4022 struct VkGeometryDataNV
4023 {
4024         VkGeometryTrianglesNV   triangles;
4025         VkGeometryAABBNV                aabbs;
4026 };
4027
4028 struct VkGeometryNV
4029 {
4030         VkStructureType         sType;
4031         const void*                     pNext;
4032         VkGeometryTypeKHR       geometryType;
4033         VkGeometryDataNV        geometry;
4034         VkGeometryFlagsKHR      flags;
4035 };
4036
4037 struct VkAccelerationStructureInfoNV
4038 {
4039         VkStructureType                                         sType;
4040         const void*                                                     pNext;
4041         VkAccelerationStructureTypeNV           type;
4042         VkBuildAccelerationStructureFlagsNV     flags;
4043         uint32_t                                                        instanceCount;
4044         uint32_t                                                        geometryCount;
4045         const VkGeometryNV*                                     pGeometries;
4046 };
4047
4048 struct VkAccelerationStructureCreateInfoNV
4049 {
4050         VkStructureType                                 sType;
4051         const void*                                             pNext;
4052         VkDeviceSize                                    compactedSize;
4053         VkAccelerationStructureInfoNV   info;
4054 };
4055
4056 struct VkBindAccelerationStructureMemoryInfoNV
4057 {
4058         VkStructureType                         sType;
4059         const void*                                     pNext;
4060         VkAccelerationStructureNV       accelerationStructure;
4061         VkDeviceMemory                          memory;
4062         VkDeviceSize                            memoryOffset;
4063         uint32_t                                        deviceIndexCount;
4064         const uint32_t*                         pDeviceIndices;
4065 };
4066
4067 struct VkWriteDescriptorSetAccelerationStructureNV
4068 {
4069         VkStructureType                                         sType;
4070         const void*                                                     pNext;
4071         uint32_t                                                        accelerationStructureCount;
4072         const VkAccelerationStructureNV*        pAccelerationStructures;
4073 };
4074
4075 struct VkAccelerationStructureMemoryRequirementsInfoNV
4076 {
4077         VkStructureType                                                                 sType;
4078         const void*                                                                             pNext;
4079         VkAccelerationStructureMemoryRequirementsTypeNV type;
4080         VkAccelerationStructureNV                                               accelerationStructure;
4081 };
4082
4083 struct VkPhysicalDeviceRayTracingPropertiesNV
4084 {
4085         VkStructureType sType;
4086         void*                   pNext;
4087         uint32_t                shaderGroupHandleSize;
4088         uint32_t                maxRecursionDepth;
4089         uint32_t                maxShaderGroupStride;
4090         uint32_t                shaderGroupBaseAlignment;
4091         uint64_t                maxGeometryCount;
4092         uint64_t                maxInstanceCount;
4093         uint64_t                maxTriangleCount;
4094         uint32_t                maxDescriptorSetAccelerationStructures;
4095 };
4096
4097 struct VkTransformMatrixKHR
4098 {
4099         float   matrix[3][4];
4100 };
4101
4102 struct VkAabbPositionsKHR
4103 {
4104         float   minX;
4105         float   minY;
4106         float   minZ;
4107         float   maxX;
4108         float   maxY;
4109         float   maxZ;
4110 };
4111
4112 struct VkAccelerationStructureInstanceKHR
4113 {
4114         VkTransformMatrixKHR            transform;
4115         uint32_t                                        instanceCustomIndex:24;
4116         uint32_t                                        mask:8;
4117         uint32_t                                        instanceShaderBindingTableRecordOffset:24;
4118         VkGeometryInstanceFlagsKHR      flags:8;
4119         uint64_t                                        accelerationStructureReference;
4120 };
4121
4122 struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV
4123 {
4124         VkStructureType sType;
4125         void*                   pNext;
4126         VkBool32                representativeFragmentTest;
4127 };
4128
4129 struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV
4130 {
4131         VkStructureType sType;
4132         const void*             pNext;
4133         VkBool32                representativeFragmentTestEnable;
4134 };
4135
4136 struct VkPhysicalDeviceImageViewImageFormatInfoEXT
4137 {
4138         VkStructureType sType;
4139         void*                   pNext;
4140         VkImageViewType imageViewType;
4141 };
4142
4143 struct VkFilterCubicImageViewImageFormatPropertiesEXT
4144 {
4145         VkStructureType sType;
4146         void*                   pNext;
4147         VkBool32                filterCubic;
4148         VkBool32                filterCubicMinmax;
4149 };
4150
4151 struct VkDeviceQueueGlobalPriorityCreateInfoEXT
4152 {
4153         VkStructureType                         sType;
4154         const void*                                     pNext;
4155         VkQueueGlobalPriorityEXT        globalPriority;
4156 };
4157
4158 struct VkImportMemoryHostPointerInfoEXT
4159 {
4160         VkStructureType                                         sType;
4161         const void*                                                     pNext;
4162         VkExternalMemoryHandleTypeFlagBits      handleType;
4163         void*                                                           pHostPointer;
4164 };
4165
4166 struct VkMemoryHostPointerPropertiesEXT
4167 {
4168         VkStructureType sType;
4169         void*                   pNext;
4170         uint32_t                memoryTypeBits;
4171 };
4172
4173 struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT
4174 {
4175         VkStructureType sType;
4176         void*                   pNext;
4177         VkDeviceSize    minImportedHostPointerAlignment;
4178 };
4179
4180 struct VkPipelineCompilerControlCreateInfoAMD
4181 {
4182         VkStructureType                                         sType;
4183         const void*                                                     pNext;
4184         VkPipelineCompilerControlFlagsAMD       compilerControlFlags;
4185 };
4186
4187 struct VkCalibratedTimestampInfoEXT
4188 {
4189         VkStructureType sType;
4190         const void*             pNext;
4191         VkTimeDomainEXT timeDomain;
4192 };
4193
4194 struct VkPhysicalDeviceShaderCorePropertiesAMD
4195 {
4196         VkStructureType sType;
4197         void*                   pNext;
4198         uint32_t                shaderEngineCount;
4199         uint32_t                shaderArraysPerEngineCount;
4200         uint32_t                computeUnitsPerShaderArray;
4201         uint32_t                simdPerComputeUnit;
4202         uint32_t                wavefrontsPerSimd;
4203         uint32_t                wavefrontSize;
4204         uint32_t                sgprsPerSimd;
4205         uint32_t                minSgprAllocation;
4206         uint32_t                maxSgprAllocation;
4207         uint32_t                sgprAllocationGranularity;
4208         uint32_t                vgprsPerSimd;
4209         uint32_t                minVgprAllocation;
4210         uint32_t                maxVgprAllocation;
4211         uint32_t                vgprAllocationGranularity;
4212 };
4213
4214 struct VkDeviceMemoryOverallocationCreateInfoAMD
4215 {
4216         VkStructureType                                         sType;
4217         const void*                                                     pNext;
4218         VkMemoryOverallocationBehaviorAMD       overallocationBehavior;
4219 };
4220
4221 struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT
4222 {
4223         VkStructureType sType;
4224         void*                   pNext;
4225         uint32_t                maxVertexAttribDivisor;
4226 };
4227
4228 struct VkVertexInputBindingDivisorDescriptionEXT
4229 {
4230         uint32_t        binding;
4231         uint32_t        divisor;
4232 };
4233
4234 struct VkPipelineVertexInputDivisorStateCreateInfoEXT
4235 {
4236         VkStructureType                                                                         sType;
4237         const void*                                                                                     pNext;
4238         uint32_t                                                                                        vertexBindingDivisorCount;
4239         const VkVertexInputBindingDivisorDescriptionEXT*        pVertexBindingDivisors;
4240 };
4241
4242 struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT
4243 {
4244         VkStructureType sType;
4245         void*                   pNext;
4246         VkBool32                vertexAttributeInstanceRateDivisor;
4247         VkBool32                vertexAttributeInstanceRateZeroDivisor;
4248 };
4249
4250 struct VkPipelineCreationFeedbackEXT
4251 {
4252         VkPipelineCreationFeedbackFlagsEXT      flags;
4253         uint64_t                                                        duration;
4254 };
4255
4256 struct VkPipelineCreationFeedbackCreateInfoEXT
4257 {
4258         VkStructureType                                 sType;
4259         const void*                                             pNext;
4260         VkPipelineCreationFeedbackEXT*  pPipelineCreationFeedback;
4261         uint32_t                                                pipelineStageCreationFeedbackCount;
4262         VkPipelineCreationFeedbackEXT*  pPipelineStageCreationFeedbacks;
4263 };
4264
4265 struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV
4266 {
4267         VkStructureType sType;
4268         void*                   pNext;
4269         VkBool32                computeDerivativeGroupQuads;
4270         VkBool32                computeDerivativeGroupLinear;
4271 };
4272
4273 struct VkPhysicalDeviceMeshShaderFeaturesNV
4274 {
4275         VkStructureType sType;
4276         void*                   pNext;
4277         VkBool32                taskShader;
4278         VkBool32                meshShader;
4279 };
4280
4281 struct VkPhysicalDeviceMeshShaderPropertiesNV
4282 {
4283         VkStructureType sType;
4284         void*                   pNext;
4285         uint32_t                maxDrawMeshTasksCount;
4286         uint32_t                maxTaskWorkGroupInvocations;
4287         uint32_t                maxTaskWorkGroupSize[3];
4288         uint32_t                maxTaskTotalMemorySize;
4289         uint32_t                maxTaskOutputCount;
4290         uint32_t                maxMeshWorkGroupInvocations;
4291         uint32_t                maxMeshWorkGroupSize[3];
4292         uint32_t                maxMeshTotalMemorySize;
4293         uint32_t                maxMeshOutputVertices;
4294         uint32_t                maxMeshOutputPrimitives;
4295         uint32_t                maxMeshMultiviewViewCount;
4296         uint32_t                meshOutputPerVertexGranularity;
4297         uint32_t                meshOutputPerPrimitiveGranularity;
4298 };
4299
4300 struct VkDrawMeshTasksIndirectCommandNV
4301 {
4302         uint32_t        taskCount;
4303         uint32_t        firstTask;
4304 };
4305
4306 struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV
4307 {
4308         VkStructureType sType;
4309         void*                   pNext;
4310         VkBool32                fragmentShaderBarycentric;
4311 };
4312
4313 struct VkPhysicalDeviceShaderImageFootprintFeaturesNV
4314 {
4315         VkStructureType sType;
4316         void*                   pNext;
4317         VkBool32                imageFootprint;
4318 };
4319
4320 struct VkPipelineViewportExclusiveScissorStateCreateInfoNV
4321 {
4322         VkStructureType sType;
4323         const void*             pNext;
4324         uint32_t                exclusiveScissorCount;
4325         const VkRect2D* pExclusiveScissors;
4326 };
4327
4328 struct VkPhysicalDeviceExclusiveScissorFeaturesNV
4329 {
4330         VkStructureType sType;
4331         void*                   pNext;
4332         VkBool32                exclusiveScissor;
4333 };
4334
4335 struct VkQueueFamilyCheckpointPropertiesNV
4336 {
4337         VkStructureType                 sType;
4338         void*                                   pNext;
4339         VkPipelineStageFlags    checkpointExecutionStageMask;
4340 };
4341
4342 struct VkCheckpointDataNV
4343 {
4344         VkStructureType                 sType;
4345         void*                                   pNext;
4346         VkPipelineStageFlagBits stage;
4347         void*                                   pCheckpointMarker;
4348 };
4349
4350 struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL
4351 {
4352         VkStructureType sType;
4353         void*                   pNext;
4354         VkBool32                shaderIntegerFunctions2;
4355 };
4356
4357 union VkPerformanceValueDataINTEL
4358 {
4359         uint32_t        value32;
4360         uint64_t        value64;
4361         float           valueFloat;
4362         VkBool32        valueBool;
4363         const char*     valueString;
4364 };
4365
4366 struct VkPerformanceValueINTEL
4367 {
4368         VkPerformanceValueTypeINTEL     type;
4369         VkPerformanceValueDataINTEL     data;
4370 };
4371
4372 struct VkInitializePerformanceApiInfoINTEL
4373 {
4374         VkStructureType sType;
4375         const void*             pNext;
4376         void*                   pUserData;
4377 };
4378
4379 struct VkQueryPoolPerformanceQueryCreateInfoINTEL
4380 {
4381         VkStructureType                                 sType;
4382         const void*                                             pNext;
4383         VkQueryPoolSamplingModeINTEL    performanceCountersSampling;
4384 };
4385
4386 struct VkPerformanceMarkerInfoINTEL
4387 {
4388         VkStructureType sType;
4389         const void*             pNext;
4390         uint64_t                marker;
4391 };
4392
4393 struct VkPerformanceStreamMarkerInfoINTEL
4394 {
4395         VkStructureType sType;
4396         const void*             pNext;
4397         uint32_t                marker;
4398 };
4399
4400 struct VkPerformanceOverrideInfoINTEL
4401 {
4402         VkStructureType                                 sType;
4403         const void*                                             pNext;
4404         VkPerformanceOverrideTypeINTEL  type;
4405         VkBool32                                                enable;
4406         uint64_t                                                parameter;
4407 };
4408
4409 struct VkPerformanceConfigurationAcquireInfoINTEL
4410 {
4411         VkStructureType                                         sType;
4412         const void*                                                     pNext;
4413         VkPerformanceConfigurationTypeINTEL     type;
4414 };
4415
4416 struct VkPhysicalDevicePCIBusInfoPropertiesEXT
4417 {
4418         VkStructureType sType;
4419         void*                   pNext;
4420         uint32_t                pciDomain;
4421         uint32_t                pciBus;
4422         uint32_t                pciDevice;
4423         uint32_t                pciFunction;
4424 };
4425
4426 struct VkDisplayNativeHdrSurfaceCapabilitiesAMD
4427 {
4428         VkStructureType sType;
4429         void*                   pNext;
4430         VkBool32                localDimmingSupport;
4431 };
4432
4433 struct VkSwapchainDisplayNativeHdrCreateInfoAMD
4434 {
4435         VkStructureType sType;
4436         const void*             pNext;
4437         VkBool32                localDimmingEnable;
4438 };
4439
4440 struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT
4441 {
4442         VkStructureType sType;
4443         void*                   pNext;
4444         VkBool32                fragmentDensityMap;
4445         VkBool32                fragmentDensityMapDynamic;
4446         VkBool32                fragmentDensityMapNonSubsampledImages;
4447 };
4448
4449 struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT
4450 {
4451         VkStructureType sType;
4452         void*                   pNext;
4453         VkExtent2D              minFragmentDensityTexelSize;
4454         VkExtent2D              maxFragmentDensityTexelSize;
4455         VkBool32                fragmentDensityInvocations;
4456 };
4457
4458 struct VkRenderPassFragmentDensityMapCreateInfoEXT
4459 {
4460         VkStructureType                 sType;
4461         const void*                             pNext;
4462         VkAttachmentReference   fragmentDensityMapAttachment;
4463 };
4464
4465 struct VkPhysicalDeviceSubgroupSizeControlFeaturesEXT
4466 {
4467         VkStructureType sType;
4468         void*                   pNext;
4469         VkBool32                subgroupSizeControl;
4470         VkBool32                computeFullSubgroups;
4471 };
4472
4473 struct VkPhysicalDeviceSubgroupSizeControlPropertiesEXT
4474 {
4475         VkStructureType         sType;
4476         void*                           pNext;
4477         uint32_t                        minSubgroupSize;
4478         uint32_t                        maxSubgroupSize;
4479         uint32_t                        maxComputeWorkgroupSubgroups;
4480         VkShaderStageFlags      requiredSubgroupSizeStages;
4481 };
4482
4483 struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT
4484 {
4485         VkStructureType sType;
4486         void*                   pNext;
4487         uint32_t                requiredSubgroupSize;
4488 };
4489
4490 struct VkPhysicalDeviceShaderCoreProperties2AMD
4491 {
4492         VkStructureType                                 sType;
4493         void*                                                   pNext;
4494         VkShaderCorePropertiesFlagsAMD  shaderCoreFeatures;
4495         uint32_t                                                activeComputeUnitCount;
4496 };
4497
4498 struct VkPhysicalDeviceCoherentMemoryFeaturesAMD
4499 {
4500         VkStructureType sType;
4501         void*                   pNext;
4502         VkBool32                deviceCoherentMemory;
4503 };
4504
4505 struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT
4506 {
4507         VkStructureType sType;
4508         void*                   pNext;
4509         VkBool32                shaderImageInt64Atomics;
4510         VkBool32                sparseImageInt64Atomics;
4511 };
4512
4513 struct VkPhysicalDeviceMemoryBudgetPropertiesEXT
4514 {
4515         VkStructureType sType;
4516         void*                   pNext;
4517         VkDeviceSize    heapBudget[VK_MAX_MEMORY_HEAPS];
4518         VkDeviceSize    heapUsage[VK_MAX_MEMORY_HEAPS];
4519 };
4520
4521 struct VkPhysicalDeviceMemoryPriorityFeaturesEXT
4522 {
4523         VkStructureType sType;
4524         void*                   pNext;
4525         VkBool32                memoryPriority;
4526 };
4527
4528 struct VkMemoryPriorityAllocateInfoEXT
4529 {
4530         VkStructureType sType;
4531         const void*             pNext;
4532         float                   priority;
4533 };
4534
4535 struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV
4536 {
4537         VkStructureType sType;
4538         void*                   pNext;
4539         VkBool32                dedicatedAllocationImageAliasing;
4540 };
4541
4542 struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT
4543 {
4544         VkStructureType sType;
4545         void*                   pNext;
4546         VkBool32                bufferDeviceAddress;
4547         VkBool32                bufferDeviceAddressCaptureReplay;
4548         VkBool32                bufferDeviceAddressMultiDevice;
4549 };
4550
4551 struct VkBufferDeviceAddressCreateInfoEXT
4552 {
4553         VkStructureType sType;
4554         const void*             pNext;
4555         VkDeviceAddress deviceAddress;
4556 };
4557
4558 struct VkPhysicalDeviceToolPropertiesEXT
4559 {
4560         VkStructureType                 sType;
4561         void*                                   pNext;
4562         char                                    name[VK_MAX_EXTENSION_NAME_SIZE];
4563         char                                    version[VK_MAX_EXTENSION_NAME_SIZE];
4564         VkToolPurposeFlagsEXT   purposes;
4565         char                                    description[VK_MAX_DESCRIPTION_SIZE];
4566         char                                    layer[VK_MAX_EXTENSION_NAME_SIZE];
4567 };
4568
4569 struct VkValidationFeaturesEXT
4570 {
4571         VkStructureType                                                 sType;
4572         const void*                                                             pNext;
4573         uint32_t                                                                enabledValidationFeatureCount;
4574         const VkValidationFeatureEnableEXT*             pEnabledValidationFeatures;
4575         uint32_t                                                                disabledValidationFeatureCount;
4576         const VkValidationFeatureDisableEXT*    pDisabledValidationFeatures;
4577 };
4578
4579 struct VkCooperativeMatrixPropertiesNV
4580 {
4581         VkStructureType         sType;
4582         void*                           pNext;
4583         uint32_t                        MSize;
4584         uint32_t                        NSize;
4585         uint32_t                        KSize;
4586         VkComponentTypeNV       AType;
4587         VkComponentTypeNV       BType;
4588         VkComponentTypeNV       CType;
4589         VkComponentTypeNV       DType;
4590         VkScopeNV                       scope;
4591 };
4592
4593 struct VkPhysicalDeviceCooperativeMatrixFeaturesNV
4594 {
4595         VkStructureType sType;
4596         void*                   pNext;
4597         VkBool32                cooperativeMatrix;
4598         VkBool32                cooperativeMatrixRobustBufferAccess;
4599 };
4600
4601 struct VkPhysicalDeviceCooperativeMatrixPropertiesNV
4602 {
4603         VkStructureType         sType;
4604         void*                           pNext;
4605         VkShaderStageFlags      cooperativeMatrixSupportedStages;
4606 };
4607
4608 struct VkPhysicalDeviceCoverageReductionModeFeaturesNV
4609 {
4610         VkStructureType sType;
4611         void*                   pNext;
4612         VkBool32                coverageReductionMode;
4613 };
4614
4615 struct VkPipelineCoverageReductionStateCreateInfoNV
4616 {
4617         VkStructureType                                                                 sType;
4618         const void*                                                                             pNext;
4619         VkPipelineCoverageReductionStateCreateFlagsNV   flags;
4620         VkCoverageReductionModeNV                                               coverageReductionMode;
4621 };
4622
4623 struct VkFramebufferMixedSamplesCombinationNV
4624 {
4625         VkStructureType                         sType;
4626         void*                                           pNext;
4627         VkCoverageReductionModeNV       coverageReductionMode;
4628         VkSampleCountFlagBits           rasterizationSamples;
4629         VkSampleCountFlags                      depthStencilSamples;
4630         VkSampleCountFlags                      colorSamples;
4631 };
4632
4633 struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT
4634 {
4635         VkStructureType sType;
4636         void*                   pNext;
4637         VkBool32                fragmentShaderSampleInterlock;
4638         VkBool32                fragmentShaderPixelInterlock;
4639         VkBool32                fragmentShaderShadingRateInterlock;
4640 };
4641
4642 struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT
4643 {
4644         VkStructureType sType;
4645         void*                   pNext;
4646         VkBool32                ycbcrImageArrays;
4647 };
4648
4649 struct VkPhysicalDeviceProvokingVertexFeaturesEXT
4650 {
4651         VkStructureType sType;
4652         void*                   pNext;
4653         VkBool32                provokingVertexLast;
4654         VkBool32                transformFeedbackPreservesProvokingVertex;
4655 };
4656
4657 struct VkPhysicalDeviceProvokingVertexPropertiesEXT
4658 {
4659         VkStructureType sType;
4660         void*                   pNext;
4661         VkBool32                provokingVertexModePerPipeline;
4662         VkBool32                transformFeedbackPreservesTriangleFanProvokingVertex;
4663 };
4664
4665 struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT
4666 {
4667         VkStructureType                         sType;
4668         const void*                                     pNext;
4669         VkProvokingVertexModeEXT        provokingVertexMode;
4670 };
4671
4672 struct VkHeadlessSurfaceCreateInfoEXT
4673 {
4674         VkStructureType                                 sType;
4675         const void*                                             pNext;
4676         VkHeadlessSurfaceCreateFlagsEXT flags;
4677 };
4678
4679 struct VkPhysicalDeviceLineRasterizationFeaturesEXT
4680 {
4681         VkStructureType sType;
4682         void*                   pNext;
4683         VkBool32                rectangularLines;
4684         VkBool32                bresenhamLines;
4685         VkBool32                smoothLines;
4686         VkBool32                stippledRectangularLines;
4687         VkBool32                stippledBresenhamLines;
4688         VkBool32                stippledSmoothLines;
4689 };
4690
4691 struct VkPhysicalDeviceLineRasterizationPropertiesEXT
4692 {
4693         VkStructureType sType;
4694         void*                   pNext;
4695         uint32_t                lineSubPixelPrecisionBits;
4696 };
4697
4698 struct VkPipelineRasterizationLineStateCreateInfoEXT
4699 {
4700         VkStructureType                         sType;
4701         const void*                                     pNext;
4702         VkLineRasterizationModeEXT      lineRasterizationMode;
4703         VkBool32                                        stippledLineEnable;
4704         uint32_t                                        lineStippleFactor;
4705         uint16_t                                        lineStipplePattern;
4706 };
4707
4708 struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT
4709 {
4710         VkStructureType sType;
4711         void*                   pNext;
4712         VkBool32                shaderBufferFloat32Atomics;
4713         VkBool32                shaderBufferFloat32AtomicAdd;
4714         VkBool32                shaderBufferFloat64Atomics;
4715         VkBool32                shaderBufferFloat64AtomicAdd;
4716         VkBool32                shaderSharedFloat32Atomics;
4717         VkBool32                shaderSharedFloat32AtomicAdd;
4718         VkBool32                shaderSharedFloat64Atomics;
4719         VkBool32                shaderSharedFloat64AtomicAdd;
4720         VkBool32                shaderImageFloat32Atomics;
4721         VkBool32                shaderImageFloat32AtomicAdd;
4722         VkBool32                sparseImageFloat32Atomics;
4723         VkBool32                sparseImageFloat32AtomicAdd;
4724 };
4725
4726 struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT
4727 {
4728         VkStructureType sType;
4729         void*                   pNext;
4730         VkBool32                indexTypeUint8;
4731 };
4732
4733 struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT
4734 {
4735         VkStructureType sType;
4736         void*                   pNext;
4737         VkBool32                extendedDynamicState;
4738 };
4739
4740 struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT
4741 {
4742         VkStructureType sType;
4743         void*                   pNext;
4744         VkBool32                shaderBufferFloat16Atomics;
4745         VkBool32                shaderBufferFloat16AtomicAdd;
4746         VkBool32                shaderBufferFloat16AtomicMinMax;
4747         VkBool32                shaderBufferFloat32AtomicMinMax;
4748         VkBool32                shaderBufferFloat64AtomicMinMax;
4749         VkBool32                shaderSharedFloat16Atomics;
4750         VkBool32                shaderSharedFloat16AtomicAdd;
4751         VkBool32                shaderSharedFloat16AtomicMinMax;
4752         VkBool32                shaderSharedFloat32AtomicMinMax;
4753         VkBool32                shaderSharedFloat64AtomicMinMax;
4754         VkBool32                shaderImageFloat32AtomicMinMax;
4755         VkBool32                sparseImageFloat32AtomicMinMax;
4756 };
4757
4758 struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT
4759 {
4760         VkStructureType sType;
4761         void*                   pNext;
4762         VkBool32                shaderDemoteToHelperInvocation;
4763 };
4764
4765 struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV
4766 {
4767         VkStructureType sType;
4768         void*                   pNext;
4769         uint32_t                maxGraphicsShaderGroupCount;
4770         uint32_t                maxIndirectSequenceCount;
4771         uint32_t                maxIndirectCommandsTokenCount;
4772         uint32_t                maxIndirectCommandsStreamCount;
4773         uint32_t                maxIndirectCommandsTokenOffset;
4774         uint32_t                maxIndirectCommandsStreamStride;
4775         uint32_t                minSequencesCountBufferOffsetAlignment;
4776         uint32_t                minSequencesIndexBufferOffsetAlignment;
4777         uint32_t                minIndirectCommandsBufferOffsetAlignment;
4778 };
4779
4780 struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV
4781 {
4782         VkStructureType sType;
4783         void*                   pNext;
4784         VkBool32                deviceGeneratedCommands;
4785 };
4786
4787 struct VkGraphicsShaderGroupCreateInfoNV
4788 {
4789         VkStructureType                                                                 sType;
4790         const void*                                                                             pNext;
4791         uint32_t                                                                                stageCount;
4792         const VkPipelineShaderStageCreateInfo*                  pStages;
4793         const VkPipelineVertexInputStateCreateInfo*             pVertexInputState;
4794         const VkPipelineTessellationStateCreateInfo*    pTessellationState;
4795 };
4796
4797 struct VkGraphicsPipelineShaderGroupsCreateInfoNV
4798 {
4799         VkStructureType                                                         sType;
4800         const void*                                                                     pNext;
4801         uint32_t                                                                        groupCount;
4802         const VkGraphicsShaderGroupCreateInfoNV*        pGroups;
4803         uint32_t                                                                        pipelineCount;
4804         const VkPipeline*                                                       pPipelines;
4805 };
4806
4807 struct VkBindShaderGroupIndirectCommandNV
4808 {
4809         uint32_t        groupIndex;
4810 };
4811
4812 struct VkBindIndexBufferIndirectCommandNV
4813 {
4814         VkDeviceAddress bufferAddress;
4815         uint32_t                size;
4816         VkIndexType             indexType;
4817 };
4818
4819 struct VkBindVertexBufferIndirectCommandNV
4820 {
4821         VkDeviceAddress bufferAddress;
4822         uint32_t                size;
4823         uint32_t                stride;
4824 };
4825
4826 struct VkSetStateFlagsIndirectCommandNV
4827 {
4828         uint32_t        data;
4829 };
4830
4831 struct VkIndirectCommandsStreamNV
4832 {
4833         VkBuffer                buffer;
4834         VkDeviceSize    offset;
4835 };
4836
4837 struct VkIndirectCommandsLayoutTokenNV
4838 {
4839         VkStructureType                                 sType;
4840         const void*                                             pNext;
4841         VkIndirectCommandsTokenTypeNV   tokenType;
4842         uint32_t                                                stream;
4843         uint32_t                                                offset;
4844         uint32_t                                                vertexBindingUnit;
4845         VkBool32                                                vertexDynamicStride;
4846         VkPipelineLayout                                pushconstantPipelineLayout;
4847         VkShaderStageFlags                              pushconstantShaderStageFlags;
4848         uint32_t                                                pushconstantOffset;
4849         uint32_t                                                pushconstantSize;
4850         VkIndirectStateFlagsNV                  indirectStateFlags;
4851         uint32_t                                                indexTypeCount;
4852         const VkIndexType*                              pIndexTypes;
4853         const uint32_t*                                 pIndexTypeValues;
4854 };
4855
4856 struct VkIndirectCommandsLayoutCreateInfoNV
4857 {
4858         VkStructureType                                                 sType;
4859         const void*                                                             pNext;
4860         VkIndirectCommandsLayoutUsageFlagsNV    flags;
4861         VkPipelineBindPoint                                             pipelineBindPoint;
4862         uint32_t                                                                tokenCount;
4863         const VkIndirectCommandsLayoutTokenNV*  pTokens;
4864         uint32_t                                                                streamCount;
4865         const uint32_t*                                                 pStreamStrides;
4866 };
4867
4868 struct VkGeneratedCommandsInfoNV
4869 {
4870         VkStructureType                                         sType;
4871         const void*                                                     pNext;
4872         VkPipelineBindPoint                                     pipelineBindPoint;
4873         VkPipeline                                                      pipeline;
4874         VkIndirectCommandsLayoutNV                      indirectCommandsLayout;
4875         uint32_t                                                        streamCount;
4876         const VkIndirectCommandsStreamNV*       pStreams;
4877         uint32_t                                                        sequencesCount;
4878         VkBuffer                                                        preprocessBuffer;
4879         VkDeviceSize                                            preprocessOffset;
4880         VkDeviceSize                                            preprocessSize;
4881         VkBuffer                                                        sequencesCountBuffer;
4882         VkDeviceSize                                            sequencesCountOffset;
4883         VkBuffer                                                        sequencesIndexBuffer;
4884         VkDeviceSize                                            sequencesIndexOffset;
4885 };
4886
4887 struct VkGeneratedCommandsMemoryRequirementsInfoNV
4888 {
4889         VkStructureType                         sType;
4890         const void*                                     pNext;
4891         VkPipelineBindPoint                     pipelineBindPoint;
4892         VkPipeline                                      pipeline;
4893         VkIndirectCommandsLayoutNV      indirectCommandsLayout;
4894         uint32_t                                        maxSequencesCount;
4895 };
4896
4897 struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV
4898 {
4899         VkStructureType sType;
4900         void*                   pNext;
4901         VkBool32                inheritedViewportScissor2D;
4902 };
4903
4904 struct VkCommandBufferInheritanceViewportScissorInfoNV
4905 {
4906         VkStructureType         sType;
4907         const void*                     pNext;
4908         VkBool32                        viewportScissor2D;
4909         uint32_t                        viewportDepthCount;
4910         const VkViewport*       pViewportDepths;
4911 };
4912
4913 struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT
4914 {
4915         VkStructureType sType;
4916         void*                   pNext;
4917         VkBool32                texelBufferAlignment;
4918 };
4919
4920 struct VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT
4921 {
4922         VkStructureType sType;
4923         void*                   pNext;
4924         VkDeviceSize    storageTexelBufferOffsetAlignmentBytes;
4925         VkBool32                storageTexelBufferOffsetSingleTexelAlignment;
4926         VkDeviceSize    uniformTexelBufferOffsetAlignmentBytes;
4927         VkBool32                uniformTexelBufferOffsetSingleTexelAlignment;
4928 };
4929
4930 struct VkRenderPassTransformBeginInfoQCOM
4931 {
4932         VkStructureType                                 sType;
4933         void*                                                   pNext;
4934         VkSurfaceTransformFlagBitsKHR   transform;
4935 };
4936
4937 struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM
4938 {
4939         VkStructureType                                 sType;
4940         void*                                                   pNext;
4941         VkSurfaceTransformFlagBitsKHR   transform;
4942         VkRect2D                                                renderArea;
4943 };
4944
4945 struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT
4946 {
4947         VkStructureType sType;
4948         void*                   pNext;
4949         VkBool32                deviceMemoryReport;
4950 };
4951
4952 struct VkDeviceMemoryReportCallbackDataEXT
4953 {
4954         VkStructureType                                         sType;
4955         void*                                                           pNext;
4956         VkDeviceMemoryReportFlagsEXT            flags;
4957         VkDeviceMemoryReportEventTypeEXT        type;
4958         uint64_t                                                        memoryObjectId;
4959         VkDeviceSize                                            size;
4960         VkObjectType                                            objectType;
4961         uint64_t                                                        objectHandle;
4962         uint32_t                                                        heapIndex;
4963 };
4964
4965 struct VkDeviceDeviceMemoryReportCreateInfoEXT
4966 {
4967         VkStructureType                                         sType;
4968         const void*                                                     pNext;
4969         VkDeviceMemoryReportFlagsEXT            flags;
4970         PFN_vkDeviceMemoryReportCallbackEXT     pfnUserCallback;
4971         void*                                                           pUserData;
4972 };
4973
4974 struct VkPhysicalDeviceRobustness2FeaturesEXT
4975 {
4976         VkStructureType sType;
4977         void*                   pNext;
4978         VkBool32                robustBufferAccess2;
4979         VkBool32                robustImageAccess2;
4980         VkBool32                nullDescriptor;
4981 };
4982
4983 struct VkPhysicalDeviceRobustness2PropertiesEXT
4984 {
4985         VkStructureType sType;
4986         void*                   pNext;
4987         VkDeviceSize    robustStorageBufferAccessSizeAlignment;
4988         VkDeviceSize    robustUniformBufferAccessSizeAlignment;
4989 };
4990
4991 struct VkSamplerCustomBorderColorCreateInfoEXT
4992 {
4993         VkStructureType         sType;
4994         const void*                     pNext;
4995         VkClearColorValue       customBorderColor;
4996         VkFormat                        format;
4997 };
4998
4999 struct VkPhysicalDeviceCustomBorderColorPropertiesEXT
5000 {
5001         VkStructureType sType;
5002         void*                   pNext;
5003         uint32_t                maxCustomBorderColorSamplers;
5004 };
5005
5006 struct VkPhysicalDeviceCustomBorderColorFeaturesEXT
5007 {
5008         VkStructureType sType;
5009         void*                   pNext;
5010         VkBool32                customBorderColors;
5011         VkBool32                customBorderColorWithoutFormat;
5012 };
5013
5014 struct VkPhysicalDevicePrivateDataFeaturesEXT
5015 {
5016         VkStructureType sType;
5017         void*                   pNext;
5018         VkBool32                privateData;
5019 };
5020
5021 struct VkDevicePrivateDataCreateInfoEXT
5022 {
5023         VkStructureType sType;
5024         const void*             pNext;
5025         uint32_t                privateDataSlotRequestCount;
5026 };
5027
5028 struct VkPrivateDataSlotCreateInfoEXT
5029 {
5030         VkStructureType                                 sType;
5031         const void*                                             pNext;
5032         VkPrivateDataSlotCreateFlagsEXT flags;
5033 };
5034
5035 struct VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT
5036 {
5037         VkStructureType sType;
5038         void*                   pNext;
5039         VkBool32                pipelineCreationCacheControl;
5040 };
5041
5042 struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV
5043 {
5044         VkStructureType sType;
5045         void*                   pNext;
5046         VkBool32                diagnosticsConfig;
5047 };
5048
5049 struct VkDeviceDiagnosticsConfigCreateInfoNV
5050 {
5051         VkStructureType                                         sType;
5052         const void*                                                     pNext;
5053         VkDeviceDiagnosticsConfigFlagsNV        flags;
5054 };
5055
5056 struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV
5057 {
5058         VkStructureType sType;
5059         void*                   pNext;
5060         VkBool32                fragmentShadingRateEnums;
5061         VkBool32                supersampleFragmentShadingRates;
5062         VkBool32                noInvocationFragmentShadingRates;
5063 };
5064
5065 struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV
5066 {
5067         VkStructureType                 sType;
5068         void*                                   pNext;
5069         VkSampleCountFlagBits   maxFragmentShadingRateInvocationCount;
5070 };
5071
5072 struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV
5073 {
5074         VkStructureType                                         sType;
5075         const void*                                                     pNext;
5076         VkFragmentShadingRateTypeNV                     shadingRateType;
5077         VkFragmentShadingRateNV                         shadingRate;
5078         VkFragmentShadingRateCombinerOpKHR      combinerOps[2];
5079 };
5080
5081 union VkDeviceOrHostAddressConstKHR
5082 {
5083         VkDeviceAddress deviceAddress;
5084         const void*             hostAddress;
5085 };
5086
5087 struct VkAccelerationStructureGeometryMotionTrianglesDataNV
5088 {
5089         VkStructureType                                 sType;
5090         const void*                                             pNext;
5091         VkDeviceOrHostAddressConstKHR   vertexData;
5092 };
5093
5094 struct VkAccelerationStructureMotionInfoNV
5095 {
5096         VkStructureType                                                         sType;
5097         const void*                                                                     pNext;
5098         uint32_t                                                                        maxInstances;
5099         VkAccelerationStructureMotionInfoFlagsNV        flags;
5100 };
5101
5102 struct VkAccelerationStructureMatrixMotionInstanceNV
5103 {
5104         VkTransformMatrixKHR            transformT0;
5105         VkTransformMatrixKHR            transformT1;
5106         uint32_t                                        instanceCustomIndex:24;
5107         uint32_t                                        mask:8;
5108         uint32_t                                        instanceShaderBindingTableRecordOffset:24;
5109         VkGeometryInstanceFlagsKHR      flags:8;
5110         uint64_t                                        accelerationStructureReference;
5111 };
5112
5113 struct VkSRTDataNV
5114 {
5115         float   sx;
5116         float   a;
5117         float   b;
5118         float   pvx;
5119         float   sy;
5120         float   c;
5121         float   pvy;
5122         float   sz;
5123         float   pvz;
5124         float   qx;
5125         float   qy;
5126         float   qz;
5127         float   qw;
5128         float   tx;
5129         float   ty;
5130         float   tz;
5131 };
5132
5133 struct VkAccelerationStructureSRTMotionInstanceNV
5134 {
5135         VkSRTDataNV                                     transformT0;
5136         VkSRTDataNV                                     transformT1;
5137         uint32_t                                        instanceCustomIndex:24;
5138         uint32_t                                        mask:8;
5139         uint32_t                                        instanceShaderBindingTableRecordOffset:24;
5140         VkGeometryInstanceFlagsKHR      flags:8;
5141         uint64_t                                        accelerationStructureReference;
5142 };
5143
5144 union VkAccelerationStructureMotionInstanceDataNV
5145 {
5146         VkAccelerationStructureInstanceKHR                              staticInstance;
5147         VkAccelerationStructureMatrixMotionInstanceNV   matrixMotionInstance;
5148         VkAccelerationStructureSRTMotionInstanceNV              srtMotionInstance;
5149 };
5150
5151 struct VkAccelerationStructureMotionInstanceNV
5152 {
5153         VkAccelerationStructureMotionInstanceTypeNV             type;
5154         VkAccelerationStructureMotionInstanceFlagsNV    flags;
5155         VkAccelerationStructureMotionInstanceDataNV             data;
5156 };
5157
5158 struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV
5159 {
5160         VkStructureType sType;
5161         void*                   pNext;
5162         VkBool32                rayTracingMotionBlur;
5163         VkBool32                rayTracingMotionBlurPipelineTraceRaysIndirect;
5164 };
5165
5166 struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT
5167 {
5168         VkStructureType sType;
5169         void*                   pNext;
5170         VkBool32                ycbcr2plane444Formats;
5171 };
5172
5173 struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT
5174 {
5175         VkStructureType sType;
5176         void*                   pNext;
5177         VkBool32                fragmentDensityMapDeferred;
5178 };
5179
5180 struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT
5181 {
5182         VkStructureType sType;
5183         void*                   pNext;
5184         VkBool32                subsampledLoads;
5185         VkBool32                subsampledCoarseReconstructionEarlyAccess;
5186         uint32_t                maxSubsampledArrayLayers;
5187         uint32_t                maxDescriptorSetSubsampledSamplers;
5188 };
5189
5190 struct VkCopyCommandTransformInfoQCOM
5191 {
5192         VkStructureType                                 sType;
5193         const void*                                             pNext;
5194         VkSurfaceTransformFlagBitsKHR   transform;
5195 };
5196
5197 struct VkPhysicalDeviceImageRobustnessFeaturesEXT
5198 {
5199         VkStructureType sType;
5200         void*                   pNext;
5201         VkBool32                robustImageAccess;
5202 };
5203
5204 struct VkPhysicalDevice4444FormatsFeaturesEXT
5205 {
5206         VkStructureType sType;
5207         void*                   pNext;
5208         VkBool32                formatA4R4G4B4;
5209         VkBool32                formatA4B4G4R4;
5210 };
5211
5212 struct VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE
5213 {
5214         VkStructureType sType;
5215         void*                   pNext;
5216         VkBool32                mutableDescriptorType;
5217 };
5218
5219 struct VkMutableDescriptorTypeListVALVE
5220 {
5221         uint32_t                                descriptorTypeCount;
5222         const VkDescriptorType* pDescriptorTypes;
5223 };
5224
5225 struct VkMutableDescriptorTypeCreateInfoVALVE
5226 {
5227         VkStructureType                                                 sType;
5228         const void*                                                             pNext;
5229         uint32_t                                                                mutableDescriptorTypeListCount;
5230         const VkMutableDescriptorTypeListVALVE* pMutableDescriptorTypeLists;
5231 };
5232
5233 struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT
5234 {
5235         VkStructureType sType;
5236         void*                   pNext;
5237         VkBool32                vertexInputDynamicState;
5238 };
5239
5240 struct VkVertexInputBindingDescription2EXT
5241 {
5242         VkStructureType         sType;
5243         void*                           pNext;
5244         uint32_t                        binding;
5245         uint32_t                        stride;
5246         VkVertexInputRate       inputRate;
5247         uint32_t                        divisor;
5248 };
5249
5250 struct VkVertexInputAttributeDescription2EXT
5251 {
5252         VkStructureType sType;
5253         void*                   pNext;
5254         uint32_t                location;
5255         uint32_t                binding;
5256         VkFormat                format;
5257         uint32_t                offset;
5258 };
5259
5260 struct VkPhysicalDeviceDrmPropertiesEXT
5261 {
5262         VkStructureType sType;
5263         void*                   pNext;
5264         VkBool32                hasPrimary;
5265         VkBool32                hasRender;
5266         int64_t                 primaryMajor;
5267         int64_t                 primaryMinor;
5268         int64_t                 renderMajor;
5269         int64_t                 renderMinor;
5270 };
5271
5272 struct VkSubpassShadingPipelineCreateInfoHUAWEI
5273 {
5274         VkStructureType sType;
5275         void*                   pNext;
5276         VkRenderPass    renderPass;
5277         uint32_t                subpass;
5278 };
5279
5280 struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI
5281 {
5282         VkStructureType sType;
5283         void*                   pNext;
5284         VkBool32                subpassShading;
5285 };
5286
5287 struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI
5288 {
5289         VkStructureType sType;
5290         void*                   pNext;
5291         uint32_t                maxSubpassShadingWorkgroupSizeAspectRatio;
5292 };
5293
5294 struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI
5295 {
5296         VkStructureType sType;
5297         void*                   pNext;
5298         VkBool32                invocationMask;
5299 };
5300
5301 struct VkMemoryGetRemoteAddressInfoNV
5302 {
5303         VkStructureType                                         sType;
5304         const void*                                                     pNext;
5305         VkDeviceMemory                                          memory;
5306         VkExternalMemoryHandleTypeFlagBits      handleType;
5307 };
5308
5309 struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV
5310 {
5311         VkStructureType sType;
5312         void*                   pNext;
5313         VkBool32                externalMemoryRDMA;
5314 };
5315
5316 struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT
5317 {
5318         VkStructureType sType;
5319         void*                   pNext;
5320         VkBool32                extendedDynamicState2;
5321         VkBool32                extendedDynamicState2LogicOp;
5322         VkBool32                extendedDynamicState2PatchControlPoints;
5323 };
5324
5325 struct VkPhysicalDeviceColorWriteEnableFeaturesEXT
5326 {
5327         VkStructureType sType;
5328         void*                   pNext;
5329         VkBool32                colorWriteEnable;
5330 };
5331
5332 struct VkPipelineColorWriteCreateInfoEXT
5333 {
5334         VkStructureType sType;
5335         const void*             pNext;
5336         uint32_t                attachmentCount;
5337         const VkBool32* pColorWriteEnables;
5338 };
5339
5340 struct VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT
5341 {
5342         VkStructureType sType;
5343         void*                   pNext;
5344         VkBool32                globalPriorityQuery;
5345 };
5346
5347 struct VkQueueFamilyGlobalPriorityPropertiesEXT
5348 {
5349         VkStructureType                         sType;
5350         void*                                           pNext;
5351         uint32_t                                        priorityCount;
5352         VkQueueGlobalPriorityEXT        priorities[VK_MAX_GLOBAL_PRIORITY_SIZE_EXT];
5353 };
5354
5355 struct VkPhysicalDeviceMultiDrawFeaturesEXT
5356 {
5357         VkStructureType sType;
5358         void*                   pNext;
5359         VkBool32                multiDraw;
5360 };
5361
5362 struct VkPhysicalDeviceMultiDrawPropertiesEXT
5363 {
5364         VkStructureType sType;
5365         void*                   pNext;
5366         uint32_t                maxMultiDrawCount;
5367 };
5368
5369 struct VkMultiDrawInfoEXT
5370 {
5371         uint32_t        firstVertex;
5372         uint32_t        vertexCount;
5373 };
5374
5375 struct VkMultiDrawIndexedInfoEXT
5376 {
5377         uint32_t        firstIndex;
5378         uint32_t        indexCount;
5379         int32_t         vertexOffset;
5380 };
5381
5382 union VkDeviceOrHostAddressKHR
5383 {
5384         VkDeviceAddress deviceAddress;
5385         void*                   hostAddress;
5386 };
5387
5388 struct VkAccelerationStructureBuildRangeInfoKHR
5389 {
5390         uint32_t        primitiveCount;
5391         uint32_t        primitiveOffset;
5392         uint32_t        firstVertex;
5393         uint32_t        transformOffset;
5394 };
5395
5396 struct VkAccelerationStructureGeometryTrianglesDataKHR
5397 {
5398         VkStructureType                                 sType;
5399         const void*                                             pNext;
5400         VkFormat                                                vertexFormat;
5401         VkDeviceOrHostAddressConstKHR   vertexData;
5402         VkDeviceSize                                    vertexStride;
5403         uint32_t                                                maxVertex;
5404         VkIndexType                                             indexType;
5405         VkDeviceOrHostAddressConstKHR   indexData;
5406         VkDeviceOrHostAddressConstKHR   transformData;
5407 };
5408
5409 struct VkAccelerationStructureGeometryAabbsDataKHR
5410 {
5411         VkStructureType                                 sType;
5412         const void*                                             pNext;
5413         VkDeviceOrHostAddressConstKHR   data;
5414         VkDeviceSize                                    stride;
5415 };
5416
5417 struct VkAccelerationStructureGeometryInstancesDataKHR
5418 {
5419         VkStructureType                                 sType;
5420         const void*                                             pNext;
5421         VkBool32                                                arrayOfPointers;
5422         VkDeviceOrHostAddressConstKHR   data;
5423 };
5424
5425 union VkAccelerationStructureGeometryDataKHR
5426 {
5427         VkAccelerationStructureGeometryTrianglesDataKHR triangles;
5428         VkAccelerationStructureGeometryAabbsDataKHR             aabbs;
5429         VkAccelerationStructureGeometryInstancesDataKHR instances;
5430 };
5431
5432 struct VkAccelerationStructureGeometryKHR
5433 {
5434         VkStructureType                                                 sType;
5435         const void*                                                             pNext;
5436         VkGeometryTypeKHR                                               geometryType;
5437         VkAccelerationStructureGeometryDataKHR  geometry;
5438         VkGeometryFlagsKHR                                              flags;
5439 };
5440
5441 struct VkAccelerationStructureBuildGeometryInfoKHR
5442 {
5443         VkStructureType                                                                         sType;
5444         const void*                                                                                     pNext;
5445         VkAccelerationStructureTypeKHR                                          type;
5446         VkBuildAccelerationStructureFlagsKHR                            flags;
5447         VkBuildAccelerationStructureModeKHR                                     mode;
5448         VkAccelerationStructureKHR                                                      srcAccelerationStructure;
5449         VkAccelerationStructureKHR                                                      dstAccelerationStructure;
5450         uint32_t                                                                                        geometryCount;
5451         const VkAccelerationStructureGeometryKHR*                       pGeometries;
5452         const VkAccelerationStructureGeometryKHR* const*        ppGeometries;
5453         VkDeviceOrHostAddressKHR                                                        scratchData;
5454 };
5455
5456 struct VkAccelerationStructureCreateInfoKHR
5457 {
5458         VkStructureType                                                 sType;
5459         const void*                                                             pNext;
5460         VkAccelerationStructureCreateFlagsKHR   createFlags;
5461         VkBuffer                                                                buffer;
5462         VkDeviceSize                                                    offset;
5463         VkDeviceSize                                                    size;
5464         VkAccelerationStructureTypeKHR                  type;
5465         VkDeviceAddress                                                 deviceAddress;
5466 };
5467
5468 struct VkWriteDescriptorSetAccelerationStructureKHR
5469 {
5470         VkStructureType                                         sType;
5471         const void*                                                     pNext;
5472         uint32_t                                                        accelerationStructureCount;
5473         const VkAccelerationStructureKHR*       pAccelerationStructures;
5474 };
5475
5476 struct VkPhysicalDeviceAccelerationStructureFeaturesKHR
5477 {
5478         VkStructureType sType;
5479         void*                   pNext;
5480         VkBool32                accelerationStructure;
5481         VkBool32                accelerationStructureCaptureReplay;
5482         VkBool32                accelerationStructureIndirectBuild;
5483         VkBool32                accelerationStructureHostCommands;
5484         VkBool32                descriptorBindingAccelerationStructureUpdateAfterBind;
5485 };
5486
5487 struct VkPhysicalDeviceAccelerationStructurePropertiesKHR
5488 {
5489         VkStructureType sType;
5490         void*                   pNext;
5491         uint64_t                maxGeometryCount;
5492         uint64_t                maxInstanceCount;
5493         uint64_t                maxPrimitiveCount;
5494         uint32_t                maxPerStageDescriptorAccelerationStructures;
5495         uint32_t                maxPerStageDescriptorUpdateAfterBindAccelerationStructures;
5496         uint32_t                maxDescriptorSetAccelerationStructures;
5497         uint32_t                maxDescriptorSetUpdateAfterBindAccelerationStructures;
5498         uint32_t                minAccelerationStructureScratchOffsetAlignment;
5499 };
5500
5501 struct VkAccelerationStructureDeviceAddressInfoKHR
5502 {
5503         VkStructureType                         sType;
5504         const void*                                     pNext;
5505         VkAccelerationStructureKHR      accelerationStructure;
5506 };
5507
5508 struct VkAccelerationStructureVersionInfoKHR
5509 {
5510         VkStructureType sType;
5511         const void*             pNext;
5512         const uint8_t*  pVersionData;
5513 };
5514
5515 struct VkCopyAccelerationStructureToMemoryInfoKHR
5516 {
5517         VkStructureType                                         sType;
5518         const void*                                                     pNext;
5519         VkAccelerationStructureKHR                      src;
5520         VkDeviceOrHostAddressKHR                        dst;
5521         VkCopyAccelerationStructureModeKHR      mode;
5522 };
5523
5524 struct VkCopyMemoryToAccelerationStructureInfoKHR
5525 {
5526         VkStructureType                                         sType;
5527         const void*                                                     pNext;
5528         VkDeviceOrHostAddressConstKHR           src;
5529         VkAccelerationStructureKHR                      dst;
5530         VkCopyAccelerationStructureModeKHR      mode;
5531 };
5532
5533 struct VkCopyAccelerationStructureInfoKHR
5534 {
5535         VkStructureType                                         sType;
5536         const void*                                                     pNext;
5537         VkAccelerationStructureKHR                      src;
5538         VkAccelerationStructureKHR                      dst;
5539         VkCopyAccelerationStructureModeKHR      mode;
5540 };
5541
5542 struct VkAccelerationStructureBuildSizesInfoKHR
5543 {
5544         VkStructureType sType;
5545         const void*             pNext;
5546         VkDeviceSize    accelerationStructureSize;
5547         VkDeviceSize    updateScratchSize;
5548         VkDeviceSize    buildScratchSize;
5549 };
5550
5551 struct VkRayTracingShaderGroupCreateInfoKHR
5552 {
5553         VkStructureType                                 sType;
5554         const void*                                             pNext;
5555         VkRayTracingShaderGroupTypeKHR  type;
5556         uint32_t                                                generalShader;
5557         uint32_t                                                closestHitShader;
5558         uint32_t                                                anyHitShader;
5559         uint32_t                                                intersectionShader;
5560         const void*                                             pShaderGroupCaptureReplayHandle;
5561 };
5562
5563 struct VkRayTracingPipelineInterfaceCreateInfoKHR
5564 {
5565         VkStructureType sType;
5566         const void*             pNext;
5567         uint32_t                maxPipelineRayPayloadSize;
5568         uint32_t                maxPipelineRayHitAttributeSize;
5569 };
5570
5571 struct VkRayTracingPipelineCreateInfoKHR
5572 {
5573         VkStructureType                                                                         sType;
5574         const void*                                                                                     pNext;
5575         VkPipelineCreateFlags                                                           flags;
5576         uint32_t                                                                                        stageCount;
5577         const VkPipelineShaderStageCreateInfo*                          pStages;
5578         uint32_t                                                                                        groupCount;
5579         const VkRayTracingShaderGroupCreateInfoKHR*                     pGroups;
5580         uint32_t                                                                                        maxPipelineRayRecursionDepth;
5581         const VkPipelineLibraryCreateInfoKHR*                           pLibraryInfo;
5582         const VkRayTracingPipelineInterfaceCreateInfoKHR*       pLibraryInterface;
5583         const VkPipelineDynamicStateCreateInfo*                         pDynamicState;
5584         VkPipelineLayout                                                                        layout;
5585         VkPipeline                                                                                      basePipelineHandle;
5586         int32_t                                                                                         basePipelineIndex;
5587 };
5588
5589 struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR
5590 {
5591         VkStructureType sType;
5592         void*                   pNext;
5593         VkBool32                rayTracingPipeline;
5594         VkBool32                rayTracingPipelineShaderGroupHandleCaptureReplay;
5595         VkBool32                rayTracingPipelineShaderGroupHandleCaptureReplayMixed;
5596         VkBool32                rayTracingPipelineTraceRaysIndirect;
5597         VkBool32                rayTraversalPrimitiveCulling;
5598 };
5599
5600 struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR
5601 {
5602         VkStructureType sType;
5603         void*                   pNext;
5604         uint32_t                shaderGroupHandleSize;
5605         uint32_t                maxRayRecursionDepth;
5606         uint32_t                maxShaderGroupStride;
5607         uint32_t                shaderGroupBaseAlignment;
5608         uint32_t                shaderGroupHandleCaptureReplaySize;
5609         uint32_t                maxRayDispatchInvocationCount;
5610         uint32_t                shaderGroupHandleAlignment;
5611         uint32_t                maxRayHitAttributeSize;
5612 };
5613
5614 struct VkStridedDeviceAddressRegionKHR
5615 {
5616         VkDeviceAddress deviceAddress;
5617         VkDeviceSize    stride;
5618         VkDeviceSize    size;
5619 };
5620
5621 struct VkTraceRaysIndirectCommandKHR
5622 {
5623         uint32_t        width;
5624         uint32_t        height;
5625         uint32_t        depth;
5626 };
5627
5628 struct VkPhysicalDeviceRayQueryFeaturesKHR
5629 {
5630         VkStructureType sType;
5631         void*                   pNext;
5632         VkBool32                rayQuery;
5633 };
5634
5635 struct VkAndroidSurfaceCreateInfoKHR
5636 {
5637         VkStructureType                                         sType;
5638         const void*                                                     pNext;
5639         VkAndroidSurfaceCreateFlagsKHR          flags;
5640         struct pt::AndroidNativeWindowPtr       window;
5641 };
5642
5643 struct VkAndroidHardwareBufferUsageANDROID
5644 {
5645         VkStructureType sType;
5646         void*                   pNext;
5647         uint64_t                androidHardwareBufferUsage;
5648 };
5649
5650 struct VkAndroidHardwareBufferPropertiesANDROID
5651 {
5652         VkStructureType sType;
5653         void*                   pNext;
5654         VkDeviceSize    allocationSize;
5655         uint32_t                memoryTypeBits;
5656 };
5657
5658 struct VkAndroidHardwareBufferFormatPropertiesANDROID
5659 {
5660         VkStructureType                                 sType;
5661         void*                                                   pNext;
5662         VkFormat                                                format;
5663         uint64_t                                                externalFormat;
5664         VkFormatFeatureFlags                    formatFeatures;
5665         VkComponentMapping                              samplerYcbcrConversionComponents;
5666         VkSamplerYcbcrModelConversion   suggestedYcbcrModel;
5667         VkSamplerYcbcrRange                             suggestedYcbcrRange;
5668         VkChromaLocation                                suggestedXChromaOffset;
5669         VkChromaLocation                                suggestedYChromaOffset;
5670 };
5671
5672 struct VkImportAndroidHardwareBufferInfoANDROID
5673 {
5674         VkStructureType                                         sType;
5675         const void*                                                     pNext;
5676         struct pt::AndroidHardwareBufferPtr     buffer;
5677 };
5678
5679 struct VkMemoryGetAndroidHardwareBufferInfoANDROID
5680 {
5681         VkStructureType sType;
5682         const void*             pNext;
5683         VkDeviceMemory  memory;
5684 };
5685
5686 struct VkExternalFormatANDROID
5687 {
5688         VkStructureType sType;
5689         void*                   pNext;
5690         uint64_t                externalFormat;
5691 };
5692
5693 struct VkVideoQueueFamilyProperties2KHR
5694 {
5695         VkStructureType                                 sType;
5696         void*                                                   pNext;
5697         VkVideoCodecOperationFlagsKHR   videoCodecOperations;
5698 };
5699
5700 struct VkVideoProfileKHR
5701 {
5702         VkStructureType                                         sType;
5703         void*                                                           pNext;
5704         VkVideoCodecOperationFlagBitsKHR        videoCodecOperation;
5705         VkVideoChromaSubsamplingFlagsKHR        chromaSubsampling;
5706         VkVideoComponentBitDepthFlagsKHR        lumaBitDepth;
5707         VkVideoComponentBitDepthFlagsKHR        chromaBitDepth;
5708 };
5709
5710 struct VkVideoProfilesKHR
5711 {
5712         VkStructureType                         sType;
5713         void*                                           pNext;
5714         uint32_t                                        profileCount;
5715         const VkVideoProfileKHR*        pProfiles;
5716 };
5717
5718 struct VkVideoCapabilitiesKHR
5719 {
5720         VkStructureType                         sType;
5721         void*                                           pNext;
5722         VkVideoCapabilitiesFlagsKHR     capabilityFlags;
5723         VkDeviceSize                            minBitstreamBufferOffsetAlignment;
5724         VkDeviceSize                            minBitstreamBufferSizeAlignment;
5725         VkExtent2D                                      videoPictureExtentGranularity;
5726         VkExtent2D                                      minExtent;
5727         VkExtent2D                                      maxExtent;
5728         uint32_t                                        maxReferencePicturesSlotsCount;
5729         uint32_t                                        maxReferencePicturesActiveCount;
5730 };
5731
5732 struct VkPhysicalDeviceVideoFormatInfoKHR
5733 {
5734         VkStructureType                         sType;
5735         const void*                                     pNext;
5736         VkImageUsageFlags                       imageUsage;
5737         const VkVideoProfilesKHR*       pVideoProfiles;
5738 };
5739
5740 struct VkVideoFormatPropertiesKHR
5741 {
5742         VkStructureType sType;
5743         void*                   pNext;
5744         VkFormat                format;
5745 };
5746
5747 struct VkVideoPictureResourceKHR
5748 {
5749         VkStructureType sType;
5750         const void*             pNext;
5751         VkOffset2D              codedOffset;
5752         VkExtent2D              codedExtent;
5753         uint32_t                baseArrayLayer;
5754         VkImageView             imageViewBinding;
5755 };
5756
5757 struct VkVideoReferenceSlotKHR
5758 {
5759         VkStructureType                                         sType;
5760         const void*                                                     pNext;
5761         int8_t                                                          slotIndex;
5762         const VkVideoPictureResourceKHR*        pPictureResource;
5763 };
5764
5765 struct VkVideoGetMemoryPropertiesKHR
5766 {
5767         VkStructureType                 sType;
5768         const void*                             pNext;
5769         uint32_t                                memoryBindIndex;
5770         VkMemoryRequirements2*  pMemoryRequirements;
5771 };
5772
5773 struct VkVideoBindMemoryKHR
5774 {
5775         VkStructureType sType;
5776         const void*             pNext;
5777         uint32_t                memoryBindIndex;
5778         VkDeviceMemory  memory;
5779         VkDeviceSize    memoryOffset;
5780         VkDeviceSize    memorySize;
5781 };
5782
5783 struct VkVideoSessionCreateInfoKHR
5784 {
5785         VkStructureType                                 sType;
5786         const void*                                             pNext;
5787         uint32_t                                                queueFamilyIndex;
5788         VkVideoSessionCreateFlagsKHR    flags;
5789         const VkVideoProfileKHR*                pVideoProfile;
5790         VkFormat                                                pictureFormat;
5791         VkExtent2D                                              maxCodedExtent;
5792         VkFormat                                                referencePicturesFormat;
5793         uint32_t                                                maxReferencePicturesSlotsCount;
5794         uint32_t                                                maxReferencePicturesActiveCount;
5795 };
5796
5797 struct VkVideoSessionParametersCreateInfoKHR
5798 {
5799         VkStructureType                         sType;
5800         const void*                                     pNext;
5801         VkVideoSessionParametersKHR     videoSessionParametersTemplate;
5802         VkVideoSessionKHR                       videoSession;
5803 };
5804
5805 struct VkVideoSessionParametersUpdateInfoKHR
5806 {
5807         VkStructureType sType;
5808         const void*             pNext;
5809         uint32_t                updateSequenceCount;
5810 };
5811
5812 struct VkVideoBeginCodingInfoKHR
5813 {
5814         VkStructureType                                         sType;
5815         const void*                                                     pNext;
5816         VkVideoBeginCodingFlagsKHR                      flags;
5817         VkVideoCodingQualityPresetFlagsKHR      codecQualityPreset;
5818         VkVideoSessionKHR                                       videoSession;
5819         VkVideoSessionParametersKHR                     videoSessionParameters;
5820         uint32_t                                                        referenceSlotCount;
5821         const VkVideoReferenceSlotKHR*          pReferenceSlots;
5822 };
5823
5824 struct VkVideoEndCodingInfoKHR
5825 {
5826         VkStructureType                         sType;
5827         const void*                                     pNext;
5828         VkVideoEndCodingFlagsKHR        flags;
5829 };
5830
5831 struct VkVideoCodingControlInfoKHR
5832 {
5833         VkStructureType                                 sType;
5834         const void*                                             pNext;
5835         VkVideoCodingControlFlagsKHR    flags;
5836 };
5837
5838 struct VkVideoDecodeInfoKHR
5839 {
5840         VkStructureType                                 sType;
5841         const void*                                             pNext;
5842         VkVideoDecodeFlagsKHR                   flags;
5843         VkOffset2D                                              codedOffset;
5844         VkExtent2D                                              codedExtent;
5845         VkBuffer                                                srcBuffer;
5846         VkDeviceSize                                    srcBufferOffset;
5847         VkDeviceSize                                    srcBufferRange;
5848         VkVideoPictureResourceKHR               dstPictureResource;
5849         const VkVideoReferenceSlotKHR*  pSetupReferenceSlot;
5850         uint32_t                                                referenceSlotCount;
5851         const VkVideoReferenceSlotKHR*  pReferenceSlots;
5852 };
5853
5854 struct VkPhysicalDevicePortabilitySubsetFeaturesKHR
5855 {
5856         VkStructureType sType;
5857         void*                   pNext;
5858         VkBool32                constantAlphaColorBlendFactors;
5859         VkBool32                events;
5860         VkBool32                imageViewFormatReinterpretation;
5861         VkBool32                imageViewFormatSwizzle;
5862         VkBool32                imageView2DOn3DImage;
5863         VkBool32                multisampleArrayImage;
5864         VkBool32                mutableComparisonSamplers;
5865         VkBool32                pointPolygons;
5866         VkBool32                samplerMipLodBias;
5867         VkBool32                separateStencilMaskRef;
5868         VkBool32                shaderSampleRateInterpolationFunctions;
5869         VkBool32                tessellationIsolines;
5870         VkBool32                tessellationPointMode;
5871         VkBool32                triangleFans;
5872         VkBool32                vertexAttributeAccessBeyondStride;
5873 };
5874
5875 struct VkPhysicalDevicePortabilitySubsetPropertiesKHR
5876 {
5877         VkStructureType sType;
5878         void*                   pNext;
5879         uint32_t                minVertexInputBindingStrideAlignment;
5880 };
5881
5882 struct VkVideoEncodeInfoKHR
5883 {
5884         VkStructureType                                 sType;
5885         const void*                                             pNext;
5886         VkVideoEncodeFlagsKHR                   flags;
5887         uint32_t                                                qualityLevel;
5888         VkExtent2D                                              codedExtent;
5889         VkBuffer                                                dstBitstreamBuffer;
5890         VkDeviceSize                                    dstBitstreamBufferOffset;
5891         VkDeviceSize                                    dstBitstreamBufferMaxRange;
5892         VkVideoPictureResourceKHR               srcPictureResource;
5893         const VkVideoReferenceSlotKHR*  pSetupReferenceSlot;
5894         uint32_t                                                referenceSlotCount;
5895         const VkVideoReferenceSlotKHR*  pReferenceSlots;
5896 };
5897
5898 struct VkVideoEncodeRateControlInfoKHR
5899 {
5900         VkStructureType                                                 sType;
5901         const void*                                                             pNext;
5902         VkVideoEncodeRateControlFlagsKHR                flags;
5903         VkVideoEncodeRateControlModeFlagBitsKHR rateControlMode;
5904         uint32_t                                                                averageBitrate;
5905         uint16_t                                                                peakToAverageBitrateRatio;
5906         uint16_t                                                                frameRateNumerator;
5907         uint16_t                                                                frameRateDenominator;
5908         uint32_t                                                                virtualBufferSizeInMs;
5909 };
5910
5911 struct StdVideoH264SpsVuiFlags
5912 {
5913         uint32_t        aspect_ratio_info_present_flag:1;
5914         uint32_t        overscan_info_present_flag:1;
5915         uint32_t        overscan_appropriate_flag:1;
5916         uint32_t        video_signal_type_present_flag:1;
5917         uint32_t        video_full_range_flag:1;
5918         uint32_t        color_description_present_flag:1;
5919         uint32_t        chroma_loc_info_present_flag:1;
5920         uint32_t        timing_info_present_flag:1;
5921         uint32_t        fixed_frame_rate_flag:1;
5922         uint32_t        bitstream_restriction_flag:1;
5923         uint32_t        nal_hrd_parameters_present_flag:1;
5924         uint32_t        vcl_hrd_parameters_present_flag:1;
5925 };
5926
5927 struct StdVideoH264HrdParameters
5928 {
5929         uint8_t         cpb_cnt_minus1;
5930         uint8_t         bit_rate_scale;
5931         uint8_t         cpb_size_scale;
5932         uint32_t        bit_rate_value_minus1[32];
5933         uint32_t        cpb_size_value_minus1[32];
5934         uint8_t         cbr_flag[32];
5935         uint32_t        initial_cpb_removal_delay_length_minus1;
5936         uint32_t        cpb_removal_delay_length_minus1;
5937         uint32_t        dpb_output_delay_length_minus1;
5938         uint32_t        time_offset_length;
5939 };
5940
5941 struct StdVideoH264SequenceParameterSetVui
5942 {
5943         StdVideoH264AspectRatioIdc      aspect_ratio_idc;
5944         uint16_t                                        sar_width;
5945         uint16_t                                        sar_height;
5946         uint8_t                                         video_format;
5947         uint8_t                                         color_primaries;
5948         uint8_t                                         transfer_characteristics;
5949         uint8_t                                         matrix_coefficients;
5950         uint32_t                                        num_units_in_tick;
5951         uint32_t                                        time_scale;
5952         StdVideoH264HrdParameters       hrd_parameters;
5953         uint8_t                                         num_reorder_frames;
5954         uint8_t                                         max_dec_frame_buffering;
5955         StdVideoH264SpsVuiFlags         flags;
5956 };
5957
5958 struct StdVideoH264SpsFlags
5959 {
5960         uint32_t        constraint_set0_flag:1;
5961         uint32_t        constraint_set1_flag:1;
5962         uint32_t        constraint_set2_flag:1;
5963         uint32_t        constraint_set3_flag:1;
5964         uint32_t        constraint_set4_flag:1;
5965         uint32_t        constraint_set5_flag:1;
5966         uint32_t        direct_8x8_inference_flag:1;
5967         uint32_t        mb_adaptive_frame_field_flag:1;
5968         uint32_t        frame_mbs_only_flag:1;
5969         uint32_t        delta_pic_order_always_zero_flag:1;
5970         uint32_t        residual_colour_transform_flag:1;
5971         uint32_t        gaps_in_frame_num_value_allowed_flag:1;
5972         uint32_t        first_picture_after_seek_flag:1;
5973         uint32_t        qpprime_y_zero_transform_bypass_flag:1;
5974         uint32_t        frame_cropping_flag:1;
5975         uint32_t        scaling_matrix_present_flag:1;
5976         uint32_t        vui_parameters_present_flag:1;
5977 };
5978
5979 struct StdVideoH264ScalingLists
5980 {
5981         uint8_t scaling_list_present_mask;
5982         uint8_t use_default_scaling_matrix_mask;
5983         uint8_t ScalingList4x4[6][16];
5984         uint8_t ScalingList8x8[2][64];
5985 };
5986
5987 struct StdVideoH264SequenceParameterSet
5988 {
5989         StdVideoH264ProfileIdc                                  profile_idc;
5990         StdVideoH264Level                                               level_idc;
5991         uint8_t                                                                 seq_parameter_set_id;
5992         StdVideoH264ChromaFormatIdc                             chroma_format_idc;
5993         uint8_t                                                                 bit_depth_luma_minus8;
5994         uint8_t                                                                 bit_depth_chroma_minus8;
5995         uint8_t                                                                 log2_max_frame_num_minus4;
5996         StdVideoH264PocType                                             pic_order_cnt_type;
5997         uint8_t                                                                 log2_max_pic_order_cnt_lsb_minus4;
5998         int32_t                                                                 offset_for_non_ref_pic;
5999         int32_t                                                                 offset_for_top_to_bottom_field;
6000         uint8_t                                                                 num_ref_frames_in_pic_order_cnt_cycle;
6001         uint8_t                                                                 max_num_ref_frames;
6002         uint32_t                                                                pic_width_in_mbs_minus1;
6003         uint32_t                                                                pic_height_in_map_units_minus1;
6004         uint32_t                                                                frame_crop_left_offset;
6005         uint32_t                                                                frame_crop_right_offset;
6006         uint32_t                                                                frame_crop_top_offset;
6007         uint32_t                                                                frame_crop_bottom_offset;
6008         StdVideoH264SpsFlags                                    flags;
6009         int32_t                                                                 offset_for_ref_frame[255];
6010         StdVideoH264ScalingLists*                               pScalingLists;
6011         StdVideoH264SequenceParameterSetVui*    pSequenceParameterSetVui;
6012 };
6013
6014 struct StdVideoH264PpsFlags
6015 {
6016         uint32_t        transform_8x8_mode_flag:1;
6017         uint32_t        redundant_pic_cnt_present_flag:1;
6018         uint32_t        constrained_intra_pred_flag:1;
6019         uint32_t        deblocking_filter_control_present_flag:1;
6020         uint32_t        weighted_bipred_idc_flag:1;
6021         uint32_t        weighted_pred_flag:1;
6022         uint32_t        pic_order_present_flag:1;
6023         uint32_t        entropy_coding_mode_flag:1;
6024         uint32_t        scaling_matrix_present_flag:1;
6025 };
6026
6027 struct StdVideoH264PictureParameterSet
6028 {
6029         uint8_t                                                 seq_parameter_set_id;
6030         uint8_t                                                 pic_parameter_set_id;
6031         uint8_t                                                 num_ref_idx_l0_default_active_minus1;
6032         uint8_t                                                 num_ref_idx_l1_default_active_minus1;
6033         StdVideoH264WeightedBiPredIdc   weighted_bipred_idc;
6034         int8_t                                                  pic_init_qp_minus26;
6035         int8_t                                                  pic_init_qs_minus26;
6036         int8_t                                                  chroma_qp_index_offset;
6037         int8_t                                                  second_chroma_qp_index_offset;
6038         StdVideoH264PpsFlags                    flags;
6039         StdVideoH264ScalingLists*               pScalingLists;
6040 };
6041
6042 struct StdVideoEncodeH264SliceHeaderFlags
6043 {
6044         uint32_t        idr_flag:1;
6045         uint32_t        is_reference_flag:1;
6046         uint32_t        num_ref_idx_active_override_flag:1;
6047         uint32_t        no_output_of_prior_pics_flag:1;
6048         uint32_t        long_term_reference_flag:1;
6049         uint32_t        adaptive_ref_pic_marking_mode_flag:1;
6050         uint32_t        no_prior_references_available_flag:1;
6051 };
6052
6053 struct StdVideoEncodeH264PictureInfoFlags
6054 {
6055         uint32_t        idr_flag:1;
6056         uint32_t        is_reference_flag:1;
6057         uint32_t        long_term_reference_flag:1;
6058 };
6059
6060 struct StdVideoEncodeH264RefMgmtFlags
6061 {
6062         uint32_t        ref_pic_list_modification_l0_flag:1;
6063         uint32_t        ref_pic_list_modification_l1_flag:1;
6064 };
6065
6066 struct StdVideoEncodeH264RefListModEntry
6067 {
6068         StdVideoH264ModificationOfPicNumsIdc    modification_of_pic_nums_idc;
6069         uint16_t                                                                abs_diff_pic_num_minus1;
6070         uint16_t                                                                long_term_pic_num;
6071 };
6072
6073 struct StdVideoEncodeH264RefPicMarkingEntry
6074 {
6075         StdVideoH264MemMgmtControlOp    operation;
6076         uint16_t                                                difference_of_pic_nums_minus1;
6077         uint16_t                                                long_term_pic_num;
6078         uint16_t                                                long_term_frame_idx;
6079         uint16_t                                                max_long_term_frame_idx_plus1;
6080 };
6081
6082 struct StdVideoEncodeH264RefMemMgmtCtrlOperations
6083 {
6084         StdVideoEncodeH264RefMgmtFlags                  flags;
6085         uint8_t                                                                 refList0ModOpCount;
6086         StdVideoEncodeH264RefListModEntry*              pRefList0ModOperations;
6087         uint8_t                                                                 refList1ModOpCount;
6088         StdVideoEncodeH264RefListModEntry*              pRefList1ModOperations;
6089         uint8_t                                                                 refPicMarkingOpCount;
6090         StdVideoEncodeH264RefPicMarkingEntry*   pRefPicMarkingOperations;
6091 };
6092
6093 struct StdVideoEncodeH264PictureInfo
6094 {
6095         StdVideoEncodeH264PictureInfoFlags      flags;
6096         StdVideoH264PictureType                         pictureType;
6097         uint32_t                                                        frameNum;
6098         uint32_t                                                        pictureOrderCount;
6099         uint16_t                                                        long_term_pic_num;
6100         uint16_t                                                        long_term_frame_idx;
6101 };
6102
6103 struct StdVideoEncodeH264SliceHeader
6104 {
6105         StdVideoEncodeH264SliceHeaderFlags                      flags;
6106         StdVideoH264SliceType                                           slice_type;
6107         uint8_t                                                                         seq_parameter_set_id;
6108         uint8_t                                                                         pic_parameter_set_id;
6109         uint16_t                                                                        idr_pic_id;
6110         uint8_t                                                                         num_ref_idx_l0_active_minus1;
6111         uint8_t                                                                         num_ref_idx_l1_active_minus1;
6112         StdVideoH264CabacInitIdc                                        cabac_init_idc;
6113         StdVideoH264DisableDeblockingFilterIdc          disable_deblocking_filter_idc;
6114         int8_t                                                                          slice_alpha_c0_offset_div2;
6115         int8_t                                                                          slice_beta_offset_div2;
6116         StdVideoEncodeH264RefMemMgmtCtrlOperations*     pMemMgmtCtrlOperations;
6117 };
6118
6119 struct VkVideoEncodeH264CapabilitiesEXT
6120 {
6121         VkStructureType                                                 sType;
6122         const void*                                                             pNext;
6123         VkVideoEncodeH264CapabilitiesFlagsEXT   flags;
6124         VkVideoEncodeH264InputModeFlagsEXT              inputModeFlags;
6125         VkVideoEncodeH264OutputModeFlagsEXT             outputModeFlags;
6126         VkExtent2D                                                              minPictureSizeInMbs;
6127         VkExtent2D                                                              maxPictureSizeInMbs;
6128         VkExtent2D                                                              inputImageDataAlignment;
6129         uint8_t                                                                 maxNumL0ReferenceForP;
6130         uint8_t                                                                 maxNumL0ReferenceForB;
6131         uint8_t                                                                 maxNumL1Reference;
6132         uint8_t                                                                 qualityLevelCount;
6133         VkExtensionProperties                                   stdExtensionVersion;
6134 };
6135
6136 struct VkVideoEncodeH264SessionCreateInfoEXT
6137 {
6138         VkStructureType                                 sType;
6139         const void*                                             pNext;
6140         VkVideoEncodeH264CreateFlagsEXT flags;
6141         VkExtent2D                                              maxPictureSizeInMbs;
6142         const VkExtensionProperties*    pStdExtensionVersion;
6143 };
6144
6145 struct VkVideoEncodeH264SessionParametersAddInfoEXT
6146 {
6147         VkStructureType                                                 sType;
6148         const void*                                                             pNext;
6149         uint32_t                                                                spsStdCount;
6150         const StdVideoH264SequenceParameterSet* pSpsStd;
6151         uint32_t                                                                ppsStdCount;
6152         const StdVideoH264PictureParameterSet*  pPpsStd;
6153 };
6154
6155 struct VkVideoEncodeH264SessionParametersCreateInfoEXT
6156 {
6157         VkStructureType                                                                         sType;
6158         const void*                                                                                     pNext;
6159         uint32_t                                                                                        maxSpsStdCount;
6160         uint32_t                                                                                        maxPpsStdCount;
6161         const VkVideoEncodeH264SessionParametersAddInfoEXT*     pParametersAddInfo;
6162 };
6163
6164 struct VkVideoEncodeH264DpbSlotInfoEXT
6165 {
6166         VkStructureType                                                 sType;
6167         const void*                                                             pNext;
6168         int8_t                                                                  slotIndex;
6169         const StdVideoEncodeH264PictureInfo*    pStdPictureInfo;
6170 };
6171
6172 struct VkVideoEncodeH264NaluSliceEXT
6173 {
6174         VkStructureType                                                 sType;
6175         const void*                                                             pNext;
6176         const StdVideoEncodeH264SliceHeader*    pSliceHeaderStd;
6177         uint32_t                                                                mbCount;
6178         uint8_t                                                                 refFinalList0EntryCount;
6179         const VkVideoEncodeH264DpbSlotInfoEXT*  pRefFinalList0Entries;
6180         uint8_t                                                                 refFinalList1EntryCount;
6181         const VkVideoEncodeH264DpbSlotInfoEXT*  pRefFinalList1Entries;
6182         uint32_t                                                                precedingNaluBytes;
6183         uint8_t                                                                 minQp;
6184         uint8_t                                                                 maxQp;
6185 };
6186
6187 struct VkVideoEncodeH264VclFrameInfoEXT
6188 {
6189         VkStructureType                                                 sType;
6190         const void*                                                             pNext;
6191         uint8_t                                                                 refDefaultFinalList0EntryCount;
6192         const VkVideoEncodeH264DpbSlotInfoEXT*  pRefDefaultFinalList0Entries;
6193         uint8_t                                                                 refDefaultFinalList1EntryCount;
6194         const VkVideoEncodeH264DpbSlotInfoEXT*  pRefDefaultFinalList1Entries;
6195         uint32_t                                                                naluSliceEntryCount;
6196         const VkVideoEncodeH264NaluSliceEXT*    pNaluSliceEntries;
6197         const VkVideoEncodeH264DpbSlotInfoEXT*  pCurrentPictureInfo;
6198 };
6199
6200 struct VkVideoEncodeH264EmitPictureParametersEXT
6201 {
6202         VkStructureType sType;
6203         const void*             pNext;
6204         uint8_t                 spsId;
6205         VkBool32                emitSpsEnable;
6206         uint32_t                ppsIdEntryCount;
6207         const uint8_t*  ppsIdEntries;
6208 };
6209
6210 struct VkVideoEncodeH264ProfileEXT
6211 {
6212         VkStructureType                 sType;
6213         const void*                             pNext;
6214         StdVideoH264ProfileIdc  stdProfileIdc;
6215 };
6216
6217 struct StdVideoDecodeH264PictureInfoFlags
6218 {
6219         uint32_t        field_pic_flag:1;
6220         uint32_t        is_intra:1;
6221         uint32_t        bottom_field_flag:1;
6222         uint32_t        is_reference:1;
6223         uint32_t        complementary_field_pair:1;
6224 };
6225
6226 struct StdVideoDecodeH264PictureInfo
6227 {
6228         uint8_t                                                         seq_parameter_set_id;
6229         uint8_t                                                         pic_parameter_set_id;
6230         uint16_t                                                        reserved;
6231         uint16_t                                                        frame_num;
6232         uint16_t                                                        idr_pic_id;
6233         int32_t                                                         PicOrderCnt[2];
6234         StdVideoDecodeH264PictureInfoFlags      flags;
6235 };
6236
6237 struct StdVideoDecodeH264ReferenceInfoFlags
6238 {
6239         uint32_t        top_field_flag:1;
6240         uint32_t        bottom_field_flag:1;
6241         uint32_t        is_long_term:1;
6242         uint32_t        is_non_existing:1;
6243 };
6244
6245 struct StdVideoDecodeH264ReferenceInfo
6246 {
6247         uint16_t                                                                FrameNum;
6248         uint16_t                                                                reserved;
6249         int32_t                                                                 PicOrderCnt[2];
6250         StdVideoDecodeH264ReferenceInfoFlags    flags;
6251 };
6252
6253 struct StdVideoDecodeH264MvcElementFlags
6254 {
6255         uint32_t        non_idr:1;
6256         uint32_t        anchor_pic:1;
6257         uint32_t        inter_view:1;
6258 };
6259
6260 struct StdVideoDecodeH264MvcElement
6261 {
6262         StdVideoDecodeH264MvcElementFlags       flags;
6263         uint16_t                                                        viewOrderIndex;
6264         uint16_t                                                        viewId;
6265         uint16_t                                                        temporalId;
6266         uint16_t                                                        priorityId;
6267         uint16_t                                                        numOfAnchorRefsInL0;
6268         uint16_t                                                        viewIdOfAnchorRefsInL0[15];
6269         uint16_t                                                        numOfAnchorRefsInL1;
6270         uint16_t                                                        viewIdOfAnchorRefsInL1[15];
6271         uint16_t                                                        numOfNonAnchorRefsInL0;
6272         uint16_t                                                        viewIdOfNonAnchorRefsInL0[15];
6273         uint16_t                                                        numOfNonAnchorRefsInL1;
6274         uint16_t                                                        viewIdOfNonAnchorRefsInL1[15];
6275 };
6276
6277 struct StdVideoDecodeH264Mvc
6278 {
6279         uint32_t                                                viewId0;
6280         uint32_t                                                mvcElementCount;
6281         StdVideoDecodeH264MvcElement*   pMvcElements;
6282 };
6283
6284 struct VkVideoDecodeH264ProfileEXT
6285 {
6286         VkStructureType                                                 sType;
6287         const void*                                                             pNext;
6288         StdVideoH264ProfileIdc                                  stdProfileIdc;
6289         VkVideoDecodeH264FieldLayoutFlagsEXT    fieldLayout;
6290 };
6291
6292 struct VkVideoDecodeH264CapabilitiesEXT
6293 {
6294         VkStructureType                 sType;
6295         void*                                   pNext;
6296         uint32_t                                maxLevel;
6297         VkOffset2D                              fieldOffsetGranularity;
6298         VkExtensionProperties   stdExtensionVersion;
6299 };
6300
6301 struct VkVideoDecodeH264SessionCreateInfoEXT
6302 {
6303         VkStructureType                                 sType;
6304         const void*                                             pNext;
6305         VkVideoDecodeH264CreateFlagsEXT flags;
6306         const VkExtensionProperties*    pStdExtensionVersion;
6307 };
6308
6309 struct VkVideoDecodeH264SessionParametersAddInfoEXT
6310 {
6311         VkStructureType                                                 sType;
6312         const void*                                                             pNext;
6313         uint32_t                                                                spsStdCount;
6314         const StdVideoH264SequenceParameterSet* pSpsStd;
6315         uint32_t                                                                ppsStdCount;
6316         const StdVideoH264PictureParameterSet*  pPpsStd;
6317 };
6318
6319 struct VkVideoDecodeH264SessionParametersCreateInfoEXT
6320 {
6321         VkStructureType                                                                         sType;
6322         const void*                                                                                     pNext;
6323         uint32_t                                                                                        maxSpsStdCount;
6324         uint32_t                                                                                        maxPpsStdCount;
6325         const VkVideoDecodeH264SessionParametersAddInfoEXT*     pParametersAddInfo;
6326 };
6327
6328 struct VkVideoDecodeH264PictureInfoEXT
6329 {
6330         VkStructureType                                                 sType;
6331         const void*                                                             pNext;
6332         const StdVideoDecodeH264PictureInfo*    pStdPictureInfo;
6333         uint32_t                                                                slicesCount;
6334         const uint32_t*                                                 pSlicesDataOffsets;
6335 };
6336
6337 struct VkVideoDecodeH264MvcEXT
6338 {
6339         VkStructureType                                 sType;
6340         const void*                                             pNext;
6341         const StdVideoDecodeH264Mvc*    pStdMvc;
6342 };
6343
6344 struct VkVideoDecodeH264DpbSlotInfoEXT
6345 {
6346         VkStructureType                                                 sType;
6347         const void*                                                             pNext;
6348         const StdVideoDecodeH264ReferenceInfo*  pStdReferenceInfo;
6349 };
6350
6351 struct StdVideoH265DecPicBufMgr
6352 {
6353         uint32_t        max_latency_increase_plus1[7];
6354         uint8_t         max_dec_pic_buffering_minus1[7];
6355         uint8_t         max_num_reorder_pics[7];
6356 };
6357
6358 struct StdVideoH265SubLayerHrdParameters
6359 {
6360         uint32_t        bit_rate_value_minus1[32];
6361         uint32_t        cpb_size_value_minus1[32];
6362         uint32_t        cpb_size_du_value_minus1[32];
6363         uint32_t        bit_rate_du_value_minus1[32];
6364         uint32_t        cbr_flag;
6365 };
6366
6367 struct StdVideoH265HrdFlags
6368 {
6369         uint32_t        nal_hrd_parameters_present_flag:1;
6370         uint32_t        vcl_hrd_parameters_present_flag:1;
6371         uint32_t        sub_pic_hrd_params_present_flag:1;
6372         uint32_t        sub_pic_cpb_params_in_pic_timing_sei_flag:1;
6373         uint8_t         fixed_pic_rate_general_flag;
6374         uint8_t         fixed_pic_rate_within_cvs_flag;
6375         uint8_t         low_delay_hrd_flag;
6376 };
6377
6378 struct StdVideoH265HrdParameters
6379 {
6380         uint8_t                                                         tick_divisor_minus2;
6381         uint8_t                                                         du_cpb_removal_delay_increment_length_minus1;
6382         uint8_t                                                         dpb_output_delay_du_length_minus1;
6383         uint8_t                                                         bit_rate_scale;
6384         uint8_t                                                         cpb_size_scale;
6385         uint8_t                                                         cpb_size_du_scale;
6386         uint8_t                                                         initial_cpb_removal_delay_length_minus1;
6387         uint8_t                                                         au_cpb_removal_delay_length_minus1;
6388         uint8_t                                                         dpb_output_delay_length_minus1;
6389         uint8_t                                                         cpb_cnt_minus1[7];
6390         uint16_t                                                        elemental_duration_in_tc_minus1[7];
6391         StdVideoH265SubLayerHrdParameters*      SubLayerHrdParametersNal[7];
6392         StdVideoH265SubLayerHrdParameters*      SubLayerHrdParametersVcl[7];
6393         StdVideoH265HrdFlags                            flags;
6394 };
6395
6396 struct StdVideoH265VpsFlags
6397 {
6398         uint32_t        vps_temporal_id_nesting_flag:1;
6399         uint32_t        vps_sub_layer_ordering_info_present_flag:1;
6400         uint32_t        vps_timing_info_present_flag:1;
6401         uint32_t        vps_poc_proportional_to_timing_flag:1;
6402 };
6403
6404 struct StdVideoH265VideoParameterSet
6405 {
6406         uint8_t                                         vps_video_parameter_set_id;
6407         uint8_t                                         vps_max_sub_layers_minus1;
6408         uint32_t                                        vps_num_units_in_tick;
6409         uint32_t                                        vps_time_scale;
6410         uint32_t                                        vps_num_ticks_poc_diff_one_minus1;
6411         StdVideoH265DecPicBufMgr*       pDecPicBufMgr;
6412         StdVideoH265HrdParameters*      hrd_parameters;
6413         StdVideoH265VpsFlags            flags;
6414 };
6415
6416 struct StdVideoH265ScalingLists
6417 {
6418         uint8_t ScalingList4x4[6][16];
6419         uint8_t ScalingList8x8[6][64];
6420         uint8_t ScalingList16x16[6][64];
6421         uint8_t ScalingList32x32[2][64];
6422         uint8_t ScalingListDCCoef16x16[6];
6423         uint8_t ScalingListDCCoef32x32[2];
6424 };
6425
6426 struct StdVideoH265SpsVuiFlags
6427 {
6428         uint32_t        aspect_ratio_info_present_flag:1;
6429         uint32_t        overscan_info_present_flag:1;
6430         uint32_t        overscan_appropriate_flag:1;
6431         uint32_t        video_signal_type_present_flag:1;
6432         uint32_t        video_full_range_flag:1;
6433         uint32_t        colour_description_present_flag:1;
6434         uint32_t        chroma_loc_info_present_flag:1;
6435         uint32_t        neutral_chroma_indication_flag:1;
6436         uint32_t        field_seq_flag:1;
6437         uint32_t        frame_field_info_present_flag:1;
6438         uint32_t        default_display_window_flag:1;
6439         uint32_t        vui_timing_info_present_flag:1;
6440         uint32_t        vui_poc_proportional_to_timing_flag:1;
6441         uint32_t        vui_hrd_parameters_present_flag:1;
6442         uint32_t        bitstream_restriction_flag:1;
6443         uint32_t        tiles_fixed_structure_flag:1;
6444         uint32_t        motion_vectors_over_pic_boundaries_flag:1;
6445         uint32_t        restricted_ref_pic_lists_flag:1;
6446 };
6447
6448 struct StdVideoH265SequenceParameterSetVui
6449 {
6450         uint8_t                                         aspect_ratio_idc;
6451         uint16_t                                        sar_width;
6452         uint16_t                                        sar_height;
6453         uint8_t                                         video_format;
6454         uint8_t                                         colour_primaries;
6455         uint8_t                                         transfer_characteristics;
6456         uint8_t                                         matrix_coeffs;
6457         uint8_t                                         chroma_sample_loc_type_top_field;
6458         uint8_t                                         chroma_sample_loc_type_bottom_field;
6459         uint16_t                                        def_disp_win_left_offset;
6460         uint16_t                                        def_disp_win_right_offset;
6461         uint16_t                                        def_disp_win_top_offset;
6462         uint16_t                                        def_disp_win_bottom_offset;
6463         uint32_t                                        vui_num_units_in_tick;
6464         uint32_t                                        vui_time_scale;
6465         uint32_t                                        vui_num_ticks_poc_diff_one_minus1;
6466         StdVideoH265HrdParameters*      hrd_parameters;
6467         uint16_t                                        min_spatial_segmentation_idc;
6468         uint8_t                                         max_bytes_per_pic_denom;
6469         uint8_t                                         max_bits_per_min_cu_denom;
6470         uint8_t                                         log2_max_mv_length_horizontal;
6471         uint8_t                                         log2_max_mv_length_vertical;
6472         StdVideoH265SpsVuiFlags         flags;
6473 };
6474
6475 struct StdVideoH265PredictorPaletteEntries
6476 {
6477         uint16_t        PredictorPaletteEntries[3][128];
6478 };
6479
6480 struct StdVideoH265SpsFlags
6481 {
6482         uint32_t        sps_temporal_id_nesting_flag:1;
6483         uint32_t        separate_colour_plane_flag:1;
6484         uint32_t        scaling_list_enabled_flag:1;
6485         uint32_t        sps_scaling_list_data_present_flag:1;
6486         uint32_t        amp_enabled_flag:1;
6487         uint32_t        sample_adaptive_offset_enabled_flag:1;
6488         uint32_t        pcm_enabled_flag:1;
6489         uint32_t        pcm_loop_filter_disabled_flag:1;
6490         uint32_t        long_term_ref_pics_present_flag:1;
6491         uint32_t        sps_temporal_mvp_enabled_flag:1;
6492         uint32_t        strong_intra_smoothing_enabled_flag:1;
6493         uint32_t        vui_parameters_present_flag:1;
6494         uint32_t        sps_extension_present_flag:1;
6495         uint32_t        sps_range_extension_flag:1;
6496         uint32_t        transform_skip_rotation_enabled_flag:1;
6497         uint32_t        transform_skip_context_enabled_flag:1;
6498         uint32_t        implicit_rdpcm_enabled_flag:1;
6499         uint32_t        explicit_rdpcm_enabled_flag:1;
6500         uint32_t        extended_precision_processing_flag:1;
6501         uint32_t        intra_smoothing_disabled_flag:1;
6502         uint32_t        high_precision_offsets_enabled_flag:1;
6503         uint32_t        persistent_rice_adaptation_enabled_flag:1;
6504         uint32_t        cabac_bypass_alignment_enabled_flag:1;
6505         uint32_t        sps_curr_pic_ref_enabled_flag:1;
6506         uint32_t        palette_mode_enabled_flag:1;
6507         uint32_t        sps_palette_predictor_initializer_present_flag:1;
6508         uint32_t        intra_boundary_filtering_disabled_flag:1;
6509 };
6510
6511 struct StdVideoH265SequenceParameterSet
6512 {
6513         StdVideoH265ProfileIdc                                  profile_idc;
6514         StdVideoH265Level                                               level_idc;
6515         uint32_t                                                                pic_width_in_luma_samples;
6516         uint32_t                                                                pic_height_in_luma_samples;
6517         uint8_t                                                                 sps_video_parameter_set_id;
6518         uint8_t                                                                 sps_max_sub_layers_minus1;
6519         uint8_t                                                                 sps_seq_parameter_set_id;
6520         uint8_t                                                                 chroma_format_idc;
6521         uint8_t                                                                 bit_depth_luma_minus8;
6522         uint8_t                                                                 bit_depth_chroma_minus8;
6523         uint8_t                                                                 log2_max_pic_order_cnt_lsb_minus4;
6524         uint8_t                                                                 sps_max_dec_pic_buffering_minus1;
6525         uint8_t                                                                 log2_min_luma_coding_block_size_minus3;
6526         uint8_t                                                                 log2_diff_max_min_luma_coding_block_size;
6527         uint8_t                                                                 log2_min_luma_transform_block_size_minus2;
6528         uint8_t                                                                 log2_diff_max_min_luma_transform_block_size;
6529         uint8_t                                                                 max_transform_hierarchy_depth_inter;
6530         uint8_t                                                                 max_transform_hierarchy_depth_intra;
6531         uint8_t                                                                 num_short_term_ref_pic_sets;
6532         uint8_t                                                                 num_long_term_ref_pics_sps;
6533         uint8_t                                                                 pcm_sample_bit_depth_luma_minus1;
6534         uint8_t                                                                 pcm_sample_bit_depth_chroma_minus1;
6535         uint8_t                                                                 log2_min_pcm_luma_coding_block_size_minus3;
6536         uint8_t                                                                 log2_diff_max_min_pcm_luma_coding_block_size;
6537         uint32_t                                                                conf_win_left_offset;
6538         uint32_t                                                                conf_win_right_offset;
6539         uint32_t                                                                conf_win_top_offset;
6540         uint32_t                                                                conf_win_bottom_offset;
6541         StdVideoH265DecPicBufMgr*                               pDecPicBufMgr;
6542         StdVideoH265SpsFlags                                    flags;
6543         StdVideoH265ScalingLists*                               pScalingLists;
6544         StdVideoH265SequenceParameterSetVui*    pSequenceParameterSetVui;
6545         uint8_t                                                                 palette_max_size;
6546         uint8_t                                                                 delta_palette_max_predictor_size;
6547         uint8_t                                                                 motion_vector_resolution_control_idc;
6548         uint8_t                                                                 sps_num_palette_predictor_initializer_minus1;
6549         StdVideoH265PredictorPaletteEntries*    pPredictorPaletteEntries;
6550 };
6551
6552 struct StdVideoH265PpsFlags
6553 {
6554         uint32_t        dependent_slice_segments_enabled_flag:1;
6555         uint32_t        output_flag_present_flag:1;
6556         uint32_t        sign_data_hiding_enabled_flag:1;
6557         uint32_t        cabac_init_present_flag:1;
6558         uint32_t        constrained_intra_pred_flag:1;
6559         uint32_t        transform_skip_enabled_flag:1;
6560         uint32_t        cu_qp_delta_enabled_flag:1;
6561         uint32_t        pps_slice_chroma_qp_offsets_present_flag:1;
6562         uint32_t        weighted_pred_flag:1;
6563         uint32_t        weighted_bipred_flag:1;
6564         uint32_t        transquant_bypass_enabled_flag:1;
6565         uint32_t        tiles_enabled_flag:1;
6566         uint32_t        entropy_coding_sync_enabled_flag:1;
6567         uint32_t        uniform_spacing_flag:1;
6568         uint32_t        loop_filter_across_tiles_enabled_flag:1;
6569         uint32_t        pps_loop_filter_across_slices_enabled_flag:1;
6570         uint32_t        deblocking_filter_control_present_flag:1;
6571         uint32_t        deblocking_filter_override_enabled_flag:1;
6572         uint32_t        pps_deblocking_filter_disabled_flag:1;
6573         uint32_t        pps_scaling_list_data_present_flag:1;
6574         uint32_t        lists_modification_present_flag:1;
6575         uint32_t        slice_segment_header_extension_present_flag:1;
6576         uint32_t        pps_extension_present_flag:1;
6577         uint32_t        cross_component_prediction_enabled_flag:1;
6578         uint32_t        chroma_qp_offset_list_enabled_flag:1;
6579         uint32_t        pps_curr_pic_ref_enabled_flag:1;
6580         uint32_t        residual_adaptive_colour_transform_enabled_flag:1;
6581         uint32_t        pps_slice_act_qp_offsets_present_flag:1;
6582         uint32_t        pps_palette_predictor_initializer_present_flag:1;
6583         uint32_t        monochrome_palette_flag:1;
6584         uint32_t        pps_range_extension_flag:1;
6585 };
6586
6587 struct StdVideoH265PictureParameterSet
6588 {
6589         uint8_t                                                                 pps_pic_parameter_set_id;
6590         uint8_t                                                                 pps_seq_parameter_set_id;
6591         uint8_t                                                                 num_extra_slice_header_bits;
6592         uint8_t                                                                 num_ref_idx_l0_default_active_minus1;
6593         uint8_t                                                                 num_ref_idx_l1_default_active_minus1;
6594         int8_t                                                                  init_qp_minus26;
6595         uint8_t                                                                 diff_cu_qp_delta_depth;
6596         int8_t                                                                  pps_cb_qp_offset;
6597         int8_t                                                                  pps_cr_qp_offset;
6598         uint8_t                                                                 num_tile_columns_minus1;
6599         uint8_t                                                                 num_tile_rows_minus1;
6600         uint16_t                                                                column_width_minus1[19];
6601         uint16_t                                                                row_height_minus1[21];
6602         int8_t                                                                  pps_beta_offset_div2;
6603         int8_t                                                                  pps_tc_offset_div2;
6604         uint8_t                                                                 log2_parallel_merge_level_minus2;
6605         StdVideoH265PpsFlags                                    flags;
6606         StdVideoH265ScalingLists*                               pScalingLists;
6607         uint8_t                                                                 log2_max_transform_skip_block_size_minus2;
6608         uint8_t                                                                 diff_cu_chroma_qp_offset_depth;
6609         uint8_t                                                                 chroma_qp_offset_list_len_minus1;
6610         int8_t                                                                  cb_qp_offset_list[6];
6611         int8_t                                                                  cr_qp_offset_list[6];
6612         uint8_t                                                                 log2_sao_offset_scale_luma;
6613         uint8_t                                                                 log2_sao_offset_scale_chroma;
6614         int8_t                                                                  pps_act_y_qp_offset_plus5;
6615         int8_t                                                                  pps_act_cb_qp_offset_plus5;
6616         int8_t                                                                  pps_act_cr_qp_offset_plus5;
6617         uint8_t                                                                 pps_num_palette_predictor_initializer;
6618         uint8_t                                                                 luma_bit_depth_entry_minus8;
6619         uint8_t                                                                 chroma_bit_depth_entry_minus8;
6620         StdVideoH265PredictorPaletteEntries*    pPredictorPaletteEntries;
6621 };
6622
6623 struct StdVideoDecodeH265PictureInfoFlags
6624 {
6625         uint32_t        IrapPicFlag:1;
6626         uint32_t        IdrPicFlag:1;
6627         uint32_t        IsReference:1;
6628         uint32_t        short_term_ref_pic_set_sps_flag:1;
6629 };
6630
6631 struct StdVideoDecodeH265PictureInfo
6632 {
6633         uint8_t                                                         vps_video_parameter_set_id;
6634         uint8_t                                                         sps_seq_parameter_set_id;
6635         uint8_t                                                         pps_pic_parameter_set_id;
6636         uint8_t                                                         num_short_term_ref_pic_sets;
6637         int32_t                                                         PicOrderCntVal;
6638         uint16_t                                                        NumBitsForSTRefPicSetInSlice;
6639         uint8_t                                                         NumDeltaPocsOfRefRpsIdx;
6640         uint8_t                                                         RefPicSetStCurrBefore[8];
6641         uint8_t                                                         RefPicSetStCurrAfter[8];
6642         uint8_t                                                         RefPicSetLtCurr[8];
6643         StdVideoDecodeH265PictureInfoFlags      flags;
6644 };
6645
6646 struct StdVideoDecodeH265ReferenceInfoFlags
6647 {
6648         uint32_t        is_long_term:1;
6649         uint32_t        is_non_existing:1;
6650 };
6651
6652 struct StdVideoDecodeH265ReferenceInfo
6653 {
6654         int32_t                                                                 PicOrderCntVal;
6655         StdVideoDecodeH265ReferenceInfoFlags    flags;
6656 };
6657
6658 struct VkVideoDecodeH265ProfileEXT
6659 {
6660         VkStructureType                 sType;
6661         const void*                             pNext;
6662         StdVideoH265ProfileIdc  stdProfileIdc;
6663 };
6664
6665 struct VkVideoDecodeH265CapabilitiesEXT
6666 {
6667         VkStructureType                 sType;
6668         void*                                   pNext;
6669         uint32_t                                maxLevel;
6670         VkExtensionProperties   stdExtensionVersion;
6671 };
6672
6673 struct VkVideoDecodeH265SessionCreateInfoEXT
6674 {
6675         VkStructureType                                 sType;
6676         const void*                                             pNext;
6677         VkVideoDecodeH265CreateFlagsEXT flags;
6678         const VkExtensionProperties*    pStdExtensionVersion;
6679 };
6680
6681 struct VkVideoDecodeH265SessionParametersAddInfoEXT
6682 {
6683         VkStructureType                                                 sType;
6684         const void*                                                             pNext;
6685         uint32_t                                                                spsStdCount;
6686         const StdVideoH265SequenceParameterSet* pSpsStd;
6687         uint32_t                                                                ppsStdCount;
6688         const StdVideoH265PictureParameterSet*  pPpsStd;
6689 };
6690
6691 struct VkVideoDecodeH265SessionParametersCreateInfoEXT
6692 {
6693         VkStructureType                                                                         sType;
6694         const void*                                                                                     pNext;
6695         uint32_t                                                                                        maxSpsStdCount;
6696         uint32_t                                                                                        maxPpsStdCount;
6697         const VkVideoDecodeH265SessionParametersAddInfoEXT*     pParametersAddInfo;
6698 };
6699
6700 struct VkVideoDecodeH265PictureInfoEXT
6701 {
6702         VkStructureType                                 sType;
6703         const void*                                             pNext;
6704         StdVideoDecodeH265PictureInfo*  pStdPictureInfo;
6705         uint32_t                                                slicesCount;
6706         const uint32_t*                                 pSlicesDataOffsets;
6707 };
6708
6709 struct VkVideoDecodeH265DpbSlotInfoEXT
6710 {
6711         VkStructureType                                                 sType;
6712         const void*                                                             pNext;
6713         const StdVideoDecodeH265ReferenceInfo*  pStdReferenceInfo;
6714 };
6715
6716 struct VkImagePipeSurfaceCreateInfoFUCHSIA
6717 {
6718         VkStructureType                                                 sType;
6719         const void*                                                             pNext;
6720         VkImagePipeSurfaceCreateFlagsFUCHSIA    flags;
6721         pt::zx_handle_t                                                 imagePipeHandle;
6722 };
6723
6724 struct VkImportMemoryZirconHandleInfoFUCHSIA
6725 {
6726         VkStructureType                                         sType;
6727         const void*                                                     pNext;
6728         VkExternalMemoryHandleTypeFlagBits      handleType;
6729         pt::zx_handle_t                                         handle;
6730 };
6731
6732 struct VkMemoryZirconHandlePropertiesFUCHSIA
6733 {
6734         VkStructureType sType;
6735         void*                   pNext;
6736         uint32_t                memoryTypeBits;
6737 };
6738
6739 struct VkMemoryGetZirconHandleInfoFUCHSIA
6740 {
6741         VkStructureType                                         sType;
6742         const void*                                                     pNext;
6743         VkDeviceMemory                                          memory;
6744         VkExternalMemoryHandleTypeFlagBits      handleType;
6745 };
6746
6747 struct VkImportSemaphoreZirconHandleInfoFUCHSIA
6748 {
6749         VkStructureType                                                 sType;
6750         const void*                                                             pNext;
6751         VkSemaphore                                                             semaphore;
6752         VkSemaphoreImportFlags                                  flags;
6753         VkExternalSemaphoreHandleTypeFlagBits   handleType;
6754         pt::zx_handle_t                                                 zirconHandle;
6755 };
6756
6757 struct VkSemaphoreGetZirconHandleInfoFUCHSIA
6758 {
6759         VkStructureType                                                 sType;
6760         const void*                                                             pNext;
6761         VkSemaphore                                                             semaphore;
6762         VkExternalSemaphoreHandleTypeFlagBits   handleType;
6763 };
6764
6765 struct VkStreamDescriptorSurfaceCreateInfoGGP
6766 {
6767         VkStructureType                                                 sType;
6768         const void*                                                             pNext;
6769         VkStreamDescriptorSurfaceCreateFlagsGGP flags;
6770         pt::GgpStreamDescriptor                                 streamDescriptor;
6771 };
6772
6773 struct VkPresentFrameTokenGGP
6774 {
6775         VkStructureType         sType;
6776         const void*                     pNext;
6777         pt::GgpFrameToken       frameToken;
6778 };
6779
6780 struct VkIOSSurfaceCreateInfoMVK
6781 {
6782         VkStructureType                         sType;
6783         const void*                                     pNext;
6784         VkIOSSurfaceCreateFlagsMVK      flags;
6785         const void*                                     pView;
6786 };
6787
6788 struct VkMacOSSurfaceCreateInfoMVK
6789 {
6790         VkStructureType                                 sType;
6791         const void*                                             pNext;
6792         VkMacOSSurfaceCreateFlagsMVK    flags;
6793         const void*                                             pView;
6794 };
6795
6796 struct VkMetalSurfaceCreateInfoEXT
6797 {
6798         VkStructureType                                 sType;
6799         const void*                                             pNext;
6800         VkMetalSurfaceCreateFlagsEXT    flags;
6801         const pt::CAMetalLayer*                 pLayer;
6802 };
6803
6804 struct VkViSurfaceCreateInfoNN
6805 {
6806         VkStructureType                         sType;
6807         const void*                                     pNext;
6808         VkViSurfaceCreateFlagsNN        flags;
6809         void*                                           window;
6810 };
6811
6812 struct VkWaylandSurfaceCreateInfoKHR
6813 {
6814         VkStructureType                                 sType;
6815         const void*                                             pNext;
6816         VkWaylandSurfaceCreateFlagsKHR  flags;
6817         pt::WaylandDisplayPtr                   display;
6818         pt::WaylandSurfacePtr                   surface;
6819 };
6820
6821 struct VkWin32SurfaceCreateInfoKHR
6822 {
6823         VkStructureType                                 sType;
6824         const void*                                             pNext;
6825         VkWin32SurfaceCreateFlagsKHR    flags;
6826         pt::Win32InstanceHandle                 hinstance;
6827         pt::Win32WindowHandle                   hwnd;
6828 };
6829
6830 struct VkImportMemoryWin32HandleInfoKHR
6831 {
6832         VkStructureType                                         sType;
6833         const void*                                                     pNext;
6834         VkExternalMemoryHandleTypeFlagBits      handleType;
6835         pt::Win32Handle                                         handle;
6836         pt::Win32LPCWSTR                                        name;
6837 };
6838
6839 struct VkExportMemoryWin32HandleInfoKHR
6840 {
6841         VkStructureType                                 sType;
6842         const void*                                             pNext;
6843         pt::Win32SecurityAttributesPtr  pAttributes;
6844         uint32_t                                                dwAccess;
6845         pt::Win32LPCWSTR                                name;
6846 };
6847
6848 struct VkMemoryWin32HandlePropertiesKHR
6849 {
6850         VkStructureType sType;
6851         void*                   pNext;
6852         uint32_t                memoryTypeBits;
6853 };
6854
6855 struct VkMemoryGetWin32HandleInfoKHR
6856 {
6857         VkStructureType                                         sType;
6858         const void*                                                     pNext;
6859         VkDeviceMemory                                          memory;
6860         VkExternalMemoryHandleTypeFlagBits      handleType;
6861 };
6862
6863 struct VkWin32KeyedMutexAcquireReleaseInfoKHR
6864 {
6865         VkStructureType                 sType;
6866         const void*                             pNext;
6867         uint32_t                                acquireCount;
6868         const VkDeviceMemory*   pAcquireSyncs;
6869         const uint64_t*                 pAcquireKeys;
6870         const uint32_t*                 pAcquireTimeouts;
6871         uint32_t                                releaseCount;
6872         const VkDeviceMemory*   pReleaseSyncs;
6873         const uint64_t*                 pReleaseKeys;
6874 };
6875
6876 struct VkImportSemaphoreWin32HandleInfoKHR
6877 {
6878         VkStructureType                                                 sType;
6879         const void*                                                             pNext;
6880         VkSemaphore                                                             semaphore;
6881         VkSemaphoreImportFlags                                  flags;
6882         VkExternalSemaphoreHandleTypeFlagBits   handleType;
6883         pt::Win32Handle                                                 handle;
6884         pt::Win32LPCWSTR                                                name;
6885 };
6886
6887 struct VkExportSemaphoreWin32HandleInfoKHR
6888 {
6889         VkStructureType                                 sType;
6890         const void*                                             pNext;
6891         pt::Win32SecurityAttributesPtr  pAttributes;
6892         uint32_t                                                dwAccess;
6893         pt::Win32LPCWSTR                                name;
6894 };
6895
6896 struct VkD3D12FenceSubmitInfoKHR
6897 {
6898         VkStructureType sType;
6899         const void*             pNext;
6900         uint32_t                waitSemaphoreValuesCount;
6901         const uint64_t* pWaitSemaphoreValues;
6902         uint32_t                signalSemaphoreValuesCount;
6903         const uint64_t* pSignalSemaphoreValues;
6904 };
6905
6906 struct VkSemaphoreGetWin32HandleInfoKHR
6907 {
6908         VkStructureType                                                 sType;
6909         const void*                                                             pNext;
6910         VkSemaphore                                                             semaphore;
6911         VkExternalSemaphoreHandleTypeFlagBits   handleType;
6912 };
6913
6914 struct VkImportFenceWin32HandleInfoKHR
6915 {
6916         VkStructureType                                         sType;
6917         const void*                                                     pNext;
6918         VkFence                                                         fence;
6919         VkFenceImportFlags                                      flags;
6920         VkExternalFenceHandleTypeFlagBits       handleType;
6921         pt::Win32Handle                                         handle;
6922         pt::Win32LPCWSTR                                        name;
6923 };
6924
6925 struct VkExportFenceWin32HandleInfoKHR
6926 {
6927         VkStructureType                                 sType;
6928         const void*                                             pNext;
6929         pt::Win32SecurityAttributesPtr  pAttributes;
6930         uint32_t                                                dwAccess;
6931         pt::Win32LPCWSTR                                name;
6932 };
6933
6934 struct VkFenceGetWin32HandleInfoKHR
6935 {
6936         VkStructureType                                         sType;
6937         const void*                                                     pNext;
6938         VkFence                                                         fence;
6939         VkExternalFenceHandleTypeFlagBits       handleType;
6940 };
6941
6942 struct VkImportMemoryWin32HandleInfoNV
6943 {
6944         VkStructureType                                         sType;
6945         const void*                                                     pNext;
6946         VkExternalMemoryHandleTypeFlagsNV       handleType;
6947         pt::Win32Handle                                         handle;
6948 };
6949
6950 struct VkExportMemoryWin32HandleInfoNV
6951 {
6952         VkStructureType                                 sType;
6953         const void*                                             pNext;
6954         pt::Win32SecurityAttributesPtr  pAttributes;
6955         uint32_t                                                dwAccess;
6956 };
6957
6958 struct VkWin32KeyedMutexAcquireReleaseInfoNV
6959 {
6960         VkStructureType                 sType;
6961         const void*                             pNext;
6962         uint32_t                                acquireCount;
6963         const VkDeviceMemory*   pAcquireSyncs;
6964         const uint64_t*                 pAcquireKeys;
6965         const uint32_t*                 pAcquireTimeoutMilliseconds;
6966         uint32_t                                releaseCount;
6967         const VkDeviceMemory*   pReleaseSyncs;
6968         const uint64_t*                 pReleaseKeys;
6969 };
6970
6971 struct VkSurfaceFullScreenExclusiveInfoEXT
6972 {
6973         VkStructureType                         sType;
6974         void*                                           pNext;
6975         VkFullScreenExclusiveEXT        fullScreenExclusive;
6976 };
6977
6978 struct VkSurfaceCapabilitiesFullScreenExclusiveEXT
6979 {
6980         VkStructureType sType;
6981         void*                   pNext;
6982         VkBool32                fullScreenExclusiveSupported;
6983 };
6984
6985 struct VkSurfaceFullScreenExclusiveWin32InfoEXT
6986 {
6987         VkStructureType                 sType;
6988         const void*                             pNext;
6989         pt::Win32MonitorHandle  hmonitor;
6990 };
6991
6992 struct VkXcbSurfaceCreateInfoKHR
6993 {
6994         VkStructureType                         sType;
6995         const void*                                     pNext;
6996         VkXcbSurfaceCreateFlagsKHR      flags;
6997         pt::XcbConnectionPtr            connection;
6998         pt::XcbWindow                           window;
6999 };
7000
7001 struct VkXlibSurfaceCreateInfoKHR
7002 {
7003         VkStructureType                         sType;
7004         const void*                                     pNext;
7005         VkXlibSurfaceCreateFlagsKHR     flags;
7006         pt::XlibDisplayPtr                      dpy;
7007         pt::XlibWindow                          window;
7008 };
7009
7010 typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
7011
7012 typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
7013
7014 typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
7015
7016 typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
7017
7018 typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
7019
7020 typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
7021
7022 typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
7023
7024 typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
7025
7026 typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
7027
7028 typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
7029
7030 typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
7031
7032 typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
7033
7034 typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
7035
7036 typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
7037
7038 typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
7039
7040 typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
7041
7042 typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
7043
7044 typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
7045
7046 typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
7047
7048 typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
7049
7050 typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
7051
7052 typedef VkFormatProperties2 VkFormatProperties2KHR;
7053
7054 typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
7055
7056 typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
7057
7058 typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
7059
7060 typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
7061
7062 typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
7063
7064 typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
7065
7066 typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
7067
7068 typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
7069
7070 typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
7071
7072 typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
7073
7074 typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
7075
7076 typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
7077
7078 typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
7079
7080 typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
7081
7082 typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
7083
7084 typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
7085
7086 typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
7087
7088 typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
7089
7090 typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
7091
7092 typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
7093
7094 typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
7095
7096 typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
7097
7098 typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
7099
7100 typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
7101
7102 typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
7103
7104 typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
7105
7106 typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
7107
7108 typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
7109
7110 typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
7111
7112 typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
7113
7114 typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
7115
7116 typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
7117
7118 typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
7119
7120 typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
7121
7122 typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
7123
7124 typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
7125
7126 typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
7127
7128 typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
7129
7130 typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
7131
7132 typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures;
7133
7134 typedef VkConformanceVersion VkConformanceVersionKHR;
7135
7136 typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR;
7137
7138 typedef VkAttachmentDescription2 VkAttachmentDescription2KHR;
7139
7140 typedef VkAttachmentReference2 VkAttachmentReference2KHR;
7141
7142 typedef VkSubpassDescription2 VkSubpassDescription2KHR;
7143
7144 typedef VkSubpassDependency2 VkSubpassDependency2KHR;
7145
7146 typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR;
7147
7148 typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR;
7149
7150 typedef VkSubpassEndInfo VkSubpassEndInfoKHR;
7151
7152 typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR;
7153
7154 typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR;
7155
7156 typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR;
7157
7158 typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR;
7159
7160 typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT;
7161
7162 typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT;
7163
7164 typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT;
7165
7166 typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT;
7167
7168 typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT;
7169
7170 typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR;
7171
7172 typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR;
7173
7174 typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT;
7175
7176 typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT;
7177
7178 typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT;
7179
7180 typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT;
7181
7182 typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR;
7183
7184 typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR;
7185
7186 typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR;
7187
7188 typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR;
7189
7190 typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR;
7191
7192 typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR;
7193
7194 typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
7195
7196 typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
7197
7198 typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR;
7199
7200 typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR;
7201
7202 typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT;
7203
7204 typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR;
7205
7206 typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR;
7207
7208 typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR;
7209
7210 typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR;
7211
7212 typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR;
7213
7214 typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR;
7215
7216 typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR;
7217
7218 typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR;
7219
7220 typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR;
7221
7222 typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR;
7223
7224 typedef VkTransformMatrixKHR VkTransformMatrixNV;
7225
7226 typedef VkAabbPositionsKHR VkAabbPositionsNV;
7227
7228 typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV;
7229
7230 typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL;
7231
7232 typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT;
7233