Add tests for VK_KHR_image_format_list
[platform/upstream/VK-GL-CTS.git] / external / vulkancts / framework / vulkan / vkStructTypes.inl
index 195c97f..688950f 100644 (file)
@@ -1434,6 +1434,23 @@ struct VkPhysicalDeviceSparseImageFormatInfo2KHR
        VkImageTiling                   tiling;
 };
 
+struct VkPhysicalDevicePushDescriptorPropertiesKHR
+{
+       VkStructureType sType;
+       void*                   pNext;
+       deUint32                maxPushDescriptors;
+};
+
+struct VkPhysicalDevice16BitStorageFeaturesKHR
+{
+       VkStructureType sType;
+       void*                   pNext;
+       VkBool32                storageBuffer16BitAccess;
+       VkBool32                uniformAndStorageBuffer16BitAccess;
+       VkBool32                storagePushConstant16;
+       VkBool32                storageInputOutput16;
+};
+
 struct VkRectLayerKHR
 {
        VkOffset2D      offset;
@@ -1455,6 +1472,73 @@ struct VkPresentRegionsKHR
        const VkPresentRegionKHR*       pRegions;
 };
 
+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 VkSharedPresentSurfaceCapabilitiesKHR
+{
+       VkStructureType         sType;
+       void*                           pNext;
+       VkImageUsageFlags       sharedPresentSupportedUsageFlags;
+};
+
+struct VkPhysicalDevicePointClippingPropertiesKHR
+{
+       VkStructureType                         sType;
+       void*                                           pNext;
+       VkPointClippingBehaviorKHR      pointClippingBehavior;
+};
+
+struct VkInputAttachmentAspectReferenceKHR
+{
+       deUint32                        subpass;
+       deUint32                        inputAttachmentIndex;
+       VkImageAspectFlags      aspectMask;
+};
+
+struct VkRenderPassInputAttachmentAspectCreateInfoKHR
+{
+       VkStructureType                                                         sType;
+       const void*                                                                     pNext;
+       deUint32                                                                        aspectReferenceCount;
+       const VkInputAttachmentAspectReferenceKHR*      pAspectReferences;
+};
+
+struct VkImageViewUsageCreateInfoKHR
+{
+       VkStructureType         sType;
+       const void*                     pNext;
+       VkImageUsageFlags       usage;
+};
+
+struct VkPipelineTessellationDomainOriginStateCreateInfoKHR
+{
+       VkStructureType                                 sType;
+       const void*                                             pNext;
+       VkTessellationDomainOriginKHR   domainOrigin;
+};
+
 struct VkPhysicalDeviceSurfaceInfo2KHR
 {
        VkStructureType sType;
@@ -1476,286 +1560,387 @@ struct VkSurfaceFormat2KHR
        VkSurfaceFormatKHR      surfaceFormat;
 };
 
-struct VkDebugReportCallbackCreateInfoEXT
+struct VkPhysicalDeviceExternalFenceInfoKHR
+{
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkExternalFenceHandleTypeFlagBitsKHR    handleType;
+};
+
+struct VkExternalFencePropertiesKHR
+{
+       VkStructureType                                         sType;
+       void*                                                           pNext;
+       VkExternalFenceHandleTypeFlagsKHR       exportFromImportedHandleTypes;
+       VkExternalFenceHandleTypeFlagsKHR       compatibleHandleTypes;
+       VkExternalFenceFeatureFlagsKHR          externalFenceFeatures;
+};
+
+struct VkExportFenceCreateInfoKHR
+{
+       VkStructureType                                         sType;
+       const void*                                                     pNext;
+       VkExternalFenceHandleTypeFlagsKHR       handleTypes;
+};
+
+struct VkImportFenceWin32HandleInfoKHR
+{
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkFence                                                                 fence;
+       VkFenceImportFlagsKHR                                   flags;
+       VkExternalFenceHandleTypeFlagBitsKHR    handleType;
+       pt::Win32Handle                                                 handle;
+       char*                                                                   name;
+};
+
+struct VkExportFenceWin32HandleInfoKHR
 {
        VkStructureType                                 sType;
        const void*                                             pNext;
-       VkDebugReportFlagsEXT                   flags;
-       PFN_vkDebugReportCallbackEXT    pfnCallback;
-       void*                                                   pUserData;
+       pt::Win32SecurityAttributesPtr  pAttributes;
+       deUint32                                                dwAccess;
+       char*                                                   name;
 };
 
