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