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