-struct VkPipelineRasterizationStateRasterizationOrderAMD
+struct VkFenceGetWin32HandleInfoKHR
 {
-       VkStructureType                 sType;
-       const void*                             pNext;
-       VkRasterizationOrderAMD rasterizationOrder;
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkFence                                                                 fence;
+       VkExternalFenceHandleTypeFlagBitsKHR    handleType;
 };
 
-struct VkDebugMarkerObjectNameInfoEXT
+struct VkImportFenceFdInfoKHR
 {
-       VkStructureType                         sType;
-       const void*                                     pNext;
-       VkDebugReportObjectTypeEXT      objectType;
-       deUint64                                        object;
-       const char*                                     pObjectName;
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkFence                                                                 fence;
+       VkFenceImportFlagsKHR                                   flags;
+       VkExternalFenceHandleTypeFlagBitsKHR    handleType;
+       int                                                                             fd;
 };
 
-struct VkDebugMarkerObjectTagInfoEXT
+struct VkFenceGetFdInfoKHR
 {
-       VkStructureType                         sType;
-       const void*                                     pNext;
-       VkDebugReportObjectTypeEXT      objectType;
-       deUint64                                        object;
-       deUint64                                        tagName;
-       deUintptr                                       tagSize;
-       const void*                                     pTag;
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkFence                                                                 fence;
+       VkExternalFenceHandleTypeFlagBitsKHR    handleType;
 };
 
-struct VkDebugMarkerMarkerInfoEXT
+struct VkMemoryDedicatedRequirementsKHR
 {
        VkStructureType sType;
-       const void*             pNext;
-       const char*             pMarkerName;
-       float                   color[4];
+       void*                   pNext;
+       VkBool32                prefersDedicatedAllocation;
+       VkBool32                requiresDedicatedAllocation;
 };
 
-struct VkDedicatedAllocationImageCreateInfoNV
+struct VkMemoryDedicatedAllocateInfoKHR
 {
        VkStructureType sType;
        const void*             pNext;
-       VkBool32                dedicatedAllocation;
+       VkImage                 image;
+       VkBuffer                buffer;
 };
 
-struct VkDedicatedAllocationBufferCreateInfoNV
+struct VkBufferMemoryRequirementsInfo2KHR
 {
        VkStructureType sType;
        const void*             pNext;
-       VkBool32                dedicatedAllocation;
+       VkBuffer                buffer;
 };
 
-struct VkDedicatedAllocationMemoryAllocateInfoNV
+struct VkImageMemoryRequirementsInfo2KHR
 {
        VkStructureType sType;
        const void*             pNext;
        VkImage                 image;
-       VkBuffer                buffer;
 };
 
-struct VkExternalImageFormatPropertiesNV
+struct VkImageSparseMemoryRequirementsInfo2KHR
 {
-       VkImageFormatProperties                         imageFormatProperties;
-       VkExternalMemoryFeatureFlagsNV          externalMemoryFeatures;
-       VkExternalMemoryHandleTypeFlagsNV       exportFromImportedHandleTypes;
-       VkExternalMemoryHandleTypeFlagsNV       compatibleHandleTypes;
+       VkStructureType sType;
+       const void*             pNext;
+       VkImage                 image;
 };
 
-struct VkExternalMemoryImageCreateInfoNV
+struct VkMemoryRequirements2KHR
 {
-       VkStructureType                                         sType;
-       const void*                                                     pNext;
-       VkExternalMemoryHandleTypeFlagsNV       handleTypes;
+       VkStructureType                 sType;
+       void*                                   pNext;
+       VkMemoryRequirements    memoryRequirements;
 };
 
-struct VkExportMemoryAllocateInfoNV
+struct VkSparseImageMemoryRequirements2KHR
 {
-       VkStructureType                                         sType;
-       const void*                                                     pNext;
-       VkExternalMemoryHandleTypeFlagsNV       handleTypes;
+       VkStructureType                                 sType;
+       void*                                                   pNext;
+       VkSparseImageMemoryRequirements memoryRequirements;
 };
 
-struct VkImportMemoryWin32HandleInfoNV
+struct VkImageFormatListCreateInfoKHR
 {
-       VkStructureType                                         sType;
-       const void*                                                     pNext;
-       VkExternalMemoryHandleTypeFlagsNV       handleType;
-       pt::Win32Handle                                         handle;
+       VkStructureType sType;
+       const void*             pNext;
+       deUint32                viewFormatCount;
+       const VkFormat* pViewFormats;
 };
 
-struct VkExportMemoryWin32HandleInfoNV
+struct VkDebugReportCallbackCreateInfoEXT
 {
        VkStructureType                                 sType;
        const void*                                             pNext;
-       pt::Win32SecurityAttributesPtr  pAttributes;
-       deUint32                                                dwAccess;
+       VkDebugReportFlagsEXT                   flags;
+       PFN_vkDebugReportCallbackEXT    pfnCallback;
+       void*                                                   pUserData;
 };
 
