blob: 9f8ede6ced24821d6a9b44f246774e9545db7ac0 [file] [log] [blame]
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
struct VkApplicationInfo
{
VkStructureType sType;
const void* pNext;
const char* pApplicationName;
deUint32 applicationVersion;
const char* pEngineName;
deUint32 engineVersion;
deUint32 apiVersion;
};
struct VkInstanceCreateInfo
{
VkStructureType sType;
const void* pNext;
VkInstanceCreateFlags flags;
const VkApplicationInfo* pApplicationInfo;
deUint32 enabledLayerCount;
const char* const* ppEnabledLayerNames;
deUint32 enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
};
struct VkAllocationCallbacks
{
void* pUserData;
PFN_vkAllocationFunction pfnAllocation;
PFN_vkReallocationFunction pfnReallocation;
PFN_vkFreeFunction pfnFree;
PFN_vkInternalAllocationNotification pfnInternalAllocation;
PFN_vkInternalFreeNotification pfnInternalFree;
};
struct VkPhysicalDeviceFeatures
{
VkBool32 robustBufferAccess;
VkBool32 fullDrawIndexUint32;
VkBool32 imageCubeArray;
VkBool32 independentBlend;
VkBool32 geometryShader;
VkBool32 tessellationShader;
VkBool32 sampleRateShading;
VkBool32 dualSrcBlend;
VkBool32 logicOp;
VkBool32 multiDrawIndirect;
VkBool32 drawIndirectFirstInstance;
VkBool32 depthClamp;
VkBool32 depthBiasClamp;
VkBool32 fillModeNonSolid;
VkBool32 depthBounds;
VkBool32 wideLines;
VkBool32 largePoints;
VkBool32 alphaToOne;
VkBool32 multiViewport;
VkBool32 samplerAnisotropy;
VkBool32 textureCompressionETC2;
VkBool32 textureCompressionASTC_LDR;
VkBool32 textureCompressionBC;
VkBool32 occlusionQueryPrecise;
VkBool32 pipelineStatisticsQuery;
VkBool32 vertexPipelineStoresAndAtomics;
VkBool32 fragmentStoresAndAtomics;
VkBool32 shaderTessellationAndGeometryPointSize;
VkBool32 shaderImageGatherExtended;
VkBool32 shaderStorageImageExtendedFormats;
VkBool32 shaderStorageImageMultisample;
VkBool32 shaderStorageImageReadWithoutFormat;
VkBool32 shaderStorageImageWriteWithoutFormat;
VkBool32 shaderUniformBufferArrayDynamicIndexing;
VkBool32 shaderSampledImageArrayDynamicIndexing;
VkBool32 shaderStorageBufferArrayDynamicIndexing;
VkBool32 shaderStorageImageArrayDynamicIndexing;
VkBool32 shaderClipDistance;
VkBool32 shaderCullDistance;
VkBool32 shaderFloat64;
VkBool32 shaderInt64;
VkBool32 shaderInt16;
VkBool32 shaderResourceResidency;
VkBool32 shaderResourceMinLod;
VkBool32 sparseBinding;
VkBool32 sparseResidencyBuffer;
VkBool32 sparseResidencyImage2D;
VkBool32 sparseResidencyImage3D;
VkBool32 sparseResidency2Samples;
VkBool32 sparseResidency4Samples;
VkBool32 sparseResidency8Samples;
VkBool32 sparseResidency16Samples;
VkBool32 sparseResidencyAliased;
VkBool32 variableMultisampleRate;
VkBool32 inheritedQueries;
};
struct VkFormatProperties
{
VkFormatFeatureFlags linearTilingFeatures;
VkFormatFeatureFlags optimalTilingFeatures;
VkFormatFeatureFlags bufferFeatures;
};
struct VkExtent3D
{
deUint32 width;
deUint32 height;
deUint32 depth;
};
struct VkImageFormatProperties
{
VkExtent3D maxExtent;
deUint32 maxMipLevels;
deUint32 maxArrayLayers;
VkSampleCountFlags sampleCounts;
VkDeviceSize maxResourceSize;
};
struct VkPhysicalDeviceLimits
{
deUint32 maxImageDimension1D;
deUint32 maxImageDimension2D;
deUint32 maxImageDimension3D;
deUint32 maxImageDimensionCube;
deUint32 maxImageArrayLayers;
deUint32 maxTexelBufferElements;
deUint32 maxUniformBufferRange;
deUint32 maxStorageBufferRange;
deUint32 maxPushConstantsSize;
deUint32 maxMemoryAllocationCount;
deUint32 maxSamplerAllocationCount;
VkDeviceSize bufferImageGranularity;
VkDeviceSize sparseAddressSpaceSize;
deUint32 maxBoundDescriptorSets;
deUint32 maxPerStageDescriptorSamplers;
deUint32 maxPerStageDescriptorUniformBuffers;
deUint32 maxPerStageDescriptorStorageBuffers;
deUint32 maxPerStageDescriptorSampledImages;
deUint32 maxPerStageDescriptorStorageImages;
deUint32 maxPerStageDescriptorInputAttachments;
deUint32 maxPerStageResources;
deUint32 maxDescriptorSetSamplers;
deUint32 maxDescriptorSetUniformBuffers;
deUint32 maxDescriptorSetUniformBuffersDynamic;
deUint32 maxDescriptorSetStorageBuffers;
deUint32 maxDescriptorSetStorageBuffersDynamic;
deUint32 maxDescriptorSetSampledImages;
deUint32 maxDescriptorSetStorageImages;
deUint32 maxDescriptorSetInputAttachments;
deUint32 maxVertexInputAttributes;
deUint32 maxVertexInputBindings;
deUint32 maxVertexInputAttributeOffset;
deUint32 maxVertexInputBindingStride;
deUint32 maxVertexOutputComponents;
deUint32 maxTessellationGenerationLevel;
deUint32 maxTessellationPatchSize;
deUint32 maxTessellationControlPerVertexInputComponents;
deUint32 maxTessellationControlPerVertexOutputComponents;
deUint32 maxTessellationControlPerPatchOutputComponents;
deUint32 maxTessellationControlTotalOutputComponents;
deUint32 maxTessellationEvaluationInputComponents;
deUint32 maxTessellationEvaluationOutputComponents;
deUint32 maxGeometryShaderInvocations;
deUint32 maxGeometryInputComponents;
deUint32 maxGeometryOutputComponents;
deUint32 maxGeometryOutputVertices;
deUint32 maxGeometryTotalOutputComponents;
deUint32 maxFragmentInputComponents;
deUint32 maxFragmentOutputAttachments;
deUint32 maxFragmentDualSrcAttachments;
deUint32 maxFragmentCombinedOutputResources;
deUint32 maxComputeSharedMemorySize;
deUint32 maxComputeWorkGroupCount[3];
deUint32 maxComputeWorkGroupInvocations;
deUint32 maxComputeWorkGroupSize[3];
deUint32 subPixelPrecisionBits;
deUint32 subTexelPrecisionBits;
deUint32 mipmapPrecisionBits;
deUint32 maxDrawIndexedIndexValue;
deUint32 maxDrawIndirectCount;
float maxSamplerLodBias;
float maxSamplerAnisotropy;
deUint32 maxViewports;
deUint32 maxViewportDimensions[2];
float viewportBoundsRange[2];
deUint32 viewportSubPixelBits;
deUintptr minMemoryMapAlignment;
VkDeviceSize minTexelBufferOffsetAlignment;
VkDeviceSize minUniformBufferOffsetAlignment;
VkDeviceSize minStorageBufferOffsetAlignment;
deInt32 minTexelOffset;
deUint32 maxTexelOffset;
deInt32 minTexelGatherOffset;
deUint32 maxTexelGatherOffset;
float minInterpolationOffset;
float maxInterpolationOffset;
deUint32 subPixelInterpolationOffsetBits;
deUint32 maxFramebufferWidth;
deUint32 maxFramebufferHeight;
deUint32 maxFramebufferLayers;
VkSampleCountFlags framebufferColorSampleCounts;
VkSampleCountFlags framebufferDepthSampleCounts;
VkSampleCountFlags framebufferStencilSampleCounts;
VkSampleCountFlags framebufferNoAttachmentsSampleCounts;
deUint32 maxColorAttachments;
VkSampleCountFlags sampledImageColorSampleCounts;
VkSampleCountFlags sampledImageIntegerSampleCounts;
VkSampleCountFlags sampledImageDepthSampleCounts;
VkSampleCountFlags sampledImageStencilSampleCounts;
VkSampleCountFlags storageImageSampleCounts;
deUint32 maxSampleMaskWords;
VkBool32 timestampComputeAndGraphics;
float timestampPeriod;
deUint32 maxClipDistances;
deUint32 maxCullDistances;
deUint32 maxCombinedClipAndCullDistances;
deUint32 discreteQueuePriorities;
float pointSizeRange[2];
float lineWidthRange[2];
float pointSizeGranularity;
float lineWidthGranularity;
VkBool32 strictLines;
VkBool32 standardSampleLocations;
VkDeviceSize optimalBufferCopyOffsetAlignment;
VkDeviceSize optimalBufferCopyRowPitchAlignment;
VkDeviceSize nonCoherentAtomSize;
};
struct VkPhysicalDeviceSparseProperties
{
VkBool32 residencyStandard2DBlockShape;
VkBool32 residencyStandard2DMultisampleBlockShape;
VkBool32 residencyStandard3DBlockShape;
VkBool32 residencyAlignedMipSize;
VkBool32 residencyNonResidentStrict;
};
struct VkPhysicalDeviceProperties
{
deUint32 apiVersion;
deUint32 driverVersion;
deUint32 vendorID;
deUint32 deviceID;
VkPhysicalDeviceType deviceType;
char deviceName[VK_MAX_PHYSICAL_DEVICE_NAME_SIZE];
deUint8 pipelineCacheUUID[VK_UUID_SIZE];
VkPhysicalDeviceLimits limits;
VkPhysicalDeviceSparseProperties sparseProperties;
};
struct VkQueueFamilyProperties
{
VkQueueFlags queueFlags;
deUint32 queueCount;
deUint32 timestampValidBits;
VkExtent3D minImageTransferGranularity;
};
struct VkMemoryType
{
VkMemoryPropertyFlags propertyFlags;
deUint32 heapIndex;
};
struct VkMemoryHeap
{
VkDeviceSize size;
VkMemoryHeapFlags flags;
};
struct VkPhysicalDeviceMemoryProperties
{
deUint32 memoryTypeCount;
VkMemoryType memoryTypes[VK_MAX_MEMORY_TYPES];
deUint32 memoryHeapCount;
VkMemoryHeap memoryHeaps[VK_MAX_MEMORY_HEAPS];
};
struct VkDeviceQueueCreateInfo
{
VkStructureType sType;
const void* pNext;
VkDeviceQueueCreateFlags flags;
deUint32 queueFamilyIndex;
deUint32 queueCount;
const float* pQueuePriorities;
};
struct VkDeviceCreateInfo
{
VkStructureType sType;
const void* pNext;
VkDeviceCreateFlags flags;
deUint32 queueCreateInfoCount;
const VkDeviceQueueCreateInfo* pQueueCreateInfos;
deUint32 enabledLayerCount;
const char* const* ppEnabledLayerNames;
deUint32 enabledExtensionCount;
const char* const* ppEnabledExtensionNames;
const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
struct VkExtensionProperties
{
char extensionName[VK_MAX_EXTENSION_NAME_SIZE];
deUint32 specVersion;
};
struct VkLayerProperties
{
char layerName[VK_MAX_EXTENSION_NAME_SIZE];
deUint32 specVersion;
deUint32 implementationVersion;
char description[VK_MAX_DESCRIPTION_SIZE];
};
struct VkSubmitInfo
{
VkStructureType sType;
const void* pNext;
deUint32 waitSemaphoreCount;
const VkSemaphore* pWaitSemaphores;
const VkPipelineStageFlags* pWaitDstStageMask;
deUint32 commandBufferCount;
const VkCommandBuffer* pCommandBuffers;
deUint32 signalSemaphoreCount;
const VkSemaphore* pSignalSemaphores;
};
struct VkMemoryAllocateInfo
{
VkStructureType sType;
const void* pNext;
VkDeviceSize allocationSize;
deUint32 memoryTypeIndex;
};
struct VkMappedMemoryRange
{
VkStructureType sType;
const void* pNext;
VkDeviceMemory memory;
VkDeviceSize offset;
VkDeviceSize size;
};
struct VkMemoryRequirements
{
VkDeviceSize size;
VkDeviceSize alignment;
deUint32 memoryTypeBits;
};
struct VkSparseImageFormatProperties
{
VkImageAspectFlags aspectMask;
VkExtent3D imageGranularity;
VkSparseImageFormatFlags flags;
};
struct VkSparseImageMemoryRequirements
{
VkSparseImageFormatProperties formatProperties;
deUint32 imageMipTailFirstLod;
VkDeviceSize imageMipTailSize;
VkDeviceSize imageMipTailOffset;
VkDeviceSize imageMipTailStride;
};
struct VkSparseMemoryBind
{
VkDeviceSize resourceOffset;
VkDeviceSize size;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
};
struct VkSparseBufferMemoryBindInfo
{
VkBuffer buffer;
deUint32 bindCount;
const VkSparseMemoryBind* pBinds;
};
struct VkSparseImageOpaqueMemoryBindInfo
{
VkImage image;
deUint32 bindCount;
const VkSparseMemoryBind* pBinds;
};
struct VkImageSubresource
{
VkImageAspectFlags aspectMask;
deUint32 mipLevel;
deUint32 arrayLayer;
};
struct VkOffset3D
{
deInt32 x;
deInt32 y;
deInt32 z;
};
struct VkSparseImageMemoryBind
{
VkImageSubresource subresource;
VkOffset3D offset;
VkExtent3D extent;
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
VkSparseMemoryBindFlags flags;
};
struct VkSparseImageMemoryBindInfo
{
VkImage image;
deUint32 bindCount;
const VkSparseImageMemoryBind* pBinds;
};
struct VkBindSparseInfo
{
VkStructureType sType;
const void* pNext;
deUint32 waitSemaphoreCount;
const VkSemaphore* pWaitSemaphores;
deUint32 bufferBindCount;
const VkSparseBufferMemoryBindInfo* pBufferBinds;
deUint32 imageOpaqueBindCount;
const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds;
deUint32 imageBindCount;
const VkSparseImageMemoryBindInfo* pImageBinds;
deUint32 signalSemaphoreCount;
const VkSemaphore* pSignalSemaphores;
};
struct VkFenceCreateInfo
{
VkStructureType sType;
const void* pNext;
VkFenceCreateFlags flags;
};
struct VkSemaphoreCreateInfo
{
VkStructureType sType;
const void* pNext;
VkSemaphoreCreateFlags flags;
};
struct VkEventCreateInfo
{
VkStructureType sType;
const void* pNext;
VkEventCreateFlags flags;
};
struct VkQueryPoolCreateInfo
{
VkStructureType sType;
const void* pNext;
VkQueryPoolCreateFlags flags;
VkQueryType queryType;
deUint32 queryCount;
VkQueryPipelineStatisticFlags pipelineStatistics;
};
struct VkBufferCreateInfo
{
VkStructureType sType;
const void* pNext;
VkBufferCreateFlags flags;
VkDeviceSize size;
VkBufferUsageFlags usage;
VkSharingMode sharingMode;
deUint32 queueFamilyIndexCount;
const deUint32* pQueueFamilyIndices;
};
struct VkBufferViewCreateInfo
{
VkStructureType sType;
const void* pNext;
VkBufferViewCreateFlags flags;
VkBuffer buffer;
VkFormat format;
VkDeviceSize offset;
VkDeviceSize range;
};
struct VkImageCreateInfo
{
VkStructureType sType;
const void* pNext;
VkImageCreateFlags flags;
VkImageType imageType;
VkFormat format;
VkExtent3D extent;
deUint32 mipLevels;
deUint32 arrayLayers;
VkSampleCountFlagBits samples;
VkImageTiling tiling;
VkImageUsageFlags usage;
VkSharingMode sharingMode;
deUint32 queueFamilyIndexCount;
const deUint32* pQueueFamilyIndices;
VkImageLayout initialLayout;
};
struct VkSubresourceLayout
{
VkDeviceSize offset;
VkDeviceSize size;
VkDeviceSize rowPitch;
VkDeviceSize arrayPitch;
VkDeviceSize depthPitch;
};
struct VkComponentMapping
{
VkComponentSwizzle r;
VkComponentSwizzle g;
VkComponentSwizzle b;
VkComponentSwizzle a;
};
struct VkImageSubresourceRange
{
VkImageAspectFlags aspectMask;
deUint32 baseMipLevel;
deUint32 levelCount;
deUint32 baseArrayLayer;
deUint32 layerCount;
};
struct VkImageViewCreateInfo
{
VkStructureType sType;
const void* pNext;
VkImageViewCreateFlags flags;
VkImage image;
VkImageViewType viewType;
VkFormat format;
VkComponentMapping components;
VkImageSubresourceRange subresourceRange;
};
struct VkShaderModuleCreateInfo
{
VkStructureType sType;
const void* pNext;
VkShaderModuleCreateFlags flags;
deUintptr codeSize;
const deUint32* pCode;
};
struct VkPipelineCacheCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineCacheCreateFlags flags;
deUintptr initialDataSize;
const void* pInitialData;
};
struct VkSpecializationMapEntry
{
deUint32 constantID;
deUint32 offset;
deUintptr size;
};
struct VkSpecializationInfo
{
deUint32 mapEntryCount;
const VkSpecializationMapEntry* pMapEntries;
deUintptr dataSize;
const void* pData;
};
struct VkPipelineShaderStageCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineShaderStageCreateFlags flags;
VkShaderStageFlagBits stage;
VkShaderModule module;
const char* pName;
const VkSpecializationInfo* pSpecializationInfo;
};
struct VkVertexInputBindingDescription
{
deUint32 binding;
deUint32 stride;
VkVertexInputRate inputRate;
};
struct VkVertexInputAttributeDescription
{
deUint32 location;
deUint32 binding;
VkFormat format;
deUint32 offset;
};
struct VkPipelineVertexInputStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineVertexInputStateCreateFlags flags;
deUint32 vertexBindingDescriptionCount;
const VkVertexInputBindingDescription* pVertexBindingDescriptions;
deUint32 vertexAttributeDescriptionCount;
const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
};
struct VkPipelineInputAssemblyStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineInputAssemblyStateCreateFlags flags;
VkPrimitiveTopology topology;
VkBool32 primitiveRestartEnable;
};
struct VkPipelineTessellationStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineTessellationStateCreateFlags flags;
deUint32 patchControlPoints;
};
struct VkViewport
{
float x;
float y;
float width;
float height;
float minDepth;
float maxDepth;
};
struct VkOffset2D
{
deInt32 x;
deInt32 y;
};
struct VkExtent2D
{
deUint32 width;
deUint32 height;
};
struct VkRect2D
{
VkOffset2D offset;
VkExtent2D extent;
};
struct VkPipelineViewportStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineViewportStateCreateFlags flags;
deUint32 viewportCount;
const VkViewport* pViewports;
deUint32 scissorCount;
const VkRect2D* pScissors;
};
struct VkPipelineRasterizationStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineRasterizationStateCreateFlags flags;
VkBool32 depthClampEnable;
VkBool32 rasterizerDiscardEnable;
VkPolygonMode polygonMode;
VkCullModeFlags cullMode;
VkFrontFace frontFace;
VkBool32 depthBiasEnable;
float depthBiasConstantFactor;
float depthBiasClamp;
float depthBiasSlopeFactor;
float lineWidth;
};
struct VkPipelineMultisampleStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineMultisampleStateCreateFlags flags;
VkSampleCountFlagBits rasterizationSamples;
VkBool32 sampleShadingEnable;
float minSampleShading;
const VkSampleMask* pSampleMask;
VkBool32 alphaToCoverageEnable;
VkBool32 alphaToOneEnable;
};
struct VkStencilOpState
{
VkStencilOp failOp;
VkStencilOp passOp;
VkStencilOp depthFailOp;
VkCompareOp compareOp;
deUint32 compareMask;
deUint32 writeMask;
deUint32 reference;
};
struct VkPipelineDepthStencilStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineDepthStencilStateCreateFlags flags;
VkBool32 depthTestEnable;
VkBool32 depthWriteEnable;
VkCompareOp depthCompareOp;
VkBool32 depthBoundsTestEnable;
VkBool32 stencilTestEnable;
VkStencilOpState front;
VkStencilOpState back;
float minDepthBounds;
float maxDepthBounds;
};
struct VkPipelineColorBlendAttachmentState
{
VkBool32 blendEnable;
VkBlendFactor srcColorBlendFactor;
VkBlendFactor dstColorBlendFactor;
VkBlendOp colorBlendOp;
VkBlendFactor srcAlphaBlendFactor;
VkBlendFactor dstAlphaBlendFactor;
VkBlendOp alphaBlendOp;
VkColorComponentFlags colorWriteMask;
};
struct VkPipelineColorBlendStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineColorBlendStateCreateFlags flags;
VkBool32 logicOpEnable;
VkLogicOp logicOp;
deUint32 attachmentCount;
const VkPipelineColorBlendAttachmentState* pAttachments;
float blendConstants[4];
};
struct VkPipelineDynamicStateCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineDynamicStateCreateFlags flags;
deUint32 dynamicStateCount;
const VkDynamicState* pDynamicStates;
};
struct VkGraphicsPipelineCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineCreateFlags flags;
deUint32 stageCount;
const VkPipelineShaderStageCreateInfo* pStages;
const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
const VkPipelineTessellationStateCreateInfo* pTessellationState;
const VkPipelineViewportStateCreateInfo* pViewportState;
const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
const VkPipelineDynamicStateCreateInfo* pDynamicState;
VkPipelineLayout layout;
VkRenderPass renderPass;
deUint32 subpass;
VkPipeline basePipelineHandle;
deInt32 basePipelineIndex;
};
struct VkComputePipelineCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineCreateFlags flags;
VkPipelineShaderStageCreateInfo stage;
VkPipelineLayout layout;
VkPipeline basePipelineHandle;
deInt32 basePipelineIndex;
};
struct VkPushConstantRange
{
VkShaderStageFlags stageFlags;
deUint32 offset;
deUint32 size;
};
struct VkPipelineLayoutCreateInfo
{
VkStructureType sType;
const void* pNext;
VkPipelineLayoutCreateFlags flags;
deUint32 setLayoutCount;
const VkDescriptorSetLayout* pSetLayouts;
deUint32 pushConstantRangeCount;
const VkPushConstantRange* pPushConstantRanges;
};
struct VkSamplerCreateInfo
{
VkStructureType sType;
const void* pNext;
VkSamplerCreateFlags flags;
VkFilter magFilter;
VkFilter minFilter;
VkSamplerMipmapMode mipmapMode;
VkSamplerAddressMode addressModeU;
VkSamplerAddressMode addressModeV;
VkSamplerAddressMode addressModeW;
float mipLodBias;
VkBool32 anisotropyEnable;
float maxAnisotropy;
VkBool32 compareEnable;
VkCompareOp compareOp;
float minLod;
float maxLod;
VkBorderColor borderColor;
VkBool32 unnormalizedCoordinates;
};
struct VkDescriptorSetLayoutBinding
{
deUint32 binding;
VkDescriptorType descriptorType;
deUint32 descriptorCount;
VkShaderStageFlags stageFlags;
const VkSampler* pImmutableSamplers;
};
struct VkDescriptorSetLayoutCreateInfo
{
VkStructureType sType;
const void* pNext;
VkDescriptorSetLayoutCreateFlags flags;
deUint32 bindingCount;
const VkDescriptorSetLayoutBinding* pBindings;
};
struct VkDescriptorPoolSize
{
VkDescriptorType type;
deUint32 descriptorCount;
};
struct VkDescriptorPoolCreateInfo
{
VkStructureType sType;
const void* pNext;
VkDescriptorPoolCreateFlags flags;
deUint32 maxSets;
deUint32 poolSizeCount;
const VkDescriptorPoolSize* pPoolSizes;
};
struct VkDescriptorSetAllocateInfo
{
VkStructureType sType;
const void* pNext;
VkDescriptorPool descriptorPool;
deUint32 descriptorSetCount;
const VkDescriptorSetLayout* pSetLayouts;
};
struct VkDescriptorImageInfo
{
VkSampler sampler;
VkImageView imageView;
VkImageLayout imageLayout;
};
struct VkDescriptorBufferInfo
{
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize range;
};
struct VkWriteDescriptorSet
{
VkStructureType sType;
const void* pNext;
VkDescriptorSet dstSet;
deUint32 dstBinding;
deUint32 dstArrayElement;
deUint32 descriptorCount;
VkDescriptorType descriptorType;
const VkDescriptorImageInfo* pImageInfo;
const VkDescriptorBufferInfo* pBufferInfo;
const VkBufferView* pTexelBufferView;
};
struct VkCopyDescriptorSet
{
VkStructureType sType;
const void* pNext;
VkDescriptorSet srcSet;
deUint32 srcBinding;
deUint32 srcArrayElement;
VkDescriptorSet dstSet;
deUint32 dstBinding;
deUint32 dstArrayElement;
deUint32 descriptorCount;
};
struct VkFramebufferCreateInfo
{
VkStructureType sType;
const void* pNext;
VkFramebufferCreateFlags flags;
VkRenderPass renderPass;
deUint32 attachmentCount;
const VkImageView* pAttachments;
deUint32 width;
deUint32 height;
deUint32 layers;
};
struct VkAttachmentDescription
{
VkAttachmentDescriptionFlags flags;
VkFormat format;
VkSampleCountFlagBits samples;
VkAttachmentLoadOp loadOp;
VkAttachmentStoreOp storeOp;
VkAttachmentLoadOp stencilLoadOp;
VkAttachmentStoreOp stencilStoreOp;
VkImageLayout initialLayout;
VkImageLayout finalLayout;
};
struct VkAttachmentReference
{
deUint32 attachment;
VkImageLayout layout;
};
struct VkSubpassDescription
{
VkSubpassDescriptionFlags flags;
VkPipelineBindPoint pipelineBindPoint;
deUint32 inputAttachmentCount;
const VkAttachmentReference* pInputAttachments;
deUint32 colorAttachmentCount;
const VkAttachmentReference* pColorAttachments;
const VkAttachmentReference* pResolveAttachments;
const VkAttachmentReference* pDepthStencilAttachment;
deUint32 preserveAttachmentCount;
const deUint32* pPreserveAttachments;
};
struct VkSubpassDependency
{
deUint32 srcSubpass;
deUint32 dstSubpass;
VkPipelineStageFlags srcStageMask;
VkPipelineStageFlags dstStageMask;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
VkDependencyFlags dependencyFlags;
};
struct VkRenderPassCreateInfo
{
VkStructureType sType;
const void* pNext;
VkRenderPassCreateFlags flags;
deUint32 attachmentCount;
const VkAttachmentDescription* pAttachments;
deUint32 subpassCount;
const VkSubpassDescription* pSubpasses;
deUint32 dependencyCount;
const VkSubpassDependency* pDependencies;
};
struct VkCommandPoolCreateInfo
{
VkStructureType sType;
const void* pNext;
VkCommandPoolCreateFlags flags;
deUint32 queueFamilyIndex;
};
struct VkCommandBufferAllocateInfo
{
VkStructureType sType;
const void* pNext;
VkCommandPool commandPool;
VkCommandBufferLevel level;
deUint32 commandBufferCount;
};
struct VkCommandBufferInheritanceInfo
{
VkStructureType sType;
const void* pNext;
VkRenderPass renderPass;
deUint32 subpass;
VkFramebuffer framebuffer;
VkBool32 occlusionQueryEnable;
VkQueryControlFlags queryFlags;
VkQueryPipelineStatisticFlags pipelineStatistics;
};
struct VkCommandBufferBeginInfo
{
VkStructureType sType;
const void* pNext;
VkCommandBufferUsageFlags flags;
const VkCommandBufferInheritanceInfo* pInheritanceInfo;
};
struct VkBufferCopy
{
VkDeviceSize srcOffset;
VkDeviceSize dstOffset;
VkDeviceSize size;
};
struct VkImageSubresourceLayers
{
VkImageAspectFlags aspectMask;
deUint32 mipLevel;
deUint32 baseArrayLayer;
deUint32 layerCount;
};
struct VkImageCopy
{
VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D extent;
};
struct VkImageBlit
{
VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffsets[2];
VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffsets[2];
};
struct VkBufferImageCopy
{
VkDeviceSize bufferOffset;
deUint32 bufferRowLength;
deUint32 bufferImageHeight;
VkImageSubresourceLayers imageSubresource;
VkOffset3D imageOffset;
VkExtent3D imageExtent;
};
union VkClearColorValue
{
float float32[4];
deInt32 int32[4];
deUint32 uint32[4];
};
struct VkClearDepthStencilValue
{
float depth;
deUint32 stencil;
};
union VkClearValue
{
VkClearColorValue color;
VkClearDepthStencilValue depthStencil;
};
struct VkClearAttachment
{
VkImageAspectFlags aspectMask;
deUint32 colorAttachment;
VkClearValue clearValue;
};
struct VkClearRect
{
VkRect2D rect;
deUint32 baseArrayLayer;
deUint32 layerCount;
};
struct VkImageResolve
{
VkImageSubresourceLayers srcSubresource;
VkOffset3D srcOffset;
VkImageSubresourceLayers dstSubresource;
VkOffset3D dstOffset;
VkExtent3D extent;
};
struct VkMemoryBarrier
{
VkStructureType sType;
const void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
};
struct VkBufferMemoryBarrier
{
VkStructureType sType;
const void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
deUint32 srcQueueFamilyIndex;
deUint32 dstQueueFamilyIndex;
VkBuffer buffer;
VkDeviceSize offset;
VkDeviceSize size;
};
struct VkImageMemoryBarrier
{
VkStructureType sType;
const void* pNext;
VkAccessFlags srcAccessMask;
VkAccessFlags dstAccessMask;
VkImageLayout oldLayout;
VkImageLayout newLayout;
deUint32 srcQueueFamilyIndex;
deUint32 dstQueueFamilyIndex;
VkImage image;
VkImageSubresourceRange subresourceRange;
};
struct VkRenderPassBeginInfo
{
VkStructureType sType;
const void* pNext;
VkRenderPass renderPass;
VkFramebuffer framebuffer;
VkRect2D renderArea;
deUint32 clearValueCount;
const VkClearValue* pClearValues;
};
struct VkDispatchIndirectCommand
{
deUint32 x;
deUint32 y;
deUint32 z;
};
struct VkDrawIndexedIndirectCommand
{
deUint32 indexCount;
deUint32 instanceCount;
deUint32 firstIndex;
deInt32 vertexOffset;
deUint32 firstInstance;
};
struct VkDrawIndirectCommand
{
deUint32 vertexCount;
deUint32 instanceCount;
deUint32 firstVertex;
deUint32 firstInstance;
};
struct VkSurfaceCapabilitiesKHR
{
deUint32 minImageCount;
deUint32 maxImageCount;
VkExtent2D currentExtent;
VkExtent2D minImageExtent;
VkExtent2D maxImageExtent;
deUint32 maxImageArrayLayers;
VkSurfaceTransformFlagsKHR supportedTransforms;
VkSurfaceTransformFlagBitsKHR currentTransform;
VkCompositeAlphaFlagsKHR supportedCompositeAlpha;
VkImageUsageFlags supportedUsageFlags;
};
struct VkSurfaceFormatKHR
{
VkFormat format;
VkColorSpaceKHR colorSpace;
};
struct VkSwapchainCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkSwapchainCreateFlagsKHR flags;
VkSurfaceKHR surface;
deUint32 minImageCount;
VkFormat imageFormat;
VkColorSpaceKHR imageColorSpace;
VkExtent2D imageExtent;
deUint32 imageArrayLayers;
VkImageUsageFlags imageUsage;
VkSharingMode imageSharingMode;
deUint32 queueFamilyIndexCount;
const deUint32* pQueueFamilyIndices;
VkSurfaceTransformFlagBitsKHR preTransform;
VkCompositeAlphaFlagBitsKHR compositeAlpha;
VkPresentModeKHR presentMode;
VkBool32 clipped;
VkSwapchainKHR oldSwapchain;
};
struct VkPresentInfoKHR
{
VkStructureType sType;
const void* pNext;
deUint32 waitSemaphoreCount;
const VkSemaphore* pWaitSemaphores;
deUint32 swapchainCount;
const VkSwapchainKHR* pSwapchains;
const deUint32* pImageIndices;
VkResult* pResults;
};
struct VkDisplayPropertiesKHR
{
VkDisplayKHR display;
const char* displayName;
VkExtent2D physicalDimensions;
VkExtent2D physicalResolution;
VkSurfaceTransformFlagsKHR supportedTransforms;
VkBool32 planeReorderPossible;
VkBool32 persistentContent;
};
struct VkDisplayModeParametersKHR
{
VkExtent2D visibleRegion;
deUint32 refreshRate;
};
struct VkDisplayModePropertiesKHR
{
VkDisplayModeKHR displayMode;
VkDisplayModeParametersKHR parameters;
};
struct VkDisplayModeCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkDisplayModeCreateFlagsKHR flags;
VkDisplayModeParametersKHR parameters;
};
struct VkDisplayPlaneCapabilitiesKHR
{
VkDisplayPlaneAlphaFlagsKHR supportedAlpha;
VkOffset2D minSrcPosition;
VkOffset2D maxSrcPosition;
VkExtent2D minSrcExtent;
VkExtent2D maxSrcExtent;
VkOffset2D minDstPosition;
VkOffset2D maxDstPosition;
VkExtent2D minDstExtent;
VkExtent2D maxDstExtent;
};
struct VkDisplayPlanePropertiesKHR
{
VkDisplayKHR currentDisplay;
deUint32 currentStackIndex;
};
struct VkDisplaySurfaceCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkDisplaySurfaceCreateFlagsKHR flags;
VkDisplayModeKHR displayMode;
deUint32 planeIndex;
deUint32 planeStackIndex;
VkSurfaceTransformFlagBitsKHR transform;
float globalAlpha;
VkDisplayPlaneAlphaFlagBitsKHR alphaMode;
VkExtent2D imageExtent;
};
struct VkDisplayPresentInfoKHR
{
VkStructureType sType;
const void* pNext;
VkRect2D srcRect;
VkRect2D dstRect;
VkBool32 persistent;
};
struct VkXlibSurfaceCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkXlibSurfaceCreateFlagsKHR flags;
pt::XlibDisplayPtr dpy;
pt::XlibWindow window;
};
struct VkXcbSurfaceCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkXcbSurfaceCreateFlagsKHR flags;
pt::XcbConnectionPtr connection;
pt::XcbWindow window;
};
struct VkWaylandSurfaceCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkWaylandSurfaceCreateFlagsKHR flags;
pt::WaylandDisplayPtr display;
pt::WaylandSurfacePtr surface;
};
struct VkMirSurfaceCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkMirSurfaceCreateFlagsKHR flags;
pt::MirConnectionPtr connection;
pt::MirSurfacePtr mirSurface;
};
struct VkAndroidSurfaceCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkAndroidSurfaceCreateFlagsKHR flags;
pt::AndroidNativeWindowPtr window;
};
struct VkWin32SurfaceCreateInfoKHR
{
VkStructureType sType;
const void* pNext;
VkWin32SurfaceCreateFlagsKHR flags;
pt::Win32InstanceHandle hinstance;
pt::Win32WindowHandle hwnd;
};
struct VkPhysicalDeviceFeatures2KHR
{
VkStructureType sType;
void* pNext;
VkPhysicalDeviceFeatures features;
};
struct VkPhysicalDeviceProperties2KHR
{
VkStructureType sType;
void* pNext;
VkPhysicalDeviceProperties properties;
};
struct VkFormatProperties2KHR
{
VkStructureType sType;
void* pNext;
VkFormatProperties formatProperties;
};
struct VkImageFormatProperties2KHR
{
VkStructureType sType;
void* pNext;
VkImageFormatProperties imageFormatProperties;
};
struct VkPhysicalDeviceImageFormatInfo2KHR
{
VkStructureType sType;
const void* pNext;
VkFormat format;
VkImageType type;
VkImageTiling tiling;
VkImageUsageFlags usage;
VkImageCreateFlags flags;
};
struct VkQueueFamilyProperties2KHR
{
VkStructureType sType;
void* pNext;
VkQueueFamilyProperties queueFamilyProperties;
};
struct VkPhysicalDeviceMemoryProperties2KHR
{
VkStructureType sType;
void* pNext;
VkPhysicalDeviceMemoryProperties memoryProperties;
};
struct VkSparseImageFormatProperties2KHR
{
VkStructureType sType;
void* pNext;
VkSparseImageFormatProperties properties;
};
struct VkPhysicalDeviceSparseImageFormatInfo2KHR
{
VkStructureType sType;
const void* pNext;
VkFormat format;
VkImageType type;
VkSampleCountFlagBits samples;
VkImageUsageFlags usage;
VkImageTiling tiling;
};
struct VkRectLayerKHR
{
VkOffset2D offset;
VkExtent2D extent;
deUint32 layer;
};
struct VkPresentRegionKHR
{
deUint32 rectangleCount;
const VkRectLayerKHR* pRectangles;
};
struct VkPresentRegionsKHR
{
VkStructureType sType;
const void* pNext;
deUint32 swapchainCount;
const VkPresentRegionKHR* pRegions;
};
struct VkPhysicalDeviceSurfaceInfo2KHR
{
VkStructureType sType;
const void* pNext;
VkSurfaceKHR surface;
};
struct VkSurfaceCapabilities2KHR
{
VkStructureType sType;
void* pNext;
VkSurfaceCapabilitiesKHR surfaceCapabilities;
};
struct VkSurfaceFormat2KHR
{
VkStructureType sType;
void* pNext;
VkSurfaceFormatKHR surfaceFormat;
};
struct VkSharedPresentSurfaceCapabilitiesKHR
{
VkStructureType sType;
void* pNext;
VkImageUsageFlags sharedPresentSupportedUsageFlags;
};
struct VkDebugReportCallbackCreateInfoEXT
{
VkStructureType sType;
const void* pNext;
VkDebugReportFlagsEXT flags;
PFN_vkDebugReportCallbackEXT pfnCallback;
void* pUserData;
};
struct VkPipelineRasterizationStateRasterizationOrderAMD
{
VkStructureType sType;
const void* pNext;
VkRasterizationOrderAMD rasterizationOrder;
};
struct VkDebugMarkerObjectNameInfoEXT
{
VkStructureType sType;
const void* pNext;
VkDebugReportObjectTypeEXT objectType;
deUint64 object;
const char* pObjectName;
};
struct VkDebugMarkerObjectTagInfoEXT
{
VkStructureType sType;
const void* pNext;
VkDebugReportObjectTypeEXT objectType;
deUint64 object;
deUint64 tagName;
deUintptr tagSize;
const void* pTag;
};
struct VkDebugMarkerMarkerInfoEXT
{
VkStructureType sType;
const void* pNext;
const char* pMarkerName;
float color[4];
};
struct VkDedicatedAllocationImageCreateInfoNV
{
VkStructureType sType;
const void* pNext;
VkBool32 dedicatedAllocation;
};
struct VkDedicatedAllocationBufferCreateInfoNV
{
VkStructureType sType;
const void* pNext;
VkBool32 dedicatedAllocation;
};
struct VkDedicatedAllocationMemoryAllocateInfoNV
{
VkStructureType sType;
const void* pNext;
VkImage image;
VkBuffer buffer;
};
struct VkExternalImageFormatPropertiesNV
{
VkImageFormatProperties imageFormatProperties;
VkExternalMemoryFeatureFlagsNV externalMemoryFeatures;
VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes;
VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes;
};
struct VkExternalMemoryImageCreateInfoNV
{
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlagsNV handleTypes;
};
struct VkExportMemoryAllocateInfoNV
{
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlagsNV handleTypes;
};
struct VkImportMemoryWin32HandleInfoNV
{
VkStructureType sType;
const void* pNext;
VkExternalMemoryHandleTypeFlagsNV handleType;
pt::Win32Handle handle;
};
struct VkExportMemoryWin32HandleInfoNV
{
VkStructureType sType;
const void* pNext;
pt::Win32SecurityAttributesPtr pAttributes;
deUint32 dwAccess;
};
struct VkWin32KeyedMutexAcquireReleaseInfoNV
{
VkStructureType sType;
const void* pNext;
deUint32 acquireCount;
const VkDeviceMemory* pAcquireSyncs;
const deUint64* pAcquireKeys;
const deUint32* pAcquireTimeoutMilliseconds;
deUint32 releaseCount;
const VkDeviceMemory* pReleaseSyncs;
const deUint64* pReleaseKeys;
};
struct VkValidationFlagsEXT
{
VkStructureType sType;
const void* pNext;
deUint32 disabledValidationCheckCount;
VkValidationCheckEXT* pDisabledValidationChecks;
};
struct VkDeviceGeneratedCommandsFeaturesNVX
{
VkStructureType sType;
const void* pNext;
VkBool32 computeBindingPointSupport;
};
struct VkDeviceGeneratedCommandsLimitsNVX
{
VkStructureType sType;
const void* pNext;
deUint32 maxIndirectCommandsLayoutTokenCount;
deUint32 maxObjectEntryCounts;
deUint32 minSequenceCountBufferOffsetAlignment;
deUint32 minSequenceIndexBufferOffsetAlignment;
deUint32 minCommandsTokenBufferOffsetAlignment;
};
struct VkIndirectCommandsTokenNVX
{
VkIndirectCommandsTokenTypeNVX tokenType;
VkBuffer buffer;
VkDeviceSize offset;
};
struct VkIndirectCommandsLayoutTokenNVX
{
VkIndirectCommandsTokenTypeNVX tokenType;
deUint32 bindingUnit;
deUint32 dynamicCount;
deUint32 divisor;
};
struct VkIndirectCommandsLayoutCreateInfoNVX
{
VkStructureType sType;
const void* pNext;
VkPipelineBindPoint pipelineBindPoint;
VkIndirectCommandsLayoutUsageFlagsNVX flags;
deUint32 tokenCount;
const VkIndirectCommandsLayoutTokenNVX* pTokens;
};
struct VkCmdProcessCommandsInfoNVX
{
VkStructureType sType;
const void* pNext;
VkObjectTableNVX objectTable;
VkIndirectCommandsLayoutNVX indirectCommandsLayout;
deUint32 indirectCommandsTokenCount;
const VkIndirectCommandsTokenNVX* pIndirectCommandsTokens;
deUint32 maxSequencesCount;
VkCommandBuffer targetCommandBuffer;
VkBuffer sequencesCountBuffer;
VkDeviceSize sequencesCountOffset;
VkBuffer sequencesIndexBuffer;
VkDeviceSize sequencesIndexOffset;
};
struct VkCmdReserveSpaceForCommandsInfoNVX
{
VkStructureType sType;
const void* pNext;
VkObjectTableNVX objectTable;
VkIndirectCommandsLayoutNVX indirectCommandsLayout;
deUint32 maxSequencesCount;
};
struct VkObjectTableCreateInfoNVX
{
VkStructureType sType;
const void* pNext;
deUint32 objectCount;
const VkObjectEntryTypeNVX* pObjectEntryTypes;
const deUint32* pObjectEntryCounts;
const VkObjectEntryUsageFlagsNVX* pObjectEntryUsageFlags;
deUint32 maxUniformBuffersPerDescriptor;
deUint32 maxStorageBuffersPerDescriptor;
deUint32 maxStorageImagesPerDescriptor;
deUint32 maxSampledImagesPerDescriptor;
deUint32 maxPipelineLayouts;
};
struct VkObjectTableEntryNVX
{
VkObjectEntryTypeNVX type;
VkObjectEntryUsageFlagsNVX flags;
};
struct VkObjectTablePipelineEntryNVX
{
VkObjectEntryTypeNVX type;
VkObjectEntryUsageFlagsNVX flags;
VkPipeline pipeline;
};
struct VkObjectTableDescriptorSetEntryNVX
{
VkObjectEntryTypeNVX type;
VkObjectEntryUsageFlagsNVX flags;
VkPipelineLayout pipelineLayout;
VkDescriptorSet descriptorSet;
};
struct VkObjectTableVertexBufferEntryNVX
{
VkObjectEntryTypeNVX type;
VkObjectEntryUsageFlagsNVX flags;
VkBuffer buffer;
};
struct VkObjectTableIndexBufferEntryNVX
{
VkObjectEntryTypeNVX type;
VkObjectEntryUsageFlagsNVX flags;
VkBuffer buffer;
};
struct VkObjectTablePushConstantEntryNVX
{
VkObjectEntryTypeNVX type;
VkObjectEntryUsageFlagsNVX flags;
VkPipelineLayout pipelineLayout;
VkShaderStageFlags stageFlags;
};
struct VkPhysicalDevicePushDescriptorPropertiesKHR
{
VkStructureType sType;
void* pNext;
deUint32 maxPushDescriptors;
};
struct VkDescriptorUpdateTemplateEntryKHR
{
deUint32 dstBinding;
deUint32 dstArrayElement;
deUint32 descriptorCount;
VkDescriptorType descriptorType;
deUintptr offset;
deUintptr stride;
};
struct VkDescriptorUpdateTemplateCreateInfoKHR
{
VkStructureType sType;
void* pNext;
VkDescriptorUpdateTemplateCreateFlagsKHR flags;
deUint32 descriptorUpdateEntryCount;
const VkDescriptorUpdateTemplateEntryKHR* pDescriptorUpdateEntries;
VkDescriptorUpdateTemplateTypeKHR templateType;
VkDescriptorSetLayout descriptorSetLayout;
VkPipelineBindPoint pipelineBindPoint;
VkPipelineLayout pipelineLayout;
deUint32 set;
};
struct VkRefreshCycleDurationGOOGLE
{
deUint64 refreshDuration;
};
struct VkPastPresentationTimingGOOGLE
{
deUint32 presentID;
deUint64 desiredPresentTime;
deUint64 actualPresentTime;
deUint64 earliestPresentTime;
deUint64 presentMargin;
};
struct VkPresentTimeGOOGLE
{
deUint32 presentID;
deUint64 desiredPresentTime;
};
struct VkPresentTimesInfoGOOGLE
{
VkStructureType sType;
const void* pNext;
deUint32 swapchainCount;
const VkPresentTimeGOOGLE* pTimes;
};