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 VkApplicationInfo
   5 {
   6         VkStructureType sType;
   7         const void*             pNext;
   8         const char*             pApplicationName;
   9         deUint32                applicationVersion;
  10         const char*             pEngineName;
  11         deUint32                engineVersion;
  12         deUint32                apiVersion;
  13 };
  14
  15 struct VkInstanceCreateInfo
  16 {
  17         VkStructureType                         sType;
  18         const void*                                     pNext;
  19         VkInstanceCreateFlags           flags;
  20         const VkApplicationInfo*        pApplicationInfo;
  21         deUint32                                        enabledLayerCount;
  22         const char* const*                      ppEnabledLayerNames;
  23         deUint32                                        enabledExtensionCount;
  24         const char* const*                      ppEnabledExtensionNames;
  25 };
  26
  27 struct VkAllocationCallbacks
  28 {
  29         void*                                                                   pUserData;
  30         PFN_vkAllocationFunction                                pfnAllocation;
  31         PFN_vkReallocationFunction                              pfnReallocation;
  32         PFN_vkFreeFunction                                              pfnFree;
  33         PFN_vkInternalAllocationNotification    pfnInternalAllocation;
  34         PFN_vkInternalFreeNotification                  pfnInternalFree;
  35 };
  36
  37 struct VkPhysicalDeviceFeatures
  38 {
  39         VkBool32        robustBufferAccess;
  40         VkBool32        fullDrawIndexUint32;
  41         VkBool32        imageCubeArray;
  42         VkBool32        independentBlend;
  43         VkBool32        geometryShader;
  44         VkBool32        tessellationShader;
  45         VkBool32        sampleRateShading;
  46         VkBool32        dualSrcBlend;
  47         VkBool32        logicOp;
  48         VkBool32        multiDrawIndirect;
  49         VkBool32        drawIndirectFirstInstance;
  50         VkBool32        depthClamp;
  51         VkBool32        depthBiasClamp;
  52         VkBool32        fillModeNonSolid;
  53         VkBool32        depthBounds;
  54         VkBool32        wideLines;
  55         VkBool32        largePoints;
  56         VkBool32        alphaToOne;
  57         VkBool32        multiViewport;
  58         VkBool32        samplerAnisotropy;
  59         VkBool32        textureCompressionETC2;
  60         VkBool32        textureCompressionASTC_LDR;
  61         VkBool32        textureCompressionBC;
  62         VkBool32        occlusionQueryPrecise;
  63         VkBool32        pipelineStatisticsQuery;
  64         VkBool32        vertexPipelineStoresAndAtomics;
  65         VkBool32        fragmentStoresAndAtomics;
  66         VkBool32        shaderTessellationAndGeometryPointSize;
  67         VkBool32        shaderImageGatherExtended;
  68         VkBool32        shaderStorageImageExtendedFormats;
  69         VkBool32        shaderStorageImageMultisample;
  70         VkBool32        shaderStorageImageReadWithoutFormat;
  71         VkBool32        shaderStorageImageWriteWithoutFormat;
  72         VkBool32        shaderUniformBufferArrayDynamicIndexing;
  73         VkBool32        shaderSampledImageArrayDynamicIndexing;
  74         VkBool32        shaderStorageBufferArrayDynamicIndexing;
  75         VkBool32        shaderStorageImageArrayDynamicIndexing;
  76         VkBool32        shaderClipDistance;
  77         VkBool32        shaderCullDistance;
  78         VkBool32        shaderFloat64;
  79         VkBool32        shaderInt64;
  80         VkBool32        shaderInt16;
  81         VkBool32        shaderResourceResidency;
  82         VkBool32        shaderResourceMinLod;
  83         VkBool32        sparseBinding;
  84         VkBool32        sparseResidencyBuffer;
  85         VkBool32        sparseResidencyImage2D;
  86         VkBool32        sparseResidencyImage3D;
  87         VkBool32        sparseResidency2Samples;
  88         VkBool32        sparseResidency4Samples;
  89         VkBool32        sparseResidency8Samples;
  90         VkBool32        sparseResidency16Samples;
  91         VkBool32        sparseResidencyAliased;
  92         VkBool32        variableMultisampleRate;
  93         VkBool32        inheritedQueries;
  94 };
  95
  96 struct VkFormatProperties
  97 {
  98         VkFormatFeatureFlags    linearTilingFeatures;
  99         VkFormatFeatureFlags    optimalTilingFeatures;
 100         VkFormatFeatureFlags    bufferFeatures;
 101 };
 102
 103 struct VkExtent3D
 104 {
 105         deUint32        width;
 106         deUint32        height;
 107         deUint32        depth;
 108 };
 109
 110 struct VkImageFormatProperties
 111 {
 112         VkExtent3D                      maxExtent;
 113         deUint32                        maxMipLevels;
 114         deUint32                        maxArrayLayers;
 115         VkSampleCountFlags      sampleCounts;
 116         VkDeviceSize            maxResourceSize;
 117 };
 118
 119 struct VkPhysicalDeviceLimits
 120 {
 121         deUint32                        maxImageDimension1D;
 122         deUint32                        maxImageDimension2D;
 123         deUint32                        maxImageDimension3D;
 124         deUint32                        maxImageDimensionCube;
 125         deUint32                        maxImageArrayLayers;
 126         deUint32                        maxTexelBufferElements;
 127         deUint32                        maxUniformBufferRange;
 128         deUint32                        maxStorageBufferRange;
 129         deUint32                        maxPushConstantsSize;
 130         deUint32                        maxMemoryAllocationCount;
 131         deUint32                        maxSamplerAllocationCount;
 132         VkDeviceSize            bufferImageGranularity;
 133         VkDeviceSize            sparseAddressSpaceSize;
 134         deUint32                        maxBoundDescriptorSets;
 135         deUint32                        maxPerStageDescriptorSamplers;
 136         deUint32                        maxPerStageDescriptorUniformBuffers;
 137         deUint32                        maxPerStageDescriptorStorageBuffers;
 138         deUint32                        maxPerStageDescriptorSampledImages;
 139         deUint32                        maxPerStageDescriptorStorageImages;
 140         deUint32                        maxPerStageDescriptorInputAttachments;
 141         deUint32                        maxPerStageResources;
 142         deUint32                        maxDescriptorSetSamplers;
 143         deUint32                        maxDescriptorSetUniformBuffers;
 144         deUint32                        maxDescriptorSetUniformBuffersDynamic;
 145         deUint32                        maxDescriptorSetStorageBuffers;
 146         deUint32                        maxDescriptorSetStorageBuffersDynamic;
 147         deUint32                        maxDescriptorSetSampledImages;
 148         deUint32                        maxDescriptorSetStorageImages;
 149         deUint32                        maxDescriptorSetInputAttachments;
 150         deUint32                        maxVertexInputAttributes;
 151         deUint32                        maxVertexInputBindings;
 152         deUint32                        maxVertexInputAttributeOffset;
 153         deUint32                        maxVertexInputBindingStride;
 154         deUint32                        maxVertexOutputComponents;
 155         deUint32                        maxTessellationGenerationLevel;
 156         deUint32                        maxTessellationPatchSize;
 157         deUint32                        maxTessellationControlPerVertexInputComponents;
 158         deUint32                        maxTessellationControlPerVertexOutputComponents;
 159         deUint32                        maxTessellationControlPerPatchOutputComponents;
 160         deUint32                        maxTessellationControlTotalOutputComponents;
 161         deUint32                        maxTessellationEvaluationInputComponents;
 162         deUint32                        maxTessellationEvaluationOutputComponents;
 163         deUint32                        maxGeometryShaderInvocations;
 164         deUint32                        maxGeometryInputComponents;
 165         deUint32                        maxGeometryOutputComponents;
 166         deUint32                        maxGeometryOutputVertices;
 167         deUint32                        maxGeometryTotalOutputComponents;
 168         deUint32                        maxFragmentInputComponents;
 169         deUint32                        maxFragmentOutputAttachments;
 170         deUint32                        maxFragmentDualSrcAttachments;
 171         deUint32                        maxFragmentCombinedOutputResources;
 172         deUint32                        maxComputeSharedMemorySize;
 173         deUint32                        maxComputeWorkGroupCount[3];
 174         deUint32                        maxComputeWorkGroupInvocations;
 175         deUint32                        maxComputeWorkGroupSize[3];
 176         deUint32                        subPixelPrecisionBits;
 177         deUint32                        subTexelPrecisionBits;
 178         deUint32                        mipmapPrecisionBits;
 179         deUint32                        maxDrawIndexedIndexValue;
 180         deUint32                        maxDrawIndirectCount;
 181         float                           maxSamplerLodBias;
 182         float                           maxSamplerAnisotropy;
 183         deUint32                        maxViewports;
 184         deUint32                        maxViewportDimensions[2];
 185         float                           viewportBoundsRange[2];
 186         deUint32                        viewportSubPixelBits;
 187         deUintptr                       minMemoryMapAlignment;
 188         VkDeviceSize            minTexelBufferOffsetAlignment;
 189         VkDeviceSize            minUniformBufferOffsetAlignment;
 190         VkDeviceSize            minStorageBufferOffsetAlignment;
 191         deInt32                         minTexelOffset;
 192         deUint32                        maxTexelOffset;
 193         deInt32                         minTexelGatherOffset;
 194         deUint32                        maxTexelGatherOffset;
 195         float                           minInterpolationOffset;
 196         float                           maxInterpolationOffset;
 197         deUint32                        subPixelInterpolationOffsetBits;
 198         deUint32                        maxFramebufferWidth;
 199         deUint32                        maxFramebufferHeight;
 200         deUint32                        maxFramebufferLayers;
 201         VkSampleCountFlags      framebufferColorSampleCounts;
 202         VkSampleCountFlags      framebufferDepthSampleCounts;
 203         VkSampleCountFlags      framebufferStencilSampleCounts;
 204         VkSampleCountFlags      framebufferNoAttachmentsSampleCounts;
 205         deUint32                        maxColorAttachments;
 206         VkSampleCountFlags      sampledImageColorSampleCounts;
 207         VkSampleCountFlags      sampledImageIntegerSampleCounts;
 208         VkSampleCountFlags      sampledImageDepthSampleCounts;
 209         VkSampleCountFlags      sampledImageStencilSampleCounts;
 210         VkSampleCountFlags      storageImageSampleCounts;
 211         deUint32                        maxSampleMaskWords;
 212         VkBool32                        timestampComputeAndGraphics;
 213         float                           timestampPeriod;
 214         deUint32                        maxClipDistances;
 215         deUint32                        maxCullDistances;
 216         deUint32                        maxCombinedClipAndCullDistances;
 217         deUint32                        discreteQueuePriorities;
 218         float                           pointSizeRange[2];
 219         float                           lineWidthRange[2];
 220         float                           pointSizeGranularity;
 221         float                           lineWidthGranularity;
 222         VkBool32                        strictLines;
 223         VkBool32                        standardSampleLocations;
 224         VkDeviceSize            optimalBufferCopyOffsetAlignment;
 225         VkDeviceSize            optimalBufferCopyRowPitchAlignment;
 226         VkDeviceSize            nonCoherentAtomSize;
 227 };
 228
 229 struct VkPhysicalDeviceSparseProperties
 230 {
 231         VkBool32        residencyStandard2DBlockShape;
 232         VkBool32        residencyStandard2DMultisampleBlockShape;
 233         VkBool32        residencyStandard3DBlockShape;
 234         VkBool32        residencyAlignedMipSize;
 235         VkBool32        residencyNonResidentStrict;
 236 };
 237
 238 struct VkPhysicalDeviceProperties
 239 {
 240         deUint32                                                        apiVersion;
 241         deUint32                                                        driverVersion;
 242         deUint32                                                        vendorID;
 243         deUint32                                                        deviceID;
 244         VkPhysicalDeviceType                            deviceType;
 245         char                                                            deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
 246         deUint8                                                         pipelineCacheUUID[VK_UUID_SIZE];
 247         VkPhysicalDeviceLimits                          limits;
 248         VkPhysicalDeviceSparseProperties        sparseProperties;
 249 };
 250
 251 struct VkQueueFamilyProperties
 252 {
 253         VkQueueFlags    queueFlags;
 254         deUint32                queueCount;
 255         deUint32                timestampValidBits;
 256         VkExtent3D              minImageTransferGranularity;
 257 };
 258
 259 struct VkMemoryType
 260 {
 261         VkMemoryPropertyFlags   propertyFlags;
 262         deUint32                                heapIndex;
 263 };
 264
 265 struct VkMemoryHeap
 266 {
 267         VkDeviceSize            size;
 268         VkMemoryHeapFlags       flags;
 269 };
 270
 271 struct VkPhysicalDeviceMemoryProperties
 272 {
 273         deUint32                memoryTypeCount;
 274         VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
 275         deUint32                memoryHeapCount;
 276         VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
 277 };
 278
 279 struct VkDeviceQueueCreateInfo
 280 {
 281         VkStructureType                         sType;
 282         const void*                                     pNext;
 283         VkDeviceQueueCreateFlags        flags;
 284         deUint32                                        queueFamilyIndex;
 285         deUint32                                        queueCount;
 286         const float*                            pQueuePriorities;
 287 };
 288
 289 struct VkDeviceCreateInfo
 290 {
 291         VkStructureType                                 sType;
 292         const void*                                             pNext;
 293         VkDeviceCreateFlags                             flags;
 294         deUint32                                                queueCreateInfoCount;
 295         const VkDeviceQueueCreateInfo*  pQueueCreateInfos;
 296         deUint32                                                enabledLayerCount;
 297         const char* const*                              ppEnabledLayerNames;
 298         deUint32                                                enabledExtensionCount;
 299         const char* const*                              ppEnabledExtensionNames;
 300         const VkPhysicalDeviceFeatures* pEnabledFeatures;
 301 };
 302
 303 struct VkExtensionProperties
 304 {
 305         char            extensionName[VK_MAX_EXTENSION_NAME_SIZE];
 306         deUint32        specVersion;
 307 };
 308
 309 struct VkLayerProperties
 310 {
 311         char            layerName[VK_MAX_EXTENSION_NAME_SIZE];
 312         deUint32        specVersion;
 313         deUint32        implementationVersion;
 314         char            description[VK_MAX_DESCRIPTION_SIZE];
 315 };
 316
 317 struct VkSubmitInfo
 318 {
 319         VkStructureType                         sType;
 320         const void*                                     pNext;
 321         deUint32                                        waitSemaphoreCount;
 322         const VkSemaphore*                      pWaitSemaphores;
 323         const VkPipelineStageFlags*     pWaitDstStageMask;
 324         deUint32                                        commandBufferCount;
 325         const VkCommandBuffer*          pCommandBuffers;
 326         deUint32                                        signalSemaphoreCount;
 327         const VkSemaphore*                      pSignalSemaphores;
 328 };
 329
 330 struct VkMemoryAllocateInfo
 331 {
 332         VkStructureType sType;
 333         const void*             pNext;
 334         VkDeviceSize    allocationSize;
 335         deUint32                memoryTypeIndex;
 336 };
 337
 338 struct VkMappedMemoryRange
 339 {
 340         VkStructureType sType;
 341         const void*             pNext;
 342         VkDeviceMemory  memory;
 343         VkDeviceSize    offset;
 344         VkDeviceSize    size;
 345 };
 346
 347 struct VkMemoryRequirements
 348 {
 349         VkDeviceSize    size;
 350         VkDeviceSize    alignment;
 351         deUint32                memoryTypeBits;
 352 };
 353
 354 struct VkSparseImageFormatProperties
 355 {
 356         VkImageAspectFlags                      aspectMask;
 357         VkExtent3D                                      imageGranularity;
 358         VkSparseImageFormatFlags        flags;
 359 };
 360
 361 struct VkSparseImageMemoryRequirements
 362 {
 363         VkSparseImageFormatProperties   formatProperties;
 364         deUint32                                                imageMipTailFirstLod;
 365         VkDeviceSize                                    imageMipTailSize;
 366         VkDeviceSize                                    imageMipTailOffset;
 367         VkDeviceSize                                    imageMipTailStride;
 368 };
 369
 370 struct VkSparseMemoryBind
 371 {
 372         VkDeviceSize                    resourceOffset;
 373         VkDeviceSize                    size;
 374         VkDeviceMemory                  memory;
 375         VkDeviceSize                    memoryOffset;
 376         VkSparseMemoryBindFlags flags;
 377 };
 378
 379 struct VkSparseBufferMemoryBindInfo
 380 {
 381         VkBuffer                                        buffer;
 382         deUint32                                        bindCount;
 383         const VkSparseMemoryBind*       pBinds;
 384 };
 385
 386 struct VkSparseImageOpaqueMemoryBindInfo
 387 {
 388         VkImage                                         image;
 389         deUint32                                        bindCount;
 390         const VkSparseMemoryBind*       pBinds;
 391 };
 392
 393 struct VkImageSubresource
 394 {
 395         VkImageAspectFlags      aspectMask;
 396         deUint32                        mipLevel;
 397         deUint32                        arrayLayer;
 398 };
 399
 400 struct VkOffset3D
 401 {
 402         deInt32 x;
 403         deInt32 y;
 404         deInt32 z;
 405 };
 406
 407 struct VkSparseImageMemoryBind
 408 {
 409         VkImageSubresource              subresource;
 410         VkOffset3D                              offset;
 411         VkExtent3D                              extent;
 412         VkDeviceMemory                  memory;
 413         VkDeviceSize                    memoryOffset;
 414         VkSparseMemoryBindFlags flags;
 415 };
 416
 417 struct VkSparseImageMemoryBindInfo
 418 {
 419         VkImage                                                 image;
 420         deUint32                                                bindCount;
 421         const VkSparseImageMemoryBind*  pBinds;
 422 };
 423
 424 struct VkBindSparseInfo
 425 {
 426         VkStructureType                                                         sType;
 427         const void*                                                                     pNext;
 428         deUint32                                                                        waitSemaphoreCount;
 429         const VkSemaphore*                                                      pWaitSemaphores;
 430         deUint32                                                                        bufferBindCount;
 431         const VkSparseBufferMemoryBindInfo*                     pBufferBinds;
 432         deUint32                                                                        imageOpaqueBindCount;
 433         const VkSparseImageOpaqueMemoryBindInfo*        pImageOpaqueBinds;
 434         deUint32                                                                        imageBindCount;
 435         const VkSparseImageMemoryBindInfo*                      pImageBinds;
 436         deUint32                                                                        signalSemaphoreCount;
 437         const VkSemaphore*                                                      pSignalSemaphores;
 438 };
 439
 440 struct VkFenceCreateInfo
 441 {
 442         VkStructureType         sType;
 443         const void*                     pNext;
 444         VkFenceCreateFlags      flags;
 445 };
 446
 447 struct VkSemaphoreCreateInfo
 448 {
 449         VkStructureType                 sType;
 450         const void*                             pNext;
 451         VkSemaphoreCreateFlags  flags;
 452 };
 453
 454 struct VkEventCreateInfo
 455 {
 456         VkStructureType         sType;
 457         const void*                     pNext;
 458         VkEventCreateFlags      flags;
 459 };
 460
 461 struct VkQueryPoolCreateInfo
 462 {
 463         VkStructureType                                 sType;
 464         const void*                                             pNext;
 465         VkQueryPoolCreateFlags                  flags;
 466         VkQueryType                                             queryType;
 467         deUint32                                                queryCount;
 468         VkQueryPipelineStatisticFlags   pipelineStatistics;
 469 };
 470
 471 struct VkBufferCreateInfo
 472 {
 473         VkStructureType         sType;
 474         const void*                     pNext;
 475         VkBufferCreateFlags     flags;
 476         VkDeviceSize            size;
 477         VkBufferUsageFlags      usage;
 478         VkSharingMode           sharingMode;
 479         deUint32                        queueFamilyIndexCount;
 480         const deUint32*         pQueueFamilyIndices;
 481 };
 482
 483 struct VkBufferViewCreateInfo
 484 {
 485         VkStructureType                 sType;
 486         const void*                             pNext;
 487         VkBufferViewCreateFlags flags;
 488         VkBuffer                                buffer;
 489         VkFormat                                format;
 490         VkDeviceSize                    offset;
 491         VkDeviceSize                    range;
 492 };
 493
 494 struct VkImageCreateInfo
 495 {
 496         VkStructureType                 sType;
 497         const void*                             pNext;
 498         VkImageCreateFlags              flags;
 499         VkImageType                             imageType;
 500         VkFormat                                format;
 501         VkExtent3D                              extent;
 502         deUint32                                mipLevels;
 503         deUint32                                arrayLayers;
 504         VkSampleCountFlagBits   samples;
 505         VkImageTiling                   tiling;
 506         VkImageUsageFlags               usage;
 507         VkSharingMode                   sharingMode;
 508         deUint32                                queueFamilyIndexCount;
 509         const deUint32*                 pQueueFamilyIndices;
 510         VkImageLayout                   initialLayout;
 511 };
 512
 513 struct VkSubresourceLayout
 514 {
 515         VkDeviceSize    offset;
 516         VkDeviceSize    size;
 517         VkDeviceSize    rowPitch;
 518         VkDeviceSize    arrayPitch;
 519         VkDeviceSize    depthPitch;
 520 };
 521
 522 struct VkComponentMapping
 523 {
 524         VkComponentSwizzle      r;
 525         VkComponentSwizzle      g;
 526         VkComponentSwizzle      b;
 527         VkComponentSwizzle      a;
 528 };
 529
 530 struct VkImageSubresourceRange
 531 {
 532         VkImageAspectFlags      aspectMask;
 533         deUint32                        baseMipLevel;
 534         deUint32                        levelCount;
 535         deUint32                        baseArrayLayer;
 536         deUint32                        layerCount;
 537 };
 538
 539 struct VkImageViewCreateInfo
 540 {
 541         VkStructureType                 sType;
 542         const void*                             pNext;
 543         VkImageViewCreateFlags  flags;
 544         VkImage                                 image;
 545         VkImageViewType                 viewType;
 546         VkFormat                                format;
 547         VkComponentMapping              components;
 548         VkImageSubresourceRange subresourceRange;
 549 };
 550
 551 struct VkShaderModuleCreateInfo
 552 {
 553         VkStructureType                         sType;
 554         const void*                                     pNext;
 555         VkShaderModuleCreateFlags       flags;
 556         deUintptr                                       codeSize;
 557         const deUint32*                         pCode;
 558 };
 559
 560 struct VkPipelineCacheCreateInfo
 561 {
 562         VkStructureType                         sType;
 563         const void*                                     pNext;
 564         VkPipelineCacheCreateFlags      flags;
 565         deUintptr                                       initialDataSize;
 566         const void*                                     pInitialData;
 567 };
 568
 569 struct VkSpecializationMapEntry
 570 {
 571         deUint32        constantID;
 572         deUint32        offset;
 573         deUintptr       size;
 574 };
 575
 576 struct VkSpecializationInfo
 577 {
 578         deUint32                                                mapEntryCount;
 579         const VkSpecializationMapEntry* pMapEntries;
 580         deUintptr                                               dataSize;
 581         const void*                                             pData;
 582 };
 583
 584 struct VkPipelineShaderStageCreateInfo
 585 {
 586         VkStructureType                                         sType;
 587         const void*                                                     pNext;
 588         VkPipelineShaderStageCreateFlags        flags;
 589         VkShaderStageFlagBits                           stage;
 590         VkShaderModule                                          module;
 591         const char*                                                     pName;
 592         const VkSpecializationInfo*                     pSpecializationInfo;
 593 };
 594
 595 struct VkVertexInputBindingDescription
 596 {
 597         deUint32                        binding;
 598         deUint32                        stride;
 599         VkVertexInputRate       inputRate;
 600 };
 601
 602 struct VkVertexInputAttributeDescription
 603 {
 604         deUint32        location;
 605         deUint32        binding;
 606         VkFormat        format;
 607         deUint32        offset;
 608 };
 609
 610 struct VkPipelineVertexInputStateCreateInfo
 611 {
 612         VkStructureType                                                         sType;
 613         const void*                                                                     pNext;
 614         VkPipelineVertexInputStateCreateFlags           flags;
 615         deUint32                                                                        vertexBindingDescriptionCount;
 616         const VkVertexInputBindingDescription*          pVertexBindingDescriptions;
 617         deUint32                                                                        vertexAttributeDescriptionCount;
 618         const VkVertexInputAttributeDescription*        pVertexAttributeDescriptions;
 619 };
 620
 621 struct VkPipelineInputAssemblyStateCreateInfo
 622 {
 623         VkStructureType                                                 sType;
 624         const void*                                                             pNext;
 625         VkPipelineInputAssemblyStateCreateFlags flags;
 626         VkPrimitiveTopology                                             topology;
 627         VkBool32                                                                primitiveRestartEnable;
 628 };
 629
 630 struct VkPipelineTessellationStateCreateInfo
 631 {
 632         VkStructureType                                                 sType;
 633         const void*                                                             pNext;
 634         VkPipelineTessellationStateCreateFlags  flags;
 635         deUint32                                                                patchControlPoints;
 636 };
 637
 638 struct VkViewport
 639 {
 640         float   x;
 641         float   y;
 642         float   width;
 643         float   height;
 644         float   minDepth;
 645         float   maxDepth;
 646 };
 647
 648 struct VkOffset2D
 649 {
 650         deInt32 x;
 651         deInt32 y;
 652 };
 653
 654 struct VkExtent2D
 655 {
 656         deUint32        width;
 657         deUint32        height;
 658 };
 659
 660 struct VkRect2D
 661 {
 662         VkOffset2D      offset;
 663         VkExtent2D      extent;
 664 };
 665
 666 struct VkPipelineViewportStateCreateInfo
 667 {
 668         VkStructureType                                         sType;
 669         const void*                                                     pNext;
 670         VkPipelineViewportStateCreateFlags      flags;
 671         deUint32                                                        viewportCount;
 672         const VkViewport*                                       pViewports;
 673         deUint32                                                        scissorCount;
 674         const VkRect2D*                                         pScissors;
 675 };
 676
 677 struct VkPipelineRasterizationStateCreateInfo
 678 {
 679         VkStructureType                                                 sType;
 680         const void*                                                             pNext;
 681         VkPipelineRasterizationStateCreateFlags flags;
 682         VkBool32                                                                depthClampEnable;
 683         VkBool32                                                                rasterizerDiscardEnable;
 684         VkPolygonMode                                                   polygonMode;
 685         VkCullModeFlags                                                 cullMode;
 686         VkFrontFace                                                             frontFace;
 687         VkBool32                                                                depthBiasEnable;
 688         float                                                                   depthBiasConstantFactor;
 689         float                                                                   depthBiasClamp;
 690         float                                                                   depthBiasSlopeFactor;
 691         float                                                                   lineWidth;
 692 };
 693
 694 struct VkPipelineMultisampleStateCreateInfo
 695 {
 696         VkStructureType                                                 sType;
 697         const void*                                                             pNext;
 698         VkPipelineMultisampleStateCreateFlags   flags;
 699         VkSampleCountFlagBits                                   rasterizationSamples;
 700         VkBool32                                                                sampleShadingEnable;
 701         float                                                                   minSampleShading;
 702         const VkSampleMask*                                             pSampleMask;
 703         VkBool32                                                                alphaToCoverageEnable;
 704         VkBool32                                                                alphaToOneEnable;
 705 };
 706
 707 struct VkStencilOpState
 708 {
 709         VkStencilOp     failOp;
 710         VkStencilOp     passOp;
 711         VkStencilOp     depthFailOp;
 712         VkCompareOp     compareOp;
 713         deUint32        compareMask;
 714         deUint32        writeMask;
 715         deUint32        reference;
 716 };
 717
 718 struct VkPipelineDepthStencilStateCreateInfo
 719 {
 720         VkStructureType                                                 sType;
 721         const void*                                                             pNext;
 722         VkPipelineDepthStencilStateCreateFlags  flags;
 723         VkBool32                                                                depthTestEnable;
 724         VkBool32                                                                depthWriteEnable;
 725         VkCompareOp                                                             depthCompareOp;
 726         VkBool32                                                                depthBoundsTestEnable;
 727         VkBool32                                                                stencilTestEnable;
 728         VkStencilOpState                                                front;
 729         VkStencilOpState                                                back;
 730         float                                                                   minDepthBounds;
 731         float                                                                   maxDepthBounds;
 732 };
 733
 734 struct VkPipelineColorBlendAttachmentState
 735 {
 736         VkBool32                                blendEnable;
 737         VkBlendFactor                   srcColorBlendFactor;
 738         VkBlendFactor                   dstColorBlendFactor;
 739         VkBlendOp                               colorBlendOp;
 740         VkBlendFactor                   srcAlphaBlendFactor;
 741         VkBlendFactor                   dstAlphaBlendFactor;
 742         VkBlendOp                               alphaBlendOp;
 743         VkColorComponentFlags   colorWriteMask;
 744 };
 745
 746 struct VkPipelineColorBlendStateCreateInfo
 747 {
 748         VkStructureType                                                         sType;
 749         const void*                                                                     pNext;
 750         VkPipelineColorBlendStateCreateFlags            flags;
 751         VkBool32                                                                        logicOpEnable;
 752         VkLogicOp                                                                       logicOp;
 753         deUint32                                                                        attachmentCount;
 754         const VkPipelineColorBlendAttachmentState*      pAttachments;
 755         float                                                                           blendConstants[4];
 756 };
 757
 758 struct VkPipelineDynamicStateCreateInfo
 759 {
 760         VkStructureType                                         sType;
 761         const void*                                                     pNext;
 762         VkPipelineDynamicStateCreateFlags       flags;
 763         deUint32                                                        dynamicStateCount;
 764         const VkDynamicState*                           pDynamicStates;
 765 };
 766
 767 struct VkGraphicsPipelineCreateInfo
 768 {
 769         VkStructureType                                                                 sType;
 770         const void*                                                                             pNext;
 771         VkPipelineCreateFlags                                                   flags;
 772         deUint32                                                                                stageCount;
 773         const VkPipelineShaderStageCreateInfo*                  pStages;
 774         const VkPipelineVertexInputStateCreateInfo*             pVertexInputState;
 775         const VkPipelineInputAssemblyStateCreateInfo*   pInputAssemblyState;
 776         const VkPipelineTessellationStateCreateInfo*    pTessellationState;
 777         const VkPipelineViewportStateCreateInfo*                pViewportState;
 778         const VkPipelineRasterizationStateCreateInfo*   pRasterizationState;
 779         const VkPipelineMultisampleStateCreateInfo*             pMultisampleState;
 780         const VkPipelineDepthStencilStateCreateInfo*    pDepthStencilState;
 781         const VkPipelineColorBlendStateCreateInfo*              pColorBlendState;
 782         const VkPipelineDynamicStateCreateInfo*                 pDynamicState;
 783         VkPipelineLayout                                                                layout;
 784         VkRenderPass                                                                    renderPass;
 785         deUint32                                                                                subpass;
 786         VkPipeline                                                                              basePipelineHandle;
 787         deInt32                                                                                 basePipelineIndex;
 788 };
 789
 790 struct VkComputePipelineCreateInfo
 791 {
 792         VkStructureType                                 sType;
 793         const void*                                             pNext;
 794         VkPipelineCreateFlags                   flags;
 795         VkPipelineShaderStageCreateInfo stage;
 796         VkPipelineLayout                                layout;
 797         VkPipeline                                              basePipelineHandle;
 798         deInt32                                                 basePipelineIndex;
 799 };
 800
 801 struct VkPushConstantRange
 802 {
 803         VkShaderStageFlags      stageFlags;
 804         deUint32                        offset;
 805         deUint32                        size;
 806 };
 807
 808 struct VkPipelineLayoutCreateInfo
 809 {
 810         VkStructureType                                 sType;
 811         const void*                                             pNext;
 812         VkPipelineLayoutCreateFlags             flags;
 813         deUint32                                                setLayoutCount;
 814         const VkDescriptorSetLayout*    pSetLayouts;
 815         deUint32                                                pushConstantRangeCount;
 816         const VkPushConstantRange*              pPushConstantRanges;
 817 };
 818
 819 struct VkSamplerCreateInfo
 820 {
 821         VkStructureType                 sType;
 822         const void*                             pNext;
 823         VkSamplerCreateFlags    flags;
 824         VkFilter                                magFilter;
 825         VkFilter                                minFilter;
 826         VkSamplerMipmapMode             mipmapMode;
 827         VkSamplerAddressMode    addressModeU;
 828         VkSamplerAddressMode    addressModeV;
 829         VkSamplerAddressMode    addressModeW;
 830         float                                   mipLodBias;
 831         VkBool32                                anisotropyEnable;
 832         float                                   maxAnisotropy;
 833         VkBool32                                compareEnable;
 834         VkCompareOp                             compareOp;
 835         float                                   minLod;
 836         float                                   maxLod;
 837         VkBorderColor                   borderColor;
 838         VkBool32                                unnormalizedCoordinates;
 839 };
 840
 841 struct VkDescriptorSetLayoutBinding
 842 {
 843         deUint32                        binding;
 844         VkDescriptorType        descriptorType;
 845         deUint32                        descriptorCount;
 846         VkShaderStageFlags      stageFlags;
 847         const VkSampler*        pImmutableSamplers;
 848 };
 849
 850 struct VkDescriptorSetLayoutCreateInfo
 851 {
 852         VkStructureType                                         sType;
 853         const void*                                                     pNext;
 854         VkDescriptorSetLayoutCreateFlags        flags;
 855         deUint32                                                        bindingCount;
 856         const VkDescriptorSetLayoutBinding*     pBindings;
 857 };
 858
 859 struct VkDescriptorPoolSize
 860 {
 861         VkDescriptorType        type;
 862         deUint32                        descriptorCount;
 863 };
 864
 865 struct VkDescriptorPoolCreateInfo
 866 {
 867         VkStructureType                         sType;
 868         const void*                                     pNext;
 869         VkDescriptorPoolCreateFlags     flags;
 870         deUint32                                        maxSets;
 871         deUint32                                        poolSizeCount;
 872         const VkDescriptorPoolSize*     pPoolSizes;
 873 };
 874
 875 struct VkDescriptorSetAllocateInfo
 876 {
 877         VkStructureType                                 sType;
 878         const void*                                             pNext;
 879         VkDescriptorPool                                descriptorPool;
 880         deUint32                                                descriptorSetCount;
 881         const VkDescriptorSetLayout*    pSetLayouts;
 882 };
 883
 884 struct VkDescriptorImageInfo
 885 {
 886         VkSampler               sampler;
 887         VkImageView             imageView;
 888         VkImageLayout   imageLayout;
 889 };
 890
 891 struct VkDescriptorBufferInfo
 892 {
 893         VkBuffer                buffer;
 894         VkDeviceSize    offset;
 895         VkDeviceSize    range;
 896 };
 897
 898 struct VkWriteDescriptorSet
 899 {
 900         VkStructureType                                 sType;
 901         const void*                                             pNext;
 902         VkDescriptorSet                                 dstSet;
 903         deUint32                                                dstBinding;
 904         deUint32                                                dstArrayElement;
 905         deUint32                                                descriptorCount;
 906         VkDescriptorType                                descriptorType;
 907         const VkDescriptorImageInfo*    pImageInfo;
 908         const VkDescriptorBufferInfo*   pBufferInfo;
 909         const VkBufferView*                             pTexelBufferView;
 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 VkFramebufferCreateInfo
 926 {
 927         VkStructureType                         sType;
 928         const void*                                     pNext;
 929         VkFramebufferCreateFlags        flags;
 930         VkRenderPass                            renderPass;
 931         deUint32                                        attachmentCount;
 932         const VkImageView*                      pAttachments;
 933         deUint32                                        width;
 934         deUint32                                        height;
 935         deUint32                                        layers;
 936 };
 937
 938 struct VkAttachmentDescription
 939 {
 940         VkAttachmentDescriptionFlags    flags;
 941         VkFormat                                                format;
 942         VkSampleCountFlagBits                   samples;
 943         VkAttachmentLoadOp                              loadOp;
 944         VkAttachmentStoreOp                             storeOp;
 945         VkAttachmentLoadOp                              stencilLoadOp;
 946         VkAttachmentStoreOp                             stencilStoreOp;
 947         VkImageLayout                                   initialLayout;
 948         VkImageLayout                                   finalLayout;
 949 };
 950
 951 struct VkAttachmentReference
 952 {
 953         deUint32                attachment;
 954         VkImageLayout   layout;
 955 };
 956
 957 struct VkSubpassDescription
 958 {
 959         VkSubpassDescriptionFlags               flags;
 960         VkPipelineBindPoint                             pipelineBindPoint;
 961         deUint32                                                inputAttachmentCount;
 962         const VkAttachmentReference*    pInputAttachments;
 963         deUint32                                                colorAttachmentCount;
 964         const VkAttachmentReference*    pColorAttachments;
 965         const VkAttachmentReference*    pResolveAttachments;
 966         const VkAttachmentReference*    pDepthStencilAttachment;
 967         deUint32                                                preserveAttachmentCount;
 968         const deUint32*                                 pPreserveAttachments;
 969 };
 970
 971 struct VkSubpassDependency
 972 {
 973         deUint32                                srcSubpass;
 974         deUint32                                dstSubpass;
 975         VkPipelineStageFlags    srcStageMask;
 976         VkPipelineStageFlags    dstStageMask;
 977         VkAccessFlags                   srcAccessMask;
 978         VkAccessFlags                   dstAccessMask;
 979         VkDependencyFlags               dependencyFlags;
 980 };
 981
 982 struct VkRenderPassCreateInfo
 983 {
 984         VkStructureType                                 sType;
 985         const void*                                             pNext;
 986         VkRenderPassCreateFlags                 flags;
 987         deUint32                                                attachmentCount;
 988         const VkAttachmentDescription*  pAttachments;
 989         deUint32                                                subpassCount;
 990         const VkSubpassDescription*             pSubpasses;
 991         deUint32                                                dependencyCount;
 992         const VkSubpassDependency*              pDependencies;
 993 };
 994
 995 struct VkCommandPoolCreateInfo
 996 {
 997         VkStructureType                         sType;
 998         const void*                                     pNext;
 999         VkCommandPoolCreateFlags        flags;
1000         deUint32                                        queueFamilyIndex;
1001 };
1002
1003 struct VkCommandBufferAllocateInfo
1004 {
1005         VkStructureType                 sType;
1006         const void*                             pNext;
1007         VkCommandPool                   commandPool;
1008         VkCommandBufferLevel    level;
1009         deUint32                                commandBufferCount;
1010 };
1011
1012 struct VkCommandBufferInheritanceInfo
1013 {
1014         VkStructureType                                 sType;
1015         const void*                                             pNext;
1016         VkRenderPass                                    renderPass;
1017         deUint32                                                subpass;
1018         VkFramebuffer                                   framebuffer;
1019         VkBool32                                                occlusionQueryEnable;
1020         VkQueryControlFlags                             queryFlags;
1021         VkQueryPipelineStatisticFlags   pipelineStatistics;
1022 };
1023
1024 struct VkCommandBufferBeginInfo
1025 {
1026         VkStructureType                                                 sType;
1027         const void*                                                             pNext;
1028         VkCommandBufferUsageFlags                               flags;
1029         const VkCommandBufferInheritanceInfo*   pInheritanceInfo;
1030 };
1031
1032 struct VkBufferCopy
1033 {
1034         VkDeviceSize    srcOffset;
1035         VkDeviceSize    dstOffset;
1036         VkDeviceSize    size;
1037 };
1038
1039 struct VkImageSubresourceLayers
1040 {
1041         VkImageAspectFlags      aspectMask;
1042         deUint32                        mipLevel;
1043         deUint32                        baseArrayLayer;
1044         deUint32                        layerCount;
1045 };
1046
1047 struct VkImageCopy
1048 {
1049         VkImageSubresourceLayers        srcSubresource;
1050         VkOffset3D                                      srcOffset;
1051         VkImageSubresourceLayers        dstSubresource;
1052         VkOffset3D                                      dstOffset;
1053         VkExtent3D                                      extent;
1054 };
1055
1056 struct VkImageBlit
1057 {
1058         VkImageSubresourceLayers        srcSubresource;
1059         VkOffset3D                                      srcOffsets[2];
1060         VkImageSubresourceLayers        dstSubresource;
1061         VkOffset3D                                      dstOffsets[2];
1062 };
1063
1064 struct VkBufferImageCopy
1065 {
1066         VkDeviceSize                            bufferOffset;
1067         deUint32                                        bufferRowLength;
1068         deUint32                                        bufferImageHeight;
1069         VkImageSubresourceLayers        imageSubresource;
1070         VkOffset3D                                      imageOffset;
1071         VkExtent3D                                      imageExtent;
1072 };
1073
1074 union VkClearColorValue
1075 {
1076         float           float32[4];
1077         deInt32         int32[4];
1078         deUint32        uint32[4];
1079 };
1080
1081 struct VkClearDepthStencilValue
1082 {
1083         float           depth;
1084         deUint32        stencil;
1085 };
1086
1087 union VkClearValue
1088 {
1089         VkClearColorValue                       color;
1090         VkClearDepthStencilValue        depthStencil;
1091 };
1092
1093 struct VkClearAttachment
1094 {
1095         VkImageAspectFlags      aspectMask;
1096         deUint32                        colorAttachment;
1097         VkClearValue            clearValue;
1098 };
1099
1100 struct VkClearRect
1101 {
1102         VkRect2D        rect;
1103         deUint32        baseArrayLayer;
1104         deUint32        layerCount;
1105 };
1106
1107 struct VkImageResolve
1108 {
1109         VkImageSubresourceLayers        srcSubresource;
1110         VkOffset3D                                      srcOffset;
1111         VkImageSubresourceLayers        dstSubresource;
1112         VkOffset3D                                      dstOffset;
1113         VkExtent3D                                      extent;
1114 };
1115
1116 struct VkMemoryBarrier
1117 {
1118         VkStructureType sType;
1119         const void*             pNext;
1120         VkAccessFlags   srcAccessMask;
1121         VkAccessFlags   dstAccessMask;
1122 };
1123
1124 struct VkBufferMemoryBarrier
1125 {
1126         VkStructureType sType;
1127         const void*             pNext;
1128         VkAccessFlags   srcAccessMask;
1129         VkAccessFlags   dstAccessMask;
1130         deUint32                srcQueueFamilyIndex;
1131         deUint32                dstQueueFamilyIndex;
1132         VkBuffer                buffer;
1133         VkDeviceSize    offset;
1134         VkDeviceSize    size;
1135 };
1136
1137 struct VkImageMemoryBarrier
1138 {
1139         VkStructureType                 sType;
1140         const void*                             pNext;
1141         VkAccessFlags                   srcAccessMask;
1142         VkAccessFlags                   dstAccessMask;
1143         VkImageLayout                   oldLayout;
1144         VkImageLayout                   newLayout;
1145         deUint32                                srcQueueFamilyIndex;
1146         deUint32                                dstQueueFamilyIndex;
1147         VkImage                                 image;
1148         VkImageSubresourceRange subresourceRange;
1149 };
1150
1151 struct VkRenderPassBeginInfo
1152 {
1153         VkStructureType         sType;
1154         const void*                     pNext;
1155         VkRenderPass            renderPass;
1156         VkFramebuffer           framebuffer;
1157         VkRect2D                        renderArea;
1158         deUint32                        clearValueCount;
1159         const VkClearValue*     pClearValues;
1160 };
1161
1162 struct VkDispatchIndirectCommand
1163 {
1164         deUint32        x;
1165         deUint32        y;
1166         deUint32        z;
1167 };
1168
1169 struct VkDrawIndexedIndirectCommand
1170 {
1171         deUint32        indexCount;
1172         deUint32        instanceCount;
1173         deUint32        firstIndex;
1174         deInt32         vertexOffset;
1175         deUint32        firstInstance;
1176 };
1177
1178 struct VkDrawIndirectCommand
1179 {
1180         deUint32        vertexCount;
1181         deUint32        instanceCount;
1182         deUint32        firstVertex;
1183         deUint32        firstInstance;
1184 };
1185
1186 struct VkPhysicalDeviceSubgroupProperties
1187 {
1188         VkStructureType                 sType;
1189         void*                                   pNext;
1190         deUint32                                subgroupSize;
1191         VkShaderStageFlags              supportedStages;
1192         VkSubgroupFeatureFlags  supportedOperations;
1193         VkBool32                                quadOperationsInAllStages;
1194 };
1195
1196 struct VkBindBufferMemoryInfo
1197 {
1198         VkStructureType sType;
1199         const void*             pNext;
1200         VkBuffer                buffer;
1201         VkDeviceMemory  memory;
1202         VkDeviceSize    memoryOffset;
1203 };
1204
1205 struct VkBindImageMemoryInfo
1206 {
1207         VkStructureType sType;
1208         const void*             pNext;
1209         VkImage                 image;
1210         VkDeviceMemory  memory;
1211         VkDeviceSize    memoryOffset;
1212 };
1213
1214 struct VkPhysicalDevice16BitStorageFeatures
1215 {
1216         VkStructureType sType;
1217         void*                   pNext;
1218         VkBool32                storageBuffer16BitAccess;
1219         VkBool32                uniformAndStorageBuffer16BitAccess;
1220         VkBool32                storagePushConstant16;
1221         VkBool32                storageInputOutput16;
1222 };
1223
1224 struct VkMemoryDedicatedRequirements
1225 {
1226         VkStructureType sType;
1227         void*                   pNext;
1228         VkBool32                prefersDedicatedAllocation;
1229         VkBool32                requiresDedicatedAllocation;
1230 };
1231
1232 struct VkMemoryDedicatedAllocateInfo
1233 {
1234         VkStructureType sType;
1235         const void*             pNext;
1236         VkImage                 image;
1237         VkBuffer                buffer;
1238 };
1239
1240 struct VkMemoryAllocateFlagsInfo
1241 {
1242         VkStructureType                 sType;
1243         const void*                             pNext;
1244         VkMemoryAllocateFlags   flags;
1245         deUint32                                deviceMask;
1246 };
1247
1248 struct VkDeviceGroupRenderPassBeginInfo
1249 {
1250         VkStructureType sType;
1251         const void*             pNext;
1252         deUint32                deviceMask;
1253         deUint32                deviceRenderAreaCount;
1254         const VkRect2D* pDeviceRenderAreas;
1255 };
1256
1257 struct VkDeviceGroupCommandBufferBeginInfo
1258 {
1259         VkStructureType sType;
1260         const void*             pNext;
1261         deUint32                deviceMask;
1262 };
1263
1264 struct VkDeviceGroupSubmitInfo
1265 {
1266         VkStructureType sType;
1267         const void*             pNext;
1268         deUint32                waitSemaphoreCount;
1269         const deUint32* pWaitSemaphoreDeviceIndices;
1270         deUint32                commandBufferCount;
1271         const deUint32* pCommandBufferDeviceMasks;
1272         deUint32                signalSemaphoreCount;
1273         const deUint32* pSignalSemaphoreDeviceIndices;
1274 };
1275
1276 struct VkDeviceGroupBindSparseInfo
1277 {
1278         VkStructureType sType;
1279         const void*             pNext;
1280         deUint32                resourceDeviceIndex;
1281         deUint32                memoryDeviceIndex;
1282 };
1283
1284 struct VkBindBufferMemoryDeviceGroupInfo
1285 {
1286         VkStructureType sType;
1287         const void*             pNext;
1288         deUint32                deviceIndexCount;
1289         const deUint32* pDeviceIndices;
1290 };
1291
1292 struct VkBindImageMemoryDeviceGroupInfo
1293 {
1294         VkStructureType sType;
1295         const void*             pNext;
1296         deUint32                deviceIndexCount;
1297         const deUint32* pDeviceIndices;
1298         deUint32                SFRRectCount;
1299         const VkRect2D* pSFRRects;
1300 };
1301
1302 struct VkPhysicalDeviceGroupProperties
1303 {
1304         VkStructureType         sType;
1305         void*                           pNext;
1306         deUint32                        physicalDeviceCount;
1307         VkPhysicalDevice        physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
1308         VkBool32                        subsetAllocation;
1309 };
1310
1311 struct VkDeviceGroupDeviceCreateInfo
1312 {
1313         VkStructureType                 sType;
1314         const void*                             pNext;
1315         deUint32                                physicalDeviceCount;
1316         const VkPhysicalDevice* pPhysicalDevices;
1317 };
1318
1319 struct VkBufferMemoryRequirementsInfo2
1320 {
1321         VkStructureType sType;
1322         const void*             pNext;
1323         VkBuffer                buffer;
1324 };
1325
1326 struct VkImageMemoryRequirementsInfo2
1327 {
1328         VkStructureType sType;
1329         const void*             pNext;
1330         VkImage                 image;
1331 };
1332
1333 struct VkImageSparseMemoryRequirementsInfo2
1334 {
1335         VkStructureType sType;
1336         const void*             pNext;
1337         VkImage                 image;
1338 };
1339
1340 struct VkMemoryRequirements2
1341 {
1342         VkStructureType                 sType;
1343         void*                                   pNext;
1344         VkMemoryRequirements    memoryRequirements;
1345 };
1346
1347 struct VkSparseImageMemoryRequirements2
1348 {
1349         VkStructureType                                 sType;
1350         void*                                                   pNext;
1351         VkSparseImageMemoryRequirements memoryRequirements;
1352 };
1353
1354 struct VkPhysicalDeviceFeatures2
1355 {
1356         VkStructureType                         sType;
1357         void*                                           pNext;
1358         VkPhysicalDeviceFeatures        features;
1359 };
1360
1361 struct VkPhysicalDeviceProperties2
1362 {
1363         VkStructureType                         sType;
1364         void*                                           pNext;
1365         VkPhysicalDeviceProperties      properties;
1366 };
1367
1368 struct VkFormatProperties2
1369 {
1370         VkStructureType         sType;
1371         void*                           pNext;
1372         VkFormatProperties      formatProperties;
1373 };
1374
1375 struct VkImageFormatProperties2
1376 {
1377         VkStructureType                 sType;
1378         void*                                   pNext;
1379         VkImageFormatProperties imageFormatProperties;
1380 };
1381
1382 struct VkPhysicalDeviceImageFormatInfo2
1383 {
1384         VkStructureType         sType;
1385         const void*                     pNext;
1386         VkFormat                        format;
1387         VkImageType                     type;
1388         VkImageTiling           tiling;
1389         VkImageUsageFlags       usage;
1390         VkImageCreateFlags      flags;
1391 };
1392
1393 struct VkQueueFamilyProperties2
1394 {
1395         VkStructureType                 sType;
1396         void*                                   pNext;
1397         VkQueueFamilyProperties queueFamilyProperties;
1398 };
1399
1400 struct VkPhysicalDeviceMemoryProperties2
1401 {
1402         VkStructureType                                         sType;
1403         void*                                                           pNext;
1404         VkPhysicalDeviceMemoryProperties        memoryProperties;
1405 };
1406
1407 struct VkSparseImageFormatProperties2
1408 {
1409         VkStructureType                                 sType;
1410         void*                                                   pNext;
1411         VkSparseImageFormatProperties   properties;
1412 };
1413
1414 struct VkPhysicalDeviceSparseImageFormatInfo2
1415 {
1416         VkStructureType                 sType;
1417         const void*                             pNext;
1418         VkFormat                                format;
1419         VkImageType                             type;
1420         VkSampleCountFlagBits   samples;
1421         VkImageUsageFlags               usage;
1422         VkImageTiling                   tiling;
1423 };
1424
1425 struct VkPhysicalDevicePointClippingProperties
1426 {
1427         VkStructureType                 sType;
1428         void*                                   pNext;
1429         VkPointClippingBehavior pointClippingBehavior;
1430 };
1431
1432 struct VkInputAttachmentAspectReference
1433 {
1434         deUint32                        subpass;
1435         deUint32                        inputAttachmentIndex;
1436         VkImageAspectFlags      aspectMask;
1437 };
1438
1439 struct VkRenderPassInputAttachmentAspectCreateInfo
1440 {
1441         VkStructureType                                                 sType;
1442         const void*                                                             pNext;
1443         deUint32                                                                aspectReferenceCount;
1444         const VkInputAttachmentAspectReference* pAspectReferences;
1445 };
1446
1447 struct VkImageViewUsageCreateInfo
1448 {
1449         VkStructureType         sType;
1450         const void*                     pNext;
1451         VkImageUsageFlags       usage;
1452 };
1453
1454 struct VkPipelineTessellationDomainOriginStateCreateInfo
1455 {
1456         VkStructureType                         sType;
1457         const void*                                     pNext;
1458         VkTessellationDomainOrigin      domainOrigin;
1459 };
1460
1461 struct VkRenderPassMultiviewCreateInfo
1462 {
1463         VkStructureType sType;
1464         const void*             pNext;
1465         deUint32                subpassCount;
1466         const deUint32* pViewMasks;
1467         deUint32                dependencyCount;
1468         const deInt32*  pViewOffsets;
1469         deUint32                correlationMaskCount;
1470         const deUint32* pCorrelationMasks;
1471 };
1472
1473 struct VkPhysicalDeviceMultiviewFeatures
1474 {
1475         VkStructureType sType;
1476         void*                   pNext;
1477         VkBool32                multiview;
1478         VkBool32                multiviewGeometryShader;
1479         VkBool32                multiviewTessellationShader;
1480 };
1481
1482 struct VkPhysicalDeviceMultiviewProperties
1483 {
1484         VkStructureType sType;
1485         void*                   pNext;
1486         deUint32                maxMultiviewViewCount;
1487         deUint32                maxMultiviewInstanceIndex;
1488 };
1489
1490 struct VkPhysicalDeviceVariablePointerFeatures
1491 {
1492         VkStructureType sType;
1493         void*                   pNext;
1494         VkBool32                variablePointersStorageBuffer;
1495         VkBool32                variablePointers;
1496 };
1497
1498 struct VkPhysicalDeviceProtectedMemoryFeatures
1499 {
1500         VkStructureType sType;
1501         void*                   pNext;
1502         VkBool32                protectedMemory;
1503 };
1504
1505 struct VkPhysicalDeviceProtectedMemoryProperties
1506 {
1507         VkStructureType sType;
1508         void*                   pNext;
1509         VkBool32                protectedNoFault;
1510 };
1511
1512 struct VkDeviceQueueInfo2
1513 {
1514         VkStructureType                         sType;
1515         const void*                                     pNext;
1516         VkDeviceQueueCreateFlags        flags;
1517         deUint32                                        queueFamilyIndex;
1518         deUint32                                        queueIndex;
1519 };
1520
1521 struct VkProtectedSubmitInfo
1522 {
1523         VkStructureType sType;
1524         const void*             pNext;
1525         VkBool32                protectedSubmit;
1526 };
1527
1528 struct VkSamplerYcbcrConversionCreateInfo
1529 {
1530         VkStructureType                                 sType;
1531         const void*                                             pNext;
1532         VkFormat                                                format;
1533         VkSamplerYcbcrModelConversion   ycbcrModel;
1534         VkSamplerYcbcrRange                             ycbcrRange;
1535         VkComponentMapping                              components;
1536         VkChromaLocation                                xChromaOffset;
1537         VkChromaLocation                                yChromaOffset;
1538         VkFilter                                                chromaFilter;
1539         VkBool32                                                forceExplicitReconstruction;
1540 };
1541
1542 struct VkSamplerYcbcrConversionInfo
1543 {
1544         VkStructureType                         sType;
1545         const void*                                     pNext;
1546         VkSamplerYcbcrConversion        conversion;
1547 };
1548
1549 struct VkBindImagePlaneMemoryInfo
1550 {
1551         VkStructureType                 sType;
1552         const void*                             pNext;
1553         VkImageAspectFlagBits   planeAspect;
1554 };
1555
1556 struct VkImagePlaneMemoryRequirementsInfo
1557 {
1558         VkStructureType                 sType;
1559         const void*                             pNext;
1560         VkImageAspectFlagBits   planeAspect;
1561 };
1562
1563 struct VkPhysicalDeviceSamplerYcbcrConversionFeatures
1564 {
1565         VkStructureType sType;
1566         void*                   pNext;
1567         VkBool32                samplerYcbcrConversion;
1568 };
1569
1570 struct VkSamplerYcbcrConversionImageFormatProperties
1571 {
1572         VkStructureType sType;
1573         void*                   pNext;
1574         deUint32                combinedImageSamplerDescriptorCount;
1575 };
1576
1577 struct VkDescriptorUpdateTemplateEntry
1578 {
1579         deUint32                        dstBinding;
1580         deUint32                        dstArrayElement;
1581         deUint32                        descriptorCount;
1582         VkDescriptorType        descriptorType;
1583         deUintptr                       offset;
1584         deUintptr                       stride;
1585 };
1586
1587 struct VkDescriptorUpdateTemplateCreateInfo
1588 {
1589         VkStructureType                                                 sType;
1590         void*                                                                   pNext;
1591         VkDescriptorUpdateTemplateCreateFlags   flags;
1592         deUint32                                                                descriptorUpdateEntryCount;
1593         const VkDescriptorUpdateTemplateEntry*  pDescriptorUpdateEntries;
1594         VkDescriptorUpdateTemplateType                  templateType;
1595         VkDescriptorSetLayout                                   descriptorSetLayout;
1596         VkPipelineBindPoint                                             pipelineBindPoint;
1597         VkPipelineLayout                                                pipelineLayout;
1598         deUint32                                                                set;
1599 };
1600
1601 struct VkExternalMemoryProperties
1602 {
1603         VkExternalMemoryFeatureFlags    externalMemoryFeatures;
1604         VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
1605         VkExternalMemoryHandleTypeFlags compatibleHandleTypes;
1606 };
1607
1608 struct VkPhysicalDeviceExternalImageFormatInfo
1609 {
1610         VkStructureType                                         sType;
1611         const void*                                                     pNext;
1612         VkExternalMemoryHandleTypeFlagBits      handleType;
1613 };
1614
1615 struct VkExternalImageFormatProperties
1616 {
1617         VkStructureType                         sType;
1618         void*                                           pNext;
1619         VkExternalMemoryProperties      externalMemoryProperties;
1620 };
1621
1622 struct VkPhysicalDeviceExternalBufferInfo
1623 {
1624         VkStructureType                                         sType;
1625         const void*                                                     pNext;
1626         VkBufferCreateFlags                                     flags;
1627         VkBufferUsageFlags                                      usage;
1628         VkExternalMemoryHandleTypeFlagBits      handleType;
1629 };
1630
1631 struct VkExternalBufferProperties
1632 {
1633         VkStructureType                         sType;
1634         void*                                           pNext;
1635         VkExternalMemoryProperties      externalMemoryProperties;
1636 };
1637
1638 struct VkPhysicalDeviceIDProperties
1639 {
1640         VkStructureType sType;
1641         void*                   pNext;
1642         deUint8                 deviceUUID[VK_UUID_SIZE];
1643         deUint8                 driverUUID[VK_UUID_SIZE];
1644         deUint8                 deviceLUID[VK_LUID_SIZE];
1645         deUint32                deviceNodeMask;
1646         VkBool32                deviceLUIDValid;
1647 };
1648
1649 struct VkExternalMemoryImageCreateInfo
1650 {
1651         VkStructureType                                 sType;
1652         const void*                                             pNext;
1653         VkExternalMemoryHandleTypeFlags handleTypes;
1654 };
1655
1656 struct VkExternalMemoryBufferCreateInfo
1657 {
1658         VkStructureType                                 sType;
1659         const void*                                             pNext;
1660         VkExternalMemoryHandleTypeFlags handleTypes;
1661 };
1662
1663 struct VkExportMemoryAllocateInfo
1664 {
1665         VkStructureType                                 sType;
1666         const void*                                             pNext;
1667         VkExternalMemoryHandleTypeFlags handleTypes;
1668 };
1669
1670 struct VkPhysicalDeviceExternalFenceInfo
1671 {
1672         VkStructureType                                         sType;
1673         const void*                                                     pNext;
1674         VkExternalFenceHandleTypeFlagBits       handleType;
1675 };
1676
1677 struct VkExternalFenceProperties
1678 {
1679         VkStructureType                                 sType;
1680         void*                                                   pNext;
1681         VkExternalFenceHandleTypeFlags  exportFromImportedHandleTypes;
1682         VkExternalFenceHandleTypeFlags  compatibleHandleTypes;
1683         VkExternalFenceFeatureFlags             externalFenceFeatures;
1684 };
1685
1686 struct VkExportFenceCreateInfo
1687 {
1688         VkStructureType                                 sType;
1689         const void*                                             pNext;
1690         VkExternalFenceHandleTypeFlags  handleTypes;
1691 };
1692
1693 struct VkExportSemaphoreCreateInfo
1694 {
1695         VkStructureType                                         sType;
1696         const void*                                                     pNext;
1697         VkExternalSemaphoreHandleTypeFlags      handleTypes;
1698 };
1699
1700 struct VkPhysicalDeviceExternalSemaphoreInfo
1701 {
1702         VkStructureType                                                 sType;
1703         const void*                                                             pNext;
1704         VkExternalSemaphoreHandleTypeFlagBits   handleType;
1705 };
1706
1707 struct VkExternalSemaphoreProperties
1708 {
1709         VkStructureType                                         sType;
1710         void*                                                           pNext;
1711         VkExternalSemaphoreHandleTypeFlags      exportFromImportedHandleTypes;
1712         VkExternalSemaphoreHandleTypeFlags      compatibleHandleTypes;
1713         VkExternalSemaphoreFeatureFlags         externalSemaphoreFeatures;
1714 };
1715
1716 struct VkPhysicalDeviceMaintenance3Properties
1717 {
1718         VkStructureType sType;
1719         void*                   pNext;
1720         deUint32                maxPerSetDescriptors;
1721         VkDeviceSize    maxMemoryAllocationSize;
1722 };
1723
1724 struct VkDescriptorSetLayoutSupport
1725 {
1726         VkStructureType sType;
1727         void*                   pNext;
1728         VkBool32                supported;
1729 };
1730
1731 struct VkPhysicalDeviceShaderDrawParameterFeatures
1732 {
1733         VkStructureType sType;
1734         void*                   pNext;
1735         VkBool32                shaderDrawParameters;
1736 };
1737
1738 struct VkSurfaceCapabilitiesKHR
1739 {
1740         deUint32                                                minImageCount;
1741         deUint32                                                maxImageCount;
1742         VkExtent2D                                              currentExtent;
1743         VkExtent2D                                              minImageExtent;
1744         VkExtent2D                                              maxImageExtent;
1745         deUint32                                                maxImageArrayLayers;
1746         VkSurfaceTransformFlagsKHR              supportedTransforms;
1747         VkSurfaceTransformFlagBitsKHR   currentTransform;
1748         VkCompositeAlphaFlagsKHR                supportedCompositeAlpha;
1749         VkImageUsageFlags                               supportedUsageFlags;
1750 };
1751
1752 struct VkSurfaceFormatKHR
1753 {
1754         VkFormat                format;
1755         VkColorSpaceKHR colorSpace;
1756 };
1757
1758 struct VkSwapchainCreateInfoKHR
1759 {
1760         VkStructureType                                 sType;
1761         const void*                                             pNext;
1762         VkSwapchainCreateFlagsKHR               flags;
1763         VkSurfaceKHR                                    surface;
1764         deUint32                                                minImageCount;
1765         VkFormat                                                imageFormat;
1766         VkColorSpaceKHR                                 imageColorSpace;
1767         VkExtent2D                                              imageExtent;
1768         deUint32                                                imageArrayLayers;
1769         VkImageUsageFlags                               imageUsage;
1770         VkSharingMode                                   imageSharingMode;
1771         deUint32                                                queueFamilyIndexCount;
1772         const deUint32*                                 pQueueFamilyIndices;
1773         VkSurfaceTransformFlagBitsKHR   preTransform;
1774         VkCompositeAlphaFlagBitsKHR             compositeAlpha;
1775         VkPresentModeKHR                                presentMode;
1776         VkBool32                                                clipped;
1777         VkSwapchainKHR                                  oldSwapchain;
1778 };
1779
1780 struct VkPresentInfoKHR
1781 {
1782         VkStructureType                 sType;
1783         const void*                             pNext;
1784         deUint32                                waitSemaphoreCount;
1785         const VkSemaphore*              pWaitSemaphores;
1786         deUint32                                swapchainCount;
1787         const VkSwapchainKHR*   pSwapchains;
1788         const deUint32*                 pImageIndices;
1789         VkResult*                               pResults;
1790 };
1791
1792 struct VkImageSwapchainCreateInfoKHR
1793 {
1794         VkStructureType sType;
1795         const void*             pNext;
1796         VkSwapchainKHR  swapchain;
1797 };
1798
1799 struct VkBindImageMemorySwapchainInfoKHR
1800 {
1801         VkStructureType sType;
1802         const void*             pNext;
1803         VkSwapchainKHR  swapchain;
1804         deUint32                imageIndex;
1805 };
1806
1807 struct VkAcquireNextImageInfoKHR
1808 {
1809         VkStructureType sType;
1810         const void*             pNext;
1811         VkSwapchainKHR  swapchain;
1812         deUint64                timeout;
1813         VkSemaphore             semaphore;
1814         VkFence                 fence;
1815         deUint32                deviceMask;
1816 };
1817
1818 struct VkDeviceGroupPresentCapabilitiesKHR
1819 {
1820         VkStructureType                                         sType;
1821         const void*                                                     pNext;
1822         deUint32                                                        presentMask[VK_MAX_DEVICE_GROUP_SIZE];
1823         VkDeviceGroupPresentModeFlagsKHR        modes;
1824 };
1825
1826 struct VkDeviceGroupPresentInfoKHR
1827 {
1828         VkStructureType                                         sType;
1829         const void*                                                     pNext;
1830         deUint32                                                        swapchainCount;
1831         const deUint32*                                         pDeviceMasks;
1832         VkDeviceGroupPresentModeFlagBitsKHR     mode;
1833 };
1834
1835 struct VkDeviceGroupSwapchainCreateInfoKHR
1836 {
1837         VkStructureType                                         sType;
1838         const void*                                                     pNext;
1839         VkDeviceGroupPresentModeFlagsKHR        modes;
1840 };
1841
1842 struct VkDisplayPropertiesKHR
1843 {
1844         VkDisplayKHR                            display;
1845         const char*                                     displayName;
1846         VkExtent2D                                      physicalDimensions;
1847         VkExtent2D                                      physicalResolution;
1848         VkSurfaceTransformFlagsKHR      supportedTransforms;
1849         VkBool32                                        planeReorderPossible;
1850         VkBool32                                        persistentContent;
1851 };
1852
1853 struct VkDisplayModeParametersKHR
1854 {
1855         VkExtent2D      visibleRegion;
1856         deUint32        refreshRate;
1857 };
1858
1859 struct VkDisplayModePropertiesKHR
1860 {
1861         VkDisplayModeKHR                        displayMode;
1862         VkDisplayModeParametersKHR      parameters;
1863 };
1864
1865 struct VkDisplayModeCreateInfoKHR
1866 {
1867         VkStructureType                         sType;
1868         const void*                                     pNext;
1869         VkDisplayModeCreateFlagsKHR     flags;
1870         VkDisplayModeParametersKHR      parameters;
1871 };
1872
1873 struct VkDisplayPlaneCapabilitiesKHR
1874 {
1875         VkDisplayPlaneAlphaFlagsKHR     supportedAlpha;
1876         VkOffset2D                                      minSrcPosition;
1877         VkOffset2D                                      maxSrcPosition;
1878         VkExtent2D                                      minSrcExtent;
1879         VkExtent2D                                      maxSrcExtent;
1880         VkOffset2D                                      minDstPosition;
1881         VkOffset2D                                      maxDstPosition;
1882         VkExtent2D                                      minDstExtent;
1883         VkExtent2D                                      maxDstExtent;
1884 };
1885
1886 struct VkDisplayPlanePropertiesKHR
1887 {
1888         VkDisplayKHR    currentDisplay;
1889         deUint32                currentStackIndex;
1890 };
1891
1892 struct VkDisplaySurfaceCreateInfoKHR
1893 {
1894         VkStructureType                                 sType;
1895         const void*                                             pNext;
1896         VkDisplaySurfaceCreateFlagsKHR  flags;
1897         VkDisplayModeKHR                                displayMode;
1898         deUint32                                                planeIndex;
1899         deUint32                                                planeStackIndex;
1900         VkSurfaceTransformFlagBitsKHR   transform;
1901         float                                                   globalAlpha;
1902         VkDisplayPlaneAlphaFlagBitsKHR  alphaMode;
1903         VkExtent2D                                              imageExtent;
1904 };
1905
1906 struct VkDisplayPresentInfoKHR
1907 {
1908         VkStructureType sType;
1909         const void*             pNext;
1910         VkRect2D                srcRect;
1911         VkRect2D                dstRect;
1912         VkBool32                persistent;
1913 };
1914
1915 struct VkXlibSurfaceCreateInfoKHR
1916 {
1917         VkStructureType                         sType;
1918         const void*                                     pNext;
1919         VkXlibSurfaceCreateFlagsKHR     flags;
1920         pt::XlibDisplayPtr                      dpy;
1921         pt::XlibWindow                          window;
1922 };
1923
1924 struct VkXcbSurfaceCreateInfoKHR
1925 {
1926         VkStructureType                         sType;
1927         const void*                                     pNext;
1928         VkXcbSurfaceCreateFlagsKHR      flags;
1929         pt::XcbConnectionPtr            connection;
1930         pt::XcbWindow                           window;
1931 };
1932
1933 struct VkWaylandSurfaceCreateInfoKHR
1934 {
1935         VkStructureType                                 sType;
1936         const void*                                             pNext;
1937         VkWaylandSurfaceCreateFlagsKHR  flags;
1938         pt::WaylandDisplayPtr                   display;
1939         pt::WaylandSurfacePtr                   surface;
1940 };
1941
1942 struct VkMirSurfaceCreateInfoKHR
1943 {
1944         VkStructureType                         sType;
1945         const void*                                     pNext;
1946         VkMirSurfaceCreateFlagsKHR      flags;
1947         pt::MirConnectionPtr            connection;
1948         pt::MirSurfacePtr                       mirSurface;
1949 };
1950
1951 struct VkAndroidSurfaceCreateInfoKHR
1952 {
1953         VkStructureType                                 sType;
1954         const void*                                             pNext;
1955         VkAndroidSurfaceCreateFlagsKHR  flags;
1956         pt::AndroidNativeWindowPtr              window;
1957 };
1958
1959 struct VkWin32SurfaceCreateInfoKHR
1960 {
1961         VkStructureType                                 sType;
1962         const void*                                             pNext;
1963         VkWin32SurfaceCreateFlagsKHR    flags;
1964         pt::Win32InstanceHandle                 hinstance;
1965         pt::Win32WindowHandle                   hwnd;
1966 };
1967
1968 struct VkImportMemoryWin32HandleInfoKHR
1969 {
1970         VkStructureType                                         sType;
1971         const void*                                                     pNext;
1972         VkExternalMemoryHandleTypeFlagBits      handleType;
1973         pt::Win32Handle                                         handle;
1974         char*                                                           name;
1975 };
1976
1977 struct VkExportMemoryWin32HandleInfoKHR
1978 {
1979         VkStructureType                                 sType;
1980         const void*                                             pNext;
1981         pt::Win32SecurityAttributesPtr  pAttributes;
1982         deUint32                                                dwAccess;
1983         char*                                                   name;
1984 };
1985
1986 struct VkMemoryWin32HandlePropertiesKHR
1987 {
1988         VkStructureType sType;
1989         void*                   pNext;
1990         deUint32                memoryTypeBits;
1991 };
1992
1993 struct VkMemoryGetWin32HandleInfoKHR
1994 {
1995         VkStructureType                                         sType;
1996         const void*                                                     pNext;
1997         VkDeviceMemory                                          memory;
1998         VkExternalMemoryHandleTypeFlagBits      handleType;
1999 };
2000
2001 struct VkImportMemoryFdInfoKHR
2002 {
2003         VkStructureType                                         sType;
2004         const void*                                                     pNext;
2005         VkExternalMemoryHandleTypeFlagBits      handleType;
2006         int                                                                     fd;
2007 };
2008
2009 struct VkMemoryFdPropertiesKHR
2010 {
2011         VkStructureType sType;
2012         void*                   pNext;
2013         deUint32                memoryTypeBits;
2014 };
2015
2016 struct VkMemoryGetFdInfoKHR
2017 {
2018         VkStructureType                                         sType;
2019         const void*                                                     pNext;
2020         VkDeviceMemory                                          memory;
2021         VkExternalMemoryHandleTypeFlagBits      handleType;
2022 };
2023
2024 struct VkWin32KeyedMutexAcquireReleaseInfoKHR
2025 {
2026         VkStructureType                 sType;
2027         const void*                             pNext;
2028         deUint32                                acquireCount;
2029         const VkDeviceMemory*   pAcquireSyncs;
2030         const deUint64*                 pAcquireKeys;
2031         const deUint32*                 pAcquireTimeouts;
2032         deUint32                                releaseCount;
2033         const VkDeviceMemory*   pReleaseSyncs;
2034         const deUint64*                 pReleaseKeys;
2035 };
2036
2037 struct VkImportSemaphoreWin32HandleInfoKHR
2038 {
2039         VkStructureType                                                 sType;
2040         const void*                                                             pNext;
2041         VkSemaphore                                                             semaphore;
2042         VkSemaphoreImportFlags                                  flags;
2043         VkExternalSemaphoreHandleTypeFlagBits   handleType;
2044         pt::Win32Handle                                                 handle;
2045         char*                                                                   name;
2046 };
2047
2048 struct VkExportSemaphoreWin32HandleInfoKHR
2049 {
2050         VkStructureType                                 sType;
2051         const void*                                             pNext;
2052         pt::Win32SecurityAttributesPtr  pAttributes;
2053         deUint32                                                dwAccess;
2054         char*                                                   name;
2055 };
2056
2057 struct VkD3D12FenceSubmitInfoKHR
2058 {
2059         VkStructureType sType;
2060         const void*             pNext;
2061         deUint32                waitSemaphoreValuesCount;
2062         const deUint64* pWaitSemaphoreValues;
2063         deUint32                signalSemaphoreValuesCount;
2064         const deUint64* pSignalSemaphoreValues;
2065 };
2066
2067 struct VkSemaphoreGetWin32HandleInfoKHR
2068 {
2069         VkStructureType                                                 sType;
2070         const void*                                                             pNext;
2071         VkSemaphore                                                             semaphore;
2072         VkExternalSemaphoreHandleTypeFlagBits   handleType;
2073 };
2074
2075 struct VkImportSemaphoreFdInfoKHR
2076 {
2077         VkStructureType                                                 sType;
2078         const void*                                                             pNext;
2079         VkSemaphore                                                             semaphore;
2080         VkSemaphoreImportFlags                                  flags;
2081         VkExternalSemaphoreHandleTypeFlagBits   handleType;
2082         int                                                                             fd;
2083 };
2084
2085 struct VkSemaphoreGetFdInfoKHR
2086 {
2087         VkStructureType                                                 sType;
2088         const void*                                                             pNext;
2089         VkSemaphore                                                             semaphore;
2090         VkExternalSemaphoreHandleTypeFlagBits   handleType;
2091 };
2092
2093 struct VkPhysicalDevicePushDescriptorPropertiesKHR
2094 {
2095         VkStructureType sType;
2096         void*                   pNext;
2097         deUint32                maxPushDescriptors;
2098 };
2099
2100 struct VkRectLayerKHR
2101 {
2102         VkOffset2D      offset;
2103         VkExtent2D      extent;
2104         deUint32        layer;
2105 };
2106
2107 struct VkPresentRegionKHR
2108 {
2109         deUint32                                rectangleCount;
2110         const VkRectLayerKHR*   pRectangles;
2111 };
2112
2113 struct VkPresentRegionsKHR
2114 {
2115         VkStructureType                         sType;
2116         const void*                                     pNext;
2117         deUint32                                        swapchainCount;
2118         const VkPresentRegionKHR*       pRegions;
2119 };
2120
2121 struct VkSharedPresentSurfaceCapabilitiesKHR
2122 {
2123         VkStructureType         sType;
2124         void*                           pNext;
2125         VkImageUsageFlags       sharedPresentSupportedUsageFlags;
2126 };
2127
2128 struct VkImportFenceWin32HandleInfoKHR
2129 {
2130         VkStructureType                                         sType;
2131         const void*                                                     pNext;
2132         VkFence                                                         fence;
2133         VkFenceImportFlags                                      flags;
2134         VkExternalFenceHandleTypeFlagBits       handleType;
2135         pt::Win32Handle                                         handle;
2136         char*                                                           name;
2137 };
2138
2139 struct VkExportFenceWin32HandleInfoKHR
2140 {
2141         VkStructureType                                 sType;
2142         const void*                                             pNext;
2143         pt::Win32SecurityAttributesPtr  pAttributes;
2144         deUint32                                                dwAccess;
2145         char*                                                   name;
2146 };
2147
2148 struct VkFenceGetWin32HandleInfoKHR
2149 {
2150         VkStructureType                                         sType;
2151         const void*                                                     pNext;
2152         VkFence                                                         fence;
2153         VkExternalFenceHandleTypeFlagBits       handleType;
2154 };
2155
2156 struct VkImportFenceFdInfoKHR
2157 {
2158         VkStructureType                                         sType;
2159         const void*                                                     pNext;
2160         VkFence                                                         fence;
2161         VkFenceImportFlags                                      flags;
2162         VkExternalFenceHandleTypeFlagBits       handleType;
2163         int                                                                     fd;
2164 };
2165
2166 struct VkFenceGetFdInfoKHR
2167 {
2168         VkStructureType                                         sType;
2169         const void*                                                     pNext;
2170         VkFence                                                         fence;
2171         VkExternalFenceHandleTypeFlagBits       handleType;
2172 };
2173
2174 struct VkPhysicalDeviceSurfaceInfo2KHR
2175 {
2176         VkStructureType sType;
2177         const void*             pNext;
2178         VkSurfaceKHR    surface;
2179 };
2180
2181 struct VkSurfaceCapabilities2KHR
2182 {
2183         VkStructureType                         sType;
2184         void*                                           pNext;
2185         VkSurfaceCapabilitiesKHR        surfaceCapabilities;
2186 };
2187
2188 struct VkSurfaceFormat2KHR
2189 {
2190         VkStructureType         sType;
2191         void*                           pNext;
2192         VkSurfaceFormatKHR      surfaceFormat;
2193 };
2194
2195 struct VkImageFormatListCreateInfoKHR
2196 {
2197         VkStructureType sType;
2198         const void*             pNext;
2199         deUint32                viewFormatCount;
2200         const VkFormat* pViewFormats;
2201 };
2202
2203 struct VkDebugReportCallbackCreateInfoEXT
2204 {
2205         VkStructureType                                 sType;
2206         const void*                                             pNext;
2207         VkDebugReportFlagsEXT                   flags;
2208         PFN_vkDebugReportCallbackEXT    pfnCallback;
2209         void*                                                   pUserData;
2210 };
2211
2212 struct VkPipelineRasterizationStateRasterizationOrderAMD
2213 {
2214         VkStructureType                 sType;
2215         const void*                             pNext;
2216         VkRasterizationOrderAMD rasterizationOrder;
2217 };
2218
2219 struct VkDebugMarkerObjectNameInfoEXT
2220 {
2221         VkStructureType                         sType;
2222         const void*                                     pNext;
2223         VkDebugReportObjectTypeEXT      objectType;
2224         deUint64                                        object;
2225         const char*                                     pObjectName;
2226 };
2227
2228 struct VkDebugMarkerObjectTagInfoEXT
2229 {
2230         VkStructureType                         sType;
2231         const void*                                     pNext;
2232         VkDebugReportObjectTypeEXT      objectType;
2233         deUint64                                        object;
2234         deUint64                                        tagName;
2235         deUintptr                                       tagSize;
2236         const void*                                     pTag;
2237 };
2238
2239 struct VkDebugMarkerMarkerInfoEXT
2240 {
2241         VkStructureType sType;
2242         const void*             pNext;
2243         const char*             pMarkerName;
2244         float                   color[4];
2245 };
2246
2247 struct VkDedicatedAllocationImageCreateInfoNV
2248 {
2249         VkStructureType sType;
2250         const void*             pNext;
2251         VkBool32                dedicatedAllocation;
2252 };
2253
2254 struct VkDedicatedAllocationBufferCreateInfoNV
2255 {
2256         VkStructureType sType;
2257         const void*             pNext;
2258         VkBool32                dedicatedAllocation;
2259 };
2260
2261 struct VkDedicatedAllocationMemoryAllocateInfoNV
2262 {
2263         VkStructureType sType;
2264         const void*             pNext;
2265         VkImage                 image;
2266         VkBuffer                buffer;
2267 };
2268
2269 struct VkTextureLODGatherFormatPropertiesAMD
2270 {
2271         VkStructureType sType;
2272         void*                   pNext;
2273         VkBool32                supportsTextureGatherLODBiasAMD;
2274 };
2275
2276 struct VkExternalImageFormatPropertiesNV
2277 {
2278         VkImageFormatProperties                         imageFormatProperties;
2279         VkExternalMemoryFeatureFlagsNV          externalMemoryFeatures;
2280         VkExternalMemoryHandleTypeFlagsNV       exportFromImportedHandleTypes;
2281         VkExternalMemoryHandleTypeFlagsNV       compatibleHandleTypes;
2282 };
2283
2284 struct VkExternalMemoryImageCreateInfoNV
2285 {
2286         VkStructureType                                         sType;
2287         const void*                                                     pNext;
2288         VkExternalMemoryHandleTypeFlagsNV       handleTypes;
2289 };
2290
2291 struct VkExportMemoryAllocateInfoNV
2292 {
2293         VkStructureType                                         sType;
2294         const void*                                                     pNext;
2295         VkExternalMemoryHandleTypeFlagsNV       handleTypes;
2296 };
2297
2298 struct VkImportMemoryWin32HandleInfoNV
2299 {
2300         VkStructureType                                         sType;
2301         const void*                                                     pNext;
2302         VkExternalMemoryHandleTypeFlagsNV       handleType;
2303         pt::Win32Handle                                         handle;
2304 };
2305
2306 struct VkExportMemoryWin32HandleInfoNV
2307 {
2308         VkStructureType                                 sType;
2309         const void*                                             pNext;
2310         pt::Win32SecurityAttributesPtr  pAttributes;
2311         deUint32                                                dwAccess;
2312 };
2313
2314 struct VkWin32KeyedMutexAcquireReleaseInfoNV
2315 {
2316         VkStructureType                 sType;
2317         const void*                             pNext;
2318         deUint32                                acquireCount;
2319         const VkDeviceMemory*   pAcquireSyncs;
2320         const deUint64*                 pAcquireKeys;
2321         const deUint32*                 pAcquireTimeoutMilliseconds;
2322         deUint32                                releaseCount;
2323         const VkDeviceMemory*   pReleaseSyncs;
2324         const deUint64*                 pReleaseKeys;
2325 };
2326
2327 struct VkValidationFlagsEXT
2328 {
2329         VkStructureType                 sType;
2330         const void*                             pNext;
2331         deUint32                                disabledValidationCheckCount;
2332         VkValidationCheckEXT*   pDisabledValidationChecks;
2333 };
2334
2335 struct VkViSurfaceCreateInfoNN
2336 {
2337         VkStructureType                         sType;
2338         const void*                                     pNext;
2339         VkViSurfaceCreateFlagsNN        flags;
2340         void*                                           window;
2341 };
2342
2343 struct VkDeviceGeneratedCommandsFeaturesNVX
2344 {
2345         VkStructureType sType;
2346         const void*             pNext;
2347         VkBool32                computeBindingPointSupport;
2348 };
2349
2350 struct VkDeviceGeneratedCommandsLimitsNVX
2351 {
2352         VkStructureType sType;
2353         const void*             pNext;
2354         deUint32                maxIndirectCommandsLayoutTokenCount;
2355         deUint32                maxObjectEntryCounts;
2356         deUint32                minSequenceCountBufferOffsetAlignment;
2357         deUint32                minSequenceIndexBufferOffsetAlignment;
2358         deUint32                minCommandsTokenBufferOffsetAlignment;
2359 };
2360
2361 struct VkIndirectCommandsTokenNVX
2362 {
2363         VkIndirectCommandsTokenTypeNVX  tokenType;
2364         VkBuffer                                                buffer;
2365         VkDeviceSize                                    offset;
2366 };
2367
2368 struct VkIndirectCommandsLayoutTokenNVX
2369 {
2370         VkIndirectCommandsTokenTypeNVX  tokenType;
2371         deUint32                                                bindingUnit;
2372         deUint32                                                dynamicCount;
2373         deUint32                                                divisor;
2374 };
2375
2376 struct VkIndirectCommandsLayoutCreateInfoNVX
2377 {
2378         VkStructureType                                                 sType;
2379         const void*                                                             pNext;
2380         VkPipelineBindPoint                                             pipelineBindPoint;
2381         VkIndirectCommandsLayoutUsageFlagsNVX   flags;
2382         deUint32                                                                tokenCount;
2383         const VkIndirectCommandsLayoutTokenNVX* pTokens;
2384 };
2385
2386 struct VkCmdProcessCommandsInfoNVX
2387 {
2388         VkStructureType                                         sType;
2389         const void*                                                     pNext;
2390         VkObjectTableNVX                                        objectTable;
2391         VkIndirectCommandsLayoutNVX                     indirectCommandsLayout;
2392         deUint32                                                        indirectCommandsTokenCount;
2393         const VkIndirectCommandsTokenNVX*       pIndirectCommandsTokens;
2394         deUint32                                                        maxSequencesCount;
2395         VkCommandBuffer                                         targetCommandBuffer;
2396         VkBuffer                                                        sequencesCountBuffer;
2397         VkDeviceSize                                            sequencesCountOffset;
2398         VkBuffer                                                        sequencesIndexBuffer;
2399         VkDeviceSize                                            sequencesIndexOffset;
2400 };
2401
2402 struct VkCmdReserveSpaceForCommandsInfoNVX
2403 {
2404         VkStructureType                         sType;
2405         const void*                                     pNext;
2406         VkObjectTableNVX                        objectTable;
2407         VkIndirectCommandsLayoutNVX     indirectCommandsLayout;
2408         deUint32                                        maxSequencesCount;
2409 };
2410
2411 struct VkObjectTableCreateInfoNVX
2412 {
2413         VkStructureType                                         sType;
2414         const void*                                                     pNext;
2415         deUint32                                                        objectCount;
2416         const VkObjectEntryTypeNVX*                     pObjectEntryTypes;
2417         const deUint32*                                         pObjectEntryCounts;
2418         const VkObjectEntryUsageFlagsNVX*       pObjectEntryUsageFlags;
2419         deUint32                                                        maxUniformBuffersPerDescriptor;
2420         deUint32                                                        maxStorageBuffersPerDescriptor;
2421         deUint32                                                        maxStorageImagesPerDescriptor;
2422         deUint32                                                        maxSampledImagesPerDescriptor;
2423         deUint32                                                        maxPipelineLayouts;
2424 };
2425
2426 struct VkObjectTableEntryNVX
2427 {
2428         VkObjectEntryTypeNVX            type;
2429         VkObjectEntryUsageFlagsNVX      flags;
2430 };
2431
2432 struct VkObjectTablePipelineEntryNVX
2433 {
2434         VkObjectEntryTypeNVX            type;
2435         VkObjectEntryUsageFlagsNVX      flags;
2436         VkPipeline                                      pipeline;
2437 };
2438
2439 struct VkObjectTableDescriptorSetEntryNVX
2440 {
2441         VkObjectEntryTypeNVX            type;
2442         VkObjectEntryUsageFlagsNVX      flags;
2443         VkPipelineLayout                        pipelineLayout;
2444         VkDescriptorSet                         descriptorSet;
2445 };
2446
2447 struct VkObjectTableVertexBufferEntryNVX
2448 {
2449         VkObjectEntryTypeNVX            type;
2450         VkObjectEntryUsageFlagsNVX      flags;
2451         VkBuffer                                        buffer;
2452 };
2453
2454 struct VkObjectTableIndexBufferEntryNVX
2455 {
2456         VkObjectEntryTypeNVX            type;
2457         VkObjectEntryUsageFlagsNVX      flags;
2458         VkBuffer                                        buffer;
2459         VkIndexType                                     indexType;
2460 };
2461
2462 struct VkObjectTablePushConstantEntryNVX
2463 {
2464         VkObjectEntryTypeNVX            type;
2465         VkObjectEntryUsageFlagsNVX      flags;
2466         VkPipelineLayout                        pipelineLayout;
2467         VkShaderStageFlags                      stageFlags;
2468 };
2469
2470 struct VkViewportWScalingNV
2471 {
2472         float   xcoeff;
2473         float   ycoeff;
2474 };
2475
2476 struct VkPipelineViewportWScalingStateCreateInfoNV
2477 {
2478         VkStructureType                         sType;
2479         const void*                                     pNext;
2480         VkBool32                                        viewportWScalingEnable;
2481         deUint32                                        viewportCount;
2482         const VkViewportWScalingNV*     pViewportWScalings;
2483 };
2484
2485 struct VkSurfaceCapabilities2EXT
2486 {
2487         VkStructureType                                 sType;
2488         void*                                                   pNext;
2489         deUint32                                                minImageCount;
2490         deUint32                                                maxImageCount;
2491         VkExtent2D                                              currentExtent;
2492         VkExtent2D                                              minImageExtent;
2493         VkExtent2D                                              maxImageExtent;
2494         deUint32                                                maxImageArrayLayers;
2495         VkSurfaceTransformFlagsKHR              supportedTransforms;
2496         VkSurfaceTransformFlagBitsKHR   currentTransform;
2497         VkCompositeAlphaFlagsKHR                supportedCompositeAlpha;
2498         VkImageUsageFlags                               supportedUsageFlags;
2499         VkSurfaceCounterFlagsEXT                supportedSurfaceCounters;
2500 };
2501
2502 struct VkDisplayPowerInfoEXT
2503 {
2504         VkStructureType                 sType;
2505         const void*                             pNext;
2506         VkDisplayPowerStateEXT  powerState;
2507 };
2508
2509 struct VkDeviceEventInfoEXT
2510 {
2511         VkStructureType                 sType;
2512         const void*                             pNext;
2513         VkDeviceEventTypeEXT    deviceEvent;
2514 };
2515
2516 struct VkDisplayEventInfoEXT
2517 {
2518         VkStructureType                 sType;
2519         const void*                             pNext;
2520         VkDisplayEventTypeEXT   displayEvent;
2521 };
2522
2523 struct VkSwapchainCounterCreateInfoEXT
2524 {
2525         VkStructureType                         sType;
2526         const void*                                     pNext;
2527         VkSurfaceCounterFlagsEXT        surfaceCounters;
2528 };
2529
2530 struct VkRefreshCycleDurationGOOGLE
2531 {
2532         deUint64        refreshDuration;
2533 };
2534
2535 struct VkPastPresentationTimingGOOGLE
2536 {
2537         deUint32        presentID;
2538         deUint64        desiredPresentTime;
2539         deUint64        actualPresentTime;
2540         deUint64        earliestPresentTime;
2541         deUint64        presentMargin;
2542 };
2543
2544 struct VkPresentTimeGOOGLE
2545 {
2546         deUint32        presentID;
2547         deUint64        desiredPresentTime;
2548 };
2549
2550 struct VkPresentTimesInfoGOOGLE
2551 {
2552         VkStructureType                         sType;
2553         const void*                                     pNext;
2554         deUint32                                        swapchainCount;
2555         const VkPresentTimeGOOGLE*      pTimes;
2556 };
2557
2558 struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX
2559 {
2560         VkStructureType sType;
2561         void*                   pNext;
2562         VkBool32                perViewPositionAllComponents;
2563 };
2564
2565 struct VkViewportSwizzleNV
2566 {
2567         VkViewportCoordinateSwizzleNV   x;
2568         VkViewportCoordinateSwizzleNV   y;
2569         VkViewportCoordinateSwizzleNV   z;
2570         VkViewportCoordinateSwizzleNV   w;
2571 };
2572
2573 struct VkPipelineViewportSwizzleStateCreateInfoNV
2574 {
2575         VkStructureType                                                         sType;
2576         const void*                                                                     pNext;
2577         VkPipelineViewportSwizzleStateCreateFlagsNV     flags;
2578         deUint32                                                                        viewportCount;
2579         const VkViewportSwizzleNV*                                      pViewportSwizzles;
2580 };
2581
2582 struct VkPhysicalDeviceDiscardRectanglePropertiesEXT
2583 {
2584         VkStructureType sType;
2585         void*                   pNext;
2586         deUint32                maxDiscardRectangles;
2587 };
2588
2589 struct VkPipelineDiscardRectangleStateCreateInfoEXT
2590 {
2591         VkStructureType                                                                 sType;
2592         const void*                                                                             pNext;
2593         VkPipelineDiscardRectangleStateCreateFlagsEXT   flags;
2594         VkDiscardRectangleModeEXT                                               discardRectangleMode;
2595         deUint32                                                                                discardRectangleCount;
2596         const VkRect2D*                                                                 pDiscardRectangles;
2597 };
2598
2599 struct VkXYColorEXT
2600 {
2601         float   x;
2602         float   y;
2603 };
2604
2605 struct VkHdrMetadataEXT
2606 {
2607         VkStructureType sType;
2608         const void*             pNext;
2609         VkXYColorEXT    displayPrimaryRed;
2610         VkXYColorEXT    displayPrimaryGreen;
2611         VkXYColorEXT    displayPrimaryBlue;
2612         VkXYColorEXT    whitePoint;
2613         float                   maxLuminance;
2614         float                   minLuminance;
2615         float                   maxContentLightLevel;
2616         float                   maxFrameAverageLightLevel;
2617 };
2618
2619 struct VkIOSSurfaceCreateInfoMVK
2620 {
2621         VkStructureType                         sType;
2622         const void*                                     pNext;
2623         VkIOSSurfaceCreateFlagsMVK      flags;
2624         const void*                                     pView;
2625 };
2626
2627 struct VkMacOSSurfaceCreateInfoMVK
2628 {
2629         VkStructureType                                 sType;
2630         const void*                                             pNext;
2631         VkMacOSSurfaceCreateFlagsMVK    flags;
2632         const void*                                             pView;
2633 };
2634
2635 struct VkSamplerReductionModeCreateInfoEXT
2636 {
2637         VkStructureType                         sType;
2638         const void*                                     pNext;
2639         VkSamplerReductionModeEXT       reductionMode;
2640 };
2641
2642 struct VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT
2643 {
2644         VkStructureType sType;
2645         void*                   pNext;
2646         VkBool32                filterMinmaxSingleComponentFormats;
2647         VkBool32                filterMinmaxImageComponentMapping;
2648 };
2649
2650 struct VkSampleLocationEXT
2651 {
2652         float   x;
2653         float   y;
2654 };
2655
2656 struct VkSampleLocationsInfoEXT
2657 {
2658         VkStructureType                         sType;
2659         const void*                                     pNext;
2660         VkSampleCountFlagBits           sampleLocationsPerPixel;
2661         VkExtent2D                                      sampleLocationGridSize;
2662         deUint32                                        sampleLocationsCount;
2663         const VkSampleLocationEXT*      pSampleLocations;
2664 };
2665
2666 struct VkAttachmentSampleLocationsEXT
2667 {
2668         deUint32                                        attachmentIndex;
2669         VkSampleLocationsInfoEXT        sampleLocationsInfo;
2670 };
2671
2672 struct VkSubpassSampleLocationsEXT
2673 {
2674         deUint32                                        subpassIndex;
2675         VkSampleLocationsInfoEXT        sampleLocationsInfo;
2676 };
2677
2678 struct VkRenderPassSampleLocationsBeginInfoEXT
2679 {
2680         VkStructureType                                                 sType;
2681         const void*                                                             pNext;
2682         deUint32                                                                attachmentInitialSampleLocationsCount;
2683         const VkAttachmentSampleLocationsEXT*   pAttachmentInitialSampleLocations;
2684         deUint32                                                                postSubpassSampleLocationsCount;
2685         const VkSubpassSampleLocationsEXT*              pSubpassSampleLocations;
2686 };
2687
2688 struct VkPipelineSampleLocationsStateCreateInfoEXT
2689 {
2690         VkStructureType                         sType;
2691         const void*                                     pNext;
2692         VkBool32                                        sampleLocationsEnable;
2693         VkSampleLocationsInfoEXT        sampleLocationsInfo;
2694 };
2695
2696 struct VkPhysicalDeviceSampleLocationsPropertiesEXT
2697 {
2698         VkStructureType         sType;
2699         void*                           pNext;
2700         VkSampleCountFlags      sampleLocationSampleCounts;
2701         VkExtent2D                      maxSampleLocationGridSize;
2702         float                           sampleLocationCoordinateRange[2];
2703         deUint32                        sampleLocationSubPixelBits;
2704         VkBool32                        variableSampleLocations;
2705 };
2706
2707 struct VkMultisamplePropertiesEXT
2708 {
2709         VkStructureType sType;
2710         void*                   pNext;
2711         VkExtent2D              maxSampleLocationGridSize;
2712 };
2713
2714 struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT
2715 {
2716         VkStructureType sType;
2717         void*                   pNext;
2718         VkBool32                advancedBlendCoherentOperations;
2719 };
2720
2721 struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT
2722 {
2723         VkStructureType sType;
2724         void*                   pNext;
2725         deUint32                advancedBlendMaxColorAttachments;
2726         VkBool32                advancedBlendIndependentBlend;
2727         VkBool32                advancedBlendNonPremultipliedSrcColor;
2728         VkBool32                advancedBlendNonPremultipliedDstColor;
2729         VkBool32                advancedBlendCorrelatedOverlap;
2730         VkBool32                advancedBlendAllOperations;
2731 };
2732
2733 struct VkPipelineColorBlendAdvancedStateCreateInfoEXT
2734 {
2735         VkStructureType         sType;
2736         const void*                     pNext;
2737         VkBool32                        srcPremultiplied;
2738         VkBool32                        dstPremultiplied;
2739         VkBlendOverlapEXT       blendOverlap;
2740 };
2741
2742 struct VkPipelineCoverageToColorStateCreateInfoNV
2743 {
2744         VkStructureType                                                         sType;
2745         const void*                                                                     pNext;
2746         VkPipelineCoverageToColorStateCreateFlagsNV     flags;
2747         VkBool32                                                                        coverageToColorEnable;
2748         deUint32                                                                        coverageToColorLocation;
2749 };
2750
2751 struct VkPipelineCoverageModulationStateCreateInfoNV
2752 {
2753         VkStructureType                                                                 sType;
2754         const void*                                                                             pNext;
2755         VkPipelineCoverageModulationStateCreateFlagsNV  flags;
2756         VkCoverageModulationModeNV                                              coverageModulationMode;
2757         VkBool32                                                                                coverageModulationTableEnable;
2758         deUint32                                                                                coverageModulationTableCount;
2759         const float*                                                                    pCoverageModulationTable;
2760 };
2761
2762 struct VkValidationCacheCreateInfoEXT
2763 {
2764         VkStructureType                                 sType;
2765         const void*                                             pNext;
2766         VkValidationCacheCreateFlagsEXT flags;
2767         deUintptr                                               initialDataSize;
2768         const void*                                             pInitialData;
2769 };
2770
2771 struct VkShaderModuleValidationCacheCreateInfoEXT
2772 {
2773         VkStructureType                 sType;
2774         const void*                             pNext;
2775         VkValidationCacheEXT    validationCache;
2776 };
2777
2778 struct VkPhysicalDeviceAndroidHardwareBufferInfoANDROID
2779 {
2780         VkStructureType         sType;
2781         void*                           pNext;
2782         VkFormat                        format;
2783         VkImageTiling           tiling;
2784         VkImageUsageFlags       imageUsage;
2785         VkImageCreateFlags      imageFlags;
2786 };
2787
2788 struct VkAndroidHardwareBufferUsageANDROID
2789 {
2790         VkStructureType sType;
2791         void*                   pNext;
2792         deUint64                androidHardwareBufferUsage;
2793 };
2794
2795 struct VkMemoryAndroidHardwareBufferPropertiesANDROID
2796 {
2797         VkStructureType sType;
2798         void*                   pNext;
2799         VkDeviceSize    allocationSize;
2800         deUint32                memoryTypeBits;
2801 };
2802
2803 struct VkImportAndroidHardwareBufferInfoANDROID
2804 {
2805         VkStructureType                                 sType;
2806         const void*                                             pNext;
2807         pt::AndroidHardwareBufferPtr    buffer;
2808 };
2809
2810 struct VkMemoryGetAndroidHardwareBufferInfoANDROID
2811 {
2812         VkStructureType sType;
2813         void*                   pNext;
2814         VkDeviceMemory  memory;
2815 };
2816
2817 struct VkAndroidHardwareBufferExternalFormatPropertiesANDROID
2818 {
2819         VkStructureType                                 sType;
2820         void*                                                   pNext;
2821         deUint32                                                externalFormat;
2822         VkFormatFeatureFlags                    formatFeatures;
2823         VkSamplerYcbcrModelConversion   suggestedYcbcrModel;
2824         VkSamplerYcbcrRange                             suggestedYcbcrRange;
2825         VkChromaLocation                                suggestedXChromaOffset;
2826         VkChromaLocation                                suggestedYChromaOffset;
2827 };
2828
2829 struct VkExternalFormatANDROID
2830 {
2831         VkStructureType sType;
2832         void*                   pNext;
2833         deUint32                externalFormat;
2834 };
2835
2836
2837
2838
2839
2840
2841
2842
2843
2844
2845
2846
2847
2848
2849
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
2867
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2883
2884
2885
2886
2887
2888
2889
2890
2891
2892
2893
2894
2895
2896
2897