-struct VkWin32KeyedMutexAcquireReleaseInfoNV
+struct VkRenderPassMultiviewCreateInfoKHX
 {
-       VkStructureType                 sType;
-       const void*                             pNext;
-       deUint32                                acquireCount;
-       const VkDeviceMemory*   pAcquireSyncs;
-       const deUint64*                 pAcquireKeys;
-       const deUint32*                 pAcquireTimeoutMilliseconds;
-       deUint32                                releaseCount;
-       const VkDeviceMemory*   pReleaseSyncs;
-       const deUint64*                 pReleaseKeys;
+       VkStructureType sType;
+       const void*             pNext;
+       deUint32                subpassCount;
+       const deUint32* pViewMasks;
+       deUint32                dependencyCount;
+       const deInt32*  pViewOffsets;
+       deUint32                correlationMaskCount;
+       const deUint32* pCorrelationMasks;
 };
 
-struct VkValidationFlagsEXT
+struct VkPhysicalDeviceMultiviewFeaturesKHX
 {
-       VkStructureType                 sType;
-       const void*                             pNext;
-       deUint32                                disabledValidationCheckCount;
-       VkValidationCheckEXT*   pDisabledValidationChecks;
+       VkStructureType sType;
+       void*                   pNext;
+       VkBool32                multiview;
+       VkBool32                multiviewGeometryShader;
+       VkBool32                multiviewTessellationShader;
 };
 
-struct VkDeviceGeneratedCommandsFeaturesNVX
+struct VkPhysicalDeviceMultiviewPropertiesKHX
 {
        VkStructureType sType;
-       const void*             pNext;
-       VkBool32                computeBindingPointSupport;
+       void*                   pNext;
+       deUint32                maxMultiviewViewCount;
+       deUint32                maxMultiviewInstanceIndex;
 };
 
-struct VkDeviceGeneratedCommandsLimitsNVX
+struct VkExternalMemoryPropertiesKHR
 {
-       VkStructureType sType;
-       const void*             pNext;
-       deUint32                maxIndirectCommandsLayoutTokenCount;
-       deUint32                maxObjectEntryCounts;
-       deUint32                minSequenceCountBufferOffsetAlignment;
-       deUint32                minSequenceIndexBufferOffsetAlignment;
-       deUint32                minCommandsTokenBufferOffsetAlignment;
+       VkExternalMemoryFeatureFlagsKHR         externalMemoryFeatures;
+       VkExternalMemoryHandleTypeFlagsKHR      exportFromImportedHandleTypes;
+       VkExternalMemoryHandleTypeFlagsKHR      compatibleHandleTypes;
 };
 
-struct VkIndirectCommandsTokenNVX
+struct VkPhysicalDeviceExternalImageFormatInfoKHR
 {
-       VkIndirectCommandsTokenTypeNVX  tokenType;
-       VkBuffer                                                buffer;
-       VkDeviceSize                                    offset;
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
 };
 
-struct VkIndirectCommandsLayoutTokenNVX
+struct VkExternalImageFormatPropertiesKHR
 {
-       VkIndirectCommandsTokenTypeNVX  tokenType;
-       deUint32                                                bindingUnit;
-       deUint32                                                dynamicCount;
-       deUint32                                                divisor;
+       VkStructureType                                 sType;
+       void*                                                   pNext;
+       VkExternalMemoryPropertiesKHR   externalMemoryProperties;
 };
 
-struct VkIndirectCommandsLayoutCreateInfoNVX
+struct VkPhysicalDeviceExternalBufferInfoKHR
 {
        VkStructureType                                                 sType;
        const void*                                                             pNext;
-       VkPipelineBindPoint                                             pipelineBindPoint;
-       VkIndirectCommandsLayoutUsageFlagsNVX   flags;
-       deUint32                                                                tokenCount;
-       const VkIndirectCommandsLayoutTokenNVX* pTokens;
+       VkBufferCreateFlags                                             flags;
+       VkBufferUsageFlags                                              usage;
+       VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
 };
 
