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 VkSurfaceCapabilitiesKHR
1187 {
1188         deUint32                                                minImageCount;
1189         deUint32                                                maxImageCount;
1190         VkExtent2D                                              currentExtent;
1191         VkExtent2D                                              minImageExtent;
1192         VkExtent2D                                              maxImageExtent;
1193         deUint32                                                maxImageArrayLayers;
1194         VkSurfaceTransformFlagsKHR              supportedTransforms;
1195         VkSurfaceTransformFlagBitsKHR   currentTransform;
1196         VkCompositeAlphaFlagsKHR                supportedCompositeAlpha;
1197         VkImageUsageFlags                               supportedUsageFlags;
1198 };
1199
1200 struct VkSurfaceFormatKHR
1201 {
1202         VkFormat                format;
1203         VkColorSpaceKHR colorSpace;
1204 };
1205
1206 struct VkSwapchainCreateInfoKHR
1207 {
1208         VkStructureType                                 sType;
1209         const void*                                             pNext;
1210         VkSwapchainCreateFlagsKHR               flags;
1211         VkSurfaceKHR                                    surface;
1212         deUint32                                                minImageCount;
1213         VkFormat                                                imageFormat;
1214         VkColorSpaceKHR                                 imageColorSpace;
1215         VkExtent2D                                              imageExtent;
1216         deUint32                                                imageArrayLayers;
1217         VkImageUsageFlags                               imageUsage;
1218         VkSharingMode                                   imageSharingMode;
1219         deUint32                                                queueFamilyIndexCount;
1220         const deUint32*                                 pQueueFamilyIndices;
1221         VkSurfaceTransformFlagBitsKHR   preTransform;
1222         VkCompositeAlphaFlagBitsKHR             compositeAlpha;
1223         VkPresentModeKHR                                presentMode;
1224         VkBool32                                                clipped;
1225         VkSwapchainKHR                                  oldSwapchain;
1226 };
1227
1228 struct VkPresentInfoKHR
1229 {
1230         VkStructureType                 sType;
1231         const void*                             pNext;
1232         deUint32                                waitSemaphoreCount;
1233         const VkSemaphore*              pWaitSemaphores;
1234         deUint32                                swapchainCount;
1235         const VkSwapchainKHR*   pSwapchains;
1236         const deUint32*                 pImageIndices;
1237         VkResult*                               pResults;
1238 };
1239
1240 struct VkDisplayPropertiesKHR
1241 {
1242         VkDisplayKHR                            display;
1243         const char*                                     displayName;
1244         VkExtent2D                                      physicalDimensions;
1245         VkExtent2D                                      physicalResolution;
1246         VkSurfaceTransformFlagsKHR      supportedTransforms;
1247         VkBool32                                        planeReorderPossible;
1248         VkBool32                                        persistentContent;
1249 };
1250
1251 struct VkDisplayModeParametersKHR
1252 {
1253         VkExtent2D      visibleRegion;
1254         deUint32        refreshRate;
1255 };
1256
1257 struct VkDisplayModePropertiesKHR
1258 {
1259         VkDisplayModeKHR                        displayMode;
1260         VkDisplayModeParametersKHR      parameters;
1261 };
1262
1263 struct VkDisplayModeCreateInfoKHR
1264 {
1265         VkStructureType                         sType;
1266         const void*                                     pNext;
1267         VkDisplayModeCreateFlagsKHR     flags;
1268         VkDisplayModeParametersKHR      parameters;
1269 };
1270
1271 struct VkDisplayPlaneCapabilitiesKHR
1272 {
1273         VkDisplayPlaneAlphaFlagsKHR     supportedAlpha;
1274         VkOffset2D                                      minSrcPosition;
1275         VkOffset2D                                      maxSrcPosition;
1276         VkExtent2D                                      minSrcExtent;
1277         VkExtent2D                                      maxSrcExtent;
1278         VkOffset2D                                      minDstPosition;
1279         VkOffset2D                                      maxDstPosition;
1280         VkExtent2D                                      minDstExtent;
1281         VkExtent2D                                      maxDstExtent;
1282 };
1283
1284 struct VkDisplayPlanePropertiesKHR
1285 {
1286         VkDisplayKHR    currentDisplay;
1287         deUint32                currentStackIndex;
1288 };
1289
1290 struct VkDisplaySurfaceCreateInfoKHR
1291 {
1292         VkStructureType                                 sType;
1293         const void*                                             pNext;
1294         VkDisplaySurfaceCreateFlagsKHR  flags;
1295         VkDisplayModeKHR                                displayMode;
1296         deUint32                                                planeIndex;
1297         deUint32                                                planeStackIndex;
1298         VkSurfaceTransformFlagBitsKHR   transform;
1299         float                                                   globalAlpha;
1300         VkDisplayPlaneAlphaFlagBitsKHR  alphaMode;
1301         VkExtent2D                                              imageExtent;
1302 };
1303
1304 struct VkDisplayPresentInfoKHR
1305 {
1306         VkStructureType sType;
1307         const void*             pNext;
1308         VkRect2D                srcRect;
1309         VkRect2D                dstRect;
1310         VkBool32                persistent;
1311 };
1312
1313 struct VkXlibSurfaceCreateInfoKHR
1314 {
1315         VkStructureType                         sType;
1316         const void*                                     pNext;
1317         VkXlibSurfaceCreateFlagsKHR     flags;
1318         pt::XlibDisplayPtr                      dpy;
1319         pt::XlibWindow                          window;
1320 };
1321
1322 struct VkXcbSurfaceCreateInfoKHR
1323 {
1324         VkStructureType                         sType;
1325         const void*                                     pNext;
1326         VkXcbSurfaceCreateFlagsKHR      flags;
1327         pt::XcbConnectionPtr            connection;
1328         pt::XcbWindow                           window;
1329 };
1330
1331 struct VkWaylandSurfaceCreateInfoKHR
1332 {
1333         VkStructureType                                 sType;
1334         const void*                                             pNext;
1335         VkWaylandSurfaceCreateFlagsKHR  flags;
1336         pt::WaylandDisplayPtr                   display;
1337         pt::WaylandSurfacePtr                   surface;
1338 };
1339
1340 struct VkMirSurfaceCreateInfoKHR
1341 {
1342         VkStructureType                         sType;
1343         const void*                                     pNext;
1344         VkMirSurfaceCreateFlagsKHR      flags;
1345         pt::MirConnectionPtr            connection;
1346         pt::MirSurfacePtr                       mirSurface;
1347 };
1348
1349 struct VkAndroidSurfaceCreateInfoKHR
1350 {
1351         VkStructureType                                 sType;
1352         const void*                                             pNext;
1353         VkAndroidSurfaceCreateFlagsKHR  flags;
1354         pt::AndroidNativeWindowPtr              window;
1355 };
1356
1357 struct VkWin32SurfaceCreateInfoKHR
1358 {
1359         VkStructureType                                 sType;
1360         const void*                                             pNext;
1361         VkWin32SurfaceCreateFlagsKHR    flags;
1362         pt::Win32InstanceHandle                 hinstance;
1363         pt::Win32WindowHandle                   hwnd;
1364 };
1365
1366 struct VkPhysicalDeviceFeatures2KHR
1367 {
1368         VkStructureType                         sType;
1369         void*                                           pNext;
1370         VkPhysicalDeviceFeatures        features;
1371 };
1372
1373 struct VkPhysicalDeviceProperties2KHR
1374 {
1375         VkStructureType                         sType;
1376         void*                                           pNext;
1377         VkPhysicalDeviceProperties      properties;
1378 };
1379
1380 struct VkFormatProperties2KHR
1381 {
1382         VkStructureType         sType;
1383         void*                           pNext;
1384         VkFormatProperties      formatProperties;
1385 };
1386
1387 struct VkImageFormatProperties2KHR
1388 {
1389         VkStructureType                 sType;
1390         void*                                   pNext;
1391         VkImageFormatProperties imageFormatProperties;
1392 };
1393
1394 struct VkPhysicalDeviceImageFormatInfo2KHR
1395 {
1396         VkStructureType         sType;
1397         const void*                     pNext;
1398         VkFormat                        format;
1399         VkImageType                     type;
1400         VkImageTiling           tiling;
1401         VkImageUsageFlags       usage;
1402         VkImageCreateFlags      flags;
1403 };
1404
1405 struct VkQueueFamilyProperties2KHR
1406 {
1407         VkStructureType                 sType;
1408         void*                                   pNext;
1409         VkQueueFamilyProperties queueFamilyProperties;
1410 };
1411
1412 struct VkPhysicalDeviceMemoryProperties2KHR
1413 {
1414         VkStructureType                                         sType;
1415         void*                                                           pNext;
1416         VkPhysicalDeviceMemoryProperties        memoryProperties;
1417 };
1418
1419 struct VkSparseImageFormatProperties2KHR
1420 {
1421         VkStructureType                                 sType;
1422         void*                                                   pNext;
1423         VkSparseImageFormatProperties   properties;
1424 };
1425
1426 struct VkPhysicalDeviceSparseImageFormatInfo2KHR
1427 {
1428         VkStructureType                 sType;
1429         const void*                             pNext;
1430         VkFormat                                format;
1431         VkImageType                             type;
1432         VkSampleCountFlagBits   samples;
1433         VkImageUsageFlags               usage;
1434         VkImageTiling                   tiling;
1435 };
1436
1437 struct VkPhysicalDevicePushDescriptorPropertiesKHR
1438 {
1439         VkStructureType sType;
1440         void*                   pNext;
1441         deUint32                maxPushDescriptors;
1442 };
1443
1444 struct VkPhysicalDevice16BitStorageFeaturesKHR
1445 {
1446         VkStructureType sType;
1447         void*                   pNext;
1448         VkBool32                storageBuffer16BitAccess;
1449         VkBool32                uniformAndStorageBuffer16BitAccess;
1450         VkBool32                storagePushConstant16;
1451         VkBool32                storageInputOutput16;
1452 };
1453
1454 struct VkRectLayerKHR
1455 {
1456         VkOffset2D      offset;
1457         VkExtent2D      extent;
1458         deUint32        layer;
1459 };
1460
1461 struct VkPresentRegionKHR
1462 {
1463         deUint32                                rectangleCount;
1464         const VkRectLayerKHR*   pRectangles;
1465 };
1466
1467 struct VkPresentRegionsKHR
1468 {
1469         VkStructureType                         sType;
1470         const void*                                     pNext;
1471         deUint32                                        swapchainCount;
1472         const VkPresentRegionKHR*       pRegions;
1473 };
1474
1475 struct VkDescriptorUpdateTemplateEntryKHR
1476 {
1477         deUint32                        dstBinding;
1478         deUint32                        dstArrayElement;
1479         deUint32                        descriptorCount;
1480         VkDescriptorType        descriptorType;
1481         deUintptr                       offset;
1482         deUintptr                       stride;
1483 };
1484
1485 struct VkDescriptorUpdateTemplateCreateInfoKHR
1486 {
1487         VkStructureType                                                         sType;
1488         void*                                                                           pNext;
1489         VkDescriptorUpdateTemplateCreateFlagsKHR        flags;
1490         deUint32                                                                        descriptorUpdateEntryCount;
1491         const VkDescriptorUpdateTemplateEntryKHR*       pDescriptorUpdateEntries;
1492         VkDescriptorUpdateTemplateTypeKHR                       templateType;
1493         VkDescriptorSetLayout                                           descriptorSetLayout;
1494         VkPipelineBindPoint                                                     pipelineBindPoint;
1495         VkPipelineLayout                                                        pipelineLayout;
1496         deUint32                                                                        set;
1497 };
1498
1499 struct VkSharedPresentSurfaceCapabilitiesKHR
1500 {
1501         VkStructureType         sType;
1502         void*                           pNext;
1503         VkImageUsageFlags       sharedPresentSupportedUsageFlags;
1504 };
1505
1506 struct VkPhysicalDevicePointClippingPropertiesKHR
1507 {
1508         VkStructureType                         sType;
1509         void*                                           pNext;
1510         VkPointClippingBehaviorKHR      pointClippingBehavior;
1511 };
1512
1513 struct VkInputAttachmentAspectReferenceKHR
1514 {
1515         deUint32                        subpass;
1516         deUint32                        inputAttachmentIndex;
1517         VkImageAspectFlags      aspectMask;
1518 };
1519
1520 struct VkRenderPassInputAttachmentAspectCreateInfoKHR
1521 {
1522         VkStructureType                                                         sType;
1523         const void*                                                                     pNext;
1524         deUint32                                                                        aspectReferenceCount;
1525         const VkInputAttachmentAspectReferenceKHR*      pAspectReferences;
1526 };
1527
1528 struct VkImageViewUsageCreateInfoKHR
1529 {
1530         VkStructureType         sType;
1531         const void*                     pNext;
1532         VkImageUsageFlags       usage;
1533 };
1534
1535 struct VkPipelineTessellationDomainOriginStateCreateInfoKHR
1536 {
1537         VkStructureType                                 sType;
1538         const void*                                             pNext;
1539         VkTessellationDomainOriginKHR   domainOrigin;
1540 };
1541
1542 struct VkPhysicalDeviceSurfaceInfo2KHR
1543 {
1544         VkStructureType sType;
1545         const void*             pNext;
1546         VkSurfaceKHR    surface;
1547 };
1548
1549 struct VkSurfaceCapabilities2KHR
1550 {
1551         VkStructureType                         sType;
1552         void*                                           pNext;
1553         VkSurfaceCapabilitiesKHR        surfaceCapabilities;
1554 };
1555
1556 struct VkSurfaceFormat2KHR
1557 {
1558         VkStructureType         sType;
1559         void*                           pNext;
1560         VkSurfaceFormatKHR      surfaceFormat;
1561 };
1562
1563 struct VkPhysicalDeviceExternalFenceInfoKHR
1564 {
1565         VkStructureType                                                 sType;
1566         const void*                                                             pNext;
1567         VkExternalFenceHandleTypeFlagBitsKHR    handleType;
1568 };
1569
1570 struct VkExternalFencePropertiesKHR
1571 {
1572         VkStructureType                                         sType;
1573         void*                                                           pNext;
1574         VkExternalFenceHandleTypeFlagsKHR       exportFromImportedHandleTypes;
1575         VkExternalFenceHandleTypeFlagsKHR       compatibleHandleTypes;
1576         VkExternalFenceFeatureFlagsKHR          externalFenceFeatures;
1577 };
1578
1579 struct VkExportFenceCreateInfoKHR
1580 {
1581         VkStructureType                                         sType;
1582         const void*                                                     pNext;
1583         VkExternalFenceHandleTypeFlagsKHR       handleTypes;
1584 };
1585
1586 struct VkImportFenceWin32HandleInfoKHR
1587 {
1588         VkStructureType                                                 sType;
1589         const void*                                                             pNext;
1590         VkFence                                                                 fence;
1591         VkFenceImportFlagsKHR                                   flags;
1592         VkExternalFenceHandleTypeFlagBitsKHR    handleType;
1593         pt::Win32Handle                                                 handle;
1594         char*                                                                   name;
1595 };
1596
1597 struct VkExportFenceWin32HandleInfoKHR
1598 {
1599         VkStructureType                                 sType;
1600         const void*                                             pNext;
1601         pt::Win32SecurityAttributesPtr  pAttributes;
1602         deUint32                                                dwAccess;
1603         char*                                                   name;
1604 };
1605
1606 struct VkFenceGetWin32HandleInfoKHR
1607 {
1608         VkStructureType                                                 sType;
1609         const void*                                                             pNext;
1610         VkFence                                                                 fence;
1611         VkExternalFenceHandleTypeFlagBitsKHR    handleType;
1612 };
1613
1614 struct VkImportFenceFdInfoKHR
1615 {
1616         VkStructureType                                                 sType;
1617         const void*                                                             pNext;
1618         VkFence                                                                 fence;
1619         VkFenceImportFlagsKHR                                   flags;
1620         VkExternalFenceHandleTypeFlagBitsKHR    handleType;
1621         int                                                                             fd;
1622 };
1623
1624 struct VkFenceGetFdInfoKHR
1625 {
1626         VkStructureType                                                 sType;
1627         const void*                                                             pNext;
1628         VkFence                                                                 fence;
1629         VkExternalFenceHandleTypeFlagBitsKHR    handleType;
1630 };
1631
1632 struct VkMemoryDedicatedRequirementsKHR
1633 {
1634         VkStructureType sType;
1635         void*                   pNext;
1636         VkBool32                prefersDedicatedAllocation;
1637         VkBool32                requiresDedicatedAllocation;
1638 };
1639
1640 struct VkMemoryDedicatedAllocateInfoKHR
1641 {
1642         VkStructureType sType;
1643         const void*             pNext;
1644         VkImage                 image;
1645         VkBuffer                buffer;
1646 };
1647
1648 struct VkBufferMemoryRequirementsInfo2KHR
1649 {
1650         VkStructureType sType;
1651         const void*             pNext;
1652         VkBuffer                buffer;
1653 };
1654
1655 struct VkImageMemoryRequirementsInfo2KHR
1656 {
1657         VkStructureType sType;
1658         const void*             pNext;
1659         VkImage                 image;
1660 };
1661
1662 struct VkImageSparseMemoryRequirementsInfo2KHR
1663 {
1664         VkStructureType sType;
1665         const void*             pNext;
1666         VkImage                 image;
1667 };
1668
1669 struct VkMemoryRequirements2KHR
1670 {
1671         VkStructureType                 sType;
1672         void*                                   pNext;
1673         VkMemoryRequirements    memoryRequirements;
1674 };
1675
1676 struct VkSparseImageMemoryRequirements2KHR
1677 {
1678         VkStructureType                                 sType;
1679         void*                                                   pNext;
1680         VkSparseImageMemoryRequirements memoryRequirements;
1681 };
1682
1683 struct VkImageFormatListCreateInfoKHR
1684 {
1685         VkStructureType sType;
1686         const void*             pNext;
1687         deUint32                viewFormatCount;
1688         const VkFormat* pViewFormats;
1689 };
1690
1691 struct VkDebugReportCallbackCreateInfoEXT
1692 {
1693         VkStructureType                                 sType;
1694         const void*                                             pNext;
1695         VkDebugReportFlagsEXT                   flags;
1696         PFN_vkDebugReportCallbackEXT    pfnCallback;
1697         void*                                                   pUserData;
1698 };
1699
1700 struct VkRenderPassMultiviewCreateInfoKHX
1701 {
1702         VkStructureType sType;
1703         const void*             pNext;
1704         deUint32                subpassCount;
1705         const deUint32* pViewMasks;
1706         deUint32                dependencyCount;
1707         const deInt32*  pViewOffsets;
1708         deUint32                correlationMaskCount;
1709         const deUint32* pCorrelationMasks;
1710 };
1711
1712 struct VkPhysicalDeviceMultiviewFeaturesKHX
1713 {
1714         VkStructureType sType;
1715         void*                   pNext;
1716         VkBool32                multiview;
1717         VkBool32                multiviewGeometryShader;
1718         VkBool32                multiviewTessellationShader;
1719 };
1720
1721 struct VkPhysicalDeviceMultiviewPropertiesKHX
1722 {
1723         VkStructureType sType;
1724         void*                   pNext;
1725         deUint32                maxMultiviewViewCount;
1726         deUint32                maxMultiviewInstanceIndex;
1727 };
1728
1729 struct VkExternalMemoryPropertiesKHR
1730 {
1731         VkExternalMemoryFeatureFlagsKHR         externalMemoryFeatures;
1732         VkExternalMemoryHandleTypeFlagsKHR      exportFromImportedHandleTypes;
1733         VkExternalMemoryHandleTypeFlagsKHR      compatibleHandleTypes;
1734 };
1735
1736 struct VkPhysicalDeviceExternalImageFormatInfoKHR
1737 {
1738         VkStructureType                                                 sType;
1739         const void*                                                             pNext;
1740         VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
1741 };
1742
1743 struct VkExternalImageFormatPropertiesKHR
1744 {
1745         VkStructureType                                 sType;
1746         void*                                                   pNext;
1747         VkExternalMemoryPropertiesKHR   externalMemoryProperties;
1748 };
1749
1750 struct VkPhysicalDeviceExternalBufferInfoKHR
1751 {
1752         VkStructureType                                                 sType;
1753         const void*                                                             pNext;
1754         VkBufferCreateFlags                                             flags;
1755         VkBufferUsageFlags                                              usage;
1756         VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
1757 };
1758
1759 struct VkExternalBufferPropertiesKHR
1760 {
1761         VkStructureType                                 sType;
1762         void*                                                   pNext;
1763         VkExternalMemoryPropertiesKHR   externalMemoryProperties;
1764 };
1765
1766 struct VkPhysicalDeviceIDPropertiesKHR
1767 {
1768         VkStructureType sType;
1769         void*                   pNext;
1770         deUint8                 deviceUUID[VK_UUID_SIZE];
1771         deUint8                 driverUUID[VK_UUID_SIZE];
1772         deUint8                 deviceLUID[VK_LUID_SIZE_KHR];
1773         deUint32                deviceNodeMask;
1774         VkBool32                deviceLUIDValid;
1775 };
1776
1777 struct VkExternalMemoryImageCreateInfoKHR
1778 {
1779         VkStructureType                                         sType;
1780         const void*                                                     pNext;
1781         VkExternalMemoryHandleTypeFlagsKHR      handleTypes;
1782 };
1783
1784 struct VkExternalMemoryBufferCreateInfoKHR
1785 {
1786         VkStructureType                                         sType;
1787         const void*                                                     pNext;
1788         VkExternalMemoryHandleTypeFlagsKHR      handleTypes;
1789 };
1790
1791 struct VkExportMemoryAllocateInfoKHR
1792 {
1793         VkStructureType                                         sType;
1794         const void*                                                     pNext;
1795         VkExternalMemoryHandleTypeFlagsKHR      handleTypes;
1796 };
1797
1798 struct VkImportMemoryWin32HandleInfoKHR
1799 {
1800         VkStructureType                                                 sType;
1801         const void*                                                             pNext;
1802         VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
1803         pt::Win32Handle                                                 handle;
1804         char*                                                                   name;
1805 };
1806
1807 struct VkExportMemoryWin32HandleInfoKHR
1808 {
1809         VkStructureType                                 sType;
1810         const void*                                             pNext;
1811         pt::Win32SecurityAttributesPtr  pAttributes;
1812         deUint32                                                dwAccess;
1813         char*                                                   name;
1814 };
1815
1816 struct VkMemoryWin32HandlePropertiesKHR
1817 {
1818         VkStructureType sType;
1819         void*                   pNext;
1820         deUint32                memoryTypeBits;
1821 };
1822
1823 struct VkMemoryGetWin32HandleInfoKHR
1824 {
1825         VkStructureType                                                 sType;
1826         const void*                                                             pNext;
1827         VkDeviceMemory                                                  memory;
1828         VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
1829 };
1830
1831 struct VkImportMemoryFdInfoKHR
1832 {
1833         VkStructureType                                                 sType;
1834         const void*                                                             pNext;
1835         VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
1836         int                                                                             fd;
1837 };
1838
1839 struct VkMemoryFdPropertiesKHR
1840 {
1841         VkStructureType sType;
1842         void*                   pNext;
1843         deUint32                memoryTypeBits;
1844 };
1845
1846 struct VkMemoryGetFdInfoKHR
1847 {
1848         VkStructureType                                                 sType;
1849         const void*                                                             pNext;
1850         VkDeviceMemory                                                  memory;
1851         VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
1852 };
1853
1854 struct VkWin32KeyedMutexAcquireReleaseInfoKHR
1855 {
1856         VkStructureType                 sType;
1857         const void*                             pNext;
1858         deUint32                                acquireCount;
1859         const VkDeviceMemory*   pAcquireSyncs;
1860         const deUint64*                 pAcquireKeys;
1861         const deUint32*                 pAcquireTimeouts;
1862         deUint32                                releaseCount;
1863         const VkDeviceMemory*   pReleaseSyncs;
1864         const deUint64*                 pReleaseKeys;
1865 };
1866
1867 struct VkPhysicalDeviceExternalSemaphoreInfoKHR
1868 {
1869         VkStructureType                                                         sType;
1870         const void*                                                                     pNext;
1871         VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
1872 };
1873
1874 struct VkExternalSemaphorePropertiesKHR
1875 {
1876         VkStructureType                                                 sType;
1877         void*                                                                   pNext;
1878         VkExternalSemaphoreHandleTypeFlagsKHR   exportFromImportedHandleTypes;
1879         VkExternalSemaphoreHandleTypeFlagsKHR   compatibleHandleTypes;
1880         VkExternalSemaphoreFeatureFlagsKHR              externalSemaphoreFeatures;
1881 };
1882
1883 struct VkExportSemaphoreCreateInfoKHR
1884 {
1885         VkStructureType                                                 sType;
1886         const void*                                                             pNext;
1887         VkExternalSemaphoreHandleTypeFlagsKHR   handleTypes;
1888 };
1889
1890 struct VkImportSemaphoreWin32HandleInfoKHR
1891 {
1892         VkStructureType                                                         sType;
1893         const void*                                                                     pNext;
1894         VkSemaphore                                                                     semaphore;
1895         VkSemaphoreImportFlagsKHR                                       flags;
1896         VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
1897         pt::Win32Handle                                                         handle;
1898         char*                                                                           name;
1899 };
1900
1901 struct VkExportSemaphoreWin32HandleInfoKHR
1902 {
1903         VkStructureType                                 sType;
1904         const void*                                             pNext;
1905         pt::Win32SecurityAttributesPtr  pAttributes;
1906         deUint32                                                dwAccess;
1907         char*                                                   name;
1908 };
1909
1910 struct VkD3D12FenceSubmitInfoKHR
1911 {
1912         VkStructureType sType;
1913         const void*             pNext;
1914         deUint32                waitSemaphoreValuesCount;
1915         const deUint64* pWaitSemaphoreValues;
1916         deUint32                signalSemaphoreValuesCount;
1917         const deUint64* pSignalSemaphoreValues;
1918 };
1919
1920 struct VkSemaphoreGetWin32HandleInfoKHR
1921 {
1922         VkStructureType                                                         sType;
1923         const void*                                                                     pNext;
1924         VkSemaphore                                                                     semaphore;
1925         VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
1926 };
1927
1928 struct VkImportSemaphoreFdInfoKHR
1929 {
1930         VkStructureType                                                         sType;
1931         const void*                                                                     pNext;
1932         VkSemaphore                                                                     semaphore;
1933         VkSemaphoreImportFlagsKHR                                       flags;
1934         VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
1935         int                                                                                     fd;
1936 };
1937
1938 struct VkSemaphoreGetFdInfoKHR
1939 {
1940         VkStructureType                                                         sType;
1941         const void*                                                                     pNext;
1942         VkSemaphore                                                                     semaphore;
1943         VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
1944 };
1945
1946 struct VkRefreshCycleDurationGOOGLE
1947 {
1948         deUint64        refreshDuration;
1949 };
1950
1951 struct VkPastPresentationTimingGOOGLE
1952 {
1953         deUint32        presentID;
1954         deUint64        desiredPresentTime;
1955         deUint64        actualPresentTime;
1956         deUint64        earliestPresentTime;
1957         deUint64        presentMargin;
1958 };
1959
1960 struct VkPresentTimeGOOGLE
1961 {
1962         deUint32        presentID;
1963         deUint64        desiredPresentTime;
1964 };
1965
1966 struct VkPresentTimesInfoGOOGLE
1967 {
1968         VkStructureType                         sType;
1969         const void*                                     pNext;
1970         deUint32                                        swapchainCount;
1971         const VkPresentTimeGOOGLE*      pTimes;
1972 };
1973
1974 struct VkPhysicalDeviceVariablePointerFeaturesKHR
1975 {
1976         VkStructureType sType;
1977         const void*             pNext;
1978         VkBool32                variablePointersStorageBuffer;
1979         VkBool32                variablePointers;
1980 };
1981
1982 struct VkBindBufferMemoryInfoKHR
1983 {
1984         VkStructureType sType;
1985         const void*             pNext;
1986         VkBuffer                buffer;
1987         VkDeviceMemory  memory;
1988         VkDeviceSize    memoryOffset;
1989 };
1990
1991 struct VkBindImageMemoryInfoKHR
1992 {
1993         VkStructureType sType;
1994         const void*             pNext;
1995         VkImage                 image;
1996         VkDeviceMemory  memory;
1997         VkDeviceSize    memoryOffset;
1998 };
1999