external/vulkancts/framework/vulkan/vkStructTypes.inl

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