-struct VkCmdProcessCommandsInfoNVX
+struct VkExternalBufferPropertiesKHR
+{
+       VkStructureType                                 sType;
+       void*                                                   pNext;
+       VkExternalMemoryPropertiesKHR   externalMemoryProperties;
+};
+
+struct VkPhysicalDeviceIDPropertiesKHR
+{
+       VkStructureType sType;
+       void*                   pNext;
+       deUint8                 deviceUUID[VK_UUID_SIZE];
+       deUint8                 driverUUID[VK_UUID_SIZE];
+       deUint8                 deviceLUID[VK_LUID_SIZE_KHR];
+       deUint32                deviceNodeMask;
+       VkBool32                deviceLUIDValid;
+};
+
+struct VkExternalMemoryImageCreateInfoKHR
 {
        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;
+       VkExternalMemoryHandleTypeFlagsKHR      handleTypes;
 };
 
-struct VkCmdReserveSpaceForCommandsInfoNVX
+struct VkExternalMemoryBufferCreateInfoKHR
 {
-       VkStructureType                         sType;
-       const void*                                     pNext;
-       VkObjectTableNVX                        objectTable;
-       VkIndirectCommandsLayoutNVX     indirectCommandsLayout;
-       deUint32                                        maxSequencesCount;
+       VkStructureType                                         sType;
+       const void*                                                     pNext;
+       VkExternalMemoryHandleTypeFlagsKHR      handleTypes;
 };
 
-struct VkObjectTableCreateInfoNVX
+struct VkExportMemoryAllocateInfoKHR
 {
        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;
+       VkExternalMemoryHandleTypeFlagsKHR      handleTypes;
 };
 
-struct VkObjectTableEntryNVX
+struct VkImportMemoryWin32HandleInfoKHR
 {
-       VkObjectEntryTypeNVX            type;
-       VkObjectEntryUsageFlagsNVX      flags;
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
+       pt::Win32Handle                                                 handle;
+       char*                                                                   name;
 };
 
-struct VkObjectTablePipelineEntryNVX
+struct VkExportMemoryWin32HandleInfoKHR
 {
-       VkObjectEntryTypeNVX            type;
-       VkObjectEntryUsageFlagsNVX      flags;
-       VkPipeline                                      pipeline;
+       VkStructureType                                 sType;
+       const void*                                             pNext;
+       pt::Win32SecurityAttributesPtr  pAttributes;
+       deUint32                                                dwAccess;
+       char*                                                   name;
 };
 
-struct VkObjectTableDescriptorSetEntryNVX
+struct VkMemoryWin32HandlePropertiesKHR
 {
-       VkObjectEntryTypeNVX            type;
-       VkObjectEntryUsageFlagsNVX      flags;
-       VkPipelineLayout                        pipelineLayout;
-       VkDescriptorSet                         descriptorSet;
+       VkStructureType sType;
+       void*                   pNext;
+       deUint32                memoryTypeBits;
 };
 
-struct VkObjectTableVertexBufferEntryNVX
+struct VkMemoryGetWin32HandleInfoKHR
 {
-       VkObjectEntryTypeNVX            type;
-       VkObjectEntryUsageFlagsNVX      flags;
-       VkBuffer                                        buffer;
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkDeviceMemory                                                  memory;
+       VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
 };
 
-struct VkObjectTableIndexBufferEntryNVX
+struct VkImportMemoryFdInfoKHR
 {
-       VkObjectEntryTypeNVX            type;
-       VkObjectEntryUsageFlagsNVX      flags;
-       VkBuffer                                        buffer;
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
+       int                                                                             fd;
 };
 
-struct VkObjectTablePushConstantEntryNVX
+struct VkMemoryFdPropertiesKHR
 {
-       VkObjectEntryTypeNVX            type;
-       VkObjectEntryUsageFlagsNVX      flags;
-       VkPipelineLayout                        pipelineLayout;
-       VkShaderStageFlags                      stageFlags;
+       VkStructureType sType;
+       void*                   pNext;
+       deUint32                memoryTypeBits;
 };
 
