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