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                                        enabledLayerNameCount;
  22         const char* const*                      ppEnabledLayerNames;
  23         deUint32                                        enabledExtensionNameCount;
  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        depthClamp;
  50         VkBool32        depthBiasClamp;
  51         VkBool32        fillModeNonSolid;
  52         VkBool32        depthBounds;
  53         VkBool32        wideLines;
  54         VkBool32        largePoints;
  55         VkBool32        alphaToOne;
  56         VkBool32        multiViewport;
  57         VkBool32        samplerAnisotropy;
  58         VkBool32        textureCompressionETC2;
  59         VkBool32        textureCompressionASTC_LDR;
  60         VkBool32        textureCompressionBC;
  61         VkBool32        occlusionQueryPrecise;
  62         VkBool32        pipelineStatisticsQuery;
  63         VkBool32        vertexPipelineStoresAndAtomics;
  64         VkBool32        fragmentStoresAndAtomics;
  65         VkBool32        shaderTessellationAndGeometryPointSize;
  66         VkBool32        shaderImageGatherExtended;
  67         VkBool32        shaderStorageImageExtendedFormats;
  68         VkBool32        shaderStorageImageMultisample;
  69         VkBool32        shaderStorageImageReadWithoutFormat;
  70         VkBool32        shaderStorageImageWriteWithoutFormat;
  71         VkBool32        shaderUniformBufferArrayDynamicIndexing;
  72         VkBool32        shaderSampledImageArrayDynamicIndexing;
  73         VkBool32        shaderStorageBufferArrayDynamicIndexing;
  74         VkBool32        shaderStorageImageArrayDynamicIndexing;
  75         VkBool32        shaderClipDistance;
  76         VkBool32        shaderCullDistance;
  77         VkBool32        shaderFloat64;
  78         VkBool32        shaderInt64;
  79         VkBool32        shaderInt16;
  80         VkBool32        shaderResourceResidency;
  81         VkBool32        shaderResourceMinLod;
  82         VkBool32        sparseBinding;
  83         VkBool32        sparseResidencyBuffer;
  84         VkBool32        sparseResidencyImage2D;
  85         VkBool32        sparseResidencyImage3D;
  86         VkBool32        sparseResidency2Samples;
  87         VkBool32        sparseResidency4Samples;
  88         VkBool32        sparseResidency8Samples;
  89         VkBool32        sparseResidency16Samples;
  90         VkBool32        sparseResidencyAliased;
  91         VkBool32        variableMultisampleRate;
  92 };
  93
  94 struct VkFormatProperties
  95 {
  96         VkFormatFeatureFlags    linearTilingFeatures;
  97         VkFormatFeatureFlags    optimalTilingFeatures;
  98         VkFormatFeatureFlags    bufferFeatures;
  99 };
 100
 101 struct VkExtent3D
 102 {
 103         deInt32 width;
 104         deInt32 height;
 105         deInt32 depth;
 106 };
 107
 108 struct VkImageFormatProperties
 109 {
 110         VkExtent3D                      maxExtent;
 111         deUint32                        maxMipLevels;
 112         deUint32                        maxArrayLayers;
 113         VkSampleCountFlags      sampleCounts;
 114         VkDeviceSize            maxResourceSize;
 115 };
 116
 117 struct VkPhysicalDeviceLimits
 118 {
 119         deUint32                        maxImageDimension1D;
 120         deUint32                        maxImageDimension2D;
 121         deUint32                        maxImageDimension3D;
 122         deUint32                        maxImageDimensionCube;
 123         deUint32                        maxImageArrayLayers;
 124         deUint32                        maxTexelBufferElements;
 125         deUint32                        maxUniformBufferRange;
 126         deUint32                        maxStorageBufferRange;
 127         deUint32                        maxPushConstantsSize;
 128         deUint32                        maxMemoryAllocationCount;
 129         deUint32                        maxSamplerAllocationCount;
 130         VkDeviceSize            bufferImageGranularity;
 131         VkDeviceSize            sparseAddressSpaceSize;
 132         deUint32                        maxBoundDescriptorSets;
 133         deUint32                        maxPerStageDescriptorSamplers;
 134         deUint32                        maxPerStageDescriptorUniformBuffers;
 135         deUint32                        maxPerStageDescriptorStorageBuffers;
 136         deUint32                        maxPerStageDescriptorSampledImages;
 137         deUint32                        maxPerStageDescriptorStorageImages;
 138         deUint32                        maxPerStageDescriptorInputAttachments;
 139         deUint32                        maxPerStageResources;
 140         deUint32                        maxDescriptorSetSamplers;
 141         deUint32                        maxDescriptorSetUniformBuffers;
 142         deUint32                        maxDescriptorSetUniformBuffersDynamic;
 143         deUint32                        maxDescriptorSetStorageBuffers;
 144         deUint32                        maxDescriptorSetStorageBuffersDynamic;
 145         deUint32                        maxDescriptorSetSampledImages;
 146         deUint32                        maxDescriptorSetStorageImages;
 147         deUint32                        maxDescriptorSetInputAttachments;
 148         deUint32                        maxVertexInputAttributes;
 149         deUint32                        maxVertexInputBindings;
 150         deUint32                        maxVertexInputAttributeOffset;
 151         deUint32                        maxVertexInputBindingStride;
 152         deUint32                        maxVertexOutputComponents;
 153         deUint32                        maxTessellationGenerationLevel;
 154         deUint32                        maxTessellationPatchSize;
 155         deUint32                        maxTessellationControlPerVertexInputComponents;
 156         deUint32                        maxTessellationControlPerVertexOutputComponents;
 157         deUint32                        maxTessellationControlPerPatchOutputComponents;
 158         deUint32                        maxTessellationControlTotalOutputComponents;
 159         deUint32                        maxTessellationEvaluationInputComponents;
 160         deUint32                        maxTessellationEvaluationOutputComponents;
 161         deUint32                        maxGeometryShaderInvocations;
 162         deUint32                        maxGeometryInputComponents;
 163         deUint32                        maxGeometryOutputComponents;
 164         deUint32                        maxGeometryOutputVertices;
 165         deUint32                        maxGeometryTotalOutputComponents;
 166         deUint32                        maxFragmentInputComponents;
 167         deUint32                        maxFragmentOutputAttachments;
 168         deUint32                        maxFragmentDualSrcAttachments;
 169         deUint32                        maxFragmentCombinedOutputResources;
 170         deUint32                        maxComputeSharedMemorySize;
 171         deUint32                        maxComputeWorkGroupCount[3];
 172         deUint32                        maxComputeWorkGroupInvocations;
 173         deUint32                        maxComputeWorkGroupSize[3];
 174         deUint32                        subPixelPrecisionBits;
 175         deUint32                        subTexelPrecisionBits;
 176         deUint32                        mipmapPrecisionBits;
 177         deUint32                        maxDrawIndexedIndexValue;
 178         deUint32                        maxDrawIndirectCount;
 179         float                           maxSamplerLodBias;
 180         float                           maxSamplerAnisotropy;
 181         deUint32                        maxViewports;
 182         deUint32                        maxViewportDimensions[2];
 183         float                           viewportBoundsRange[2];
 184         deUint32                        viewportSubPixelBits;
 185         deUintptr                       minMemoryMapAlignment;
 186         VkDeviceSize            minTexelBufferOffsetAlignment;
 187         VkDeviceSize            minUniformBufferOffsetAlignment;
 188         VkDeviceSize            minStorageBufferOffsetAlignment;
 189         deInt32                         minTexelOffset;
 190         deUint32                        maxTexelOffset;
 191         deInt32                         minTexelGatherOffset;
 192         deUint32                        maxTexelGatherOffset;
 193         float                           minInterpolationOffset;
 194         float                           maxInterpolationOffset;
 195         deUint32                        subPixelInterpolationOffsetBits;
 196         deUint32                        maxFramebufferWidth;
 197         deUint32                        maxFramebufferHeight;
 198         deUint32                        maxFramebufferLayers;
 199         VkSampleCountFlags      framebufferColorSampleCounts;
 200         VkSampleCountFlags      framebufferDepthSampleCounts;
 201         VkSampleCountFlags      framebufferStencilSampleCounts;
 202         VkSampleCountFlags      framebufferNoAttachmentsSampleCounts;
 203         deUint32                        maxColorAttachments;
 204         VkSampleCountFlags      sampledImageColorSampleCounts;
 205         VkSampleCountFlags      sampledImageIntegerSampleCounts;
 206         VkSampleCountFlags      sampledImageDepthSampleCounts;
 207         VkSampleCountFlags      sampledImageStencilSampleCounts;
 208         VkSampleCountFlags      storageImageSampleCounts;
 209         deUint32                        maxSampleMaskWords;
 210         float                           timestampPeriod;
 211         deUint32                        maxClipDistances;
 212         deUint32                        maxCullDistances;
 213         deUint32                        maxCombinedClipAndCullDistances;
 214         deUint32                        discreteQueuePriorities;
 215         float                           pointSizeRange[2];
 216         float                           lineWidthRange[2];
 217         float                           pointSizeGranularity;
 218         float                           lineWidthGranularity;
 219         VkBool32                        strictLines;
 220         VkBool32                        standardSampleLocations;
 221         VkDeviceSize            optimalBufferCopyOffsetAlignment;
 222         VkDeviceSize            optimalBufferCopyRowPitchAlignment;
 223         VkDeviceSize            nonCoherentAtomSize;
 224 };
 225
 226 struct VkPhysicalDeviceSparseProperties
 227 {
 228         VkBool32        residencyStandard2DBlockShape;
 229         VkBool32        residencyStandard2DMultisampleBlockShape;
 230         VkBool32        residencyStandard3DBlockShape;
 231         VkBool32        residencyAlignedMipSize;
 232         VkBool32        residencyNonResidentStrict;
 233 };
 234
 235 struct VkPhysicalDeviceProperties
 236 {
 237         deUint32                                                        apiVersion;
 238         deUint32                                                        driverVersion;
 239         deUint32                                                        vendorID;
 240         deUint32                                                        deviceID;
 241         VkPhysicalDeviceType                            deviceType;
 242         char                                                            deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
 243         deUint8                                                         pipelineCacheUUID[VK_UUID_SIZE];
 244         VkPhysicalDeviceLimits                          limits;
 245         VkPhysicalDeviceSparseProperties        sparseProperties;
 246 };
 247
 248 struct VkQueueFamilyProperties
 249 {
 250         VkQueueFlags    queueFlags;
 251         deUint32                queueCount;
 252         deUint32                timestampValidBits;
 253         VkExtent3D              minImageTransferGranularity;
 254 };
 255
 256 struct VkMemoryType
 257 {
 258         VkMemoryPropertyFlags   propertyFlags;
 259         deUint32                                heapIndex;
 260 };
 261
 262 struct VkMemoryHeap
 263 {
 264         VkDeviceSize            size;
 265         VkMemoryHeapFlags       flags;
 266 };
 267
 268 struct VkPhysicalDeviceMemoryProperties
 269 {
 270         deUint32                memoryTypeCount;
 271         VkMemoryType    memoryTypes[VK_MAX_MEMORY_TYPES];
 272         deUint32                memoryHeapCount;
 273         VkMemoryHeap    memoryHeaps[VK_MAX_MEMORY_HEAPS];
 274 };
 275
 276 struct VkDeviceQueueCreateInfo
 277 {
 278         VkStructureType                         sType;
 279         const void*                                     pNext;
 280         VkDeviceQueueCreateFlags        flags;
 281         deUint32                                        queueFamilyIndex;
 282         deUint32                                        queueCount;
 283         const float*                            pQueuePriorities;
 284 };
 285
 286 struct VkDeviceCreateInfo
 287 {
 288         VkStructureType                                 sType;
 289         const void*                                             pNext;
 290         VkDeviceCreateFlags                             flags;
 291         deUint32                                                queueCreateInfoCount;
 292         const VkDeviceQueueCreateInfo*  pQueueCreateInfos;
 293         deUint32                                                enabledLayerNameCount;
 294         const char* const*                              ppEnabledLayerNames;
 295         deUint32                                                enabledExtensionNameCount;
 296         const char* const*                              ppEnabledExtensionNames;
 297         const VkPhysicalDeviceFeatures* pEnabledFeatures;
 298 };
 299
 300 struct VkExtensionProperties
 301 {
 302         char            extensionName[VK_MAX_EXTENSION_NAME_SIZE];
 303         deUint32        specVersion;
 304 };
 305
 306 struct VkLayerProperties
 307 {
 308         char            layerName[VK_MAX_EXTENSION_NAME_SIZE];
 309         deUint32        specVersion;
 310         deUint32        implementationVersion;
 311         char            description[VK_MAX_DESCRIPTION_SIZE];
 312 };
 313
 314 struct VkSubmitInfo
 315 {
 316         VkStructureType                 sType;
 317         const void*                             pNext;
 318         deUint32                                waitSemaphoreCount;
 319         const VkSemaphore*              pWaitSemaphores;
 320         deUint32                                commandBufferCount;
 321         const VkCommandBuffer*  pCommandBuffers;
 322         deUint32                                signalSemaphoreCount;
 323         const VkSemaphore*              pSignalSemaphores;
 324 };
 325
 326 struct VkMemoryAllocateInfo
 327 {
 328         VkStructureType sType;
 329         const void*             pNext;
 330         VkDeviceSize    allocationSize;
 331         deUint32                memoryTypeIndex;
 332 };
 333
 334 struct VkMappedMemoryRange
 335 {
 336         VkStructureType sType;
 337         const void*             pNext;
 338         VkDeviceMemory  memory;
 339         VkDeviceSize    offset;
 340         VkDeviceSize    size;
 341 };
 342
 343 struct VkMemoryRequirements
 344 {
 345         VkDeviceSize    size;
 346         VkDeviceSize    alignment;
 347         deUint32                memoryTypeBits;
 348 };
 349
 350 struct VkSparseImageFormatProperties
 351 {
 352         VkImageAspectFlags                      aspectMask;
 353         VkExtent3D                                      imageGranularity;
 354         VkSparseImageFormatFlags        flags;
 355 };
 356
 357 struct VkSparseImageMemoryRequirements
 358 {
 359         VkSparseImageFormatProperties   formatProperties;
 360         deUint32                                                imageMipTailStartLod;
 361         VkDeviceSize                                    imageMipTailSize;
 362         VkDeviceSize                                    imageMipTailOffset;
 363         VkDeviceSize                                    imageMipTailStride;
 364 };
 365
 366 struct VkSparseMemoryBind
 367 {
 368         VkDeviceSize                    resourceOffset;
 369         VkDeviceSize                    size;
 370         VkDeviceMemory                  memory;
 371         VkDeviceSize                    memoryOffset;
 372         VkSparseMemoryBindFlags flags;
 373 };
 374
 375 struct VkSparseBufferMemoryBindInfo
 376 {
 377         VkBuffer                                        buffer;
 378         deUint32                                        bindCount;
 379         const VkSparseMemoryBind*       pBinds;
 380 };
 381
 382 struct VkSparseImageOpaqueMemoryBindInfo
 383 {
 384         VkImage                                         image;
 385         deUint32                                        bindCount;
 386         const VkSparseMemoryBind*       pBinds;
 387 };
 388
 389 struct VkImageSubresource
 390 {
 391         VkImageAspectFlags      aspectMask;
 392         deUint32                        mipLevel;
 393         deUint32                        arrayLayer;
 394 };
 395
 396 struct VkOffset3D
 397 {
 398         deInt32 x;
 399         deInt32 y;
 400         deInt32 z;
 401 };
 402
 403 struct VkSparseImageMemoryBind
 404 {
 405         VkImageSubresource              subresource;
 406         VkOffset3D                              offset;
 407         VkExtent3D                              extent;
 408         VkDeviceMemory                  memory;
 409         VkDeviceSize                    memoryOffset;
 410         VkSparseMemoryBindFlags flags;
 411 };
 412
 413 struct VkSparseImageMemoryBindInfo
 414 {
 415         VkImage                                                 image;
 416         deUint32                                                bindCount;
 417         const VkSparseImageMemoryBind*  pBinds;
 418 };
 419
 420 struct VkBindSparseInfo
 421 {
 422         VkStructureType                                                         sType;
 423         const void*                                                                     pNext;
 424         deUint32                                                                        waitSemaphoreCount;
 425         const VkSemaphore*                                                      pWaitSemaphores;
 426         deUint32                                                                        bufferBindCount;
 427         const VkSparseBufferMemoryBindInfo*                     pBufferBinds;
 428         deUint32                                                                        imageOpaqueBindCount;
 429         const VkSparseImageOpaqueMemoryBindInfo*        pImageOpaqueBinds;
 430         deUint32                                                                        imageBindCount;
 431         const VkSparseImageMemoryBindInfo*                      pImageBinds;
 432         deUint32                                                                        signalSemaphoreCount;
 433         const VkSemaphore*                                                      pSignalSemaphores;
 434 };
 435
 436 struct VkFenceCreateInfo
 437 {
 438         VkStructureType         sType;
 439         const void*                     pNext;
 440         VkFenceCreateFlags      flags;
 441 };
 442
 443 struct VkSemaphoreCreateInfo
 444 {
 445         VkStructureType                 sType;
 446         const void*                             pNext;
 447         VkSemaphoreCreateFlags  flags;
 448 };
 449
 450 struct VkEventCreateInfo
 451 {
 452         VkStructureType         sType;
 453         const void*                     pNext;
 454         VkEventCreateFlags      flags;
 455 };
 456
 457 struct VkQueryPoolCreateInfo
 458 {
 459         VkStructureType                                 sType;
 460         const void*                                             pNext;
 461         VkQueryPoolCreateFlags                  flags;
 462         VkQueryType                                             queryType;
 463         deUint32                                                entryCount;
 464         VkQueryPipelineStatisticFlags   pipelineStatistics;
 465 };
 466
 467 struct VkBufferCreateInfo
 468 {
 469         VkStructureType         sType;
 470         const void*                     pNext;
 471         VkBufferCreateFlags     flags;
 472         VkDeviceSize            size;
 473         VkBufferUsageFlags      usage;
 474         VkSharingMode           sharingMode;
 475         deUint32                        queueFamilyIndexCount;
 476         const deUint32*         pQueueFamilyIndices;
 477 };
 478
 479 struct VkBufferViewCreateInfo
 480 {
 481         VkStructureType                 sType;
 482         const void*                             pNext;
 483         VkBufferViewCreateFlags flags;
 484         VkBuffer                                buffer;
 485         VkFormat                                format;
 486         VkDeviceSize                    offset;
 487         VkDeviceSize                    range;
 488 };
 489
 490 struct VkImageCreateInfo
 491 {
 492         VkStructureType                 sType;
 493         const void*                             pNext;
 494         VkImageCreateFlags              flags;
 495         VkImageType                             imageType;
 496         VkFormat                                format;
 497         VkExtent3D                              extent;
 498         deUint32                                mipLevels;
 499         deUint32                                arrayLayers;
 500         VkSampleCountFlagBits   samples;
 501         VkImageTiling                   tiling;
 502         VkImageUsageFlags               usage;
 503         VkSharingMode                   sharingMode;
 504         deUint32                                queueFamilyIndexCount;
 505         const deUint32*                 pQueueFamilyIndices;
 506         VkImageLayout                   initialLayout;
 507 };
 508
 509 struct VkSubresourceLayout
 510 {
 511         VkDeviceSize    offset;
 512         VkDeviceSize    size;
 513         VkDeviceSize    rowPitch;
 514         VkDeviceSize    depthPitch;
 515 };
 516
 517 struct VkComponentMapping
 518 {
 519         VkComponentSwizzle      r;
 520         VkComponentSwizzle      g;
 521         VkComponentSwizzle      b;
 522         VkComponentSwizzle      a;
 523 };
 524
 525 struct VkImageSubresourceRange
 526 {
 527         VkImageAspectFlags      aspectMask;
 528         deUint32                        baseMipLevel;
 529         deUint32                        levelCount;
 530         deUint32                        baseArrayLayer;
 531         deUint32                        layerCount;
 532 };
 533
 534 struct VkImageViewCreateInfo
 535 {
 536         VkStructureType                 sType;
 537         const void*                             pNext;
 538         VkImageViewCreateFlags  flags;
 539         VkImage                                 image;
 540         VkImageViewType                 viewType;
 541         VkFormat                                format;
 542         VkComponentMapping              components;
 543         VkImageSubresourceRange subresourceRange;
 544 };
 545
 546 struct VkShaderModuleCreateInfo
 547 {
 548         VkStructureType                         sType;
 549         const void*                                     pNext;
 550         VkShaderModuleCreateFlags       flags;
 551         deUintptr                                       codeSize;
 552         const deUint32*                         pCode;
 553 };
 554
 555 struct VkPipelineCacheCreateInfo
 556 {
 557         VkStructureType                         sType;
 558         const void*                                     pNext;
 559         VkPipelineCacheCreateFlags      flags;
 560         deUintptr                                       initialDataSize;
 561         const void*                                     pInitialData;
 562 };
 563
 564 struct VkSpecializationMapEntry
 565 {
 566         deUint32        constantID;
 567         deUint32        offset;
 568         deUintptr       size;
 569 };
 570
 571 struct VkSpecializationInfo
 572 {
 573         deUint32                                                mapEntryCount;
 574         const VkSpecializationMapEntry* pMapEntries;
 575         deUintptr                                               dataSize;
 576         const void*                                             pData;
 577 };
 578
 579 struct VkPipelineShaderStageCreateInfo
 580 {
 581         VkStructureType                                         sType;
 582         const void*                                                     pNext;
 583         VkPipelineShaderStageCreateFlags        flags;
 584         VkShaderStageFlagBits                           stage;
 585         VkShaderModule                                          module;
 586         const char*                                                     pName;
 587         const VkSpecializationInfo*                     pSpecializationInfo;
 588 };
 589
 590 struct VkVertexInputBindingDescription
 591 {
 592         deUint32                        binding;
 593         deUint32                        stride;
 594         VkVertexInputRate       inputRate;
 595 };
 596
 597 struct VkVertexInputAttributeDescription
 598 {
 599         deUint32        location;
 600         deUint32        binding;
 601         VkFormat        format;
 602         deUint32        offset;
 603 };
 604
 605 struct VkPipelineVertexInputStateCreateInfo
 606 {
 607         VkStructureType                                                         sType;
 608         const void*                                                                     pNext;
 609         VkPipelineVertexInputStateCreateFlags           flags;
 610         deUint32                                                                        vertexBindingDescriptionCount;
 611         const VkVertexInputBindingDescription*          pVertexBindingDescriptions;
 612         deUint32                                                                        vertexAttributeDescriptionCount;
 613         const VkVertexInputAttributeDescription*        pVertexAttributeDescriptions;
 614 };
 615
 616 struct VkPipelineInputAssemblyStateCreateInfo
 617 {
 618         VkStructureType                                                 sType;
 619         const void*                                                             pNext;
 620         VkPipelineInputAssemblyStateCreateFlags flags;
 621         VkPrimitiveTopology                                             topology;
 622         VkBool32                                                                primitiveRestartEnable;
 623 };
 624
 625 struct VkPipelineTessellationStateCreateInfo
 626 {
 627         VkStructureType                                                 sType;
 628         const void*                                                             pNext;
 629         VkPipelineTesselationStateCreateFlags   flags;
 630         deUint32                                                                patchControlPoints;
 631 };
 632
 633 struct VkViewport
 634 {
 635         float   x;
 636         float   y;
 637         float   width;
 638         float   height;
 639         float   minDepth;
 640         float   maxDepth;
 641 };
 642
 643 struct VkOffset2D
 644 {
 645         deInt32 x;
 646         deInt32 y;
 647 };
 648
 649 struct VkExtent2D
 650 {
 651         deInt32 width;
 652         deInt32 height;
 653 };
 654
 655 struct VkRect2D
 656 {
 657         VkOffset2D      offset;
 658         VkExtent2D      extent;
 659 };
 660
 661 struct VkPipelineViewportStateCreateInfo
 662 {
 663         VkStructureType                                         sType;
 664         const void*                                                     pNext;
 665         VkPipelineViewportStateCreateFlags      flags;
 666         deUint32                                                        viewportCount;
 667         const VkViewport*                                       pViewports;
 668         deUint32                                                        scissorCount;
 669         const VkRect2D*                                         pScissors;
 670 };
 671
 672 struct VkPipelineRasterizationStateCreateInfo
 673 {
 674         VkStructureType                                                 sType;
 675         const void*                                                             pNext;
 676         VkPipelineRasterizationStateCreateFlags flags;
 677         VkBool32                                                                depthClampEnable;
 678         VkBool32                                                                rasterizerDiscardEnable;
 679         VkPolygonMode                                                   polygonMode;
 680         VkCullModeFlags                                                 cullMode;
 681         VkFrontFace                                                             frontFace;
 682         VkBool32                                                                depthBiasEnable;
 683         float                                                                   depthBiasConstantFactor;
 684         float                                                                   depthBiasClamp;
 685         float                                                                   depthBiasSlopeFactor;
 686         float                                                                   lineWidth;
 687 };
 688
 689 struct VkPipelineMultisampleStateCreateInfo
 690 {
 691         VkStructureType                                                 sType;
 692         const void*                                                             pNext;
 693         VkPipelineMultisampleStateCreateFlags   flags;
 694         VkSampleCountFlagBits                                   rasterizationSamples;
 695         VkBool32                                                                sampleShadingEnable;
 696         float                                                                   minSampleShading;
 697         const VkSampleMask*                                             pSampleMask;
 698         VkBool32                                                                alphaToCoverageEnable;
 699         VkBool32                                                                alphaToOneEnable;
 700 };
 701
 702 struct VkStencilOpState
 703 {
 704         VkStencilOp     failOp;
 705         VkStencilOp     passOp;
 706         VkStencilOp     depthFailOp;
 707         VkCompareOp     compareOp;
 708         deUint32        compareMask;
 709         deUint32        writeMask;
 710         deUint32        reference;
 711 };
 712
 713 struct VkPipelineDepthStencilStateCreateInfo
 714 {
 715         VkStructureType                                                 sType;
 716         const void*                                                             pNext;
 717         VkPipelineDepthStencilStateCreateFlags  flags;
 718         VkBool32                                                                depthTestEnable;
 719         VkBool32                                                                depthWriteEnable;
 720         VkCompareOp                                                             depthCompareOp;
 721         VkBool32                                                                depthBoundsTestEnable;
 722         VkBool32                                                                stencilTestEnable;
 723         VkStencilOpState                                                front;
 724         VkStencilOpState                                                back;
 725         float                                                                   minDepthBounds;
 726         float                                                                   maxDepthBounds;
 727 };
 728
 729 struct VkPipelineColorBlendAttachmentState
 730 {
 731         VkBool32                                blendEnable;
 732         VkBlendFactor                   srcColorBlendFactor;
 733         VkBlendFactor                   dstColorBlendFactor;
 734         VkBlendOp                               colorBlendOp;
 735         VkBlendFactor                   srcAlphaBlendFactor;
 736         VkBlendFactor                   dstAlphaBlendFactor;
 737         VkBlendOp                               alphaBlendOp;
 738         VkColorComponentFlags   colorWriteMask;
 739 };
 740
 741 struct VkPipelineColorBlendStateCreateInfo
 742 {
 743         VkStructureType                                                         sType;
 744         const void*                                                                     pNext;
 745         VkPipelineColorBlendStateCreateFlags            flags;
 746         VkBool32                                                                        logicOpEnable;
 747         VkLogicOp                                                                       logicOp;
 748         deUint32                                                                        attachmentCount;
 749         const VkPipelineColorBlendAttachmentState*      pAttachments;
 750         float                                                                           blendConstants[4];
 751 };
 752
 753 struct VkPipelineDynamicStateCreateInfo
 754 {
 755         VkStructureType                                         sType;
 756         const void*                                                     pNext;
 757         VkPipelineDynamicStateCreateFlags       flags;
 758         deUint32                                                        dynamicStateCount;
 759         const VkDynamicState*                           pDynamicStates;
 760 };
 761
 762 struct VkGraphicsPipelineCreateInfo
 763 {
 764         VkStructureType                                                                 sType;
 765         const void*                                                                             pNext;
 766         VkPipelineCreateFlags                                                   flags;
 767         deUint32                                                                                stageCount;
 768         const VkPipelineShaderStageCreateInfo*                  pStages;
 769         const VkPipelineVertexInputStateCreateInfo*             pVertexInputState;
 770         const VkPipelineInputAssemblyStateCreateInfo*   pInputAssemblyState;
 771         const VkPipelineTessellationStateCreateInfo*    pTessellationState;
 772         const VkPipelineViewportStateCreateInfo*                pViewportState;
 773         const VkPipelineRasterizationStateCreateInfo*   pRasterizationState;
 774         const VkPipelineMultisampleStateCreateInfo*             pMultisampleState;
 775         const VkPipelineDepthStencilStateCreateInfo*    pDepthStencilState;
 776         const VkPipelineColorBlendStateCreateInfo*              pColorBlendState;
 777         const VkPipelineDynamicStateCreateInfo*                 pDynamicState;
 778         VkPipelineLayout                                                                layout;
 779         VkRenderPass                                                                    renderPass;
 780         deUint32                                                                                subpass;
 781         VkPipeline                                                                              basePipelineHandle;
 782         deInt32                                                                                 basePipelineIndex;
 783 };
 784
 785 struct VkComputePipelineCreateInfo
 786 {
 787         VkStructureType                                 sType;
 788         const void*                                             pNext;
 789         VkPipelineCreateFlags                   flags;
 790         VkPipelineShaderStageCreateInfo stage;
 791         VkPipelineLayout                                layout;
 792         VkPipeline                                              basePipelineHandle;
 793         deInt32                                                 basePipelineIndex;
 794 };
 795
 796 struct VkPushConstantRange
 797 {
 798         VkShaderStageFlags      stageFlags;
 799         deUint32                        offset;
 800         deUint32                        size;
 801 };
 802
 803 struct VkPipelineLayoutCreateInfo
 804 {
 805         VkStructureType                                 sType;
 806         const void*                                             pNext;
 807         VkPipelineLayoutCreateFlags             flags;
 808         deUint32                                                setLayoutCount;
 809         const VkDescriptorSetLayout*    pSetLayouts;
 810         deUint32                                                pushConstantRangeCount;
 811         const VkPushConstantRange*              pPushConstantRanges;
 812 };
 813
 814 struct VkSamplerCreateInfo
 815 {
 816         VkStructureType                 sType;
 817         const void*                             pNext;
 818         VkSamplerCreateFlags    flags;
 819         VkFilter                                magFilter;
 820         VkFilter                                minFilter;
 821         VkSamplerMipmapMode             mipmapMode;
 822         VkSamplerAddressMode    addressModeU;
 823         VkSamplerAddressMode    addressModeV;
 824         VkSamplerAddressMode    addressModeW;
 825         float                                   mipLodBias;
 826         float                                   maxAnisotropy;
 827         VkBool32                                compareEnable;
 828         VkCompareOp                             compareOp;
 829         float                                   minLod;
 830         float                                   maxLod;
 831         VkBorderColor                   borderColor;
 832         VkBool32                                unnormalizedCoordinates;
 833 };
 834
 835 struct VkDescriptorSetLayoutBinding
 836 {
 837         deUint32                        binding;
 838         VkDescriptorType        descriptorType;
 839         deUint32                        descriptorCount;
 840         VkShaderStageFlags      stageFlags;
 841         const VkSampler*        pImmutableSamplers;
 842 };
 843
 844 struct VkDescriptorSetLayoutCreateInfo
 845 {
 846         VkStructureType                                         sType;
 847         const void*                                                     pNext;
 848         VkDescriptorSetLayoutCreateFlags        flags;
 849         deUint32                                                        bindingCount;
 850         const VkDescriptorSetLayoutBinding*     pBinding;
 851 };
 852
 853 struct VkDescriptorPoolSize
 854 {
 855         VkDescriptorType        type;
 856         deUint32                        descriptorCount;
 857 };
 858
 859 struct VkDescriptorPoolCreateInfo
 860 {
 861         VkStructureType                         sType;
 862         const void*                                     pNext;
 863         VkDescriptorPoolCreateFlags     flags;
 864         deUint32                                        maxSets;
 865         deUint32                                        poolSizeCount;
 866         const VkDescriptorPoolSize*     pPoolSizes;
 867 };
 868
 869 struct VkDescriptorSetAllocateInfo
 870 {
 871         VkStructureType                                 sType;
 872         const void*                                             pNext;
 873         VkDescriptorPool                                descriptorPool;
 874         deUint32                                                setLayoutCount;
 875         const VkDescriptorSetLayout*    pSetLayouts;
 876 };
 877
 878 struct VkDescriptorImageInfo
 879 {
 880         VkSampler               sampler;
 881         VkImageView             imageView;
 882         VkImageLayout   imageLayout;
 883 };
 884
 885 struct VkDescriptorBufferInfo
 886 {
 887         VkBuffer                buffer;
 888         VkDeviceSize    offset;
 889         VkDeviceSize    range;
 890 };
 891
 892 struct VkWriteDescriptorSet
 893 {
 894         VkStructureType                                 sType;
 895         const void*                                             pNext;
 896         VkDescriptorSet                                 dstSet;
 897         deUint32                                                dstBinding;
 898         deUint32                                                dstArrayElement;
 899         deUint32                                                descriptorCount;
 900         VkDescriptorType                                descriptorType;
 901         const VkDescriptorImageInfo*    pImageInfo;
 902         const VkDescriptorBufferInfo*   pBufferInfo;
 903         const VkBufferView*                             pTexelBufferView;
 904 };
 905
 906 struct VkCopyDescriptorSet
 907 {
 908         VkStructureType sType;
 909         const void*             pNext;
 910         VkDescriptorSet srcSet;
 911         deUint32                srcBinding;
 912         deUint32                srcArrayElement;
 913         VkDescriptorSet dstSet;
 914         deUint32                dstBinding;
 915         deUint32                dstArrayElement;
 916         deUint32                descriptorCount;
 917 };
 918
 919 struct VkFramebufferCreateInfo
 920 {
 921         VkStructureType                         sType;
 922         const void*                                     pNext;
 923         VkFramebufferCreateFlags        flags;
 924         VkRenderPass                            renderPass;
 925         deUint32                                        attachmentCount;
 926         const VkImageView*                      pAttachments;
 927         deUint32                                        width;
 928         deUint32                                        height;
 929         deUint32                                        layers;
 930 };
 931
 932 struct VkAttachmentDescription
 933 {
 934         VkAttachmentDescriptionFlags    flags;
 935         VkFormat                                                format;
 936         VkSampleCountFlagBits                   samples;
 937         VkAttachmentLoadOp                              loadOp;
 938         VkAttachmentStoreOp                             storeOp;
 939         VkAttachmentLoadOp                              stencilLoadOp;
 940         VkAttachmentStoreOp                             stencilStoreOp;
 941         VkImageLayout                                   initialLayout;
 942         VkImageLayout                                   finalLayout;
 943 };
 944
 945 struct VkAttachmentReference
 946 {
 947         deUint32                attachment;
 948         VkImageLayout   layout;
 949 };
 950
 951 struct VkSubpassDescription
 952 {
 953         VkSubpassDescriptionFlags               flags;
 954         VkPipelineBindPoint                             pipelineBindPoint;
 955         deUint32                                                inputAttachmentCount;
 956         const VkAttachmentReference*    pInputAttachments;
 957         deUint32                                                colorAttachmentCount;
 958         const VkAttachmentReference*    pColorAttachments;
 959         const VkAttachmentReference*    pResolveAttachments;
 960         const VkAttachmentReference*    pDepthStencilAttachment;
 961         deUint32                                                preserveAttachmentCount;
 962         const VkAttachmentReference*    pPreserveAttachments;
 963 };
 964
 965 struct VkSubpassDependency
 966 {
 967         deUint32                                srcSubpass;
 968         deUint32                                dstSubpass;
 969         VkPipelineStageFlags    srcStageMask;
 970         VkPipelineStageFlags    dstStageMask;
 971         VkAccessFlags                   srcAccessMask;
 972         VkAccessFlags                   dstAccessMask;
 973         VkDependencyFlags               dependencyFlags;
 974 };
 975
 976 struct VkRenderPassCreateInfo
 977 {
 978         VkStructureType                                 sType;
 979         const void*                                             pNext;
 980         VkRenderPassCreateFlags                 flags;
 981         deUint32                                                attachmentCount;
 982         const VkAttachmentDescription*  pAttachments;
 983         deUint32                                                subpassCount;
 984         const VkSubpassDescription*             pSubpasses;
 985         deUint32                                                dependencyCount;
 986         const VkSubpassDependency*              pDependencies;
 987 };
 988
 989 struct VkCommandPoolCreateInfo
 990 {
 991         VkStructureType                         sType;
 992         const void*                                     pNext;
 993         VkCommandPoolCreateFlags        flags;
 994         deUint32                                        queueFamilyIndex;
 995 };
 996
 997 struct VkCommandBufferAllocateInfo
 998 {
 999         VkStructureType                 sType;
1000         const void*                             pNext;
1001         VkCommandPool                   commandPool;
1002         VkCommandBufferLevel    level;
1003         deUint32                                bufferCount;
1004 };
1005
1006 struct VkCommandBufferBeginInfo
1007 {
1008         VkStructureType                                 sType;
1009         const void*                                             pNext;
1010         VkCommandBufferUsageFlags               flags;
1011         VkRenderPass                                    renderPass;
1012         deUint32                                                subpass;
1013         VkFramebuffer                                   framebuffer;
1014         VkBool32                                                occlusionQueryEnable;
1015         VkQueryControlFlags                             queryFlags;
1016         VkQueryPipelineStatisticFlags   pipelineStatistics;
1017 };
1018
1019 struct VkBufferCopy
1020 {
1021         VkDeviceSize    srcOffset;
1022         VkDeviceSize    dstOffset;
1023         VkDeviceSize    size;
1024 };
1025
1026 struct VkImageSubresourceLayers
1027 {
1028         VkImageAspectFlags      aspectMask;
1029         deUint32                        mipLevel;
1030         deUint32                        baseArrayLayer;
1031         deUint32                        layerCount;
1032 };
1033
1034 struct VkImageCopy
1035 {
1036         VkImageSubresourceLayers        srcSubresource;
1037         VkOffset3D                                      srcOffset;
1038         VkImageSubresourceLayers        dstSubresource;
1039         VkOffset3D                                      dstOffset;
1040         VkExtent3D                                      extent;
1041 };
1042
1043 struct VkImageBlit
1044 {
1045         VkImageSubresourceLayers        srcSubresource;
1046         VkOffset3D                                      srcOffset;
1047         VkExtent3D                                      srcExtent;
1048         VkImageSubresourceLayers        dstSubresource;
1049         VkOffset3D                                      dstOffset;
1050         VkExtent3D                                      dstExtent;
1051 };
1052
1053 struct VkBufferImageCopy
1054 {
1055         VkDeviceSize                            bufferOffset;
1056         deUint32                                        bufferRowLength;
1057         deUint32                                        bufferImageHeight;
1058         VkImageSubresourceLayers        imageSubresource;
1059         VkOffset3D                                      imageOffset;
1060         VkExtent3D                                      imageExtent;
1061 };
1062
1063 union VkClearColorValue
1064 {
1065         float           float32[4];
1066         deInt32         int32[4];
1067         deUint32        uint32[4];
1068 };
1069
1070 struct VkClearDepthStencilValue
1071 {
1072         float           depth;
1073         deUint32        stencil;
1074 };
1075
1076 union VkClearValue
1077 {
1078         VkClearColorValue                       color;
1079         VkClearDepthStencilValue        depthStencil;
1080 };
1081
1082 struct VkClearAttachment
1083 {
1084         VkImageAspectFlags      aspectMask;
1085         deUint32                        colorAttachment;
1086         VkClearValue            clearValue;
1087 };
1088
1089 struct VkClearRect
1090 {
1091         VkRect2D        rect;
1092         deUint32        baseArrayLayer;
1093         deUint32        layerCount;
1094 };
1095
1096 struct VkImageResolve
1097 {
1098         VkImageSubresourceLayers        srcSubresource;
1099         VkOffset3D                                      srcOffset;
1100         VkImageSubresourceLayers        dstSubresource;
1101         VkOffset3D                                      dstOffset;
1102         VkExtent3D                                      extent;
1103 };
1104
1105 struct VkRenderPassBeginInfo
1106 {
1107         VkStructureType         sType;
1108         const void*                     pNext;
1109         VkRenderPass            renderPass;
1110         VkFramebuffer           framebuffer;
1111         VkRect2D                        renderArea;
1112         deUint32                        clearValueCount;
1113         const VkClearValue*     pClearValues;
1114 };
1115
1116 struct VkBufferMemoryBarrier
1117 {
1118         VkStructureType sType;
1119         const void*             pNext;
1120         VkAccessFlags   srcAccessMask;
1121         VkAccessFlags   dstAccessMask;
1122         deUint32                srcQueueFamilyIndex;
1123         deUint32                dstQueueFamilyIndex;
1124         VkBuffer                buffer;
1125         VkDeviceSize    offset;
1126         VkDeviceSize    size;
1127 };
1128
1129 struct VkDispatchIndirectCommand
1130 {
1131         deUint32        x;
1132         deUint32        y;
1133         deUint32        z;
1134 };
1135
1136 struct VkDrawIndexedIndirectCommand
1137 {
1138         deUint32        indexCount;
1139         deUint32        instanceCount;
1140         deUint32        firstIndex;
1141         deInt32         vertexOffset;
1142         deUint32        firstInstance;
1143 };
1144
1145 struct VkDrawIndirectCommand
1146 {
1147         deUint32        vertexCount;
1148         deUint32        instanceCount;
1149         deUint32        firstVertex;
1150         deUint32        firstInstance;
1151 };
1152
1153 struct VkImageMemoryBarrier
1154 {
1155         VkStructureType                 sType;
1156         const void*                             pNext;
1157         VkAccessFlags                   srcAccessMask;
1158         VkAccessFlags                   dstAccessMask;
1159         VkImageLayout                   oldLayout;
1160         VkImageLayout                   newLayout;
1161         deUint32                                srcQueueFamilyIndex;
1162         deUint32                                dstQueueFamilyIndex;
1163         VkImage                                 image;
1164         VkImageSubresourceRange subresourceRange;
1165 };
1166
1167 struct VkMemoryBarrier
1168 {
1169         VkStructureType sType;
1170         const void*             pNext;
1171         VkAccessFlags   srcAccessMask;
1172         VkAccessFlags   dstAccessMask;
1173 };
1174
1175 struct VkSurfaceCapabilitiesKHR
1176 {
1177         deUint32                                                minImageCount;
1178         deUint32                                                maxImageCount;
1179         VkExtent2D                                              currentExtent;
1180         VkExtent2D                                              minImageExtent;
1181         VkExtent2D                                              maxImageExtent;
1182         deUint32                                                maxImageArrayLayers;
1183         VkSurfaceTransformFlagsKHR              supportedTransforms;
1184         VkSurfaceTransformFlagBitsKHR   currentTransform;
1185         VkCompositeAlphaFlagsKHR                supportedCompositeAlpha;
1186         VkImageUsageFlags                               supportedUsageFlags;
1187 };
1188
1189 struct VkSurfaceFormatKHR
1190 {
1191         VkFormat                format;
1192         VkColorSpaceKHR colorSpace;
1193 };
1194
1195 struct VkSwapchainCreateInfoKHR
1196 {
1197         VkStructureType                                 sType;
1198         const void*                                             pNext;
1199         VkSwapchainCreateFlagsKHR               flags;
1200         VkSurfaceKHR                                    surface;
1201         deUint32                                                minImageCount;
1202         VkFormat                                                imageFormat;
1203         VkColorSpaceKHR                                 imageColorSpace;
1204         VkExtent2D                                              imageExtent;
1205         deUint32                                                imageArrayLayers;
1206         VkImageUsageFlags                               imageUsage;
1207         VkSharingMode                                   imageSharingMode;
1208         deUint32                                                queueFamilyIndexCount;
1209         const deUint32*                                 pQueueFamilyIndices;
1210         VkSurfaceTransformFlagBitsKHR   preTransform;
1211         VkCompositeAlphaFlagBitsKHR             compositeAlpha;
1212         VkPresentModeKHR                                presentMode;
1213         VkBool32                                                clipped;
1214         VkSwapchainKHR                                  oldSwapchain;
1215 };
1216
1217 struct VkPresentInfoKHR
1218 {
1219         VkStructureType                 sType;
1220         const void*                             pNext;
1221         deUint32                                waitSemaphoreCount;
1222         const VkSemaphore*              pWaitSemaphores;
1223         deUint32                                swapchainCount;
1224         const VkSwapchainKHR*   pSwapchains;
1225         const deUint32*                 pImageIndices;
1226         VkResult*                               pResults;
1227 };
1228
1229 struct VkDisplayPropertiesKHR
1230 {
1231         VkDisplayKHR                            display;
1232         const char*                                     displayName;
1233         VkExtent2D                                      physicalDimensions;
1234         VkExtent2D                                      physicalResolution;
1235         VkSurfaceTransformFlagsKHR      supportedTransforms;
1236         VkBool32                                        planeReorderPossible;
1237         VkBool32                                        persistentContent;
1238 };
1239
1240 struct VkDisplayModeParametersKHR
1241 {
1242         VkExtent2D      visibleRegion;
1243         deUint32        refreshRate;
1244 };
1245
1246 struct VkDisplayModePropertiesKHR
1247 {
1248         VkDisplayModeKHR                        displayMode;
1249         VkDisplayModeParametersKHR      parameters;
1250 };
1251
1252 struct VkDisplayModeCreateInfoKHR
1253 {
1254         VkStructureType                         sType;
1255         const void*                                     pNext;
1256         VkDisplayModeCreateFlagsKHR     flags;
1257         VkDisplayModeParametersKHR      parameters;
1258 };
1259
1260 struct VkDisplayPlaneCapabilitiesKHR
1261 {
1262         VkDisplayPlaneAlphaFlagsKHR     supportedAlpha;
1263         VkOffset2D                                      minSrcPosition;
1264         VkOffset2D                                      maxSrcPosition;
1265         VkExtent2D                                      minSrcExtent;
1266         VkExtent2D                                      maxSrcExtent;
1267         VkOffset2D                                      minDstPosition;
1268         VkOffset2D                                      maxDstPosition;
1269         VkExtent2D                                      minDstExtent;
1270         VkExtent2D                                      maxDstExtent;
1271 };
1272
1273 struct VkDisplayPlanePropertiesKHR
1274 {
1275         VkDisplayKHR    currentDisplay;
1276         deUint32                currentStackIndex;
1277 };
1278
1279 struct VkDisplaySurfaceCreateInfoKHR
1280 {
1281         VkStructureType                                 sType;
1282         const void*                                             pNext;
1283         VkDisplaySurfaceCreateFlagsKHR  flags;
1284         VkDisplayModeKHR                                displayMode;
1285         deUint32                                                planeIndex;
1286         deUint32                                                planeStackIndex;
1287         VkSurfaceTransformFlagBitsKHR   transform;
1288         float                                                   globalAlpha;
1289         VkDisplayPlaneAlphaFlagBitsKHR  alphaMode;
1290         VkExtent2D                                              imageExtent;
1291 };
1292
1293 struct VkDisplayPresentInfoKHR
1294 {
1295         VkStructureType sType;
1296         const void*             pNext;
1297         VkRect2D                srcRect;
1298         VkRect2D                dstRect;
1299         VkBool32                persistent;
1300 };
1301