-struct VkPhysicalDevicePushDescriptorPropertiesKHR
+struct VkMemoryGetFdInfoKHR
+{
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkDeviceMemory                                                  memory;
+       VkExternalMemoryHandleTypeFlagBitsKHR   handleType;
+};
+
+struct VkWin32KeyedMutexAcquireReleaseInfoKHR
+{
+       VkStructureType                 sType;
+       const void*                             pNext;
+       deUint32                                acquireCount;
+       const VkDeviceMemory*   pAcquireSyncs;
+       const deUint64*                 pAcquireKeys;
+       const deUint32*                 pAcquireTimeouts;
+       deUint32                                releaseCount;
+       const VkDeviceMemory*   pReleaseSyncs;
+       const deUint64*                 pReleaseKeys;
+};
+
+struct VkPhysicalDeviceExternalSemaphoreInfoKHR
+{
+       VkStructureType                                                         sType;
+       const void*                                                                     pNext;
+       VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
+};
+
+struct VkExternalSemaphorePropertiesKHR
+{
+       VkStructureType                                                 sType;
+       void*                                                                   pNext;
+       VkExternalSemaphoreHandleTypeFlagsKHR   exportFromImportedHandleTypes;
+       VkExternalSemaphoreHandleTypeFlagsKHR   compatibleHandleTypes;
+       VkExternalSemaphoreFeatureFlagsKHR              externalSemaphoreFeatures;
+};
+
+struct VkExportSemaphoreCreateInfoKHR
+{
+       VkStructureType                                                 sType;
+       const void*                                                             pNext;
+       VkExternalSemaphoreHandleTypeFlagsKHR   handleTypes;
+};
+
+struct VkImportSemaphoreWin32HandleInfoKHR
+{
+       VkStructureType                                                         sType;
+       const void*                                                                     pNext;
+       VkSemaphore                                                                     semaphore;
+       VkSemaphoreImportFlagsKHR                                       flags;
+       VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
+       pt::Win32Handle                                                         handle;
+       char*                                                                           name;
+};
+
+struct VkExportSemaphoreWin32HandleInfoKHR
+{
+       VkStructureType                                 sType;
+       const void*                                             pNext;
+       pt::Win32SecurityAttributesPtr  pAttributes;
+       deUint32                                                dwAccess;
+       char*                                                   name;
+};
+
+struct VkD3D12FenceSubmitInfoKHR
 {
        VkStructureType sType;
-       void*                   pNext;
-       deUint32                maxPushDescriptors;
+       const void*             pNext;
+       deUint32                waitSemaphoreValuesCount;
+       const deUint64* pWaitSemaphoreValues;
+       deUint32                signalSemaphoreValuesCount;
+       const deUint64* pSignalSemaphoreValues;
 };
 
-struct VkDescriptorUpdateTemplateEntryKHR
+struct VkSemaphoreGetWin32HandleInfoKHR
 {
-       deUint32                        dstBinding;
-       deUint32                        dstArrayElement;
-       deUint32                        descriptorCount;
-       VkDescriptorType        descriptorType;
-       deUintptr                       offset;
-       deUintptr                       stride;
+       VkStructureType                                                         sType;
+       const void*                                                                     pNext;
+       VkSemaphore                                                                     semaphore;
+       VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
 };
 
-struct VkDescriptorUpdateTemplateCreateInfoKHR
+struct VkImportSemaphoreFdInfoKHR
 {
        VkStructureType                                                         sType;
-       void*                                                                           pNext;
-       VkDescriptorUpdateTemplateCreateFlagsKHR        flags;
-       deUint32                                                                        descriptorUpdateEntryCount;
-       const VkDescriptorUpdateTemplateEntryKHR*       pDescriptorUpdateEntries;
-       VkDescriptorUpdateTemplateTypeKHR                       templateType;
-       VkDescriptorSetLayout                                           descriptorSetLayout;
-       VkPipelineBindPoint                                                     pipelineBindPoint;
-       VkPipelineLayout                                                        pipelineLayout;
-       deUint32                                                                        set;
+       const void*                                                                     pNext;
+       VkSemaphore                                                                     semaphore;
+       VkSemaphoreImportFlagsKHR                                       flags;
+       VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
+       int                                                                                     fd;
+};
+
+struct VkSemaphoreGetFdInfoKHR
+{
+       VkStructureType                                                         sType;
+       const void*                                                                     pNext;
+       VkSemaphore                                                                     semaphore;
+       VkExternalSemaphoreHandleTypeFlagBitsKHR        handleType;
 };
 
 struct VkRefreshCycleDurationGOOGLE
@@ -1786,3 +1971,29 @@ struct VkPresentTimesInfoGOOGLE
        const VkPresentTimeGOOGLE*      pTimes;
 };
 
+struct VkPhysicalDeviceVariablePointerFeaturesKHR
+{
+       VkStructureType sType;
+       const void*             pNext;
+       VkBool32                variablePointersStorageBuffer;
+       VkBool32                variablePointers;
+};
+
+struct VkBindBufferMemoryInfoKHR
+{
+       VkStructureType sType;
+       const void*             pNext;
+       VkBuffer                buffer;
+       VkDeviceMemory  memory;
+       VkDeviceSize    memoryOffset;
+};
+
+struct VkBindImageMemoryInfoKHR
+{
+       VkStructureType sType;
+       const void*             pNext;
+       VkImage                 image;
+       VkDeviceMemory  memory;
+       VkDeviceSize    memoryOffset;
+};
+